一、技术定位与商业价值重构
1688 店铺商品接口（alibaba.item.list.get）作为获取店铺全量商品数据的核心入口，其价值远不止于简单的数据采集。与常规实现不同，本文方案聚焦B 端供应链数据的深度挖掘，通过商品结构化解析、价格策略分析、供应链能力评估三大维度，解决批发商关注的 "店铺品类布局"" 批量采购议价空间 ""供应商履约能力" 等核心问题，构建从数据采集到商业决策的完整技术链路。
区别于网络上常见的基础调用示例，本方案实现三大突破：
- 支持全量商品智能分页（突破单页限制，自动处理百万级商品）
- 构建商品供应链标签体系（生产周期、定制能力、起订量梯度等）
- 实现价格敏感度分析（批量采购优惠力度、价格波动预警）
二、接口权限与技术门槛解析
1. 特殊权限说明
- 个人开发者无法调用，需企业认证账号（提供营业执照）
- 基础权限：仅能获取店铺公开商品（无价格阶梯、库存等核心数据）
- 高级权限：需申请 "诚信通企业会员"，可获取完整交易数据（年费 6688 元起）
- 调用限制：单店铺单日最多 100 次请求，单页最大 50 条（需合理设计分页）
2. 核心参数与 B 端数据维度
| 参数名 | 类型 | 说明 | 批发场景价值 |
|---|---|---|---|
memberId |
String | 店铺 ID（必填） | 唯一标识目标店铺 |
page |
Number | 页码 | 全量数据分页采集 |
pageSize |
Number | 每页条数 | 建议 50（平衡性能与稳定性） |
fields |
String | 字段列表 | 精准控制返回数据（减少冗余） |
startModified |
String | 开始修改时间 | 增量采集（仅获取更新商品） |
categoryId |
Number | 类目 ID | 按品类筛选商品 |
priceType |
String | 价格类型 | 区分批发价 / 代理价 / 定制价 |
点击获取key和secret
三、差异化技术实现：从数据采集到智能分析
1. 全量商品智能采集引擎
突破常规分页限制，实现百万级商品自动采集，包含增量更新机制：
python
运行
import time
import hashlib
import requests
import json
import logging
from typing import Dict, List, Optional, Generator
from datetime import datetime, timedelta
from decimal import Decimal
import pandas as pd
from tqdm import tqdm
# 配置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
class AlibabaStoreProductAPI:
def __init__(self, app_key: str, app_secret: str, access_token: str):
self.app_key = app_key
self.app_secret = app_secret
self.access_token = access_token
self.api_url = "https://gw.open.1688.com/openapi/param2/1/com.alibaba.product/alibaba.item.list.get"
self.session = self._init_session()
# 核心字段配置（B端场景必备）
self.core_fields = (
"id,title,mainImageUrl,priceRange,minOrderQuantity,priceType,"
"categoryId,categoryName,specInfo,saleInfo,supplyAbility,"
"customization,supplierId,modifiedTime,tradeType,skuInfo"
)
def _init_session(self) -> requests.Session:
"""初始化会话，配置连接池与超时"""
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(
pool_connections=10,
pool_maxsize=30,
max_retries=3
)
session.mount('https://', adapter)
return session
def _generate_sign(self, params: Dict) -> str:
"""生成1688签名（SHA1算法）"""
sorted_params = sorted(params.items(), key=lambda x: x[0])
sign_str = self.app_secret
for k, v in sorted_params:
if isinstance(v, bool):
value = "true" if v else "false"
else:
value = str(v)
sign_str += f"{k}{value}"
sign_str += self.app_secret
return hashlib.sha1(sign_str.encode('utf-8')).hexdigest().upper()
def _parse_single_product(self, raw_product: Dict) -> Dict:
"""解析单个商品数据，提取B端关键信息"""
# 解析价格阶梯
price_ladder = self._parse_price_ladder(raw_product.get("priceRange", ""))
# 解析SKU信息
skus = self._parse_skus(raw_product.get("skuInfo", {}))
# 解析供应能力
supply_ability = self._parse_supply_ability(raw_product.get("supplyAbility", {}))
# 解析定制信息
customization = self._parse_customization(raw_product.get("customization", {}))
# 解析销售信息
sale_info = raw_product.get("saleInfo", {})
return {
"product_id": raw_product.get("id", ""),
"title": raw_product.get("title", ""),
"main_image": raw_product.get("mainImageUrl", ""),
"category_id": raw_product.get("categoryId", ""),
"category_name": raw_product.get("categoryName", ""),
"price_type": raw_product.get("priceType", "wholesale"),
"price_ladder": price_ladder,
"min_order_quantity": raw_product.get("minOrderQuantity", 1),
"trade_type": raw_product.get("tradeType", []), # 支持的交易类型
"spec_info": raw_product.get("specInfo", {}), # 规格信息
"skus": skus,
"month_sales": sale_info.get("monthSalesCount", 0), # 月销量
"total_sales": sale_info.get("totalSalesCount", 0), # 总销量
"supply_ability": supply_ability,
"customization": customization,
"modified_time": raw_product.get("modifiedTime", ""), # 最后修改时间
"supplier_id": raw_product.get("supplierId", "")
}
def get_store_products(self, member_id: str,** kwargs) -> Generator[Dict, None, None]:
"""
全量获取店铺商品，支持分页与增量采集
:param member_id: 店铺memberId
:param **kwargs: 可选参数
- start_page: 起始页码
- page_size: 每页条数（最大50）
- start_modified: 开始修改时间（增量采集）
- category_id: 类目ID筛选
- max_pages: 最大采集页数（防止无限循环）
:return: 生成器，逐件返回商品数据
"""
page = kwargs.get("start_page", 1)
page_size = min(kwargs.get("page_size", 50), 50) # 最大50
max_pages = kwargs.get("max_pages", 1000) # 防止无限循环
start_modified = kwargs.get("start_modified")
category_id = kwargs.get("category_id")
while page <= max_pages:
try:
# 构建请求参数
params = {
"app_key": self.app_key,
"access_token": self.access_token,
"timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
"format": "json",
"v": "1.0",
"sign_method": "sha1",
"memberId": member_id,
"page": page,
"pageSize": page_size,
"fields": self.core_fields
}
# 添加可选参数
if start_modified:
params["startModified"] = start_modified
if category_id:
params["categoryId"] = category_id
# 生成签名
params["sign"] = self._generate_sign(params)
# 发送请求
response = self.session.get(
self.api_url,
params=params,
timeout=(10, 30)
)
response.raise_for_status()
result = response.json()
# 处理API错误
if "error_response" in result:
error = result["error_response"]
logger.error(f"API错误: {error.get('msg')} (代码: {error.get('code')})")
# 权限错误直接终止
if error.get('code') in [400, 401, 403]:
break
# 其他错误重试
time.sleep(3)
continue
# 解析结果
data = result.get("result", {})
products = data.get("products", {}).get("product", [])
total_count = data.get("totalResults", 0)
total_pages = (total_count + page_size - 1) // page_size
logger.info(f"采集进度: 第{page}/{total_pages}页，本页{len(products)}件，总计{total_count}件")
# 处理商品数据
for product in products:
yield self._parse_single_product(product)
# 分页控制
if page >= total_pages or len(products) < page_size:
logger.info(f"店铺{member_id}商品采集完成，共{total_count}件")
break
page += 1
# 控制请求频率（避免触发限流）
time.sleep(1.5)
except requests.exceptions.RequestException as e:
logger.error(f"请求异常: {str(e)}，将重试第{page}页")
time.sleep(5)
except Exception as e:
logger.error(f"处理异常: {str(e)}，将跳过第{page}页")
page += 1
time.sleep(3)2. 供应链数据深度解析模块
针对 B 端采购需求，解析商品的价格策略、供应能力和定制属性：
python
运行
def _parse_price_ladder(self, price_range: str) -> List[Dict]:
"""解析价格阶梯，计算批量采购优惠力度"""
if not price_range:
return []
import re
ladder_pattern = re.compile(r'(\d+)(?:-(\d+))?件(?:以上|以下)?:¥?(\d+\.\d+)')
ladders = []
for ladder_str in price_range.split(';'):
match = ladder_pattern.match(ladder_str.strip())
if match:
min_qty = int(match.group(1))
max_qty = int(match.group(2)) if match.group(2) else None
price = Decimal(match.group(3))
ladders.append({
"min_qty": min_qty,
"max_qty": max_qty,
"price": price,
"discount": 0 # 后续计算
})
# 计算折扣（相对于最小起订量价格）
if ladders:
base_price = ladders[0]["price"]
for ladder in ladders:
ladder["discount"] = round(float(ladder["price"] / base_price), 4)
return ladders
def _parse_skus(self, sku_info: Dict) -> List[Dict]:
"""解析SKU信息，提取规格与价格对应关系"""
skus = []
sku_list = sku_info.get("skuArray", [])
for sku in sku_list:
# 解析SKU规格（如颜色、尺寸等）
specs = []
for spec in sku.get("specs", []):
specs.append({
"name": spec.get("specName", ""),
"value": spec.get("specValue", "")
})
skus.append({
"sku_id": sku.get("skuId", ""),
"specs": specs,
"price": Decimal(str(sku.get("price", 0))),
"stock": sku.get("stock", 0),
"image": sku.get("imageUrl", "")
})
return skus
def _parse_supply_ability(self, supply_data: Dict) -> Dict:
"""解析供应能力，评估供应商履约能力"""
# 转换产能单位
capacity_unit = supply_data.get("unit", "件/月")
monthly_capacity = supply_data.get("monthly", 0)
# 评估产能等级
capacity_level = "低"
if monthly_capacity > 10000:
capacity_level = "高"
elif monthly_capacity > 1000:
capacity_level = "中"
return {
"monthly_capacity": monthly_capacity,
"unit": capacity_unit,
"capacity_level": capacity_level,
"lead_time": supply_data.get("leadTime", "未知"), # 生产周期
"packaging": supply_data.get("packaging", "未知") # 包装信息
}
def _parse_customization(self, custom_data: Dict) -> Dict:
"""解析定制信息，构建定制能力矩阵"""
# 定制服务类型映射
service_map = {
"supportOem": "支持OEM",
"supportOdm": "支持ODM",
"supportSample": "支持打样",
"supportPrint": "支持印刷"
}
supported_services = []
for key, label in service_map.items():
if custom_data.get(key, False):
supported_services.append(label)
# 定制难度评估
difficulty = "简单"
if custom_data.get("minOrder", 0) > 1000:
difficulty = "复杂"
elif custom_data.get("minOrder", 0) > 500:
difficulty = "中等"
return {
"supported": len(supported_services) > 0,
"services": supported_services,
"min_order": custom_data.get("minOrder", 0),
"sample_fee": Decimal(str(custom_data.get("sampleFee", 0))),
"sample_days": custom_data.get("sampleDays", 0), # 打样周期
"difficulty": difficulty
}3. 商业智能分析引擎
基于采集的商品数据，实现供应链决策支持：
python
运行
def analyze_store_strategy(self, products: List[Dict]) -> Dict:
"""分析店铺经营策略，生成供应链评估报告"""
if not products:
return {"error": "无商品数据可分析"}
# 1. 品类结构分析
category_stats = {}
for p in products:
cat_name = p["category_name"]
if cat_name not in category_stats:
category_stats[cat_name] = {
"count": 0,
"avg_price": [],
"total_sales": 0
}
category_stats[cat_name]["count"] += 1
if p["price_ladder"]:
category_stats[cat_name]["avg_price"].append(p["price_ladder"][0]["price"])
category_stats[cat_name]["total_sales"] += p["total_sales"]
# 处理品类统计数据
for cat in category_stats:
prices = category_stats[cat]["avg_price"]
category_stats[cat]["avg_price"] = round(sum(prices)/len(prices), 2) if prices else 0
category_stats[cat]["proportion"] = round(
category_stats[cat]["count"] / len(products) * 100, 1
)
# 2. 价格策略分析
price_strategy = self._analyze_price_strategy(products)
# 3. 供应能力评估
supply_analysis = self._analyze_supply_capability(products)
# 4. 定制服务评估
custom_analysis = self._analyze_custom_services(products)
# 5. 核心商品识别（销量与供应能力双高）
core_products = self._identify_core_products(products)
return {
"basic_stats": {
"total_products": len(products),
"category_count": len(category_stats),
"update_rate": self._calculate_update_rate(products),
"has_custom_services": any(p["customization"]["supported"] for p in products)
},
"category_structure": category_stats,
"price_strategy": price_strategy,
"supply_capability": supply_analysis,
"custom_services": custom_analysis,
"core_products": core_products[:5] # 取前5名核心商品
}
def _analyze_price_strategy(self, products: List[Dict]) -> Dict:
"""分析店铺价格策略，评估批量采购优惠力度"""
ladder_counts = []
discount_rates = []
for p in products:
ladders = p["price_ladder"]
if len(ladders) > 1:
ladder_counts.append(len(ladders))
# 计算最大批量相对于最小批量的折扣率
max_discount = min(ladder["discount"] for ladder in ladders)
discount_rates.append(1 - max_discount)
# 价格敏感度分析（批量采购优惠力度）
sensitivity_level = "低" # 优惠小，价格不敏感
if discount_rates:
avg_discount = sum(discount_rates) / len(discount_rates)
if avg_discount > 0.2:
sensitivity_level = "高" # 优惠大，价格敏感
elif avg_discount > 0.1:
sensitivity_level = "中"
return {
"avg_ladder_levels": round(sum(ladder_counts)/len(ladder_counts), 1) if ladder_counts else 1,
"batch_discount_level": sensitivity_level,
"avg_batch_discount": round(sum(discount_rates)/len(discount_rates)*100, 1) if discount_rates else 0,
"min_order_distribution": self._get_order_distribution(products)
}
def _analyze_supply_capability(self, products: List[Dict]) -> Dict:
"""评估店铺整体供应能力"""
capacities = []
lead_times = []
for p in products:
cap = p["supply_ability"]["monthly_capacity"]
if cap > 0:
capacities.append(cap)
lead_time = p["supply_ability"]["lead_time"]
if lead_time and lead_time != "未知":
lead_times.append(lead_time)
# 生产周期分析
lead_time_stats = {}
for lt in lead_times:
lead_time_stats[lt] = lead_time_stats.get(lt, 0) + 1
return {
"avg_monthly_capacity": round(sum(capacities)/len(capacities), 0) if capacities else 0,
"capacity_level_distribution": {
"高": sum(1 for p in products if p["supply_ability"]["capacity_level"] == "高"),
"中": sum(1 for p in products if p["supply_ability"]["capacity_level"] == "中"),
"低": sum(1 for p in products if p["supply_ability"]["capacity_level"] == "低")
},
"lead_time_stats": lead_time_stats,
"shortest_lead_time": min(lead_times) if lead_times else "未知"
}
def _analyze_custom_services(self, products: List[Dict]) -> Dict:
"""分析店铺定制服务能力"""
custom_products = [p for p in products if p["customization"]["supported"]]
service_stats = {}
for p in custom_products:
for service in p["customization"]["services"]:
service_stats[service] = service_stats.get(service, 0) + 1
# 定制难度分布
difficulty_dist = {
"简单": 0,
"中等": 0,
"复杂": 0
}
for p in custom_products:
difficulty_dist[p["customization"]["difficulty"]] += 1
return {
"custom_product_ratio": round(len(custom_products)/len(products)*100, 1) if products else 0,
"service_popularity": sorted(service_stats.items(), key=lambda x: x[1], reverse=True),
"difficulty_distribution": difficulty_dist,
"avg_sample_fee": round(sum(p["customization"]["sample_fee"] for p in custom_products)/len(custom_products), 2) if custom_products else 0
}
def _identify_core_products(self, products: List[Dict]) -> List[Dict]:
"""识别核心商品（销量高且供应能力强）"""
scored_products = []
for p in products:
# 销量得分（30%）
sales_score = min(p["total_sales"] / 1000, 1) * 30 if p["total_sales"] > 0 else 0
# 供应能力得分（30%）
cap = p["supply_ability"]["monthly_capacity"]
cap_score = min(cap / 10000, 1) * 30 if cap > 0 else 0
# 价格优势得分（20%）
price_score = 0
if p["price_ladder"] and len(p["price_ladder"]) > 1:
price_score = (1 - min(l["discount"] for l in p["price_ladder"])) * 20
# 定制能力得分（20%）
custom_score = 20 if p["customization"]["supported"] else 0
total_score = round(sales_score + cap_score + price_score + custom_score, 1)
scored_products.append({
**{k: p[k] for k in ["product_id", "title", "total_sales", "main_image"]},
"score": total_score,
"sales_score": round(sales_score, 1),
"cap_score": round(cap_score, 1)
})
# 按总分排序
return sorted(scored_products, key=lambda x: x["score"], reverse=True)
def _calculate_update_rate(self, products: List[Dict]) -> Dict:
"""计算商品更新频率"""
if not products:
return {"error": "无商品数据"}
# 解析修改时间
modified_dates = []
for p in products:
try:
dt = datetime.strptime(p["modified_time"], "%Y-%m-%d %H:%M:%S")
modified_dates.append(dt)
except:
continue
if not modified_dates:
return {"recent_30_days": 0}
# 计算近30天更新商品比例
recent_date = datetime.now() - timedelta(days=30)
recent_updates = sum(1 for dt in modified_dates if dt >= recent_date)
return {
"total_updated": len(modified_dates),
"recent_30_days": round(recent_updates / len(modified_dates) * 100, 1)
}
def _get_order_distribution(self, products: List[Dict]) -> Dict:
"""分析最小起订量分布"""
distribution = {
"1-10件": 0,
"11-50件": 0,
"51-100件": 0,
"101-500件": 0,
"501件以上": 0
}
for p in products:
min_order = p["min_order_quantity"]
if min_order <= 10:
distribution["1-10件"] += 1
elif min_order <= 50:
distribution["11-50件"] += 1
elif min_order <= 100:
distribution["51-100件"] += 1
elif min_order <= 500:
distribution["101-500件"] += 1
else:
distribution["501件以上"] += 1
return distribution四、完整应用示例与结果解析
python
运行
def export_analysis_report(self, analysis: Dict, export_path: str) -> bool:
"""导出分析报告为Excel"""
try:
with pd.ExcelWriter(export_path) as writer:
# 1. 基本统计
pd.DataFrame([analysis["basic_stats"]]).to_excel(writer, sheet_name="基本统计", index=False)
# 2. 品类结构
pd.DataFrame.from_dict(analysis["category_structure"], orient="index").to_excel(writer, sheet_name="品类结构")
# 3. 价格策略
pd.DataFrame([analysis["price_strategy"]]).to_excel(writer, sheet_name="价格策略", index=False)
# 4. 供应能力
pd.DataFrame([analysis["supply_capability"]]).to_excel(writer, sheet_name="供应能力", index=False)
# 5. 定制服务
pd.DataFrame([analysis["custom_services"]]).to_excel(writer, sheet_name="定制服务", index=False)
# 6. 核心商品
pd.DataFrame(analysis["core_products"]).to_excel(writer, sheet_name="核心商品", index=False)
logger.info(f"分析报告已导出至: {export_path}")
return True
except Exception as e:
logger.error(f"导出报告失败: {str(e)}")
return False
# 调用示例
if __name__ == "__main__":
# 初始化API客户端
APP_KEY = "your_enterprise_app_key"
APP_SECRET = "your_enterprise_app_secret"
ACCESS_TOKEN = "your_access_token"
api = AlibabaStoreProductAPI(APP_KEY, APP_SECRET, ACCESS_TOKEN)
# 目标店铺memberId（可从店铺首页URL获取）
TARGET_STORE_ID = "b2b-123456789"
try:
# 1. 全量采集店铺商品（支持增量采集）
print("===== 开始采集店铺商品 =====")
# 增量采集：仅获取近30天更新的商品
thirty_days_ago = (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d %H:%M:%S")
# 使用生成器逐件处理商品
products = []
for product in tqdm(
api.get_store_products(
member_id=TARGET_STORE_ID,
start_modified=thirty_days_ago,
page_size=50
),
desc="采集商品"
):
products.append(product)
print(f"成功采集 {len(products)} 件商品")
# 2. 分析店铺经营策略
if products:
print("\n===== 开始分析店铺数据 =====")
analysis = api.analyze_store_strategy(products)
# 3. 输出关键分析结果
print("\n===== 店铺核心分析结果 =====")
print(f"1. 基本情况: 共{analysis['basic_stats']['total_products']}件商品，"
f"{analysis['basic_stats']['category_count']}个品类，"
f"近30天更新率{analysis['basic_stats']['update_rate']['recent_30_days']}%")
print("\n2. 品类结构（前三名）:")
top_categories = sorted(
analysis["category_structure"].items(),
key=lambda x: x[1]["count"],
reverse=True
)[:3]
for i, (cat_name, stats) in enumerate(top_categories, 1):
print(f" {i}. {cat_name}: {stats['count']}件 ({stats['proportion']}%)，"
f"均价¥{stats['avg_price']}，总销量{stats['total_sales']}")
print("\n3. 价格策略:")
print(f" 批量采购优惠力度: {analysis['price_strategy']['batch_discount_level']} "
f"(平均{analysis['price_strategy']['avg_batch_discount']}%)")
print(f" 最小起订量分布: {analysis['price_strategy']['min_order_distribution']}")
print("\n4. 供应能力:")
print(f" 平均月产能: {analysis['supply_capability']['avg_monthly_capacity']}件，"
f"最短生产周期: {analysis['supply_capability']['shortest_lead_time']}")
print("\n5. 定制服务:")
print(f" 支持定制商品比例: {analysis['custom_services']['custom_product_ratio']}%，"
f"热门服务: {[s[0] for s in analysis['custom_services']['service_popularity'][:3]]}")
# 6. 导出分析报告
export_path = f"1688_store_analysis_{TARGET_STORE_ID}.xlsx"
if api.export_analysis_report(analysis, export_path):
print(f"\n分析报告已导出至: {export_path}")
except Exception as e:
print(f"执行出错: {str(e)}")五、技术亮点与商业应用
本方案与常规实现的核心差异体现在三个维度：
-
智能采集引擎
- 增量更新机制：通过
start_modified参数仅采集近 30 天更新商品，减少 70% 数据传输量 - 抗限流设计：自动控制请求频率，失败自动重试，确保百万级商品完整采集
- 生成器模式：逐件处理商品，避免内存溢出（尤其适合大型店铺）
- 增量更新机制：通过
-
供应链数据解析
- 价格阶梯深度解析：不仅提取价格区间，还计算批量采购折扣率，直接指导议价
- 供应能力量化：将模糊的 "产能充足" 转化为具体的 "月产能 10000 件 + 生产周期 7 天"
- 定制能力矩阵：从服务类型、起订量、打样周期等多维度评估供应商定制实力
-
商业智能分析
- 核心商品识别：通过销量、供应能力、价格优势、定制能力四维度评分，精准定位店铺主力商品
- 价格敏感度分析：量化批量采购优惠力度，判断供应商价格策略（刚性 / 弹性）
- 全维度 Excel 报告：自动生成可直接用于决策的分析文档，包含 6 大模块 18 项关键指标
六、使用说明与扩展建议
- 环境依赖：Python 3.8+，需安装
requests、pandas、tqdm库（pip install requests pandas tqdm） - 权限获取：登录 1688 开放平台（open.1688.com），注册企业账号并申请
alibaba.item.list.get接口权限 - 店铺 ID 获取：从店铺首页 URL 提取（如
https://xxx.1688.com中的xxx即为 memberId）