干了十幾年程序員，大半精力扎在 B2B 電商數(shù)據(jù)領(lǐng)域 —— 從早年手寫爬蟲抓 1688 商品圖，到如今深度對(duì)接拍立淘接口（官方名alibaba.image.search.product），光這一個(gè)接口就踩過(guò) 20 多個(gè)坑。比如第一次傳透明背景的產(chǎn)品圖，接口直接返回 “無(wú)效圖像”；還有次沒(méi)做圖像預(yù)處理，找同款工廠的匹配度只有 30%，折騰半天才發(fā)現(xiàn)是對(duì)比度不夠。今天把這些年沉淀的實(shí)戰(zhàn)方案掏出來(lái)，不管是做批發(fā)采購(gòu)工具，還是供應(yīng)鏈對(duì)接，新手照做能少走兩年彎路。

一、接口核心價(jià)值：B2B 場(chǎng)景的 “看圖找廠” 剛需

1688 的拍立淘https://o0b.cn/lin和淘寶的 C 端拍立淘完全是兩碼事 —— 后者只幫你找同款商品，前者能按 “生產(chǎn)能力、起訂量、定制服務(wù)” 這些 B 端維度篩選，相當(dāng)于給批發(fā)商裝了個(gè) “看圖找廠” 的放大鏡。這幾年做過(guò)的 90 + 供應(yīng)鏈項(xiàng)目里，不管是服裝批發(fā)商 “按樣找代工廠”，還是五金商家 “看圖找源頭廠”，缺了這個(gè)接口根本玩不轉(zhuǎn)。

但它的技術(shù)難點(diǎn)也很突出：工業(yè)品圖像（比如五金件、面料）細(xì)節(jié)多，直接上傳原圖識(shí)別率低；接口默認(rèn)排序只看相似度，不區(qū)分 “貿(mào)易公司” 和 “源頭工廠”，批發(fā)商要手動(dòng)篩半天；更麻煩的是定制能力識(shí)別，接口返回的信息太零散，得自己拼出供應(yīng)商能不能 “來(lái)樣加工”—— 這些都是我早年踩過(guò)的硬坑，今天按實(shí)戰(zhàn)邏輯拆。

二、接口調(diào)用避坑：B2B 專屬的權(quán)限與參數(shù)門道

1. 權(quán)限申請(qǐng)的 “隱形門檻”（踩過(guò)的坑總結(jié)）

1688 拍立淘接口不是誰(shuí)都能申請(qǐng)，早年用個(gè)人賬號(hào)提交 3 次全被拒，后來(lái)才摸清規(guī)則：

資質(zhì)硬要求：必須企業(yè)認(rèn)證（個(gè)人開發(fā)者直接 pass），得傳營(yíng)業(yè)執(zhí)照，經(jīng)營(yíng)范圍里要有 “批發(fā)”“采購(gòu)” 相關(guān)類目，不然審核必拒；

版本差異坑：基礎(chǔ)版（年費(fèi) 2800 元）只認(rèn)白底產(chǎn)品圖，場(chǎng)景圖、細(xì)節(jié)圖傳了也白傳；增強(qiáng)版（年費(fèi) 9800 元）支持多圖類型，但每日限額 500 次，得按需求選，別花冤枉錢；

圖像格式坑：分辨率必須 800×800 以上，但也別超 2MB（早年傳了 3MB 的高清圖，接口直接超時(shí)），格式只認(rèn) JPG/PNG，WebP 格式得先轉(zhuǎn)碼。

2. 核心參數(shù)實(shí)戰(zhàn)對(duì)照表（實(shí)測(cè) 150 + 次）

早年沒(méi)填 cat_id，搜 “純棉 T 恤” 返回 200 條結(jié)果，其中 120 條是 T 恤印花設(shè)備，白折騰半天 —— 這參數(shù)千萬(wàn)別??！

三、核心技術(shù)實(shí)現(xiàn)：從圖像優(yōu)化到工廠排序（附可跑代碼）

1. 圖像預(yù)處理：識(shí)別率從 40% 提到 75% 的關(guān)鍵

直接傳原圖是新手最常犯的錯(cuò)，我封裝的這個(gè)預(yù)處理工具，解決了透明背景、對(duì)比度低、尺寸不統(tǒng)一三大坑：

import time
import hashlib
import requests
import base64
import io
from PIL import Image, ImageEnhance
import numpy as np
import json
from typing import Dict, List, Optional
from decimal import Decimal
class AlibabaImageSearchAPI:
    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.image.search.product"
        self.session = self._init_session()
    def _init_session(self) -> requests.Session:
        """初始化會(huì)話：早年沒(méi)設(shè)連接池，并發(fā)調(diào)用時(shí)頻繁斷連，現(xiàn)在穩(wěn)定多了"""
        session = requests.Session()
        adapter = requests.adapters.HTTPAdapter(
            pool_connections=15,
            pool_maxsize=50,
            max_retries=3  # 失敗自動(dòng)重試3次，應(yīng)對(duì)接口偶爾抽風(fēng)
        )
        session.mount('https://', adapter)
        return session
    def _preprocess_image(self, image_path: str, is_product: bool = True) -> str:
        """
        圖像預(yù)處理：B2B工業(yè)品專屬優(yōu)化，識(shí)別率提35%
        :param image_path: 本地圖像路徑
        :param is_product: True=產(chǎn)品圖，F(xiàn)alse=場(chǎng)景圖/細(xì)節(jié)圖
        """
        try:
            with Image.open(image_path) as img:
                # 坑點(diǎn)1：處理透明背景（接口不認(rèn)RGBA格式，早年踩過(guò)）
                if img.mode in ('RGBA', 'LA'):
                    background = Image.new(img.mode[:-1], img.size, (255, 255, 255))  # 白底填充
                    background.paste(img, img.split()[-1])
                    img = background
                elif img.mode == 'P':  # 調(diào)色板模式轉(zhuǎn)RGB
                    img = img.convert('RGB')
                # 坑點(diǎn)2：統(tǒng)一尺寸（太大超時(shí)，太小模糊）
                max_size = 1200  # 實(shí)測(cè)這個(gè)尺寸兼顧精度和速度
                width, height = img.size
                if max(width, height) > max_size:
                    ratio = max_size / max(width, height)
                    img = img.resize((int(width * ratio), int(height * ratio)), Image.LANCZOS)  # 抗鋸齒縮放
                # 坑點(diǎn)3：按圖像類型優(yōu)化（產(chǎn)品圖提對(duì)比度，細(xì)節(jié)圖提銳度）
                if is_product:
                    # 產(chǎn)品圖：增強(qiáng)對(duì)比度，突出輪廓（比如五金件的邊角）
                    enhancer = ImageEnhance.Contrast(img)
                    img = enhancer.enhance(1.2)
                else:
                    # 細(xì)節(jié)圖：增強(qiáng)銳度，突出工藝（比如面料紋理、印刷細(xì)節(jié)）
                    enhancer = ImageEnhance.Sharpness(img)
                    img = enhancer.enhance(1.3)
                # 轉(zhuǎn)Base64（接口只認(rèn)這個(gè)格式）
                buffer = io.BytesIO()
                img.save(buffer, format='JPEG', quality=90)  # 質(zhì)量90%，文件控制在500KB內(nèi)
                return base64.b64encode(buffer.getvalue()).decode('utf-8')
        except Exception as e:
            raise ValueError(f"圖像預(yù)處理失敗：{str(e)}（早年傳WebP格式報(bào)過(guò)這錯(cuò)，記得轉(zhuǎn)JPG）")

2. 工廠優(yōu)先排序：解決接口默認(rèn)排序 “不分廠貿(mào)” 的坑

接口默認(rèn)按相似度排序，經(jīng)常把貿(mào)易公司排前面，批發(fā)商要手動(dòng)篩 —— 我寫的這個(gè)排序算法，按 “源頭工廠＞認(rèn)證工廠＞貿(mào)易公司” 權(quán)重，結(jié)合定制能力和價(jià)格，直接出最優(yōu)供應(yīng)商列表：

def _factory_priority_sort(self, products: List[Dict]) -> List[Dict]:
        """
        工廠優(yōu)先排序：B2B采購(gòu)最實(shí)用的排序邏輯
        核心權(quán)重：供應(yīng)商類型（40%）＞定制能力（25%）＞價(jià)格優(yōu)勢(shì)（20%）＞起訂量（15%）
        """
        if not products:
            return []
        scored_products = []
        for product in products:
            supplier = product.get("supplier", {})
            score = 0
            # 1. 供應(yīng)商類型得分（40分，源頭工廠最優(yōu)先）
            supplier_type = supplier.get("type", "")
            if supplier_type == "源頭工廠":
                score += 40
                # 額外加5分：有工廠認(rèn)證的（比如ISO9001）
                if "工廠認(rèn)證" in supplier.get("certifications", []):
                    score += 5
            elif supplier_type == "生產(chǎn)廠家":
                score += 30
            elif supplier_type == "品牌商":
                score += 20
            else:  # 貿(mào)易公司、經(jīng)銷商
                score += 10
            # 2. 定制能力得分（25分，來(lái)樣加工是B2B剛需）
            custom_info = product.get("customization", {})
            if custom_info.get("supported", False):
                score += 10
            if "來(lái)樣加工" in custom_info.get("services", []):
                score += 8
            # 小批量定制加分（比如起訂量＜500件）
            if custom_info.get("min_order", 1000) < 500:
                score += 7
            # 3. 價(jià)格優(yōu)勢(shì)得分（20分，按100件采購(gòu)價(jià)算）
            price_100 = self._get_price_for_qty(product.get("price_ladder", []), 100)
            avg_price = self._calculate_average_price(products)  # 同類產(chǎn)品均價(jià)
            if price_100 < avg_price * 0.9:  # 比均價(jià)低10%以上
                score += 20
            elif price_100 < avg_price * 0.95:  # 低5%-10%
                score += 15
            elif price_100 <= avg_price:  # 持平均價(jià)
                score += 10
            # 4. 起訂量合理性得分（15分，符合采購(gòu)規(guī)模最加分）
            min_order = product.get("min_order_quantity", 1)
            if min_order <= 50:  # 小批量友好
                score += 15
            elif min_order <= 100:
                score += 12
            elif min_order <= 500:
                score += 8
            else:  # 大批量（＞500件）
                score += 5
            # 加總分到商品數(shù)據(jù)里
            scored_products.append({
                **product,
                "sort_info": {
                    "total_score": score,
                    "supplier_type_score": score - (score - (40 if supplier_type == "源頭工廠" else 30)),  # 拆分得分
                    "custom_score": 25 if custom_info.get("supported") else 0
                }
            })
        # 按總分降序排列，優(yōu)先推薦高分工廠
        return sorted(scored_products, key=lambda x: x["sort_info"]["total_score"], reverse=True)
    def _get_price_for_qty(self, price_ladder: List[Dict], qty: int) -?> Decimal:
        """輔助函數(shù)：根據(jù)采購(gòu)量拿對(duì)應(yīng)單價(jià)（比如100件的批發(fā)價(jià)）"""
        if not price_ladder:
            return Decimal("0.00")
        # 遍歷價(jià)格階梯，找對(duì)應(yīng)區(qū)間
        for ladder in price_ladder:
            min_q = ladder["min_qty"]
            max_q = ladder["max_qty"] if ladder["max_qty"] is not None else float('inf')
            if min_q <= qty <= max_q:
                return Decimal(str(ladder["price"]))
        # 超過(guò)最大階梯，拿最高量的價(jià)格
        return Decimal(str(price_ladder[-1]["price"]))
    def _calculate_average_price(self, products: List[Dict]) -?> Decimal:
        """輔助函數(shù)：算同類產(chǎn)品的100件采購(gòu)均價(jià)"""
        prices = []
        for p in products:
            price = self._get_price_for_qty(p.get("price_ladder", []), 100)
            if price > 0:
                prices.append(price)
        return sum(prices) / len(prices) if prices else Decimal("0.00")

3. 完整搜索實(shí)現(xiàn)：從圖像到供應(yīng)鏈匹配的閉環(huán)

def search_by_image(self, image_path: str, is_product: bool = True, **kwargs) -> Dict:
        """
        核心方法：完整的圖像搜索+供應(yīng)鏈匹配
        :param image_path: 圖像路徑
        :param is_product: 是否為產(chǎn)品圖（False=細(xì)節(jié)圖/場(chǎng)景圖）
        :param kwargs: 篩選參數(shù)（cat_id、min_order、region等）
        """
        try:
            # 1. 圖像預(yù)處理（關(guān)鍵步驟，早年沒(méi)做這步識(shí)別率慘不忍睹）
            image_base64 = self._preprocess_image(image_path, is_product)
            # 2. 構(gòu)建請(qǐng)求參數(shù)
            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",
                "image": image_base64,
                "page": kwargs.get("page", 1),
                "page_size": kwargs.get("page_size", 20),
                # 必拿B2B字段：別漏了供應(yīng)商類型、定制能力、價(jià)格階梯
                "fields": "product_id,title,main_image,price_ladder,min_order_quantity,"
                          "supplier_info,customization,similarity,category_id"
            }
            # 3. 加篩選條件（按采購(gòu)需求填）
            if "cat_id" in kwargs:
                params["cat_id"] = kwargs["cat_id"]
            if "min_order" in kwargs:
                params["min_order"] = kwargs["min_order"]
            if "supplier_type" in kwargs:
                params["supplier_type"] = kwargs["supplier_type"]
            if kwargs.get("need_custom", False):  # 需要定制就加這個(gè)
                params["custom_type"] = "sample"
            if "region" in kwargs:
                params["region"] = kwargs["region"]
            # 4. 生成簽名（SHA1算法，早年拼錯(cuò)參數(shù)順序報(bào)過(guò)100次錯(cuò)）
            params["sign"] = self._generate_sign(params)
            # 5. 發(fā)送請(qǐng)求（圖像搜索慢，超時(shí)設(shè)長(zhǎng)點(diǎn)）
            response = self.session.post(
                self.api_url,
                data=params,
                timeout=(10, 30)  # 連接10秒，讀取30秒
            )
            response.raise_for_status()
            result = response.json()
            # 6. 處理接口錯(cuò)誤
            if "error_response" in result:
                err = result["error_response"]
                return {
                    "success": False,
                    "error": f"{err.get('msg', '未知錯(cuò)誤')}（錯(cuò)誤碼：{err.get('code', -1)}）",
                    "tip": "早年遇到過(guò)code=403，是因?yàn)閍ccess_token過(guò)期，記得定時(shí)刷新"
                }
            # 7. 解析原始數(shù)據(jù)
            raw_data = result.get("result", {})
            raw_products = raw_data.get("products", {}).get("product", [])
            total_count = raw_data.get("total_results", 0)
            # 8. 整理商品數(shù)據(jù)（補(bǔ)全價(jià)格階梯、供應(yīng)商信息）
            processed_products = []
            for p in raw_products:
                # 解析價(jià)格階梯（接口返回的是字符串，要拆成結(jié)構(gòu)化數(shù)據(jù)）
                price_ladder = self._parse_price_ladder(p.get("price", {}))
                # 解析供應(yīng)商信息（提取地區(qū)、認(rèn)證這些關(guān)鍵信息）
                supplier = self._parse_supplier(p.get("supplier_info", {}))
                # 解析定制能力（明確能不能來(lái)樣加工）
                customization = self._parse_custom(p.get("customization", {}))
                processed_products.append({
                    "product_id": p.get("product_id", ""),
                    "title": p.get("title", ""),
                    "main_image": p.get("main_image", ""),
                    "similarity": min(p.get("similarity", 0), 100),  # 相似度不超過(guò)100
                    "price_ladder": price_ladder,
                    "min_order": p.get("min_order_quantity", 1),
                    "supplier": supplier,
                    "customization": customization
                })
            # 9. 工廠優(yōu)先排序（核心優(yōu)化，幫批發(fā)商省2小時(shí)篩選時(shí)間）
            sorted_products = self._factory_priority_sort(processed_products)
            # 10. 生成匹配分析（告訴用戶哪些工廠值得優(yōu)先聯(lián)系）
            analysis = self._generate_matching_analysis(sorted_products)
            return {
                "success": True,
                "total_count": total_count,
                "page": kwargs.get("page", 1),
                "products": sorted_products,
                "analysis": analysis,
                "has_more": (kwargs.get("page", 1) * kwargs.get("page_size", 20)) < total_count
            }
        except requests.exceptions.Timeout:
            return {"success": False, "error": "接口超時(shí)（高峰在9-11點(diǎn)，建議錯(cuò)峰調(diào)用）"}
        except Exception as e:
            return {"success": False, "error": f"處理失敗：{str(e)}", "tip": "檢查圖像格式是不是JPG/PNG"}
    def _generate_sign(self, params: Dict) -?> str:
        """生成SHA1簽名：早年沒(méi)排序參數(shù)，連續(xù)報(bào)10次簽名錯(cuò)誤"""
        # 必須按參數(shù)名ASCII升序排序，錯(cuò)序必?cái)?        sorted_params = sorted(params.items(), key=lambda x: x[0])
        sign_str = self.app_secret
        for k, v in sorted_params:
            # 布爾值要轉(zhuǎn)成小寫字符串，不然簽名不對(duì)
            value = "true" if isinstance(v, bool) and v else "false" if isinstance(v, bool) else str(v)
            sign_str += f"{k}{value}"
        sign_str += self.app_secret
        return hashlib.sha1(sign_str.encode('utf-8')).hexdigest().upper()
    def _parse_price_ladder(self, price_data: Dict) -> List[Dict]:
        """解析價(jià)格階梯：接口返回的是“10-50件:￥20;51-100件:￥18”這樣的字符串"""
        ladder_str = price_data.get("priceRange", "")
        if not ladder_str:
            # 沒(méi)有階梯，按單價(jià)算
            return [{
                "min_qty": 1,
                "max_qty": None,
                "price": Decimal(str(price_data.get("price", 0)))
            }]
        import re
        ladder_list = []
        for part in ladder_str.split(';'):
            # 正則匹配“10-50件:￥20”這種格式
            match = re.match(r'(d+)(?:-(d+))?件.*?:￥?(d+.d+)', part)
            if match:
                min_q = int(match.group(1))
                max_q = int(match.group(2)) if match.group(2) else None
                price = Decimal(match.group(3))
                ladder_list.append({
                    "min_qty": min_q,
                    "max_qty": max_q,
                    "price": price
                })
        return ladder_list
    def _parse_supplier(self, supplier_data: Dict) -> Dict:
        """解析供應(yīng)商信息：提取B2B采購(gòu)關(guān)心的字段"""
        return {
            "id": supplier_data.get("supplier_id", ""),
            "name": supplier_data.get("supplier_name", ""),
            "type": supplier_data.get("supplier_type", "未知"),
            "region": f"{supplier_data.get('province', '')}{supplier_data.get('city', '')}",
            "certifications": [c.get("type", "") for c in supplier_data.get("certifications", [])],
            "operating_years": supplier_data.get("operating_years", 0)  # 經(jīng)營(yíng)年限，越久越靠譜
        }
    def _parse_custom(self, custom_data: Dict) -> Dict:
        """解析定制能力：明確能不能來(lái)樣加工、最小打樣量"""
        return {
            "supported": custom_data.get("supportCustomization", False),
            "can_sample": "來(lái)樣加工" in custom_data.get("serviceTags", []),
            "min_sample_qty": custom_data.get("minSampleQuantity", 0),
            "sample_price": Decimal(str(custom_data.get("samplePrice", 0)))
        }
    def _generate_matching_analysis(self, products: List[Dict]) -> Dict:
        """生成匹配分析：告訴用戶哪些工廠值得優(yōu)先聯(lián)系"""
        if not products:
            return {"conclusion": ["無(wú)匹配商品，建議優(yōu)化圖像或調(diào)整篩選條件"]}
        # 統(tǒng)計(jì)源頭工廠數(shù)量
        factory_count = sum(1 for p in products if p["supplier"]["type"] == "源頭工廠")
        # 平均相似度
        avg_similarity = sum(p["similarity"] for p in products) / len(products)
        # 最佳匹配工廠（總分最高的）
        top_factory = products[0]["supplier"] if products else None
        conclusion = []
        if factory_count > 0:
            conclusion.append(f"找到{factory_count}家源頭工廠，優(yōu)先聯(lián)系{top_factory['name']}（綜合得分最高）")
        if avg_similarity < 60:
            conclusion.append("注意：整體匹配度較低，建議上傳細(xì)節(jié)圖（如面料、工藝特寫）提升精度")
        if any(p["customization"]["can_sample"] for p in products):
            conclusion.append(f"共有{sum(1 for p in products if p['customization']['can_sample'])}家工廠支持來(lái)樣加工，可滿足定制需求")
        return {
            "factory_count": factory_count,
            "avg_similarity": round(avg_similarity, 1),
            "top_factory": top_factory,
            "conclusion": conclusion
        }

四、高級(jí)應(yīng)用：多圖交叉驗(yàn)證與定制方案生成

1. 多圖交叉驗(yàn)證：匹配精度從 60% 提到 85%

單張圖容易識(shí)別偏差，比如搜 T 恤只傳正面圖，可能匹配到款式不同的 —— 多圖交叉驗(yàn)證（正面 + 細(xì)節(jié) + 場(chǎng)景）能解決這個(gè)問(wèn)題：

def multi_image_verify(self, image_paths: List[str]) -> Dict:
        """
        多圖交叉驗(yàn)證：用多張圖（正面+細(xì)節(jié)+場(chǎng)景）共同檢索，提升精度
        :param image_paths: 圖像路徑列表（至少2張）
        """
        if len(image_paths) < 2:
            return {"success": False, "error": "至少需要2張圖（建議：正面+細(xì)節(jié)）"}
        # 1. 分別搜每張圖，存結(jié)果
        all_results = []
        for i, path in enumerate(image_paths):
            # 第一張當(dāng)主圖（品類識(shí)別），其余當(dāng)細(xì)節(jié)圖（工藝匹配）
            is_product = (i == 0)
            res = self.search_by_image(path, is_product, page_size=30)
            if res["success"]:
                all_results.append({
                    "image_type": "主圖" if is_product else "細(xì)節(jié)圖",
                    "product_map": {p["product_id"]: p for p in res["products"]}  # 用商品ID當(dāng)key
                })
        if not all_results:
            return {"success": False, "error": "所有圖像檢索失敗，檢查格式和尺寸"}
        # 2. 找所有圖都匹配到的商品（共同匹配，精度最高）
        common_product_ids = set(all_results[0]["product_map"].keys())
        for res in all_results[1:]:
            common_product_ids.intersection_update(res["product_map"].keys())
        # 3. 算綜合相似度（多張圖的平均）
        verified_products = []
        for pid in common_product_ids:
            similarities = []
            product_info = None
            for res in all_results:
                if pid in res["product_map"]:
                    p = res["product_map"][pid]
                    similarities.append(p["similarity"])
                    product_info = p  # 取第一張圖的商品信息
            if product_info:
                product_info["comprehensive_similarity"] = round(sum(similarities) / len(similarities), 1)
                verified_products.append(product_info)
        # 4. 排序（按綜合相似度降序）
        verified_products.sort(key=lambda x: x["comprehensive_similarity"], reverse=True)
        return {
            "success": True,
            "total_common": len(verified_products),
            "products": verified_products,
            "analysis": {
                "confidence": "高" if len(verified_products) > 5 else "中" if len(verified_products) > 0 else "低",
                "tip": "早年幫服裝批發(fā)商做過(guò)，3張圖交叉驗(yàn)證后，錯(cuò)配率從30%降到5%"
            }
        }

2. 定制方案生成：從匹配到采購(gòu)的閉環(huán)

找到工廠后，還要算成本、定打樣方案 —— 這個(gè)功能幫批發(fā)商省了手動(dòng)算價(jià)的時(shí)間：

def generate_custom_plan(self, product_id: str, min_order: int, complexity: str = "standard") -> Dict:
        """
        生成定制采購(gòu)方案：算價(jià)格、打樣時(shí)間、總成本
        :param product_id: 匹配到的商品ID
        :param min_order: 預(yù)計(jì)采購(gòu)量
        :param complexity: 定制復(fù)雜度（simple/standard/complex）
        """
        # 1. 先拿商品和供應(yīng)商詳情（復(fù)用商品詳情接口）
        product_detail = self._get_product_detail(product_id)
        if not product_detail["success"]:
            return {"success": False, "error": product_detail["error"]}
        p = product_detail["data"]
        supplier = p["supplier"]
        custom = p["customization"]
        # 2. 檢查能不能定制
        if not custom["supported"] or not custom["can_sample"]:
            return {"success": False, "error": f"{supplier['name']}不支持來(lái)樣加工，換其他工廠"}
        # 3. 算定制價(jià)格（基礎(chǔ)價(jià)+復(fù)雜度加價(jià)）
        base_price = self._get_price_for_qty(p["price_ladder"], min_order)
        # 復(fù)雜度加價(jià)：簡(jiǎn)單10%，標(biāo)準(zhǔn)20%，復(fù)雜35%（早年調(diào)研30家工廠得出的平均比例）
        price_add = {
            "simple": 0.1,
            "standard": 0.2,
            "complex": 0.35
        }[complexity]
        custom_price = base_price * (1 + price_add)
        # 4. 算總成本（打樣費(fèi)+批量成本+運(yùn)費(fèi)）
        sample_fee = custom["sample_price"]  # 打樣費(fèi)
        batch_cost = custom_price * min_order  # 批量成本
        shipping_fee = 20 if min_order <= 100 else 50  # 估算運(yùn)費(fèi)（實(shí)際按地區(qū)算）
        total_cost = sample_fee + batch_cost + shipping_fee
        # 5. 生成方案
        return {
            "success": True,
            "supplier": {
                "name": supplier["name"],
                "region": supplier["region"],
                "operating_years": supplier["operating_years"],
                "contact_tip": "建議先聯(lián)系要樣品，確認(rèn)質(zhì)量再下單"
            },
            "custom_plan": {
                "min_order": max(min_order, custom["min_sample_qty"]),  # 不低于工廠最小起訂量
                "unit_price": round(custom_price, 2),
                "sample_fee": round(sample_fee, 2),
                "sample_days": 3 if "快速打樣" in custom["services"] else 7,  # 打樣時(shí)間
                "production_days": 15 if complexity == "simple" else 20 if complexity == "standard" else 30
            },
            "cost_estimate": {
                "sample_total": round(sample_fee + 10, 2),  # 打樣+運(yùn)費(fèi)
                "batch_total": round(batch_cost, 2),
                "total_cost": round(total_cost, 2)
            },
            "notes": [
                f"供應(yīng)商有{supplier['operating_years']}年經(jīng)驗(yàn)，相對(duì)靠譜",
                f"復(fù)雜度越高，建議先打2-3個(gè)樣品確認(rèn)",
                f"批量付款建議分兩筆：30%預(yù)付款，70%尾款"
            ]
        }
    def _get_product_detail(self, product_id: str) -?> Dict:
        """輔助方法：獲取商品詳情（實(shí)際項(xiàng)目中需對(duì)接1688商品詳情接口）"""
        # 此處簡(jiǎn)化，實(shí)際需調(diào)用alibaba.product.get接口
        return {
            "success": True,
            "data": {
                "product_id": product_id,
                "price_ladder": [{"min_qty": 10, "max_qty": 50, "price": 20}, {"min_qty": 51, "max_qty": None, "price": 18}],
                "supplier": {"name": "廣州XX服裝廠", "region": "廣東廣州", "operating_years": 8, "type": "源頭工廠"},
                "customization": {"supported": True, "can_sample": True, "min_sample_qty": 5, "sample_price": 50, "services": ["來(lái)樣加工", "快速打樣"]}
            }
        }

五、實(shí)戰(zhàn)調(diào)用示例（拿來(lái)就用）

if __name__ == "__main__": # 初始化客戶端（替換成自己的app_key、secret、token） api = AlibabaImageSearchAPI( app_key="your_enterprise_app_key", app_secret="your_app_secret", access_token="your_access_token" ) # 示例1：?jiǎn)螆D搜索（找廣州的T恤生產(chǎn)廠家，50件起訂，支持定制） print("===== 單圖搜索找T恤廠 =====") single_result = api.search_by_image( image_path="tshirt_front.jpg", # T恤正面圖 is_product=True, cat_id=1008003, # 服裝類目ID min_order=50, region="廣州", need_custom=True # 需要來(lái)樣加工 ) if single_result["success"]: print(f"找到{single_result['total_count']}個(gè)匹配商品，其中{single_result['analysis']['factory_count']}家源頭工廠") print("Top 2 推薦工廠：") for i, p in enumerate(single_result["products"][:2]): print(f"{i+1}. {p['supplier']['name']}（綜合得分：{p['sort_info']['total_score']}）") print(f" 100件單價(jià)：￥{p['price_ladder'][1]['price']} | 支持來(lái)樣加工：{'是' if p['customization']['can_sample'] else '否'}") print(f" 匹配度：{p['similarity']}%") print("-" * 60) # 示例2：多圖交叉驗(yàn)證（用正面+領(lǐng)口細(xì)節(jié)圖，提升精度） if single_result["success"]: print("n===== 多圖交叉驗(yàn)證 =====") multi_result = api.multi_image_verify([ "tshirt_front.jpg", # 正面主圖 "tshirt_collar.jpg" # 領(lǐng)口細(xì)節(jié)圖（看工藝） ]) if multi_result["success"]: print(f"多圖共同匹配到{multi_result['total_common']}個(gè)商品，可信度：{multi_result['analysis']['confidence']}") if multi_result["products"]: top = multi_result["products"][0] print(f"最佳綜合匹配：{top['supplier']['name']}（綜合匹配度：{top['comprehensive_similarity']}%）") print("-" * 60) # 示例3：生成定制方案（按100件采購(gòu)，標(biāo)準(zhǔn)復(fù)雜度） if single_result["success"] and single_result["products"]: print("n===== 生成定制采購(gòu)方案 =====") product_id = single_result["products"][0]["product_id"] plan_result = api.generate_custom_plan( product_id=product_id, min_order=100, complexity="standard" ) if plan_result["success"]: print(f"定制供應(yīng)商：{plan_result['supplier']['name']}（{plan_result['supplier']['operating_years']}年經(jīng)驗(yàn)）") print(f"100件單價(jià)：￥{plan_result['custom_plan']['unit_price']} | 打樣費(fèi)：￥{plan_result['custom_plan']['sample_fee']}") print(f"總成本：￥{plan_result['cost_estimate']['total_cost']}") print("注意事項(xiàng)：") for note in plan_result["notes"]: print(f"- {note}")

干 B2B 電商接口十幾年，最清楚拍立淘接口的坑不在技術(shù)本身，而在 “B2B 場(chǎng)景適配”—— 比如批發(fā)商要的是工廠，不是貿(mào)易公司；要的是定制能力，不是單純的同款商品。我當(dāng)年為了調(diào)圖像預(yù)處理參數(shù)，測(cè)試了 200 多張工業(yè)品圖；為了定工廠排序權(quán)重，調(diào)研了 50 家批發(fā)商的需求，這些經(jīng)驗(yàn)攢下來(lái)，就是想讓后來(lái)人少走點(diǎn)彎路。

要是你需要 1688 拍立淘接口的試用資源，或者在圖像優(yōu)化、工廠匹配上卡了殼，隨時(shí)找我交流。老程序員了，消息看到必回，不搞虛的，能幫你省點(diǎn)調(diào)試時(shí)間、避點(diǎn)平臺(tái)坑，就挺值的。

審核編輯 黃宇