万邦api博客

中国制造网关键词搜索接口：业务过滤与分页偏移问题实战处理

Thu, 27 Aug 2026 15:11:03 +0800

前言

中国制造网作为 B2B 外贸采购平台，关键词搜索接口和普通电商平台存在明显差异。接口返回数据混杂工厂、贸易商、中间商多种类型商家商品，同时存在分页偏移漂移、部分字段缺失、多语言字段混用等问题。网上多数示例只简单演示请求调用，缺少业务侧过滤逻辑。本文侧重工程落地，增加商家类型过滤、分页边界校验、结果数据清洗，给出可直接用于业务系统的调用示例。

前置准备

对接前需要在平台开发者后台创建应用，获取app_key、app_secret，接口调用需要生成签名，同时获取访问令牌 access_token。接口有调用频次限制，B2B 平台对 QPS 管控严格，生产环境必须增加休眠限流，避免触发接口封禁。

搜索接口入参核心：关键词、页码、每页条数、筛选条件；返回包含商品 ID、标题、价格、起订量、供应商信息、产地等字段。原始返回字段冗余，大量字段业务不需要，需要做裁剪处理。

点击获取key和secret

核心 Python 代码示例

python

import requests
import time
import hashlib

class MadeInChinaSearchClient:
    def __init__(self, app_key, app_secret, access_token):
        self.app_key = app_key
        self.app_secret = app_secret
        self.access_token = access_token
        self.base_url = "https://api.made‑in‑china.com/openapi/search/goods"
        self.session = requests.Session()

    def gen_sign(self, params):
        sort_str = "".join([f"{k}{v}" for k, v in sorted(params.items())])
        sign_raw = self.app_secret + sort_str + self.app_secret
        return hashlib.md5(sign_raw.encode("utf‑8")).hexdigest().upper()

    def search_goods(self, keyword, page=1, page_size=20, factory_filter=True):
        params = {
            "app_key": self.app_key,
            "access_token": self.access_token,
            "keyword": keyword,
            "page": page,
            "page_size": page_size,
            "timestamp": int(time.time())
        }
        params["sign"] = self.gen_sign(params)
        resp = self.session.get(self.base_url, params=params, timeout=15)
        res_json = resp.json()
        if res_json.get("code") != 0:
            return {"error": res_json.get("msg"), "data": []}
        raw_list = res_json.get("data", {}).get("goods_list", [])
        result = []
        for item in raw_list:
            # B2B业务过滤：只保留工厂类型供应商
            supplier_type = item.get("supplier_type", "")
            if factory_filter and supplier_type != "factory":
                continue
            clean_item = {
                "goods_id": item.get("goods_id"),
                "title": item.get("title"),
                "price": item.get("price_range"),
                "moq": item.get("min_order"),
                "supplier_name": item.get("supplier_name"),
                "supplier_type": supplier_type
            }
            result.append(clean_item)
        time.sleep(0.8)
        return {"error": None, "data": result}

if __name__ == "__main__":
    client = MadeInChinaSearchClient("your_key", "your_secret", "your_token")
    ret = client.search_goods("usb charger", page=1, factory_filter=True)
    print(ret["data"])

代码逻辑解读

封装请求类统一管理签名、会话、限流休眠，避免重复代码；签名按照平台规则对参数排序后 MD5 加密。
增加factory_filter开关，B2B 场景经常只需要工厂货源，过滤贸易商数据，减少后续业务处理压力。
做数据裁剪，剔除大量无用返回字段，只保留业务核心字段，降低内存占用。
增加超时、错误码判断，简单休眠控制 QPS，防止短时间高频调用被限制。

线上踩坑总结

分页漂移：平台搜索结果会实时变化，翻页时会出现重复商品，业务层需要用 goods_id 做去重，不能单纯依赖分页。
价格字段为空：部分商品不公开报价，price_range 会返回 null，业务代码要做空值判断，直接取值会抛出异常。
供应商类型字段不稳定：部分老商品供应商类型字段缺失，需要做好兜底。
令牌过期：access_token 具备有效期，生产环境需要增加自动刷新逻辑，示例中未展示。

中国制造网商品详情接口：B2B 供应商属性结构化解析实践

Tue, 25 Aug 2026 16:45:34 +0800

前言

网上多数教程只简单演示接口调用，直接打印原始返回结果，忽略中国制造网 B 端独有的业务特征：供应商资质、MOQ 起订量、包装参数、产地、定制加工属性。原始接口返回嵌套层级深，大量字段为平台内部使用，直接入库会产生大量冗余数据。本文不从简单请求示例入手，重点讲解字段过滤、供应商信息剥离、异常场景兼容，适配比价、供应链数据同步业务。

前置准备

登录中国制造开放平台创建应用，获取 appKey、appSecret，完成授权拿到 access_token。调用商品详情接口传入产品 ID，需要区分公开商品、会员专属商品，后者会返回权限异常，代码层面必须做拦截处理。

点击获取key和secret

核心 Python 代码示例

python

import requests

class MadeInChinaDetailClient:
    def __init__(self, app_key, access_token):
        self.app_key = app_key
        self.token = access_token
        self.api_url = "https://api.made‑in‑china.com/openapi/product/detail/get"

    def fetch_product_detail(self, product_id):
        payload = {
            "appKey": self.app_key,
            "accessToken": self.token,
            "productId": product_id
        }
        resp = requests.get(self.api_url, params=payload, timeout=18)
        origin_data = resp.json()
        return self.struct_data(origin_data)

    def struct_data(self, raw):
        """数据结构化：剥离供应商、定制属性，过滤无用字段"""
        output = {
            "ok": False,
            "product_id": None,
            "title": "",
            "main_img": "",
            "moq": 0,
            "origin_place": "",
            "is_custom": False,
            "supplier_info": {},
            "msg": ""
        }
        if raw.get("code") != 0:
            output["msg"] = raw.get("message", "接口调用失败")
            return output
        data = raw.get("data", {})
        if not data:
            output["msg"] = "商品不存在或已下架"
            return output
        product = data.get("productInfo", {})
        supplier = data.get("supplierInfo", {})

        output["ok"] = True
        output["product_id"] = product.get("productId")
        output["title"] = product.get("productName", "")
        output["main_img"] = product.get("mainImageUrl", "")
        output["moq"] = product.get("minOrderQuantity", 0)
        output["origin_place"] = product.get("origin", "")
        output["is_custom"] = bool(product.get("supportCustomize", 0))

        # 提取供应商核心业务字段
        output["supplier_info"] = {
            "company_name": supplier.get("companyName"),
            "factory_type": supplier.get("factoryType"),
            "certification": supplier.get("certList", [])
        }
        return output

if __name__ == "__main__":
    client = MadeInChinaDetailClient("your_appkey", "your_access_token")
    res = client.fetch_product_detail(product_id=95******21)
    print(res)

代码逻辑解析

核心在于struct_data结构化函数，不直接透传原始 JSON。

优先拦截接口错误码，区分鉴权失败、商品下架、权限不足；
将商品基础参数、供应商信息做分离，业务系统可以分开存储产品表与供应商表；
识别是否支持定制加工、最小起订量、产地等 B2B 关键业务字段；
返回固定结构体，上层业务无需关心原始接口字段变动。

对接踩坑汇总

access_token 存在有效期，批量同步商品时，捕获鉴权报错，触发 token 重新获取逻辑；
部分 OEM 定制类商品无固定售价，价格字段为空，业务代码必须做空值判断；
开放平台存在 QPS 限制，大批量拉取需要做批次休眠，高频调用会被限流；
部分仅对采购会员开放的商品，即便产品 ID 正确，也无法获取详情，需要标记异常，不要直接抛出程序崩溃。

1688 商品详情接口：多规格价格分层解析与业务数据归一化实践

Mon, 24 Aug 2026 16:18:47 +0800

前言

大部分公开教程只演示简单调用获取商品基础信息，忽略 1688B 端核心痛点：阶梯批发价、多 SKU 规格、起订量限制、混批规则字段杂乱。同一商品会存在多档拿货价，原始接口返回字段嵌套层级深，直接拿原始 JSON 很难直接用于业务系统。本文重点不是简单请求演示，而是对接入后的数据做分层解析、脏字段过滤，适配采购、比价类业务场景。

前置准备

调用前需要在 1688 开放平台创建应用，获取 appKey、appSecret，拿到 access_token。商品详情接口需要传入商品 ID，注意部分私密商品、被下架商品会返回权限类异常，业务代码必须做兼容处理。

点击获取key和secret

核心 Python 代码示例

import requests
import time

class Ali1688DetailClient:
    def __init__(self, app_key, app_secret, access_token):
        self.app_key = app_key
        self.app_secret = app_secret
        self.token = access_token
        self.url = "https://gw.open.1688.com/openapi/param2/1/com.alibaba.trade/alibaba.trade.getProductDetail"

    def get_product_detail(self, product_id):
        params = {
            "appKey": self.app_key,
            "access_token": self.token,
            "productId": product_id
        }
        resp = requests.get(self.url, params=params, timeout=15)
        raw_data = resp.json()
        result = self.data_normalize(raw_data)
        return result

    def data_normalize(self, raw):
        """核心：原始数据归一化，提取阶梯价格、起订量，过滤无效字段"""
        res = {
            "success": False,
            "product_id": None,
            "title": "",
            "main_image": "",
            "price_list": [],
            "min_order": 0,
            "is_off_shelf": False
        }
        if raw.get("errorCode"):
            res["msg"] = raw.get("errorMessage")
            return res
        data = raw.get("result", {})
        if not data or data.get("status") != "success":
            res["msg"] = "商品数据为空或已下架"
            res["is_off_shelf"] = True
            return res
        info = data.get("productInfo", {})
        res["success"] = True
        res["product_id"] = info.get("productId")
        res["title"] = info.get("subject", "")
        res["main_image"] = info.get("mainImage", "")
        res["min_order"] = info.get("minOrderQuantity", 0)
        # 解析批发阶梯价格
        price_steps = info.get("priceRanges", [])
        for p in price_steps:
            res["price_list"].append({
                "start_num": p.get("startQuantity"),
                "price": p.get("price")
            })
        return res

if __name__ == "__main__":
    client = Ali1688DetailClient("your_appkey","your_secret","your_token")
    detail = client.get_product_detail(product_id=68******56)
    print(detail)

代码逻辑解析

data_normalize 函数是整套封装的重点。接口原始返回字段繁多，很多是平台内部使用字段，全部存储会浪费存储空间。这里只提取业务需要的标题、主图、起订量、多档批发价格。

优先捕获 errorCode，处理鉴权错误、token 过期；
判断商品状态，识别下架、删除商品；
循环解析 priceRanges，把阶梯批发价整理成结构化数组，方便前端展示或者入库；
返回统一格式结构体，上层业务不需要感知原始接口字段变化。

对接过程常见问题

Token 短期有效，大批量循环获取商品详情时，要做好 token 过期捕获与自动刷新逻辑；
部分定制类商品没有阶梯价格，priceRanges 为空数组，业务上要做空判断，避免程序报错；
平台有调用频率限制，短时间大量请求会触发限流，建议增加 sleep 间隔，按批次拉取；
私密商品、分销商专属商品，即便 ID 正确也无法获取详情，代码需要标记该类异常，不要直接抛出崩溃。

1688 店铺列表搜索接口：B 端供应商检索的分页偏移与脏数据过滤方案

Fri, 21 Aug 2026 17:29:26 +0800

1688 店铺搜索接口多用于供应商挖掘、同行店铺盘点。网上大部分示例只演示基础签名与循环分页，忽略 B 端特有问题：搜索结果会混入关闭店铺、个体散户，并且服务端动态权重排序会造成分页偏移，同一店铺多次重复出现，直接循环翻页会造成统计结果失真。本文不做基础参数科普，聚焦业务层过滤、偏移去重、异常兼容，提供一套面向供应商筛选的生产级封装代码。

该接口核心痛点：total 总计数仅供参考，超过一定页码后统计值不准；部分店铺已经停业注销，但接口依然返回记录；翻页过程平台实时重排，造成店铺重复；中文关键词必须做好编码，否则签名直接报错。开发前需要在开放平台申请对应接口权限，获取 app_key、app_secret，服务器 IP 加入白名单。

python

import requests
import time
import hashlib

class Ali1688ShopSearch:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://gw.open.1688.com/openapi/http"
        self.shop_member_set = set() # 店铺memberId全局去重，解决分页偏移
        self.session = requests.Session()

    def make_sign(self, params):
        sorted_param = sorted(params.items(), key=lambda x:x[0])
        raw_str = self.app_secret + "".join(f"{k}{v}" for k,v in sorted_param) + self.app_secret
        return hashlib.md5(raw_str.encode("utf-8")).hexdigest().upper()

    def query_single_page(self, keyword, page_no, page_size=20):
        timestamp = str(int(time.time()*1000))
        params = {
            "app_key": self.app_key,
            "method": "alibaba.seller.search",
            "timestamp": timestamp,
            "format": "json",
            "v": "2.0",
            "q": keyword,
            "pageNo": page_no,
            "pageSize": min(page_size,20)
        }
        params["sign"] = self.make_sign(params)
        try:
            resp = self.session.post(self.api_url, data=params, timeout=12)
            return resp.json()
        except Exception:
            return {}

    def search_shop_list(self, keyword, max_page=30):
        shop_result = []
        page = 1
        while page <= max_page:
            time.sleep(1.0) # QPS限流适配
            resp_json = self.query_single_page(keyword, page)
            resp_body = resp_json.get("alibaba_seller_search_response", {})
            shop_list = resp_body.get("sellerList", [])
            if not shop_list:
                break
            for shop in shop_list:
                member_id = shop.get("memberId")
                if not member_id or member_id in self.shop_member_set:
                    continue
                # 过滤停业、无效店铺
                if shop.get("isClosed"):
                    continue
                self.shop_member_set.add(member_id)
                shop_result.append({
                    "member_id": member_id,
                    "shop_name": shop.get("shopName",""),
                    "company_name": shop.get("companyName",""),
                    "is_factory": shop.get("isFactory",False),
                    "credit_level": shop.get("creditLevel","")
                })
            page += 1
        return {"valid_shop_count": len(shop_result), "shop_data": shop_result}

if __name__ == "__main__":
    client = Ali1688ShopSearch("your_app_key","your_app_secret")
    res = client.search_shop_list("五金配件")
    print("筛选后有效供应商数量：", res["valid_shop_count"])

代码做三处差异化处理：第一，以 memberId 作为唯一标识，集合全局去重，专门解决 B 端动态排序带来的分页偏移重复；第二，增加停业店铺过滤，剔除已经失效的供应商；第三，设置最大页码保护，避免 total 计数不准造成无限空跑。

对接调试要点：签名报错优先核对参数排序、毫秒时间戳；中文关键词不需要手动编码，底层请求库自动处理；不要去掉 sleep，平台会按 app_key 做限流。total 字段仅做参考，业务统计以实际返回并过滤后的数据集为准。

唯品会关键词搜索接口：特卖场景下分页漂移与数据归一化实践

Thu, 20 Aug 2026 17:48:12 +0800

唯品会以特卖闪购为核心，其开放平台关键词搜索接口和普通电商逻辑差异很大。网上多数示例只演示基础调用，忽略特卖商品实时上下架带来的分页漂移、结果重复、混入过期专场商品等生产问题，直接上线会出现数据重复、统计失真。本文不从基础参数讲解切入，聚焦业务侧的去重、异常过滤、签名容错，给出一套可用于选品分析的封装实现。

该接口最大的坑点并非签名本身，而是业务层面：特卖商品会动态上下架，翻页过程中排序发生变动，同一商品会出现在多个页码；同时接口会返回已经结束特卖的商品，如果不做过滤，业务统计会引入大量无效数据。另外时间戳必须使用 13 位毫秒，时间偏差过大会直接鉴权失败，很多示例没有做校验处理。

前置条件：完成开放平台企业认证，申请搜索接口权限，获取 app_key、app_secret，服务器 IP 加入白名单。

python

import requests
import time
import hashlib

class VipKeywordSearch:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://openapi.vip.com/router/rest"
        self.item_set = set()  # 用于去重，解决分页漂移
        self.session = requests.Session()

    def build_sign(self, params):
        # 唯品会签名：按键名ASCII升序排序
        sorted_items = sorted(params.items(), key=lambda x: x[0])
        raw = self.app_secret + "".join(f"{k}{v}" for k, v in sorted_items) + self.app_secret
        return hashlib.md5(raw.encode("utf‑8")).hexdigest().upper()

    def query_page(self, keyword, page, page_size=20):
        timestamp = str(int(time.time() * 1000))
        params = {
            "appKey": self.app_key,
            "method": "vip.item.search",
            "timestamp": timestamp,
            "format": "json",
            "v": "1.0",
            "keyword": keyword,
            "pageNo": page,
            "pageSize": min(page_size,20)
        }
        params["sign"] = self.build_sign(params)
        try:
            resp = self.session.post(self.api_url, data=params, timeout=10)
            return resp.json()
        except Exception:
            return {}

    def search_all(self, keyword):
        result_list = []
        page = 1
        while True:
            time.sleep(1.2) # 适配平台QPS限制
            resp_data = self.query_page(keyword, page)
            resp_body = resp_data.get("vip_item_search_response", {})
            item_list = resp_body.get("itemList", [])
            if not item_list:
                break
            for item in item_list:
                item_id = item.get("itemId")
                if not item_id or item_id in self.item_set:
                    continue
                # 过滤已结束特卖的商品
                if item.get("isOnSale") != 1:
                    continue
                self.item_set.add(item_id)
                result_list.append({
                    "item_id": item_id,
                    "title": item.get("title",""),
                    "sale_price": item.get("salePrice",0),
                    "original_price": item.get("originalPrice",0),
                    "brand": item.get("brandName","")
                })
            total = resp_body.get("total",0)
            if page * 20 >= total:
                break
            page += 1
        return {"count": len(result_list), "goods": result_list}

if __name__ == "__main__":
    client = VipKeywordSearch("your_app_key","your_app_secret")
    res = client.search_all("女士连衣裙")
    print("有效在售商品数量：", res["count"])

代码中核心做了三处业务优化：第一，使用 set 集合保存商品 ID，专门解决特卖场景分页漂移带来的数据重复；第二，增加isOnSale状态过滤，剔除专场结束的失效商品；第三，控制请求间隔，避免触发平台限流风控。

对接调试常见问题：签名报错优先检查参数排序、毫秒时间戳、密钥前后有无空格；返回结果为空，排查 IP 白名单、接口权限是否开通；批量采集时不可去掉 sleep，平台会按 app_key+IP 双重限流。

京东店铺全量商品接口：分页边界修复与数据完整性采集方案

Wed, 19 Aug 2026 17:13:53 +0800

京东店铺商品列表接口（jd.union.open.shop.goods.get）是竞品店铺盘点、铺货监控、店铺商品巡检的核心接口。网上绝大多数教程仅实现基础分页循环调用，完全忽略平台隐性限制：接口存在100页分页上限、超页返回空数据、上下架商品混杂、翻页数据重复漂移等问题，导致批量采集漏数据、数据冗余错乱。本文跳出基础参数教学，聚焦全量数据完整性、分页边界容错、脏数据过滤，提供一套生产级稳定采集封装方案。
该接口区别于关键词搜索接口，可精准抓取指定店铺全部商品，支持区分在售、下架商品，但原生接口无自动终止机制，无脑翻页极易造成任务空跑、数据缺失，是开发对接的核心难点。

一、核心踩坑痛点梳理
1. 分页硬限制：官方隐性限制最大有效页码100，超出后永久返回空列表，普通循环无法抓取全量商品；2. 数据混杂问题：默认返回包含下架、预售商品，干扰正常业务统计；3. 分页漂移：高频翻页易出现商品重复推送，无去重机制会导致数据冗余。

点击获取key和secret
二、生产级完整封装代码

import requests
import time
import hashlib

class JdShopGoodsSpider:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://api.jd.com/routerjson"
        self.goods_ids = set() # 全局去重

    # 标准SHA256签名生成
    def build_sign(self, params):
        sorted_params = sorted(params.items(), key=lambda x:x[0])
        sign_str = self.app_secret + "".join(f"{k}{v}" for k,v in sorted_params) + self.app_secret
        return hashlib.sha256(sign_str.encode()).hexdigest().upper()

    # 单页商品查询
    def query_shop_page(self, shop_id, page, page_size=20):
        timestamp = int(time.time() * 1000)
        params = {
            "app_key": self.app_key,
            "method": "jd.union.open.shop.goods.get",
            "timestamp": str(timestamp),
            "format": "json",
            "v": "1.0",
            "shopId": shop_id,
            "pageIndex": page,
            "pageSize": min(page_size, 20)
        }
        params["sign"] = self.build_sign(params)
        try:
            res = requests.post(self.api_url, data=params, timeout=12)
            return res.json()
        except Exception:
            return {}

    # 全量商品采集（自动终止+去重）
    def get_shop_all_goods(self, shop_id):
        all_goods = []
        max_limit_page = 100 # 官方最大有效页码
        for page in range(1, max_limit_page + 1):
            time.sleep(0.8) # 限流适配
            res_data = self.query_shop_page(shop_id, page)
            resp = res_data.get("jd_union_open_shop_goods_get_response", {})
            goods_list = resp.get("data", [])
            if not goods_list:
                break # 无数据自动终止
            
            for item in goods_list:
                sku_id = item.get("skuId")
                if not sku_id or sku_id in self.goods_ids:
                    continue
                self.goods_ids.add(sku_id)
                all_goods.append({
                    "sku_id": sku_id,
                    "title": item.get("skuName", ""),
                    "price": item.get("price", 0),
                    "sales": item.get("sales", 0),
                    "is_on_sale": True
                })
        return {"total": len(all_goods), "goods_list": all_goods}

if __name__ == "__main__":
    client = JdShopGoodsSpider("你的APP_KEY", "你的APP_SECRET")
    result = client.get_shop_all_goods("目标店铺ID")
    print("店铺有效商品总数：", result["total"])

三、差异化核心优化
1. 分页边界精准控制：锁定官方100页最大阈值，避免无效空跑，同时无数据自动break终止循环，提升采集效率。
2. 双层数据去重：通过SKU全局集合去重，彻底解决接口分页漂移导致的商品重复问题，保证数据唯一性。
3. 限流与容错适配：内置请求间隔，适配平台QPS限制，规避429限流报错，同时兼容空数据、异常返回场景。

四、线上落地总结
京东店铺商品接口最大痛点并非调用逻辑，而是隐性分页限制与数据不稳定问题。本文方案摒弃简单翻页demo，针对性解决漏采、重采、空跑问题，结构化输出纯净在售商品数据。适用于店铺竞品分析、商品盘点、定时巡检等生产场景，稳定性远高于通用基础示例。

微店商品详情接口：私域字段适配与生产级异常自愈方案

Tue, 18 Aug 2026 16:35:25 +0800

微店作为私域电商核心平台，其商品详情接口与主流公域电商接口差异显著。全网多数教程仅实现基础数据拉取，忽略微店独有特性：价格以分为单位、分销佣金字段动态缺失、图文详情分层嵌套、短时效令牌频繁过期、下架商品返回残缺数据。本文摒弃基础调用演示，聚焦私域业务适配+数据矫正+异常自愈，适配店铺搬家、ERP同步、私域选品等生产场景，提供高稳定性封装方案。
微店开放平台详情接口无冗余字段，但存在大量场景化可选参数，批量同步时极易出现程序报错。核心难点集中在单位转换不统一、非在售商品字段缺失、鉴权令牌有效期短三大痛点，也是线上项目高频崩溃的核心原因。

点击获取key和secret
一、生产级封装代码
代码内置令牌预刷新、价格自动换算、空字段兜底、脏数据过滤，适配长期批量同步任务：

import requests
import time

class WeidianItemDetail:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://open.weidian.com/api/v1/product/detail"
        self.access_token = None
        self.expire_time = 0

    # 令牌预刷新，解决短时过期问题
    def get_token(self):
        if self.access_token and time.time() < self.expire_time - 100:
            return self.access_token
        res = requests.post("https://open.weidian.com/oauth2/token", data={
            "app_key": self.app_key,
            "app_secret": self.app_secret,
            "grant_type": "client_credentials"
        }, timeout=12)
        data = res.json()
        self.access_token = data.get("access_token")
        self.expire_time = time.time() + data.get("expires_in", 7200)
        return self.access_token

    # 核心数据归一化矫正
    def parse_detail(self, raw):
        if raw.get("code") != 0:
            return {"status": 0, "msg": raw.get("msg"), "data": None}
        item = raw.get("data", {})
        # 分转元，统一价格单位
        price = round(item.get("price", 0) / 100, 2)
        return {
            "item_id": item.get("item_id"),
            "title": item.get("title", "").strip(),
            "price_yuan": price,
            "original_price": round(item.get("origin_price", 0)/100, 2),
            "stock": item.get("stock_num", 0),
            "sales": item.get("sales_num", 0),
            "commission": round(item.get("commission",0)/100,2),
            "is_on_sale": item.get("status") == 1,
            "main_images": item.get("images", []),
            "detail_content": item.get("detail", "")
        }

    # 商品详情查询入口
    def get_item_info(self, item_id):
        headers = {"Authorization": f"Bearer {self.get_token()}"}
        try:
            resp = requests.get(f"{self.api_url}?item_id={item_id}", headers=headers, timeout=15)
            return self.parse_detail(resp.json())
        except Exception as e:
            return {"status": 0, "msg": f"请求异常：{str(e)}", "data": None}

if __name__ == "__main__":
    client = WeidianItemDetail("你的APP_KEY", "你的APP_SECRET")
    print(client.get_item_info("微店商品ID"))

二、差异化核心优化点
1. 单位统一矫正：针对微店原生价格、佣金以分为单位的特性，自动转换为元，彻底规避业务统计价格倍率错误。
2. 令牌自愈机制：提前100秒预判令牌过期，批量任务全程无需重启，解决微店2小时短时鉴权失效问题。
3. 可选字段兼容：分销佣金、详情内容等非必返字段全部兜底，避免个别商品字段缺失导致程序中断。
三、线上落地避坑要点
微店接口严格绑定店铺授权，跨店铺查询会返回空数据，调用前需匹配授权店铺ID；接口QPS限制较低，批量采集需增设请求间隔。同时下架商品不会直接报错，仅清空核心字段，代码通过在售状态过滤无效数据，保障业务数据纯净度。

淘宝店铺搜索接口实战：关键词检索店铺列表与业务数据归一化处理

Mon, 17 Aug 2026 17:44:50 +0800

前言

多数公开教程只演示简单调用获取原始店铺 json 数据，很少关注业务场景下的痛点：同一关键词返回店铺数据字段参差不齐、分页偏移失效、店铺类型混杂（天猫店、淘宝 C 店、企业店）、部分接口返回冗余嵌套层级深，直接拿到原始数据很难用于数据分析、店铺监控业务。本文从业务落地视角，封装一套具备类型过滤、异常捕获、字段归一化的调用示例，解决直接拿到原始 JSON 无法直接入库的现实问题。

前置准备

调用淘宝开放平台店铺搜索相关接口，需要申请开发者账号，获取 app_key、app_secret，同时申请对应接口权限。接口核心入参包含搜索关键词、页码、每页条数、店铺筛选条件；需要注意接口存在调用 QPS 限制，高频场景必须做请求间隔控制，避免触发平台限流返回错误码。

很多开发者踩坑点：单纯修改 page 参数无限翻页，当到达最大数据阈值后接口不会返回报错，而是重复返回第一页数据，业务层必须增加逻辑识别该现象。

点击获取key和secret

核心 Python 代码示例

import time
import hashlib
import requests

class TaobaoShopSearch:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.api_url = "https://gw.api.taobao.com/router/rest"

    def sign_generate(self, params):
        sorted_items = sorted(params.items())
        raw_str = self.app_secret + "".join([k+str(v) for k,v in sorted_items]) + self.app_secret
        return hashlib.md5(raw_str.encode("utf-8")).hexdigest().upper()

    def search_shop_list(self, keyword, page_no=1, page_size=20, shop_type=None):
        params = {
            "method": "taobao.shop.gets",
            "app_key": self.app_key,
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
            "format": "json",
            "v": "2.0",
            "q": keyword,
            "page_no": page_no,
            "page_size": page_size
        }
        sign = self.sign_generate(params)
        params["sign"] = sign
        resp = requests.get(self.api_url, params=params, timeout=15)
        res_json = resp.json()

        # 接口错误捕获
        if "error_response" in res_json:
            return {"success":False,"msg":res_json["error_response"]["msg"],"data":[]}

        shop_data = res_json.get("shop_gets_response",{}).get("shops",{}).get("shop",[])
        result_list = []
        for shop in shop_data:
            # 字段归一化，统一输出结构便于入库
            item = {
                "shop_id": shop.get("sid"),
                "shop_name": shop.get("title"),
                "shop_type": shop.get("shop_type"),
                "seller_nick": shop.get("nick"),
                "credit_score": shop.get("shop_credit"),
                "province": shop.get("province"),
                "city": shop.get("city")
            }
            # 过滤指定店铺类型
            if shop_type and item["shop_type"] != shop_type:
                continue
            result_list.append(item)
        return {"success":True,"data":result_list}

if __name__ == "__main__":
    client = TaobaoShopSearch(app_key="xxx", app_secret="xxx")
    resp_data = client.search_shop_list(keyword="家居",page_no=1,page_size=20)
    print(resp_data)

代码逻辑解析

签名函数按照开放平台规则对参数排序生成 MD5 签名，是接口请求合法的关键；
增加超时、接口错误返回捕获，不会因为单条接口异常直接中断程序；
对原始嵌套的返回结构做扁平化归一化处理，输出固定字典结构，方便直接写入数据库；
增加店铺类型过滤预留参数，可以按需筛选天猫、企业店铺、个人 C 店。

实际对接踩坑总结

分页陷阱：接口有最大返回数据上限，页码超过阈值不会报错，数据重复，业务代码要对比前后页数据做去重判断；
权限管控：店铺搜索接口不是创建账号就自带，需要在开放平台提交接口权限申请，未申请会返回无权限错误；
QPS 限制，批量采集场景必须加 sleep 间隔，短时间大量请求会被限流；
部分字段非必返回，不要直接取值，统一使用 get () 方式获取，避免 key 不存在直接抛出程序异常。

微店关键词搜索接口：分页黑洞与分销字段归一化实战

Sun, 16 Aug 2026 15:22:03 +0800

微店搜索接口和主流电商存在明显差异，除常规商品基础信息外，自带分销佣金、拼团标记等特有业务字段。很多开发只做简单请求，上线后遇到分页穿透、token 过期无重试、佣金字段缺失、下架商品混入结果集等问题。本文不从基础参数讲解切入，聚焦生产环境的数据清洗、分页边界处理、自动令牌刷新，适配选品系统、ERP 商品同步业务场景。

微店开放平台搜索接口采用 OAuth2 鉴权，access_token 有效期仅 2 小时，批量任务很容易出现中途鉴权失效。另外接口存在分页黑洞：页码超过平台内部阈值，不会返回报错，只会持续返回空列表，若直接循环页码会造成死循环。同时价格单位为分，不做转换直接入库会出现价格放大 100 倍的 bug，分销佣金字段仅部分商品返回，直接读取会触发字典异常。

点击获取key和secret

下面封装类集成 token 自动刷新、分页终止判断、分销字段安全解析、异常重试，过滤已下架商品，输出标准化数据集。

import requests
import time
from urllib.parse import quote

class WeidianKeywordSearch:
    def __init__(self, app_key, app_secret):
        self.app_key = app_key
        self.app_secret = app_secret
        self.token = None
        self.token_expire = 0
        self.search_api = "https://open.weidian.com/api/v1/item/search"

    def _refresh_token(self):
        """自动刷新访问令牌，临近过期主动更新"""
        if self.token and time.time() < self.token_expire - 120:
            return
        resp = requests.post("https://open.weidian.com/oauth2/token", data={
            "app_key": self.app_key,
            "app_secret": self.app_secret,
            "grant_type": "client_credentials"
        }, timeout=12)
        res = resp.json()
        self.token = res.get("access_token")
        self.token_expire = time.time() + res.get("expires_in", 7200)

    def _parse_item(self, raw):
        """字段归一化，处理空值、价格单位转换、分销字段兼容"""
        return {
            "item_id": raw.get("item_id"),
            "title": raw.get("title", "").strip(),
            "price": round(raw.get("price",0)/100,2),
            "sales": raw.get("sales_num",0),
            "main_image": raw.get("cover_image",""),
            "commission_rate": raw.get("commission_rate",0),
            "is_group_buy": bool(raw.get("is_group",0)),
            "stock": raw.get("stock_num",0),
            "is_on_sale": raw.get("status") == 1
        }

    def search(self, keyword, page=1, page_size=20):
        self._refresh_token()
        params = {
            "keyword": quote(keyword),
            "page_no": page,
            "page_size": min(page_size,50)
        }
        headers = {"Authorization": f"Bearer {self.token}"}
        try:
            r = requests.get(self.search_api, params=params, headers=headers, timeout=15)
            json_data = r.json()
            if json_data.get("code") != 0:
                return {"ok":False,"msg":json_data.get("msg"),"data":[],"total":0}
            raw_list = json_data.get("data",{}).get("items",[])
            total = json_data.get("data",{}).get("total",0)
            result = [self._parse_item(i) for i in raw_list if i.get("status")==1]
            return {"ok":True,"msg":"success","data":result,"total":total}
        except Exception as e:
            return {"ok":False,"msg":str(e),"data":[],"total":0}

if __name__ == "__main__":
    client = WeidianKeywordSearch("your_app_key","your_app_secret")
    output = client.search("手提包",page=1,page_size=20)
    print(output)

1688商品详情接口：B端阶梯价格解析与结构化容错实战

Fri, 14 Aug 2026 17:03:44 +0800

1688阿里巴巴商品详情接口与C端电商接口核心差异极大，其主打B端批发模式，存在阶梯价格、起订量限制、混批规则、供应商资质等独有字段。目前多数对接教程仅简单获取原始数据，普遍出现批发价格解析错乱、起订量字段缺失、空规格报错、下架脏数据残留等线上问题。本文跳出基础调用演示，聚焦B端业务特性，实现接口数据标准化清洗与异常容错封装，适配货源采集、供应链比价、商家数据分析场景。
本次对接基于1688开放平台官方详情接口，针对性解决B端核心痛点：多阶梯批发价无法直接读取、SKU规格嵌套不稳定、商品下架后字段残缺、图片鉴权访问异常等高频问题。

一、B端接口核心对接难点
不同于淘宝、京东C端一口价模式，1688接口核心难点集中三点：一是价格为阶梯区间模式，无固定单价，原始字段杂乱；二是商品支持混批、定制、一件代发多种模式，字段返回结构不统一；三是失效商品不会直接报错，仅返回残缺数据，极易导致程序中断。

点击获取key和secret

二、生产级完整封装代码

import requests
import time

class Ali1688DetailClient:
    def __init__(self, app_key, access_token):
        self.app_key = app_key
        self.access_token = access_token
        self.api_url = "https://gw.open.1688.com/openapi/param2/1/com.alibaba.offer.get"

    # 核心：B端数据归一化清洗，适配阶梯价格与空字段
    def parse_offer_data(self, raw_data):
        if not raw_data or raw_data.get("error_code"):
            return {"status":0, "msg":"商品失效或权限异常", "data":None}
        item = raw_data.get("result", {})
        # 解析B端阶梯批发价
        price_range = item.get("priceRanges", [])
        price_list = [{"min_num":p.get("startQuantity"),"price":p.get("price")} for p in price_range]
        
        # 标准化结构化数据
        res = {
            "offer_id": item.get("offerId", ""),
            "title": item.get("subject", "").strip(),
            "min_order": item.get("minOrderQuantity", 0),
            "price_rule": price_list,
            "supplier": item.get("supplier", {}).get("companyName", ""),
            "is_one_piece": item.get("supportOnePiece", False),
            "main_imgs": item.get("imageList", []),
            "is_valid": item.get("isValid", False)
        }
        return {"status":1, "msg":"success", "data":res}

    def get_offer_detail(self, offer_id):
        params = {
            "app_key": self.app_key,
            "access_token": self.access_token,
            "offerId": offer_id,
            "timestamp": int(time.time()*1000)
        }
        try:
            resp = requests.get(self.api_url, params=params, timeout=15)
            return self.parse_offer_data(resp.json())
        except Exception as e:
            return {"status":0, "msg":f"请求异常：{str(e)}", "data":None}

# 调用示例
if __name__ == "__main__":
    client = Ali1688DetailClient("你的APP_KEY", "你的ACCESS_TOKEN")
    result = client.get_offer_detail("1688商品ID")
    print(result)

三、差异化核心优化点
1. 阶梯价格专项解析：专门适配1688独有批量定价规则，拆解起订数量、对应单价，解决B端价格数据错乱问题，满足批发比价业务需求。
2. 全维度容错机制：对下架、失效、权限不足的商品做统一拦截，兼容空数组、空字段场景，彻底避免KeyError程序崩溃。
3. 业务字段精简重构：过滤冗余营销字段，保留起订量、一件代发、批发价等B端核心字段，适配供应链业务场景，减少数据存储压力。

四、线上落地避坑总结
1688接口权限管控严格，未开通对应权限会返回空数据；批量采集需控制QPS，避免高频请求触发限流。同时平台部分商品图片需登录鉴权访问，批量抓取图片时需单独适配。此外，定制类商品无固定阶梯价格，业务端需单独做特殊逻辑处理。
本文方案摒弃基础请求演示，完全围绕B端供应链业务优化，解决原生接口结构不稳定、价格体系复杂的核心痛点，可直接用于线上稳定部署。