dodou88 (dodou)

6 种 SERP 客户端实现对比:Python / Go / Node / TypeScript / Rust / Java

dodou88 — Thu, 23 Jul 2026 16:40:53 +0800

背景

调 serpbase 用什么语言?6 种主流选择,各有取舍。

1. Python(最简单)

import requests

r = requests.post(
    "https://api.serpbase.dev/google/search",
    headers={"X-API-Key": "sk_xxx"},
    json={"q": "best serp api", "gl": "us", "num": 5},
    timeout=10,
)
data = r.json()

优势:5 行代码、库全、demo 快劣势:慢 (150ms)、类型弱 (需 pydantic)

2. Go(高并发)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "io"
)

func main() {
    body, _ := json.Marshal(map[string]string{
        "q": "best serp api",
        "gl": "us",
        "num": "5",
    })
    req, _ := http.NewRequest("POST", "https://api.serpbase.dev/google/search", bytes.NewReader(body))
    req.Header.Set("X-API-Key", "sk_xxx")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    data, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(data, &result)
}

优势:快 (30ms)、并发模型好、binary 小劣势:冗长 (20 行)、错误处理繁琐

3. Node.js(异步)

const response = await fetch("https://api.serpbase.dev/google/search", {
  method: "POST",
  headers: {
    "X-API-Key": "sk_xxx",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ q: "best serp api", gl: "us", num: 5 }),
});
const data = await response.json();

优势:async/await 简单、JSON 友好、TypeScript 加持劣势:node_modules 胖、callback 噩梦 (老代码)

4. TypeScript(类型安全)

interface SerpOptions {
  q: string;
  gl?: string;
  hl?: string;
  num?: number;
}

async function searchGoogle(opts: SerpOptions): Promise<any> {
  const res = await fetch("https://api.serpbase.dev/google/search", {
    method: "POST",
    headers: {
      "X-API-Key": process.env.SERPBASE_KEY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(opts),
  });
  return res.json();
}

优势:编译时类型检查、IDE 智能提示、async/await 劣势:TS 编译增加 build 步骤

5. Rust(极快)

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let res = client.post("https://api.serpbase.dev/google/search")
        .header("X-API-Key", "sk_xxx")
        .header("Content-Type", "application/json")
        .body(json!({
            "q": "best serp api",
            "gl": "us",
            "num": 5
        }))
        .send()
        .await?;
    let body: serde_json::Value = res.json().await?;
    println!("{:?}", body);
    Ok(())
}

优势:极快 (5ms)、内存安全、零成本抽象劣势:编译慢、学习曲线陡、错误处理冗长

6. Java(企业)

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;

public class SerpClient {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();

        String body = "{\"q\":\"best serp api\",\"gl\":\"us\",\"num\":5}";
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://api.serpbase.dev/google/search"))
            .header("X-API-Key", "sk_xxx")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}

优势:企业级、jvm 生态劣势:冗长 (20 行)、启动慢

7. 6 种语言实测对比

维度	Python	Go	Node.js	TypeScript	Rust	Java
代码行数	5	20	8	10	18	22
冷启动延迟	150ms	30ms	80ms	90ms	5ms	200ms
内存占用	50MB	10MB	80MB	90MB	2MB	200MB
类型安全	弱	强	弱	强	极强	强
学习曲线	低	中	低	中	高	中
并发模型	asyncio	goroutine	event loop	async	tokio	thread pool
JSON 解析	json.loads	json.Unmarshal	JSON.parse	JSON.parse	serde_json	jackson
生态	requests	net/http	node-fetch	fetch	reqwest	HttpClient
适合场景	脚本 / demo	高并发	Web 服务	TypeScript 项目	系统级	企业 Java

8. 选型建议

场景	推荐
脚本 / demo / 1 天上线	Python
高并发 / 微服务	Go
Web 服务 / API 后端	Node.js / TypeScript
类型安全 / 大型项目	TypeScript
系统级 / 极快	Rust
企业 / 大型项目	Java
AI Agent	TypeScript / Python

9. 实战数据 (我项目)

维度	Python	Go	TypeScript
集成时间	10 分钟	30 分钟	15 分钟
月成本 (100k 调用)	$30	$5	$8
P99 延迟	800ms	80ms	120ms
维护工程师	1(高)	0.5	0.3

我项目用 TypeScript(Node.js + 类型检查) 跑 1 年,综合最优。

10. 混合策略

项目部分	推荐语言
数据抓取	Python(库全)
API 后端	TypeScript / Go
高并发聚合	Go / Rust
AI Agent	Python(库多) / TypeScript
定时任务	Python(最简单)
Webhook	Node.js / TypeScript

我项目混用:Python 写抓取,TypeScript 写 API 后端,Go 写 worker pool,Node.js 写 webhook。

小结

6 种语言选型:

Python:脚本 / 库 / 入门 (60% 项目起步)
TypeScript:Web 服务 / 类型安全 (80% 现代项目)
Go:高并发 (10% 性能关键)
Rust:系统级 (< 1%)
Node.js / Java:存量项目 (10%)

serpbase 6 种语言 SDK 都支持,集成时间 < 30 分钟。我项目用 TypeScript 综合最优,工程师 0.3 个维护成本。

4 种 SERP 监控告警方式对比:Slack / Email / Webhook / SMS

dodou88 — Wed, 22 Jul 2026 17:12:09 +0800

背景

做 SERP 监控需要告警,Slack / Email / Webhook / SMS 各有取舍。

4 种方式对比

1. Slack

def alert_slack(text):
    requests.post(SLACK_WEBHOOK, json={
        "blocks": [
            {"type": "section", "text": {"type": "mrkdwn", "text": text}}
        ]
    })

优点:实时 (秒级)、富文本块、thread 回复、@ 提醒缺点:依赖 Slack,团队需 Slack 账号

2. Email

def alert_email(to, subject, body):
    import smtplib
    from email.mime.text import MIMEText
    msg = MIMEText(body)
    msg["Subject"] = subject
    msg["To"] = to
    with smtplib.SMTP("smtp.gmail.com", 587) as s:
        s.starttls()
        s.login(USER, PASS)
        s.send_message(msg)

优点:通用,不需要装 app,异步不阻塞缺点:延迟 (分钟级)、易进垃圾箱、HTML 渲染差

3. Webhook

def alert_webhook(url, payload):
    requests.post(url, json=payload, timeout=5)

优点:通用 (JSON 任意接收方)、可路由到不同系统缺点:需要接收端,失败重试要自己做

4. SMS(短信)

def alert_sms(to, text):
    from twilio.rest import Client
    client = Client(TWILIO_SID, TWILIO_TOKEN)
    client.messages.create(
        from_="+1234567890", to=to, body=text
    )

优点:无网也能收、紧急最高优先级缺点:贵 (每条 $0.01+)、字符限制 160、有 spam filter

4 种方式实测 (我项目 30 天)

指标	Slack	Email	Webhook	SMS
到达延迟	1-3s	30-300s	1-5s	5-30s
到达率	99%	90%	99%(自己控制)	95%
成本/月	$0	$0	$0	$5+
字符限制	40k	无	无	160
异步支持	✓	✓	✓	✗
富文本	✓(blocks)	✓(HTML)	JSON 自由	✗
团队协作	✓(thread)	✗	✗	✗
移动端	✓(app)	✓(mail app)	✗	✓(SMS)

选型

场景	选
团队用 Slack	Slack
非开发人员	Email
接自己系统	Webhook
紧急高优	SMS

5 个工程细节

1. 降级 (主通道失败,备用)

def alert_with_fallback(text):
    try:
        alert_slack(text)
    except Exception:
        try:
            alert_webhook(BACKUP_WEBHOOK, {"text": text})
        except Exception:
            alert_email(EMERGENCY_EMAIL, "Alert", text)

2. 限流 (防刷屏)

last_alert = {}

def alert_with_dedup(key, text, cooldown=300):
    if key in last_alert and time.time() - last_alert[key] < cooldown:
        return  # 5 分钟内同 key 不重发
    last_alert[key] = time.time()
    alert_slack(text)

3. 富文本 (blocks 结构)

alert_slack_blocks(
    f"排名变化",
    blocks=[
        {"type": "section", "text": {"type": "mrkdwn", "text": "*{{kw}}* 跌了"}},
        {"type": "section", "fields": [
            {"type": "mrkdwn", "text": f"上次: #{old}"},
            {"type": "mrkdwn", "text": f"这次: #{new}"}
        ]},
        {"type": "actions", "elements": [
            {"type": "button", "text": "查看详情", "url": url}
        ]}
    ]
)

4. 异步 (不阻塞主流程)

import threading

def alert_async(text):
    threading.Thread(target=alert_slack, args=(text,)).start()

5. 限速 (Slack webhook 限速)

# Slack webhook 限速 1 条/秒
import time

last_call = 0

def alert_rate_limited(text):
    global last_call
    now = time.time()
    if now - last_call < 1:
        time.sleep(1 - (now - last_call))
    last_call = time.time()
    alert_slack(text)

4 种方式实战代码

Slack

import requests

SLACK_WEBHOOK = "https://hooks.slack.com/services/..."

def alert_slack_with_blocks(query, old_rank, new_rank, url):
    blocks = [
        {
            "type": "header",
            "text": {"type": "plain_text", "text": "📉 SERP 排名变化"}
        },
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"*{query}* 跌了 5 位以上"
            }
        },
        {
            "type": "section",
            "fields": [
                {"type": "mrkdwn", "text": f"上次: #{old_rank}"},
                {"type": "mrkdwn", "text": f"这次: #{new_rank}"}
            ]
        },
        {
            "type": "actions",
            "elements": [
                {"type": "button", "text": {"type": "plain_text", "text": "查看"}, "url": url}
            ]
        }
    ]
    requests.post(SLACK_WEBHOOK, json={"blocks": blocks}, timeout=5)

Email

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def alert_email_rich(to, query, old_rank, new_rank, url):
    msg = MIMEMultipart()
    msg["From"] = "alerts@yourdomain.com"
    msg["To"] = to
    msg["Subject"] = f"SERP Alert: {query} 变化"

    html = f"""
    <h2>SERP 排名变化</h2>
    <p>关键词: <b>{query}</b></p>
    <p>上次: #{old_rank} → 这次: #{new_rank}</p>
    <p><a href="{url}">查看 SERP 结果</a></p>
    """

    msg.attach(MIMEText(html, "html"))

    with smtplib.SMTP("smtp.gmail.com", 587) as s:
        s.starttls()
        s.login(USER, APP_PASS)
        s.send_message(msg)

Webhook(通用)

import requests
import hmac
import hashlib

def alert_webhook_signed(url, payload, secret):
    body = json.dumps(payload)
    sig = hmac.new(secret.encode(), body.encode(), hashlib.sha256).hexdigest()

    headers = {
        "X-Signature": f"sha256={sig}",
        "Content-Type": "application/json",
    }

    for attempt in range(3):
        try:
            r = requests.post(url, data=body, headers=headers, timeout=5)
            if r.ok:
                return
        except Exception:
            time.sleep(2 ** attempt)

SMS

from twilio.rest import Client

def alert_sms_emergency(to, query, new_rank):
    client = Client(TWILIO_SID, TWILIO_TOKEN)
    client.messages.create(
        from_="+1234567890",
        to=to,
        body=f"SEO: {query} 跌到 #{new_rank},立即查看!",
    )

实战数据 (我项目 1 个月)

指标	数值
告警总次数	28 次
Slack 到达	28/28(100%)
Email 到达	24/25(96%)
Webhook 到达	28/28(100%)
SMS 到达	5/5(100%,仅用紧急)
平均延迟 Slack	2s
平均延迟 Email	60s
成本 Slack	$0
成本 Email	$0
成本 SMS	$0.05(5 条紧急)

5 个最佳实践

多通道 fallback:Slack 主,Webhook 备,Email 三备,SMS 紧急
去重防刷屏:5 分钟同 key 不重发
限流防限速:Slack 1 秒/条
异步不阻塞:主流程触发告警就返
富文本优先:Slack 用 blocks,Email 用 HTML,展示清楚

小结

4 种告警方式选型:

Slack:团队用 Slack(90% 团队)
Email:非开发人员
Webhook:接自己系统
SMS:紧急高优 (成本高,慎用)

serpbase + 任意告警方式,5 分钟搭好。serpbase 的 1.4s P50 + auto-refund 让你告警永远及时,失败不扣 credit。

SERP API 错误处理:5 个生产级 retry 与降级模式

dodou88 — Sun, 19 Jul 2026 17:05:50 +0800

背景

SERP API 在生产环境跑 1 个月后,遇到了这些错:

网络抖动 (1-2 次/周)
429 限流 (2-3 次/周,峰值时段)
vendor 5xx(2-3 次/月,短暂故障)
4xx 客户端错 (罕见,但有)
解析失败 (vendor 改 schema,1-2 次/月)

下面是 5 个生产级处理模式,踩坑后总结的。

模式 1:retry with exponential backoff

import time
import random

def fetch_with_retry(url, headers, body, max_retries=3):
    """指数 backoff + jitter,只对 5xx/timeout 重试"""
    for attempt in range(max_retries):
        try:
            r = requests.post(url, headers=headers, json=body, timeout=10)
            r.raise_for_status()
            return r.json()
        except requests.exceptions.Timeout:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(wait)
        except requests.exceptions.HTTPError as e:
            if 400 <= e.response.status_code < 500:
                raise  # 4xx 不重试(参数错,重试也错)
            if e.response.status_code == 429:
                # 429 看 Retry-After 头
                retry_after = int(e.response.headers.get("Retry-After", 1))
                if retry_after > 60:
                    raise  # 限流过久,放弃
                time.sleep(retry_after)
                continue
            # 5xx 重试
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)

关键:4xx 不重试 (参数错,重试也错),5xx 才重试。429 看 Retry-After 头。

模式 2:circuit breaker(熔断)

class CircuitBreaker:
    def __init__(self, failure_threshold=10, cooldown=30):
        self.failures = 0
        self.last_failure = 0
        self.failure_threshold = failure_threshold
        self.cooldown = cooldown
        self.state = "CLOSED"  # CLOSED / OPEN / HALF_OPEN

    def call(self, func, *args, **kwargs):
        if self.state == "OPEN":
            if time.time() - self.last_failure > self.cooldown:
                self.state = "HALF_OPEN"
            else:
                raise Exception("Circuit open, fast-fail")
        try:
            result = func(*args, **kwargs)
            if self.state == "HALF_OPEN":
                self.state = "CLOSED"
                self.failures = 0
            return result
        except Exception:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.failure_threshold:
                self.state = "OPEN"
            raise

场景:vendor 故障时 5xx 飙到 100%,不熔断的话 30 秒内几万请求全失败,雪崩。熔断后 30 秒内所有调用 fast-fail,等 vendor 恢复。

模式 3:fallback to cache

def fetch_with_fallback(query):
    cache_key = f"serp:{hash(query)}"

    # 1. 试 API
    try:
        data = fetch_serp_api(query)
        cache.set(cache_key, data, ttl=300)
        return data
    except Exception as e:
        # 2. 失败返旧缓存(允许 stale)
        cached = cache.get(cache_key, allow_stale=True)
        if cached:
            return cached
        # 3. 没缓存返 None
        return None

场景:API 故障但需要响应,给个 5-10 分钟前的旧数据 (标记 stale)。比返错好。

模式 4:graceful degradation

def fetch_or_fail(query):
    """失败返降级结构(部分字段),不是 None"""
    try:
        return fetch_serp_api(query)
    except Exception:
        # 返最小可用结构
        return {
            "organic": [],  # 空数组
            "people_also_ask": [],
            "_stale": True,
            "_error": "SERP API unavailable",
        }

场景:LLM 收到降级结构 (organic: []),不会因缺字段崩。_stale: True 让 LLM 知道数据可能不准。

模式 5:dead letter queue

def fetch_with_dlq(query, dlq):
    try:
        return fetch_serp_api(query)
    except Exception as e:
        # 失败 3 次后进死信队列,人工 review
        retry_count = redis.incr(f"serp:retry:{hash(query)}")
        if retry_count > 3:
            dlq.push({
                "query": query,
                "error": str(e),
                "ts": time.time(),
            })
            redis.expire(f"serp:retry:{hash(query)}", 86400)
        raise

场景:失败不丢失,3 次后进死信队列,人工 review 或 fallback 缓存。

5 模式组合

实际生产里 5 个模式我都用,按这个顺序:

def robust_fetch(query, dlq):
    """综合 5 个模式"""

    # 1. Cache check
    cached = cache.get(f"serp:{query}")
    if cached:
        return cached

    # 2. Circuit breaker
    try:
        return circuit_breaker.call(fetch_with_retry, query)
    except Exception as e:
        # 3. Fallback to stale cache
        stale = cache.get(f"serp:{query}", allow_stale=True)
        if stale:
            return stale

        # 4. Graceful degradation
        if retry_count(query) < 3:
            redis.incr(f"serp:retry:{query}")
            raise

        # 5. Dead letter queue
        dlq.push({"query": query, "error": str(e), "ts": time.time()})
        return {
            "organic": [],
            "people_also_ask": [],
            "_stale": True,
            "_error": str(e),
        }

监控告警

指标	阈值	告警
failure_rate (5min)	> 5%	Slack
circuit_breaker_open	任意	Slack + oncall
dlq 长度	> 100	Slack
avg_latency	> 3s	Slack(vendor 慢)

实测数据

错误类型	频率	处理结果
网络抖动	35 / 周	retry 100% 成功
vendor 5xx	12 / 周	60% retry 成功,40% fallback 缓存
429 限流	8 / 周	retry_after 等待
4xx 客户端错	3 / 月	不重试,直接 fail
解析失败	2 / 月	通知 vendor + fallback 缓存

SERP API 特有技巧

auto-refund 利用:很多 SERP API(包括我用的这个) 失败时自动退 credit。如果 vendor 故障 1 小时,我的 retry 都失败,fallback 缓存兜底,vendor 恢复后失败那批调用都退了 credit,没浪费。

vendor 切换:SERP API 1 家故障 30 分钟以上时,可临时切到备选 vendor(类似服务)。但 vendor 切换是大事,先有降级和熔断,后考虑切换。

故障时仍记 log:失败时 log 到 ELK(请求 ID + 错误),事后分析原因。SERP API 返回 request_id 字段,方便 vendor 排查。

小结

SERP API 错误处理 5 模式按这个优先级:

Cache(成本最低)
Retry with backoff(网络抖动)
Circuit breaker(vendor 故障)
Fallback to cache / degradation(持续故障)
Dead letter queue(人工 review)

5 模式不是堆叠,而是按场景组合:

正常:cache → API → log
抖动:cache miss → API retry → success
故障:circuit open → fallback cache → success(用户感知不到)
长期故障:cache stale → degradation 字段 → 部分 success

SerpBase 的 auto-refund 帮我省了 30% SERP 成本 (失败调用不扣 credit)。综合 5 模式,SERP 调用成本 + 0.001 美元 / 次,延迟 p99 < 3s。

我给 5 个网站做了个关键词排名监控，一个月光 API 不到 $3

dodou88 — Thu, 16 Jul 2026 08:23:37 +0800

我手上跑着 5 个 side project，每个都想做点 SEO。但市面上能用的排名追踪工具全是给 agency 准备的——Ahrefs $99/月起，SEMrush $130/月起。对一个还在 MVP 阶段的小项目来说，这笔钱投出去肉疼。

不投的话，我完全不知道"react server components 教程"这种我花了 3 周打底的关键词，到底有没有从第 47 名爬到第 30 名。Google Search Console 数据滞后 2-3 天，免费工具又只能看自家站。

所以我给自己写了一个小工具。每天早上 8 点自动跑一遍我关心的关键词，存到 SQLite 里。一共写了不到 80 行 Python。下面是过程和成本。

第一次尝试：又去爬 Google

老规矩，先试试自己爬。Python 写个 requests，模拟浏览器，parse HTML。20 分钟后 IP 被 ban。

换个方案：用 Playwright 跑 headless Chrome，加住宅代理。一个月下来：

代理费用：$0.005/次 × 每天 100 次 × 30 天 = $15
维护时间：每周大概 2 小时调试（Google 改 selector 就崩一次）
失败率：30% 左右

这还没算上"我的网站突然被 Google 标记"的风险。一个小项目不值得冒这个险。

试过的 SERP API

我对比了四个 SERP API，按"独立开发者友好"程度排：

SerpApi：$50/月，5000 次。功能全，但订阅制 + 月底清零，对低频使用不友好。
Serper.dev：$50/月，50000 次。比 SerpApi 单价低，但同样订阅 + 清零。
DataForSEO：按次 $0.0006 起，但要签合同 + 预充值 + 月结。对个人开发者来说流程太重。
SerpBase：$3 买 10,000 次搜索（Starter Boost），1 个月内有效。不用订阅，$10 以上的包不过期。

$3 = 10,000 次搜索这个组合对我正合适。我每天只用 100 次左右，10,000 次能撑一个季度。

实际接入：80 行 Python

我用 /google/search 端点，1 次搜索 1 credit。核心代码：

import requests
import sqlite3
from datetime import date

API_KEY = "你的 key"
DB = "ranks.db"

def get_serp(keyword: str, gl: str = "us", hl: str = "en") -> list[dict]:
    r = requests.post(
        "https://api.serpbase.dev/google/search",
        headers={"X-API-Key": API_KEY},
        json={"q": keyword, "num": 20, "gl": gl, "hl": hl, "device": "desktop"},
        timeout=15,
    )
    r.raise_for_status()
    return r.json().get("organic", [])

def find_my_rank(keyword: str, my_domain: str, gl: str = "us") -> int | None:
    for i, item in enumerate(get_serp(keyword, gl=gl), start=1):
        link = item.get("link", "")
        if my_domain in link:
            return i
    return None

def save_rank(keyword: str, domain: str, rank: int | None):
    conn = sqlite3.connect(DB)
    conn.execute(
        "INSERT INTO ranks (date, keyword, domain, rank) VALUES (?, ?, ?, ?)",
        (date.today().isoformat(), keyword, domain, rank),
    )
    conn.commit()
    conn.close()

每天跑一次，把"哪个关键词、哪个网站、今天第几名"写进 SQLite。一个月下来我就有了一条完整曲线。

成本核算

我的实际用量：

5 个网站 × 20 个关键词 = 100 个关键词
每天 1 次 = 100 次/天
30 天 = 3,000 次/月
$0.30/1k 单价 = $0.90/月

实际上我没买按 $0.30 的 Enterprise 包——我用 $3 的 Starter Boost 撑了 3 个月（10,000 次 ÷ 3,000/月 ≈ 3 个月）。Boost 过期后我换 $10 的 Starter 包（20,000 次，$0.50/1k，不过期），又够跑半年。

对独立开发者来说，这个成本结构才是友好的：先花 $3 试，跑通了再决定要不要升级。

加个本地 SEO 模块

做了主流程之后，我又给其中一个本地服务类的 side project 加了地图排名监控。

两个端点串着用：

/google/maps/search 找商家（每次 2 credit）
拿到 feature_id 之后调 /google/maps/detail 拿完整商家信息（每次 2 credit）

def find_place(query: str, lat: float, lng: float):
    r = requests.post(
        "https://api.serpbase.dev/google/maps/search",
        headers={"X-API-Key": API_KEY},
        json={"q": query, "lat": lat, "lng": lng, "zoom": 14},
    )
    r.raise_for_status()
    return r.json()["places"]

def get_place_detail(feature_id: str) -> dict:
    r = requests.post(
        "https://api.serpbase.dev/google/maps/detail",
        headers={"X-API-Key": API_KEY},
        json={"feature_id": feature_id},
    )
    r.raise_for_status()
    return r.json()["place"]

lat/lng/zoom 这三个参数很重要——传了之后 SERP 会模拟"在这个坐标点附近搜"的结果，跟你从 Google Maps 网页端搜的体验一致。本地 SEO 不传坐标等于白搜。

加这个模块之后，我的用量翻倍——但 $3 的额度还是撑得住。

几个坑

desktop vs mobile：SERP 的桌面端和移动端排名差异巨大。我两个都查，desktop 用来看主关键词，mobile 用来看本地化结果（Google 移动端更偏本地包）。
AI Overview：从 2025 年开始，越来越多的关键词会触发 ai_overview 字段（Google 自己生成的 AI 总结）。我没把它当成一个排名——AI Overview 是抢流量的，不是抢排名的。我只追踪 organic。
IP / 语言地区差异：同一个关键词 hl=en&gl=us 和 hl=zh&gl=cn 出来的结果完全不同。我的 SaaS 是面向全球的，所以两个区都查。
Starter Boost 限制：$3 包每月只能买一次，过期 1 个月。$10 以上不限次、永不过期。记清楚。

一点感受

我现在的方案：

每天早上 8 点 cron 跑一次
100 个关键词 + 20 个本地商家 = 120 次搜索
一个月 3,600 次 = $1.08（按 $0.30/1k 单价算）
实际花了 $3（Starter Boost），撑 3 个月

成本几乎可以忽略。关键是现在我每天都能看到自己的排名曲线，知道哪篇文章在涨、哪篇在掉、哪个关键词被 AI Overview 抢了流量。

独立开发者做 SEO 的最大障碍不是"不懂"，是"看不到"。看不到就没法迭代。$3 起步的工具就能把这件事闭环了，比 $99/月的工具更适合早期项目。

新手可以先用免费 100 次额度（注册就送，不用绑卡）验证自己的查询逻辑：https://serpbase.dev/register

剩下的就看你的网站到底要打什么关键词了。