京东关键词搜索 item_search_pro API 接口获取数据

京东item_search_pro是官方推出的增强版关键词搜索 API，相比基础版item_search，其核心优势在于「字段更全、筛选维度更多、数据精度更高」（支持品牌、价格区间、服务标签等多维度精准筛选，返回商品规格、售后保障、店铺评分等深度数据），适用于中高阶选品分析、竞品监控、精细化运营等场景。本文将从「接口特性、合规接入、多语言进阶代码、高级数据解析、实战场景落地」五大维度，提供可直接落地的技术方案。

一、item_search_pro 核心优势与适用场景

1. 核心优势（对比基础版 item_search）

特性	item_search（基础版）	item_search_pro（增强版）
筛选维度	仅支持关键词、排序、分类	支持品牌、价格区间、服务标签、规格、产地等 10 + 维度
返回字段数量	基础字段（价格、销量、库存）	新增店铺评分、商品规格、售后政策、实时销量、物流信息等 30 + 字段
数据精度	累计销量、基础价格	实时销量（近 7 天 / 30 天）、优惠后实际价格、规格对应价格
批量查询支持	单关键词单次查询	支持多关键词批量查询、分页批量获取（最大支持 100 页）
适用场景	简单选品、基础数据监控	精细化选品、竞品深度分析、定价策略优化、服务对标

2. 合规接入前提

item_search_pro属于京东开放平台高级接口，需满足以下条件：

已注册京东开放平台开发者账号（企业 / 个人资质认证通过）；

已创建应用并申请「商品搜索增强版」接口权限（需单独申请，基础版权限不包含）；

核心凭证：AppKey、AppSecret（与基础版通用，无需重新申请）；

官方文档参考：京东开放平台 - item_search_pro 接口（v4.0）：https://open.jd.com/doc/api.htm?apiId=45487

二、item_search_pro 接口核心配置（参数 + 签名）

1. 公共参数（与基础版一致）

参数名	类型	必选	说明	示例值
app_key	String	是	应用唯一标识（应用管理页获取）	23456789（替换为实际值）
method	String	是	接口名称（pro 版固定值）	jd.union.open.goods.search.pro
format	String	否	响应格式（默认 json）	json
v	String	是	接口版本（pro 版推荐 v4.0）	4.0
timestamp	String	是	请求时间戳（格式：yyyy-MM-dd HH:mm:ss）	2024-08-20 15:30:00
sign	String	是	签名值（HMAC-SHA256 算法）	8F7A6B5C4D3E2F1A...

2. 专属高级参数（pro 版核心亮点）

参数名	类型	必选	说明	示例值
keyword	String	是	搜索关键词（支持多关键词，空格分隔）	无线蓝牙耳机 主动降噪 长续航
page	Int	否	页码（默认 1，最大 100 页）	2
page_size	Int	否	每页条数（默认 30，最大 100）	100
sort_type	String	否	排序方式（新增 real_sales：实时销量）	real_sales_desc（实时销量降序）
brand_id	String	否	品牌 ID（精准筛选特定品牌，多品牌用逗号分隔）	12345,67890（需通过品牌列表接口获取）
price_from	Float	否	最低价格（元）	100.00
price_to	Float	否	最高价格（元）	300.00
service_tags	String	否	服务标签（多标签用逗号分隔，需参考标签 ID 字典）	1,3,5（1 = 京东物流，3=7 天无理由，5 = 上门换新）
is_jd_logistics	Int	否	是否京东物流（1 = 是，0 = 否）	1
spec_ids	String	否	规格 ID（筛选特定规格，如颜色、内存）	8GB+256GB, 黑色（需通过商品规格接口获取）
province	String	否	省份（筛选区域库存 / 价格）	广东省

关键说明：

brand_id获取：调用京东开放平台「品牌列表接口」（jd.union.open.category.brand.get），根据分类 ID 查询品牌 ID；

service_tags标签 ID 字典：可在京东开放平台接口文档中下载，包含京东物流、售后保障、发票服务等所有支持的标签 ID；

spec_ids：需先通过「商品规格接口」获取目标商品的规格 ID，再用于筛选。

3. 签名算法（与基础版一致，无需修改）

按参数名 ASCII 升序排列所有请求参数（含公共参数 + 业务参数）；

拼接为「key=value&key=value」格式字符串（无 URL 编码）；

用AppSecret作为密钥，执行 HMAC-SHA256 加密，得到大写签名值（sign）；

将 sign 加入请求参数，以 GET/POST 方式提交。

三、多语言进阶代码实现（item_search_pro）

以下代码基于京东开放平台item_search_pro（v4.0），包含高级参数配置、批量查询、数据入库功能，直接替换AppKey、AppSecret即可运行。

1. Python 实现（推荐，含批量搜索 + MySQL 入库）

python

运行

 

import requests
import hashlib
import hmac
import time
import pymysql
from urllib.parse import urlencode
from typing import List, Dict

class JDItemSearchPro:
    def __init__(self, app_key: str, app_secret: str, db_config: Dict = None):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://api.jd.com/routerjson"
        # 数据库连接（可选，用于存储数据）
        self.db = pymysql.connect(**db_config) if db_config else None
        self.cursor = self.db.cursor() if self.db else None

    # 生成签名（核心方法）
    def generate_sign(self, params: Dict) - > str:
        sorted_params = sorted(params.items(), key=lambda x: x[0])
        sign_str = "&".join([f"{k}={v}" for k, v in sorted_params])
        hmac_obj = hmac.new(
            self.app_secret.encode("utf-8"),
            sign_str.encode("utf-8"),
            hashlib.sha256
        )
        return hmac_obj.hexdigest().upper()

    # 单关键词搜索（支持高级筛选）
    def search_single_keyword(self, keyword: str, **kwargs) - > Dict:
        """
        kwargs支持的高级参数：
        page: 页码，default=1
        page_size: 每页条数，default=100
        sort_type: 排序方式，default=real_sales_desc
        brand_id: 品牌ID，default=""
        price_from: 最低价格，default=0.0
        price_to: 最高价格，default=99999.0
        service_tags: 服务标签，default=""
        is_jd_logistics: 是否京东物流，default=1
        """
        # 公共参数
        params = {
            "app_key": self.app_key,
            "method": "jd.union.open.goods.search.pro",
            "format": "json",
            "v": "4.0",
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
            "keyword": keyword,
            "page": str(kwargs.get("page", 1)),
            "page_size": str(kwargs.get("page_size", 100)),
            "sort_type": kwargs.get("sort_type", "real_sales_desc"),
            "brand_id": kwargs.get("brand_id", ""),
            "price_from": str(kwargs.get("price_from", 0.0)),
            "price_to": str(kwargs.get("price_to", 99999.0)),
            "service_tags": kwargs.get("service_tags", ""),
            "is_jd_logistics": str(kwargs.get("is_jd_logistics", 1))
        }
        # 生成签名
        params["sign"] = self.generate_sign(params)
        # 发送请求
        response = requests.get(self.api_url, params=params, timeout=15)
        if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"请求失败：状态码{response.status_code}，响应：{response.text}")

    # 多关键词批量搜索
    def batch_search(self, keywords: List[str], **kwargs) - > List[Dict]:
        """批量搜索多个关键词，返回合并后的数据"""
        all_goods = []
        for keyword in keywords:
            print(f"正在搜索关键词：{keyword}")
            for page in range(1, kwargs.get("max_page", 3) + 1):  # 最多获取3页
                try:
                    result = self.search_single_keyword(
                        keyword=keyword,
                        page=page,
                        page_size=kwargs.get("page_size", 100),
                        sort_type=kwargs.get("sort_type", "real_sales_desc"),
                        brand_id=kwargs.get("brand_id", ""),
                        price_from=kwargs.get("price_from", 0.0),
                        price_to=kwargs.get("price_to", 99999.0),
                        service_tags=kwargs.get("service_tags", ""),
                        is_jd_logistics=kwargs.get("is_jd_logistics", 1)
                    )
                    # 解析数据
                    goods_list = self.parse_result(result)
                    if not goods_list:
                        break  # 无更多数据，停止分页
                    all_goods.extend(goods_list)
                    # 存入数据库（如果配置了DB）
                    if self.db:
                        self.save_to_db(goods_list)
                    time.sleep(1)  # 避免QPS超限
                except Exception as e:
                    print(f"关键词{keyword}第{page}页搜索失败：{str(e)}")
                    continue
        return all_goods

    # 解析返回结果（提取pro版核心字段）
    def parse_result(self, result: Dict) - > List[Dict]:
        """提取商品核心字段，适配运营需求"""
        parsed_goods = []
        data = result.get("jd_union_open_goods_search_pro_response", {}) 
            .get("result", {}) 
            .get("data", [])
        for goods in data:
            # 解析规格信息（pro版新增）
            spec_info = goods.get("specInfo", {})
            spec_details = "; ".join([f"{k}:{v}" for k, v in spec_info.items()]) if spec_info else "无"
            
            # 解析售后保障（pro版新增）
            after_sale = goods.get("afterSaleService", {})
            after_sale_details = f"7天无理由：{'是' if after_sale.get('sevenDaysNoReasonReturn') else '否'}；" 
                                f"上门换新：{'是' if after_sale.get('onSiteReplacement') else '否'}；" 
                                f"全国联保：{'是' if after_sale.get('nationalWarranty') else '否'}"
            
            parsed_goods.append({
                "sku_id": goods.get("skuId", ""),  # 商品唯一ID
                "goods_name": goods.get("goodsName", ""),  # 商品标题
                "brand_name": goods.get("brandName", ""),  # 品牌名称
                "brand_id": goods.get("brandId", ""),  # 品牌ID
                "current_price": goods.get("price", 0.0),  # 现价
                "original_price": goods.get("originalPrice", 0.0),  # 原价
                "real_sales_7d": goods.get("realSales7d", 0),  # 7天实时销量（pro新增）
                "total_sales": goods.get("salesCount", 0),  # 累计销量
                "review_count": goods.get("reviewCount", 0),  # 评价数
                "shop_name": goods.get("shopName", ""),  # 店铺名称
                "shop_type": goods.get("shopType", ""),  # 店铺类型（自营/第三方）
                "shop_score": goods.get("shopScore", 0.0),  # 店铺评分（pro新增）
                "stock": goods.get("stock", 0),  # 库存
                "is_jd_logistics": goods.get("isJdLogistics", 0),  # 是否京东物流
                "service_tags": goods.get("serviceTags", ""),  # 服务标签
                "spec_details": spec_details,  # 规格详情
                "after_sale_details": after_sale_details,  # 售后详情
                "coupon_amount": goods.get("couponInfo", {}).get("discount", 0.0),  # 优惠券金额
                "create_time": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  # 数据采集时间
            })
        return parsed_goods

    # 数据存入MySQL（可选）
    def save_to_db(self, goods_list: List[Dict]):
        """创建商品数据表并插入数据"""
        # 创建表SQL
        create_table_sql = """
        CREATE TABLE IF NOT EXISTS jd_goods_pro (
            id INT AUTO_INCREMENT PRIMARY KEY,
            sku_id VARCHAR(50) UNIQUE NOT NULL,
            goods_name VARCHAR(500) NOT NULL,
            brand_name VARCHAR(100),
            brand_id VARCHAR(50),
            current_price DECIMAL(10,2),
            original_price DECIMAL(10,2),
            real_sales_7d INT,
            total_sales INT,
            review_count INT,
            shop_name VARCHAR(200),
            shop_type VARCHAR(50),
            shop_score DECIMAL(3,2),
            stock INT,
            is_jd_logistics TINYINT,
            service_tags VARCHAR(200),
            spec_details VARCHAR(500),
            after_sale_details VARCHAR(500),
            coupon_amount DECIMAL(10,2),
            create_time DATETIME
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
        """
        self.cursor.execute(create_table_sql)
        # 插入数据SQL
        insert_sql = """
        INSERT IGNORE INTO jd_goods_pro (
            sku_id, goods_name, brand_name, brand_id, current_price, original_price,
            real_sales_7d, total_sales, review_count, shop_name, shop_type, shop_score,
            stock, is_jd_logistics, service_tags, spec_details, after_sale_details,
            coupon_amount, create_time
        ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
        """
        # 批量插入
        values = [
            (
                g["sku_id"], g["goods_name"], g["brand_name"], g["brand_id"], g["current_price"],
                g["original_price"], g["real_sales_7d"], g["total_sales"], g["review_count"],
                g["shop_name"], g["shop_type"], g["shop_score"], g["stock"], g["is_jd_logistics"],
                g["service_tags"], g["spec_details"], g["after_sale_details"], g["coupon_amount"],
                g["create_time"]
            ) for g in goods_list
        ]
        self.cursor.executemany(insert_sql, values)
        self.db.commit()
        print(f"成功存入{len(values)}条商品数据")

# ------------------- 实战调用示例 -------------------
if __name__ == "__main__":
    # 配置信息（替换为实际值）
    APP_KEY = "你的京东AppKey"
    APP_SECRET = "你的京东AppSecret"
    DB_CONFIG = {
        "host": "localhost",
        "user": "root",
        "password": "你的数据库密码",
        "database": "jd_data",
        "charset": "utf8mb4"
    }

    # 初始化实例（如需存储数据，传入DB_CONFIG；无需则不传）
    jd_pro = JDItemSearchPro(APP_KEY, APP_SECRET, DB_CONFIG)

    # 1. 单关键词高级搜索（筛选京东物流、100-300元、华为品牌）
    single_result = jd_pro.search_single_keyword(
        keyword="无线蓝牙耳机 主动降噪",
        brand_id="1000000779",  # 华为品牌ID（示例）
        price_from=100.0,
        price_to=300.0,
        service_tags="1,3",  # 1=京东物流，3=7天无理由
        sort_type="real_sales_desc"
    )
    parsed_single = jd_pro.parse_result(single_result)
    print(f"单关键词搜索结果：{len(parsed_single)}条商品")

    # 2. 多关键词批量搜索（存储到MySQL）
    keywords = ["无线蓝牙耳机 主动降噪", "机械键盘 青轴", "充电宝 20000mAh"]
    batch_result = jd_pro.batch_search(
        keywords=keywords,
        max_page=2,  # 每个关键词获取2页
        page_size=100,
        price_from=50.0,
        is_jd_logistics=1
    )
    print(f"批量搜索总结果：{len(batch_result)}条商品")

    # 关闭数据库连接
    if jd_pro.db:
        jd_pro.cursor.close()
        jd_pro.db.close()

 

2. Java 实现（含高级筛选 + 数据解析）

java

运行

 

import org.apache.commons.codec.digest.HmacUtils;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONArray;
import java.util.*;
import java.net.URLEncoder;

public class JDItemSearchPro {
    private static final String APP_KEY = "你的京东AppKey";
    private static final String APP_SECRET = "你的京东AppSecret";
    private static final String API_URL = "https://api.jd.com/routerjson";

    // 生成签名
    private static String generateSign(Map< String, String > params) {
        List< Map.Entry< String, String >> entryList = new ArrayList<  >(params.entrySet());
        entryList.sort(Map.Entry.comparingByKey());
        StringBuilder signStr = new StringBuilder();
        for (Map.Entry< String, String > entry : entryList) {
            signStr.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }
        signStr.deleteCharAt(signStr.length() - 1);
        return new HmacUtils("HmacSHA256", APP_SECRET).hmacHex(signStr.toString()).toUpperCase();
    }

    // 高级搜索方法（支持多维度筛选）
    public static JSONObject searchPro(String keyword, int page, int pageSize, String brandId,
                                       double priceFrom, double priceTo, String serviceTags, int isJdLogistics) throws Exception {
        Map< String, String > params = new HashMap<  >();
        // 公共参数
        params.put("app_key", APP_KEY);
        params.put("method", "jd.union.open.goods.search.pro");
        params.put("format", "json");
        params.put("v", "4.0");
        params.put("timestamp", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        // 业务参数（高级筛选）
        params.put("keyword", keyword);
        params.put("page", String.valueOf(page));
        params.put("page_size", String.valueOf(pageSize));
        params.put("sort_type", "real_sales_desc");
        params.put("brand_id", brandId);
        params.put("price_from", String.valueOf(priceFrom));
        params.put("price_to", String.valueOf(priceTo));
        params.put("service_tags", serviceTags);
        params.put("is_jd_logistics", String.valueOf(isJdLogistics));
        // 生成签名
        params.put("sign", generateSign(params));

        // 构建请求URL
        StringBuilder urlBuilder = new StringBuilder(API_URL).append("?");
        for (Map.Entry< String, String > entry : params.entrySet()) {
            urlBuilder.append(entry.getKey())
                    .append("=")
                    .append(URLEncoder.encode(entry.getValue(), "UTF-8"))
                    .append("&");
        }
        String url = urlBuilder.deleteCharAt(urlBuilder.length() - 1).toString();

        // 发送请求
        try (CloseableHttpClient client = HttpClients.createDefault()) {
            HttpGet request = new HttpGet(url);
            return JSONObject.parseObject(EntityUtils.toString(client.execute(request).getEntity()));
        }
    }

    // 解析Pro版核心数据
    public static List< Map< String, Object >> parseProResult(JSONObject result) {
        List< Map< String, Object >> parsedGoods = new ArrayList<  >();
        JSONArray data = result.getJSONObject("jd_union_open_goods_search_pro_response")
                .getJSONObject("result")
                .getJSONArray("data");

        for (Object obj : data) {
            JSONObject goods = (JSONObject) obj;
            Map< String, Object > goodsMap = new HashMap<  >();

            // 基础字段
            goodsMap.put("skuId", goods.getString("skuId"));
            goodsMap.put("goodsName", goods.getString("goodsName"));
            goodsMap.put("brandName", goods.getString("brandName"));
            goodsMap.put("currentPrice", goods.getBigDecimal("price"));
            goodsMap.put("originalPrice", goods.getBigDecimal("originalPrice"));

            // Pro版新增字段
            goodsMap.put("realSales7d", goods.getIntValue("realSales7d"));
            goodsMap.put("shopScore", goods.getBigDecimal("shopScore"));
            goodsMap.put("specDetails", goods.getJSONObject("specInfo").toString());
            goodsMap.put("afterSaleDetails", goods.getJSONObject("afterSaleService").toString());
            goodsMap.put("isJdLogistics", goods.getIntValue("isJdLogistics"));

            parsedGoods.add(goodsMap);
        }
        return parsedGoods;
    }

    // 主函数调用
    public static void main(String[] args) throws Exception {
        // 搜索：华为无线蓝牙耳机（品牌ID=1000000779），100-300元，京东物流
        JSONObject result = searchPro(
                "无线蓝牙耳机 主动降噪",
                1, 100,
                "1000000779",
                100.0, 300.0,
                "1,3", 1
        );

        // 解析数据
        List< Map< String, Object >> goodsList = parseProResult(result);
        System.out.println("搜索结果数量：" + goodsList.size());
        for (Map< String, Object > goods : goodsList) {
            System.out.println("商品ID：" + goods.get("skuId"));
            System.out.println("商品名称：" + goods.get("goodsName"));
            System.out.println("7天实时销量：" + goods.get("realSales7d"));
            System.out.println("店铺评分：" + goods.get("shopScore"));
            System.out.println("---------------------");
        }
    }
}

 

3. PHP 实现（简洁版，含高级参数）

php

运行

 

< ?php
class JDItemSearchPro {
    private $appKey = "你的京东AppKey";
    private $appSecret = "你的京东AppSecret";
    private $apiUrl = "https://api.jd.com/routerjson";

    // 生成签名
    private function generateSign($params) {
        ksort($params);
        $signStr = http_build_query($params, '', '&');
        return strtoupper(hash_hmac('sha256', $signStr, $this- >appSecret));
    }

    // 高级搜索
    public function searchPro($keyword, $page = 1, $pageSize = 100, $brandId = '', $priceFrom = 0, $priceTo = 99999, $serviceTags = '', $isJdLogistics = 1) {
        $params = [
            'app_key' = > $this- >appKey,
            'method' = > 'jd.union.open.goods.search.pro',
            'format' = > 'json',
            'v' = > '4.0',
            'timestamp' = > date('Y-m-d H:i:s'),
            'keyword' = > $keyword,
            'page' = > (string)$page,
            'page_size' = > (string)$pageSize,
            'sort_type' = > 'real_sales_desc',
            'brand_id' = > $brandId,
            'price_from' = > (string)$priceFrom,
            'price_to' = > (string)$priceTo,
            'service_tags' = > $serviceTags,
            'is_jd_logistics' = > (string)$isJdLogistics
        ];
        $params['sign'] = $this- >generateSign($params);

        // 发送请求
        $url = $this- >apiUrl . '?' . http_build_query($params);
        $response = file_get_contents($url);
        return json_decode($response, true);
    }

    // 解析数据
    public function parseResult($result) {
        $goodsList = $result['jd_union_open_goods_search_pro_response']['result']['data'] ?? [];
        $parsed = [];
        foreach ($goodsList as $goods) {
            $parsed[] = [
                'sku_id' = > $goods['skuId'],
                'goods_name' = > $goods['goodsName'],
                'brand_name' = > $goods['brandName'],
                'current_price' = > $goods['price'],
                'real_sales_7d' = > $goods['realSales7d'],
                'shop_score' = > $goods['shopScore'],
                'spec_details' = > json_encode($goods['specInfo']),
                'after_sale' = > json_encode($goods['afterSaleService'])
            ];
        }
        return $parsed;
    }
}

// 调用示例
$jdPro = new JDItemSearchPro();
$result = $jdPro- >searchPro(
    '无线蓝牙耳机 主动降噪',
    1, 100,
    '1000000779',  // 华为品牌ID
    100, 300,
    '1,3', 1
);
$parsedData = $jdPro- >parseResult($result);
print_r("搜索结果：" . count($parsedData) . "条n");
print_r($parsedData[0]);
? >

 

四、item_search_pro 核心数据解析与运营落地

1. Pro 版新增核心字段（运营关键）

字段名	说明	运营价值
realSales7d/realSales30d	7 天 / 30 天实时销量（非累计）	判断商品近期热度，避免选品 “过时爆款”
shopScore	店铺评分（1-5 分）	筛选高口碑店铺，降低合作 / 对标风险
specInfo	商品规格详情（颜色、内存、尺寸等）	分析热门规格，优化自身商品 SKU 配置
afterSaleService	售后保障（7 天无理由、上门换新等）	对标竞品服务，提升自身店铺售后竞争力
isJdLogistics	是否京东物流（1 = 是）	筛选高物流体验商品，适合主打 “极速送达” 场景
couponEffectiveTime	优惠券生效 / 失效时间	精准把握促销节点，调整定价 / 推广策略

2. 高阶运营场景落地（基于 Pro 版数据）

（1）精细化选品（精准锁定高潜力商品）

筛选逻辑：京东物流（is_jd_logistics=1）+ 7 天实时销量 > 500（realSales7d>500）+ 店铺评分 > 4.8（shopScore>4.8）+ 有上门换新服务（afterSaleService.onSiteReplacement=true）+ 价格区间 100-300 元。Python 代码示例：

python

运行

 

# 筛选高潜力商品
high_potential = [
    g for g in parsed_single
    if g["real_sales_7d"] > 500
    and g["shop_score"] > 4.8
    and "上门换新：是" in g["after_sale_details"]
    and 100 <= g["current_price"] <= 300
]
print(f"高潜力商品数量：{len(high_potential)}")
for goods in high_potential:
    print(f"商品：{goods['goods_name']}，7天销量：{goods['real_sales_7d']}，店铺评分：{goods['shop_score']}")

 

（2）竞品服务对标分析

核心需求：分析竞品的售后保障、服务标签，优化自身店铺服务配置。数据提取逻辑：提取同类竞品的service_tags和after_sale_details，统计高频服务标签和售后政策。代码示例：

python

运行

 

# 统计竞品高频服务标签
service_tags_count = {}
for goods in batch_result:
    tags = goods["service_tags"].split(",")
    for tag in tags:
        if tag:
            service_tags_count[tag] = service_tags_count.get(tag, 0) + 1

# 统计售后政策分布
after_sale_count = {"7天无理由": 0, "上门换新": 0, "全国联保": 0}
for goods in batch_result:
    if "7天无理由：是" in goods["after_sale_details"]:
        after_sale_count["7天无理由"] += 1
    if "上门换新：是" in goods["after_sale_details"]:
        after_sale_count["上门换新"] += 1
    if "全国联保：是" in goods["after_sale_details"]:
        after_sale_count["全国联保"] += 1

print("竞品服务标签分布：", service_tags_count)
print("竞品售后政策分布：", after_sale_count)

 

（3）动态定价策略优化

核心逻辑：基于同类商品的价格区间、优惠券金额、规格配置，制定差异化定价。

提取同类商品价格区间：min_price = min([g["current_price"] for g in batch_result])，max_price = max([g["current_price"] for g in batch_result])；

热门规格溢价分析：若 “8GB+256GB” 规格的商品价格比 “6GB+128GB” 高 30% 以上，可适当降低溢价，提升竞争力。

五、常见问题与解决方案（Pro 版专属）

问题类型	原因分析	解决方案
接口权限不足（403）	未申请「商品搜索增强版」权限，仅拥有基础版	登录京东开放平台，在 “应用权限管理” 中申请 item_search_pro 权限
realSales7d 字段缺失	接口版本低于 v4.0，或未开通实时销量权限	升级接口版本至 v4.0，申请 “实时销量数据” 权限
brand_id 筛选无效	品牌 ID 错误，或该品牌无匹配商品	通过「品牌列表接口」重新获取品牌 ID，优化关键词 + 品牌组合
分页数据重复	未按 sku_id 去重，或接口返回数据缓存	存入数据库时用 sku_id 作为唯一键（INSERT IGNORE），或添加去重逻辑
QPS 超限（429）	超过 Pro 版 QPS 限制（通常为 10-20 QPS）	1. 申请提高 QPS；2. 批量查询时加入 1-2 秒延迟；3. 缓存重复查询结果

六、合规与风险提示

接口使用限制：item_search_pro的 QPS 限制高于基础版，但仍需遵守平台规定，禁止高频恶意调用（否则会导致 AppKey 封禁）；

数据使用范围：仅用于自身运营分析，不得转售、泄露商品数据或店铺信息，遵守《京东开放平台服务协议》；

权限有效期：高级接口权限需定期审核，确保资质合规，避免权限到期导致服务中断。

审核编辑 黄宇