亚马逊 Alexa for Shopping 搜索结果数据采集实战：Python 调用 Pangolinfo Alexa API 完整指南

摘要：
2026年5月，亚马逊将 Rufus 并入 Alexa for Shopping，AI 购物助手正式嵌入主搜索栏。本文从技术视角解析 Alexa for Shopping 的前端数据结构（AI摘要模块、推荐商品卡片、Prompts 广告位），并提供完整 Python 代码示例，展示如何通过 Pangolinfo Alexa API（全球首个第三方 Alexa 搜索数据采集服务）系统性地获取结构化数据，用于竞品监控、品牌曝光追踪和 Listing 优化验证。

---

一、 技术背景：Alexa for Shopping 的页面结构变化

在 Rufus 时代，亚马逊搜索结果页（SERP）的结构相对固定：顶部广告位 → 自然排名商品 → 底部 Rufus 聊天入口（角落图标）。

Alexa for Shopping 上线后，SERP 的层次结构发生了本质变化，新增了至少三个 AI 驱动的数据模块：

1. Alexa AI 搜索摘要（AI Summary Module）： 出现在搜索栏下方、广告位之前，展示 AI 生成的品类选购建议、推荐理由和关键考量维度。这是流量最高、用户最先接触的内容区域。
2. Alexa AI 推荐商品卡片（AI-Recommended Products）： AI 摘要下方的商品卡片，通常展示 3-6 款，每张卡片包含 ASIN、价格、评分和 AI 推荐理由文本。
3. Prompts 广告位（AI Native Ads）： AI 摘要区域内或紧随其后的 CPC 广告位，于 2026年3月正式转为付费模式。

对于数据采集方，这三个模块的 HTML 结构与传统商品排名结果截然不同，需要专门的解析模板才能稳定采集。

---

二、 为什么需要专用 API？自建爬虫的技术挑战

许多开发者首先考虑自建爬虫来采集 Alexa 搜索结果。以下是实际工程中遭遇的核心难点：

难点1：Alexa AI 内容的动态渲染

Alexa AI 摘要不是静态 HTML，而是通过 JavaScript 异步渲染的动态内容。标准的 requests + BeautifulSoup 组合无法获取完整的 AI 摘要文本，必须使用 Playwright 或 Selenium 等无头浏览器方案，工程复杂度大幅上升。

难点2：亚马逊的高强度反爬系统

亚马逊针对自动化访问部署了多层防御：

• JA3 TLS 指纹检测： 标准 Python requests 库的 TLS 握手特征与真实浏览器差异显著，会被迅速识别
• 高频行为检测： 单 IP 短时间内重复访问搜索结果页，极易触发 Robot 验证码
• Geoblocking： 数据中心 IP 段的通过率不足 5%，必须使用住宅代理，成本高昂

难点3：AI 模块的 HTML 类名动态变化

亚马逊对 AI 摘要模块的 CSS 类名和 DOM 结构频繁进行 A/B 测试，导致硬编码的选择器在维护成本上远超价值。Pangolinfo 的工程团队需要持续更新解析规则，这正是自建团队难以独立承担的维护负担。

---

三、 解决方案：Pangolinfo Alexa API 技术架构

Pangolinfo Scrape API作为全球首家支持 Amazon Alexa for Shopping 搜索结果数据采集的第三方 API 服务，在云端完整处理上述工程挑战：

• 住宅代理池自动轮换： 无需自购代理，API 后端维护全球分布的住宅 IP 资源
• 浏览器指纹伪装： 模拟真实 Chrome 浏览器的 TLS 握手和行为特征
• 动态内容渲染： AI 摘要等 JavaScript 渲染内容在返回数据前已完成渲染
• 实时解析规则维护： Pangolinfo 工程团队持续跟踪亚马逊页面结构变动，用户无需关心解析器维护

---

四、 完整 Python 代码实战

4.1 环境准备

pip install requests python-dotenv

.env 文件配置：

PANGOLINFO_API_KEY=your_api_key_here

4.2 核心采集模块

import requests
import json
import os
import time
from datetime import datetime
from dotenv import load_dotenv

load_dotenv()

class PangolinAlexaAPI:
    """
    Pangolinfo Alexa API 封装类
    用于采集 Amazon Alexa for Shopping 搜索结果数据
    """
    BASE_URL = "https://scrapeapi.pangolinfo.com/api/v2/scrape"  # 官方文档: https://docs.pangolinfo.com/cn-api-reference/amazonAlexaAPI/amazonAlexaAPI
    
    def __init__(self):
        self.api_key = os.getenv("PANGOLINFO_API_KEY")
        if not self.api_key:
            raise ValueError("未找到 PANGOLINFO_API_KEY，请在 .env 文件中配置")
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        })
    
    def search(self, prompts, screenshot=False):
        """
        向 Alexa for Shopping 发起对话式搜索
        
        Args:
            prompts    : 提示词列表，支持自然语言（如：["适合小户型的 queen 床架"]），每条 6 积点
            screenshot : 是否需要页面截图，默认 False
        Returns:
            dict: 完整 API 响应；data.json[] 为每轮对话结果
        注意: 平均响应时间约 30 秒，timeout 建议设为 90s 以上
        """
        payload = {
            "parserName": "amazonAlexa",
            "param": prompts,          # 提示词数组，每个元素一轮对话
            "screenshot": screenshot
        }
        
        try:
            response = self.session.post(
                self.BASE_URL,
                json=payload,
                timeout=90  # Alexa 响应慢，建议 ≥ 90 秒
            response.raise_for_status()
            return response.json()
        
        except requests.exceptions.HTTPError as e:
            error_msg = f"HTTP 错误 [{response.status_code}]"
            if response.status_code == 429:
                error_msg += " - 请求频率超限，请降低并发或增加请求间隔"
            elif response.status_code == 401:
                error_msg += " - API Key 无效，请检查 .env 配置"
            print(error_msg)
            return None
        
        except requests.exceptions.Timeout:
            print("请求超时，目标页面渲染时间过长，建议稍后重试")
            return None
        
        except Exception as e:
            print(f"未知异常: {str(e)}")
            return None
    
    def batch_search(self, keyword_groups, delay_seconds=35.0):
        """
        批量关键词采集（每次最多 5 个提示词，含请求间隔控制）
        
        Args:
            keyword_groups: 关键词分组列表，每组最多 5 个（Alexa API param 上限）
            delay_seconds : 每次请求之间的等待时间（秒），建议 ≥ 35 秒（响应约 30s）
        Returns:
            list: 每组请求的完整结果列表
        """
        results = []
        total = len(keyword_groups)
        
        for i, group in enumerate(keyword_groups, 1):
            print(f"[{i}/{total}] 正在采集: {group}")
            result = self.search(group)
            results.append(result)
            
            if i < total:
                time.sleep(delay_seconds)
        
        return results


class AlexaDataAnalyzer:
    """
    Alexa 搜索数据分析模块
    用于从 API 返回数据中提取竞争情报
    """
    
    @staticmethod
    def extract_round_summary(round_data):
        """提取单轮对话的核心信息（prompt、Alexa 回复、follow_up_questions）"""
        if not round_data:
            return {}
        return {
            "prompt": round_data.get("prompt", ""),
            "content": round_data.get("content", ""),
            "follow_up_questions": round_data.get("follow_up_questions", [])
        }
    
    @staticmethod
    def check_brand_visibility(round_data, brand_name):
        """
        检查指定品牌是否出现在 Alexa 推荐商品或回复正文中
        
        Args:
            round_data : 单轮对话数据（json[i]）
            brand_name : 要检查的品牌名称（大小写不敏感）
        Returns:
            dict: 品牌可见性分析结果
        """
        brand_lower = brand_name.lower()
        content = round_data.get("content", "") if round_data else ""
        groups = round_data.get("products", []) if round_data else []
        
        brand_in_content = brand_lower in content.lower()
        brand_in_products = any(
            brand_lower in item.get("title", "").lower() or
            brand_lower in item.get("describe", "").lower()
            for group in groups
            for item in group.get("items", [])
        )
        is_visible = brand_in_content or brand_in_products
        
        return {
            "brand": brand_name,
            "visible_in_alexa_result": is_visible,
            "action_needed": not is_visible
        }
    
    @staticmethod
    def extract_top_products(round_data, limit=5):
        """提取单轮对话中 Alexa 推荐商品列表（按分类展开）"""
        if not round_data:
            return []
        
        rows = []
        for group in round_data.get("products", []):
            group_title = group.get("title", "")
            for i, item in enumerate(group.get("items", [])[:limit]):
                rows.append({
                    "group_title": group_title,
                    "asin": item.get("asin"),
                    "title": item.get("title", "")[:80],
                    "price": item.get("price"),
                    "score": item.get("score"),
                    "ratings_count": item.get("ratingsCount"),
                    "describe": item.get("describe", "")[:150],
                    "original_price": item.get("originalPrice", "")
                })
        return rows
    



def generate_competitive_report(prompts, your_brand, api_client):
    """
    生成 Alexa 竞争情报报告（支持多轮对话批量分析）
    """
    print(f"\n{'='*60}")
    print(f"Alexa 竞争情报报告")
    print(f"时间: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    print(f"提示词数量: {len(prompts)}")
    print(f"{'='*60}")
    
    # 采集数据
    response = api_client.search(prompts)
    if not response or response.get("code") != 0:
        print("数据采集失败，请检查 API Key 和网络连接")
        return
    
    results = response.get("data", {}).get("json", [])
    task_id = response.get("data", {}).get("taskId", "")
    print(f"任务 ID: {task_id}")
    
    analyzer = AlexaDataAnalyzer()
    
    for round_data in results:
        prompt = round_data.get("prompt", "")
        print(f"\n{'─'*55}")
        print(f"提示词: {prompt}")
        print(f"{'─'*55}")
        
        # 1. 品牌可见性
        visibility = analyzer.check_brand_visibility(round_data, your_brand)
        print(f"\n📊 品牌可见性")
        print(f"  '{your_brand}': {'✅ 出现在推荐结果中' if visibility['visible_in_alexa_result'] else '❌ 未出现 — 建议优化 Listing 的 AI 可读性'}")
        
        # 2. Alexa 回复正文
        summary = analyzer.extract_round_summary(round_data)
        print(f"\n📝 Alexa 回复（前200字）")
        print(f"  {summary['content'][:200]}...")
        
        # 3. 推荐商品
        products = analyzer.extract_top_products(round_data, limit=5)
        print(f"\n🛍️  Alexa 推荐商品（按分类展示）")
        for p in products:
            print(f"\n  [{p['group_title']}] ASIN: {p['asin']} | {p['price']} | ⭐{p['score']}")
            print(f"  标题: {p['title']}")
            print(f"  AI 描述: {p['describe'][:100]}")
        
        # 4. AI 追问问题
        if summary['follow_up_questions']:
            print(f"\n🔍 Alexa AI 追问问题（AEO 决策路径）")
            for q in summary['follow_up_questions']:
                print(f"  · {q}")
    
    # 保存数据
    filename = f"alexa_report_{datetime.now().strftime('%Y%m%d')}.json"
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(response, f, ensure_ascii=False, indent=4)
    print(f"\n📁 完整数据已保存至: {filename}")
    
    return response


if __name__ == "__main__":
    # 初始化 API 客户端
    client = PangolinAlexaAPI()
    
    # 多轮对话竞品情报报告
    generate_competitive_report(
        prompts=[
            "queen bed frame easy assembly apartment storage",
            "platform bed frame no box spring"
        ],
        your_brand="YourBrandName",
        api_client=client
    )
    
    # 批量关键词监控（每组最多 5 个，建议按品类分组）
    keyword_groups = [
        ["queen bed frame under 100", "platform bed frame no box spring"],
        ["king bed frame with storage", "bed frame easy assembly"]
    ]
    
    print(f"\n{'='*60}")
    print("批量关键词监控")
    batch_results = client.batch_search(keyword_groups, delay_seconds=35)
    
    analyzer = AlexaDataAnalyzer()
    for i, result in enumerate(batch_results):
        if result and result.get("code") == 0:
            for round_data in result.get("data", {}).get("json", []):
                visibility = analyzer.check_brand_visibility(round_data, "YourBrandName")
                status = "✅ 可见" if visibility['visible_in_alexa_result'] else "❌ 未见"
                print(f"  {status} | {round_data.get('prompt', '')[:50]}")

---

五、 数据字段说明与最佳实践

API 返回数据结构（简化版）

{
  "code": 0,
  "message": "ok",
  "data": {
    "taskId": "1779712950213-66c47c8a3bb862d5",
    "json": [
      {
        "prompt": "queen bed frame easy assembly apartment",
        "content": "Here are some great options for queen bed frames that are easy to assemble and perfect for apartments! Are you looking for one with storage, or do you need it to work without a box spring?",
        "products": [
          {
            "title": "Top Picks for Apartment Living",
            "items": [
              {
                "asin": "B0XXXXXX",
                "url": "https://www.amazon.com/dp/B0XXXXXX",
                "title": "Example Queen Bed Frame Easy Assembly No Box Spring",
                "cover": "https://m.media-amazon.com/images/I/example.jpg",
                "score": "4.6",
                "ratingsCount": "12,345",
                "price": "$89.99",
                "originalPrice": "$129.99",
                "describe": "Tool-free assembly in 10 minutes, 12-inch clearance for under-bed storage."
              }
            ]
          }
        ],
        "follow_up_questions": [
          "Does it work without a box spring?",
          "Compare with similar",
          "What do customers say about assembly?"
        ]
      }
    ]
  }
}

生产环境最佳实践

1. 请求频率控制： API 默认 QPS 为 3，建议批量任务每次请求间隔 ≥ 35 秒（Alexa 平均响应约 30 秒）
2. 积点管理： 每轮对话（param 数组每个元素）消耗 6 积点，批量任务前请确认账户余额
3. 数据存储： 建议将原始 JSON 写入 PostgreSQL 或 MongoDB，便于时序分析
4. 监控调度： 使用 Celery + Redis 搭建定时任务，实现每日/每周自动化采集
5. Timeout 配置： Alexa 平均响应 30 秒，Python requests 的 timeout 建议设为 90 秒以上

---

六、 总结

在大数据的时代洪流中，真正拉开跨境企业差距的，不仅是获取公开数据的技术速度，更是深谙合规边界、将海量信息转化为敏捷决策的商业智慧。