跨境卖家如何用3万关键词做市场调研：我的自动化词库搭建经历

Keano Reurink

647人浏览 · 2026-05-15 00:09:32

Keano Reurink · 2026-05-15 00:09:32 发布

帮一个做跨境的朋友搭关键词词库，他说想要"看看美国市场都在搜什么"，我说行，然后花了三天搭了一套自动化工具。结果跑了两周，拉出来 3 万多个长尾词，他说：“这么多词我怎么看得完？” 我说你不需要看完，你只需要知道哪些词值得投。

一、跨境卖家的关键词困境

做跨境的朋友普遍面临一个问题：不知道海外用户到底用什么词搜你的产品。

大部分卖家的做法是：

用 Google Keyword Planner 一个个查——免费的额度只有几个
买 Ahrefs/SEMrush——月费 $99-$399，小卖家肉疼
直接抄竞争对手的广告词——不精准，且被动

我的想法是换个思路：不从关键词工具出发，而是从真实的 Google 搜索结果出发。通过大量搜索自己行业的词，分析 SERP 里出现的"相关搜索"和"People Also Ask"，反向挖长尾词。

二、方案设计：SERP 反向挖掘

2.1 核心逻辑

种子词（30-50个核心词）
    ↓
分别搜索 → 提取 "related_searches" 和 "people_also_ask"
    ↓
把这些关键词作为新种子继续搜索（2-3层扩展）
    ↓
去重 → 按出现频率排序 → 分析搜索意图
    ↓
输出词库（按搜索类型分类）

2.2 为什么选 SerpBase

这个方案对搜索引擎的要求：

必须能拿到 “related_searches” 和 “people_also_ask” 数据
请求量大（可能几千上万次）
必须是 JSON，不然没法自动化
成本要低（朋友是小卖家，预算有限）

SerpBase 的返回结果天然包含这些字段，而且 $3 起步、按量计费，很适合这个场景。

对比了一圈：

Google Custom Search API：没有 related_searches 字段
SerpAPI：有，但 $25/千次，跑 3 万个词要 $750
SerpBase：$0.30/千次，同样的量 $9，差了 80 多倍

三、核心实现

3.1 种子词扩展

import requests
import json
import time
from typing import Set, List, Dict

class KeywordMiner:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.serpbase.dev/google/search"
        self.seen = set()       # 去重
        self.keywords = []      # 结果集
    
    def search(self, query: str) -> dict:
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        body = {"q": query, "gl": "us", "hl": "en", "page": 1}
        resp = requests.post(self.base_url, headers=headers, json=body, timeout=30)
        return resp.json()
    
    def extract_keywords(self, data: dict) -> List[str]:
        """从 SERP 响应中提取所有关键词"""
        extracted = []
        
        # 1. 相关搜索
        related = data.get("related_searches", [])
        for item in related:
            if isinstance(item, str):
                extracted.append(item)
            elif isinstance(item, dict) and "query" in item:
                extracted.append(item["query"])
        
        # 2. People Also Ask
        paa = data.get("people_also_ask", [])
        for item in paa:
            if isinstance(item, dict) and "question" in item:
                extracted.append(item["question"])
            elif isinstance(item, str):
                extracted.append(item)
        
        return [kw for kw in extracted if kw.lower() not in self.seen]
    
    def mine(self, seeds: List[str], max_depth: int = 2, max_keywords: int = 30000):
        """从种子词开始递归挖掘"""
        queue = [(seed, 0) for seed in seeds]
        
        while queue and len(self.keywords) < max_keywords:
            kw, depth = queue.pop(0)
            
            if kw.lower() in self.seen:
                continue
            self.seen.add(kw.lower())
            
            try:
                data = self.search(kw)
                new_kws = self.extract_keywords(data)
                
                self.keywords.append({
                    "keyword": kw,
                    "depth": depth,
                    "new_count": len(new_kws),
                    "timestamp": time.time()
                })
                
                if depth < max_depth:
                    for nkw in new_kws[:5]:  # 每层只取前 5 个
                        queue.append((nkw, depth + 1))
                
                time.sleep(0.5)  # 限流
                print(f"[深度{depth}] {kw} -> 发现 {len(new_kws)} 个新词（已有 {len(self.keywords)}）")
                
            except Exception as e:
                print(f"搜索失败 [{kw}]: {e}")
                continue
        
        return self.keywords

3.2 关键词分类与意图识别

光有 3 万个词不行，得分类。我按搜索意图分了四类：

import re

class KeywordClassifier:
    def __init__(self):
        self.patterns = {
            "buy": [
                r"\bbuy\b", r"\bprice\b", r"\bcost\b", r"\bshop\b",
                r"\bdiscount\b", r"\bcoupon\b", r"\bdeal\b",
                r"\bcheap\b", r"\bfor sale\b", r"\border\b"
            ],
            "research": [
                r"\bvs\b", r"\bcompare\b", r"\breview\b", r"\bbest\b",
                r"\btop\b", r"\bor\b", r"\balternative\b", r"\brating\b"
            ],
            "howto": [
                r"\bhow to\b", r"\bguide\b", r"\btutorial\b",
                r"\bsteps\b", r"\bway to\b", r"\btips\b"
            ],
            "problem": [
                r"\bproblem\b", r"\berror\b", r"\bfix\b", r"\bissue\b",
                r"\bnot working\b", r"\bhelp\b", r"\bsolution\b"
            ]
        }
    
    def classify(self, keyword: str) -> List[str]:
        kw_lower = keyword.lower()
        types = []
        for intent, patterns in self.patterns.items():
            for p in patterns:
                if re.search(p, kw_lower):
                    types.append(intent)
                    break
        return types if types else ["informational"]

分类的意义在于：“buy” 意图的词可以直接投广告，“research” 意图的词适合做内容营销，“howto” 意图的词适合做教程视频。每个词的价值不一样，投放策略也不一样。

3.3 导出报告

import csv
from collections import Counter

def export_report(keywords: List[Dict], classifier: KeywordClassifier):
    classified = []
    intent_counter = Counter()
    
    for kw in keywords:
        intents = classifier.classify(kw["keyword"])
        for intent in intents:
            intent_counter[intent] += 1
        classified.append({
            "keyword": kw["keyword"],
            "depth": kw["depth"],
            "intent": ",".join(intents)
        })
    
    # 写 CSV
    with open("keyword_report.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["keyword", "depth", "intent"])
        writer.writeheader()
        writer.writerows(classified)
    
    # 意图分布
    print(f"=== 搜索意图分布 ===")
    for intent, count in intent_counter.most_common():
        print(f"{intent}: {count} 个词")
    
    # 建议
    print(f"\n建议优先投放 'buy' 意图关键词（{intent_counter['buy']} 个）")
    print(f"建议用 'howto' 意图关键词做内容营销（{intent_counter['howto']} 个）")

# 使用
miner = KeywordMiner(api_key="YOUR_KEY")
seeds = ["wireless earbuds", "bluetooth speaker", "phone charger"]
keywords = miner.mine(seeds, max_depth=2, max_keywords=30000)

classifier = KeywordClassifier()
export_report(keywords, classifier)

四、实际效果

两周跑下来（不是连续跑，每天跑几个小时的频率）：

指标	数值
种子词数量	42 个
挖掘深度	2 层
总挖掘词数	31,847 个
去重后有效词	28,423 个
API 请求次数	~4,500 次
SerpBase 费用	~$2.7（4500 × $0.60/千次 PAYG）
耗时	约 8 小时（含限流等待）