使用代理追踪亚马逊关键词排名：开发者完整指南

法律与合规声明：本文仅涉及公开搜索数据的采集。在美国，需遵守 《计算机欺诈和滥用法》(CFAA) 的相关规定；在欧盟，需遵守 GDPR 对个人数据的保护要求。请勿绕过技术访问控制措施、采集非公开数据，或违反亚马逊服务条款。建议优先使用 Amazon SP-API 获取合规数据。本指南面向追踪自有商品列表和公开搜索结果的场景。

为什么使用代理追踪亚马逊关键词排名是卖家的核心需求

亚马逊搜索是一个独立于 Google 的 SERP 生态系统。排名算法由相关性和销售速度（sales velocity）驱动，而非传统的链接权重。这意味着卖家必须持续追踪自己产品（ASIN）在特定关键词、特定市场（marketplace）下的自然排名位置——这正是「亚马逊关键词排名追踪器」的核心场景。

与 Google SERP 不同，亚马逊的搜索结果高度本地化：不同国家、邮编、甚至设备类型返回的排名可能完全不同。一个在美国纽约搜索 "bluetooth speaker" 的用户看到的结果，与德国柏林的用户看到的结果截然不同。如果卖家只用单一 IP 从一个地理位置抓取，得到的排名数据无法反映目标市场真实买家的视角。

使用代理追踪亚马逊关键词排名解决了两个核心问题：地理准确性（通过住宅代理的国家级地理定位获取目标市场真实排名）和反爬规避（通过 IP 轮换和真实住宅 IP 降低被封风险）。本文将从技术实现角度，带你完整搭建一套生产级的排名追踪系统。

技术背景：亚马逊搜索结果页的结构

亚马逊搜索结果页的 HTML 结构相对稳定。每个商品结果被包裹在一个带有 data-component-type="s-search-result" 属性的 div 中，ASIN 存储在 data-asin 属性里。广告位（Sponsored）通过结果卡片内的 "Sponsored" 文本标签标识。理解这些结构是解析排名的基础。

关键解析逻辑如下：

• 定位结果容器：遍历所有 [data-component-type="s-search-result"] 元素
• 提取 ASIN：读取 data-asin 属性，空值通常为广告或非商品卡片
• 区分自然位与广告位：检测卡片内是否包含 "Sponsored" 文本
• 计算自然排名：仅对非广告结果计数，得到目标 ASIN 的自然位

亚马逊的 A/B 测试和前端改版时有发生，因此解析代码需要具备容错能力——当选择器失效时记录错误而非直接崩溃。

代理类型对比：住宅 vs 数据中心 vs 移动

选择正确的代理类型是亚马逊排名追踪成功的关键。以下是三种代理的对比：

对于亚马逊关键词排名追踪，住宅代理是首选。数据中心 IP 几乎在亚马逊上无法使用——亚马逊的反爬系统对已知云服务商 IP 段（AWS、GCP、Azure 等）有极高的识别率。

ProxyHat 代理配置：地理定位与粘性会话

ProxyHat 住宅代理通过用户名中的标志实现地理定位和会话管理。以下是亚马逊排名追踪的推荐配置：

国家地理定位

不同亚马逊站点需要匹配对应国家的代理 IP：

# amazon.com → 美国住宅 IP
http://user-country-US:pass@gate.proxyhat.com:8080

# amazon.de → 德国住宅 IP
http://user-country-DE:pass@gate.proxyhat.com:8080

# amazon.co.uk → 英国住宅 IP
http://user-country-GB:pass@gate.proxyhat.com:8080

# amazon.co.jp → 日本住宅 IP
http://user-country-JP:pass@gate.proxyhat.com:8080

粘性会话（Sticky Session）

翻页时必须保持同一 IP，否则不同页面的排名可能因 IP 切换而产生偏差。使用 -session- 标志创建粘性会话：

# 为同一关键词的翻页请求绑定同一 IP
http://user-country-US-session-kw123:pass@gate.proxyhat.com:8080

会话 ID 建议使用关键词 + 日期的组合（如 bluetooth-speaker-20260115），确保同一天同一关键词的所有页面来自同一 IP。不同关键词或不同天使用不同会话 ID，实现 IP 轮换。

更多代理配置选项请参考 ProxyHat 官方文档，或查看 支持的代理位置。

代码实战：用 Python 追踪亚马逊关键词排名

以下示例使用 curl_cffi（模拟浏览器 TLS 指纹）配合 ProxyHat 代理，抓取 amazon.com 上关键词 "bluetooth speaker" 的前 5 页搜索结果，定位目标 ASIN 的自然排名。

示例 1：使用 curl_cffi 抓取搜索结果

import re
import time
import json
import logging
from datetime import datetime
from curl_cffi import requests as cffi_requests

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
logger = logging.getLogger(__name__)

# ProxyHat 代理配置
PROXY_BASE = "http://user-country-US-session-{session}:pass@gate.proxyhat.com:8080"
TARGET_ASIN = "B0DXXXXXXXX"  # 替换为你的 ASIN
KEYWORD = "bluetooth speaker"
MARKETPLACE = "www.amazon.com"
MAX_PAGES = 5

def build_proxy_url(session_id: str) -> str:
    """构建带粘性会话的代理 URL"""
    return PROXY_BASE.format(session=session_id)

def fetch_search_page(keyword: str, page: int, session_id: str) -> str | None:
    """抓取亚马逊搜索结果单页 HTML"""
    proxy_url = build_proxy_url(session_id)
    proxies = {"http": proxy_url, "https": proxy_url}
    
    url = f"https://{MARKETPLACE}/s"
    params = {"k": keyword, "page": page}
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    }
    
    for attempt in range(3):
        try:
            resp = cffi_requests.get(
                url, params=params, headers=headers,
                proxies=proxies, impersonate="chrome120",
                timeout=30, allow_redirects=True
            )
            if resp.status_code == 200:
                html = resp.text
                if "captcha" in html.lower() or "robot" in html.lower():
                    logger.warning(f"CAPTCHA detected on page {page}, attempt {attempt+1}")
                    time.sleep(5 * (attempt + 1))  # 退避
                    continue
                return html
            elif resp.status_code == 503:
                logger.warning(f"503 on page {page}, retrying...")
                time.sleep(3 * (attempt + 1))
            else:
                logger.error(f"HTTP {resp.status_code} on page {page}")
                return None
        except Exception as e:
            logger.error(f"Request error on page {page}: {e}")
            time.sleep(3 * (attempt + 1))
    return None

def parse_rankings(html: str) -> list[dict]:
    """解析搜索结果页，返回 ASIN 列表及自然/广告标记"""
    results = []
    # 匹配所有 s-search-result 容器
    pattern = r'data-component-type="s-search-result"[^>]*data-asin="([A-Z0-9]+)"[^>]*>'
    blocks = re.findall(r'(<div[^>]*data-component-type="s-search-result".*?</div>)', html, re.DOTALL)
    
    organic_position = 0
    for block in blocks:
        asin_match = re.search(r'data-asin="([A-Z0-9]+)"', block)
        if not asin_match or not asin_match.group(1):
            continue
        asin = asin_match.group(1)
        is_sponsored = "Sponsored" in block
        if not is_sponsored:
            organic_position += 1
            results.append({
                "asin": asin,
                "organic_position": organic_position,
                "is_sponsored": False,
            })
        else:
            results.append({
                "asin": asin,
                "organic_position": None,
                "is_sponsored": True,
            })
    return results

def track_keyword_rank(keyword: str, target_asin: str, max_pages: int) -> dict:
    """追踪目标 ASIN 在指定关键词下的自然排名"""
    session_id = re.sub(r'[^a-z0-9]', '-', keyword.lower())[:20]
    all_results = []
    
    for page in range(1, max_pages + 1):
        logger.info(f"Fetching page {page} for '{keyword}'")
        html = fetch_search_page(keyword, page, session_id)
        if not html:
            logger.error(f"Failed to fetch page {page}")
            break
        results = parse_rankings(html)
        all_results.extend(results)
        time.sleep(3)  # 请求间隔
    
    # 查找目标 ASIN
    target_result = None
    for r in all_results:
        if r["asin"] == target_asin and not r["is_sponsored"]:
            target_result = r
            break
    
    record = {
        "keyword": keyword,
        "asin": target_asin,
        "marketplace": MARKETPLACE,
        "timestamp": datetime.utcnow().isoformat(),
        "found": target_result is not None,
        "organic_position": target_result["organic_position"] if target_result else None,
        "page": ((target_result["organic_position"] - 1) // 60 + 1) if target_result else None,
    }
    return record

# 运行追踪
if __name__ == "__main__":
    result = track_keyword_rank(KEYWORD, TARGET_ASIN, MAX_PAGES)
    print(json.dumps(result, indent=2))
    
    # 保存到历史文件
    with open(f"rank_history_{TARGET_ASIN}.jsonl", "a") as f:
        f.write(json.dumps(result) + "\n")

示例 2：使用 Playwright 抓取（处理 JS 渲染）

部分亚马逊搜索结果依赖 JavaScript 渲染。当 curl_cffi 无法获取完整结果时，使用 Playwright 配合代理：

import asyncio
import re
import json
import logging
from datetime import datetime
from playwright.async_api import async_playwright

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

PROXY_HOST = "gate.proxyhat.com"
PROXY_PORT = "8080"
PROXY_USER = "user-country-US-session-{session}"
PROXY_PASS = "pass"
TARGET_ASIN = "B0DXXXXXXXX"
KEYWORD = "bluetooth speaker"

async def fetch_with_playwright(keyword: str, page_num: int, session_id: str) -> str:
    """使用 Playwright 通过代理抓取搜索结果页"""
    username = PROXY_USER.format(session=session_id)
    proxy_config = {
        "server": f"http://{PROXY_HOST}:{PROXY_PORT}",
        "username": username,
        "password": PROXY_PASS,
    }
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy=proxy_config,
            args=["--disable-blink-features=AutomationControlled"]
        )
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            locale="en-US",
            viewport={"width": 1920, "height": 1080},
        )
        page = await context.new_page()
        
        url = f"https://www.amazon.com/s?k={keyword}&page={page_num}"
        try:
            await page.goto(url, wait_until="domcontentloaded", timeout=30000)
            await page.wait_for_selector('[data-component-type="s-search-result"]', timeout=10000)
            html = await page.content()
            
            # CAPTCHA 检测
            if "captcha" in html.lower():
                logger.warning("CAPTCHA detected")
                return None
            return html
        except Exception as e:
            logger.error(f"Playwright error: {e}")
            return None
        finally:
            await browser.close()

async def parse_playwright_html(html: str) -> list[dict]:
    """解析 Playwright 渲染后的 HTML"""
    results = []
    blocks = re.findall(
        r'<div[^>]*data-component-type="s-search-result"[^>]*data-asin="([A-Z0-9]+)"[^>]*>(.*?)(?=<div[^>]*data-component-type="s-search-result"|</div>\s*</div>\s*</div>)',
        html, re.DOTALL
    )
    organic_pos = 0
    for asin, block in blocks:
        if not asin:
            continue
        is_sponsored = "Sponsored" in block
        if not is_sponsored:
            organic_pos += 1
        results.append({
            "asin": asin,
            "organic_position": organic_pos if not is_sponsored else None,
            "is_sponsored": is_sponsored,
        })
    return results

async def main():
    session_id = re.sub(r'[^a-z0-9]', '-', KEYWORD.lower())[:20]
    all_results = []
    
    for pg in range(1, 6):
        logger.info(f"Playwright fetching page {pg}")
        html = await fetch_with_playwright(KEYWORD, pg, session_id)
        if html:
            results = await parse_playwright_html(html)
            all_results.extend(results)
            await asyncio.sleep(4)
    
    target = next(
        (r for r in all_results if r["asin"] == TARGET_ASIN and not r["is_sponsored"]),
        None
    )
    print(json.dumps({
        "keyword": KEYWORD,
        "asin": TARGET_ASIN,
        "found": target is not None,
        "organic_position": target["organic_position"] if target else None,
        "timestamp": datetime.utcnow().isoformat(),
    }, indent=2))

if __name__ == "__main__":
    asyncio.run(main())

示例 3：curl 命令行快速验证

# 使用 curl 通过 ProxyHat 代理抓取亚马逊搜索结果
curl -x "http://user-country-US-session-test01:pass@gate.proxyhat.com:8080" \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
  -H "Accept-Language: en-US,en;q=0.9" \
  "https://www.amazon.com/s?k=bluetooth+speaker&page=1" \
  -o amazon_page1.html --max-time 30

# 检查是否被 CAPTCHA 拦截
grep -i "captcha" amazon_page1.html

示例 4：批量关键词追踪（并发控制）

import asyncio
import aiohttp
import json
import re
import logging
from datetime import datetime
from asyncio import Semaphore

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

PROXY_TEMPLATE = "http://user-country-US-session-{session}:pass@gate.proxyhat.com:8080"
KEYWORDS = ["bluetooth speaker", "wireless earbuds", "phone charger", "laptop stand"]
TARGET_ASIN = "B0DXXXXXXXX"
MAX_CONCURRENT = 3  # 并发上限
REQUEST_DELAY = 3  # 秒

semaphore = Semaphore(MAX_CONCURRENT)

async def fetch_keyword_rank(session: aiohttp.ClientSession, keyword: str) -> dict:
    """并发追踪多个关键词的排名"""
    async with semaphore:
        session_id = re.sub(r'[^a-z0-9]', '-', keyword.lower())[:20]
        proxy_url = PROXY_TEMPLATE.format(session=session_id)
        
        all_results = []
        for page in range(1, 4):  # 前 3 页
            url = f"https://www.amazon.com/s?k={keyword}&page={page}"
            headers = {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
                "Accept-Language": "en-US,en;q=0.9",
            }
            try:
                async with session.get(
                    url, proxy=proxy_url, headers=headers, timeout=aiohttp.ClientTimeout(total=30)
                ) as resp:
                    if resp.status != 200:
                        logger.warning(f"{keyword} page {page}: HTTP {resp.status}")
                        break
                    html = await resp.text()
                    if "captcha" in html.lower():
                        logger.warning(f"CAPTCHA for '{keyword}' page {page}")
                        break
                    # 简化解析
                    asins = re.findall(r'data-asin="([A-Z0-9]{10})"', html)
                    all_results.extend(asins)
            except Exception as e:
                logger.error(f"Error fetching '{keyword}' page {page}: {e}")
                break
            await asyncio.sleep(REQUEST_DELAY)
        
        # 查找目标 ASIN 的位置
        position = None
        for i, asin in enumerate(all_results, 1):
            if asin == TARGET_ASIN:
                position = i
                break
        
        return {
            "keyword": keyword,
            "asin": TARGET_ASIN,
            "found": position is not None,
            "position": position,
            "timestamp": datetime.utcnow().isoformat(),
        }

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_keyword_rank(session, kw) for kw in KEYWORDS]
        results = await asyncio.gather(*tasks)
        
    for r in results:
        print(json.dumps(r, indent=2))
        with open(f"rank_history_{TARGET_ASIN}.jsonl", "a") as f:
            f.write(json.dumps(r) + "\n")

if __name__ == "__main__":
    asyncio.run(main())

示例 5：SOCKS5 代理 + 重试与断路器

import requests
import time
import json
import logging
from datetime import datetime
from circuitbreaker import circuit  # pip install circuitbreaker

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

SOCKS5_PROXY = "socks5://user-country-US-session-rank01:pass@gate.proxyhat.com:1080"
TARGET_ASIN = "B0DXXXXXXXX"

class AmazonRankTracker:
    """带断路器保护的亚马逊排名追踪器"""
    
    def __init__(self, proxy: str, max_retries: int = 3):
        self.proxy = proxy
        self.max_retries = max_retries
        self.session = requests.Session()
        self.session.proxies = {"http": proxy, "https": proxy}
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
            "Accept-Language": "en-US,en;q=0.9",
        })
    
    @circuit(failure_threshold=5, recovery_timeout=60)
    def fetch_page(self, keyword: str, page: int) -> str:
        """带断路器保护的页面抓取"""
        url = f"https://www.amazon.com/s?k={keyword}&page={page}"
        
        for attempt in range(self.max_retries):
            try:
                resp = self.session.get(url, timeout=30)
                if resp.status_code == 200:
                    if "captcha" in resp.text.lower():
                        raise Exception("CAPTCHA detected")
                    return resp.text
                elif resp.status_code == 503:
                    wait = 2 ** attempt
                    logger.warning(f"503, waiting {wait}s before retry")
                    time.sleep(wait)
                else:
                    raise Exception(f"HTTP {resp.status_code}")
            except Exception as e:
                logger.error(f"Attempt {attempt+1} failed: {e}")
                if attempt < self.max_retries - 1:
                    time.sleep(2 ** attempt)
                else:
                    raise
        raise Exception("Max retries exceeded")
    
    def check_indexation(self, keyword: str, asin: str, max_pages: int = 5) -> dict:
        """检查 ASIN 是否被索引（是否出现在搜索结果中）"""
        for page in range(1, max_pages + 1):
            try:
                html = self.fetch_page(keyword, page)
                if asin in html:
                    return {
                        "indexed": True,
                        "keyword": keyword,
                        "asin": asin,
                        "page_found": page,
                        "timestamp": datetime.utcnow().isoformat(),
                    }
            except Exception as e:
                logger.error(f"Indexation check failed on page {page}: {e}")
                break
            time.sleep(3)
        
        return {
            "indexed": False,
            "keyword": keyword,
            "asin": asin,
            "timestamp": datetime.utcnow().isoformat(),
        }

# 使用示例
tracker = AmazonRankTracker(SOCKS5_PROXY)
result = tracker.check_indexation("bluetooth speaker", TARGET_ASIN)
print(json.dumps(result, indent=2))

常见错误与边界情况

1. 未分离广告位与自然位

亚马逊搜索结果页顶部和中间穿插广告位。如果不区分 "Sponsored" 标签，你的排名数据会将广告位计入自然排名，导致数据失真。务必在解析时检测广告标记并单独计数。

2. 翻页时 IP 变化导致结果不一致

如果翻页时代理 IP 发生变化，亚马逊可能返回不同的搜索结果集——尤其是排名 40-60 以后的商品。使用粘性会话（-session-）确保同一关键词的所有页面请求来自同一 IP。

3. 忽略 CAPTCHA 信号

亚马逊在检测到可疑流量时会返回 CAPTCHA 页面而非搜索结果。如果解析代码未检测 CAPTCHA，会将 CAPTCHA 页面的内容误解析为空结果，导致「ASIN 未排名」的错误结论。务必在解析前检查 HTML 中是否包含 "captcha" 或 "robot" 关键词。

4. 请求频率过高

即使使用住宅代理，短时间内大量请求仍会触发封禁。建议每个关键词的页面请求间隔 3-5 秒，并发数不超过 3-5 个关键词。对于大规模追踪（100+ 关键词），考虑分批执行，每批之间间隔 10-15 分钟。

5. 未做索引检查

如果 ASIN 根本没有被亚马逊索引（即不出现在任何搜索结果中），排名追踪无意义。在开始追踪前，先做一次索引检查——搜索关键词的前 5 页是否包含目标 ASIN。如果未找到，可能需要检查产品 listing 状态或关键词相关性。

生产级实践建议

每日定时调度

# 使用 cron 每天凌晨 2 点运行排名追踪
# crontab -e
0 2 * * * /usr/bin/python3 /path/to/amazon_rank_tracker.py >> /var/log/rank_tracker.log 2>&1

数据存储与历史趋势

将每日排名数据以 JSONL 格式追加到文件或写入数据库（SQLite/PostgreSQL），便于后续分析排名趋势。关键字段包括：timestamp、keyword、asin、marketplace、organic_position、page。

重试与退避策略

实现指数退避重试：首次失败等待 2 秒，第二次 4 秒，第三次 8 秒。连续失败 5 次后触发断路器，暂停 60 秒。这避免了在亚马逊临时限流时持续重试导致更严重的封禁。

多市场并行追踪

如果卖家在多个亚马逊站点销售（如 amazon.com + amazon.de + amazon.co.uk），使用不同国家地理定位的代理分别追踪。每个市场使用独立的会话 ID 命名空间，避免会话冲突。

合规与伦理考量

排名追踪应遵循以下原则：

• 只追踪公开数据和自有商品：搜索结果页是公开可见的，但大量自动化请求可能违反亚马逊 ToS。优先考虑 Amazon SP-API 获取合规的产品目录和报告数据。
• 控制请求频率：合理限速，避免对亚马逊服务器造成压力。每个关键词间隔 3-5 秒是合理基准。
• 遵守 robots.txt：检查 amazon.com/robots.txt 了解允许抓取的路径。
• 遵守 CFAA 和 GDPR：在美国，CFAA 禁止「未经授权」访问计算机系统；在欧盟，GDPR 保护个人数据。搜索结果中的卖家信息可能涉及个人数据，采集时需谨慎。
• 考虑 SP-API 替代方案：Amazon SP-API 提供了合规的 Catalog Items API 和产品报告接口，对于自有商品的排名和销量数据，SP-API 是首选。

关键要点总结

关键要点：

• 亚马逊搜索是独立 SERP，排名由相关性和销售速度驱动，必须按关键词、市场、ASIN 追踪自然位。
• 解析 [data-component-type="s-search-result"] 容器，读取 data-asin，检测 "Sponsored" 标签分离广告与自然排名。
• 住宅代理配合国家地理定位（-country-US、-country-DE）确保排名数据反映目标市场真实视角。
• 粘性会话（-session-）保证翻页时 IP 一致，避免排名结果因 IP 切换而波动。
• 生产环境需实现 CAPTCHA 检测、指数退避重试、断路器保护和每日定时调度。
• 合规优先：优先考虑 Amazon SP-API，只追踪公开数据和自有商品，遵守 CFAA 和 GDPR。

准备好搭建你的亚马逊关键词排名追踪系统了吗？查看 ProxyHat 定价方案选择适合的住宅代理套餐，或访问 SERP 追踪用例了解更多应用场景。如需了解代理覆盖的地理位置，请查看 代理位置列表。更多 Web 采集技巧请参考 Web 采集用例。

常见问题

什么是使用代理追踪亚马逊关键词排名？

使用代理追踪亚马逊关键词排名是指通过住宅或移动代理在不同亚马逊站点上搜索关键词，解析搜索结果页中的自然排名位置和 ASIN，从而持续监控产品在特定关键词下的排名变化。代理用于绕过地理限制和反爬机制，确保排名数据反映真实买家看到的搜索结果。

为什么代理用户需要使用代理追踪亚马逊关键词排名？

亚马逊搜索结果高度本地化——不同国家、邮编甚至设备返回的排名不同。直接从单一 IP 大量请求会触发 CAPTCHA 和 IP 封禁。住宅代理提供真实住宅 IP，配合国家地理定位可以准确获取目标市场的排名数据，同时降低被封风险。

哪种代理类型最适合追踪亚马逊关键词排名？

住宅代理是最佳选择，因为亚马逊对数据中心 IP 的检测非常严格。住宅代理使用真实 ISP 分配的 IP，行为更像真实买家。建议使用粘性会话确保翻页时 IP 一致。移动代理适用于移动端排名追踪场景。

如何在实现亚马逊关键词排名追踪时避免被封？

关键策略包括：使用住宅代理配合国家地理定位、控制请求频率（每个关键词间隔 3-5 秒）、使用粘性会话保持翻页一致性、检测并处理 CAPTCHA 页面、实现指数退避重试机制、轮换 User-Agent，以及优先考虑 Amazon SP-API 获取合规数据。只追踪公开搜索数据和自有商品列表。