SERP API Pricing in 2026: I Did the Math So You Don't Have To (Every Provider, Same Unit)

#webdev #api #python #productivity

SERP API Pricing in 2026: The Math Nobody Does

Most developers compare SERP APIs by glancing
at the homepage price. This is almost always
the wrong comparison because every provider
quotes a different unit.

I converted all 9 major providers to
cost-per-1,000-searches at three real
volume tiers. Here's what I found.

Why the headline price is almost always wrong

SerpApi quotes monthly plan cost.

DataForSEO quotes per-request.

Serper quotes per-credit-pack.

ScraperAPI quotes per-credit where
1 Google search costs 25 credits.

Bright Data quotes per-result, not
per-search (one search = 10 results =
10 billable units).

Until you convert everything to the same
unit, you cannot compare them.

The conversion table

Provider	Per 1K at 10K/mo	Per 1K at 100K/mo	Credit expiry
Serpent API	$0.06	$0.03	Never ✓
DataForSEO (async)	$0.60	$0.60	Never ✓
Serper.dev	$1.00	$0.50	6 months
SerpApi Starter	$25.00	$15.00	Monthly ✗
Bright Data	$0.75–$1.50	$0.65+	N/A
ScrapingDog	$2.00	$0.29	Cycle ✗
ScraperAPI	$12.25 (effective)	$1.07	Monthly ✗
Oxylabs	$1.60/result	Varies	N/A
SearchAPI.io	$4.00	~$1.00	N/A

The ScraperAPI credit trap

ScraperAPI's Hobby plan: $49/month for
"100,000 API credits."

What the homepage doesn't say prominently:
1 structured Google SERP request = 25 credits.

100,000 credits ÷ 25 credits/search
= 4,000 actual Google searches
= $12.25 per 1,000 searches effective rate
That makes it the most expensive entry
tier on this list after SerpApi.

The credit expiry tax

SerpApi resets credits monthly. If your
usage is inconsistent — seasonal campaigns,
project-based workloads, quarterly audits —
you're paying for credits you never use.

At 60% average utilisation on a $75/month
plan:

python
plan_cost = 75          # $/month
utilisation = 0.60      # 60% used on average
credits_allocated = 5000
credits_used = credits_allocated * utilisation  # 3,000
effective_cost_per_1k = plan_cost / (credits_used / 1000)
# = $25.00 per 1,000 — not $15.00 as advertised

Real effective cost: $25/1K, not $15/1K.

The async vs synchronous problem

DataForSEO's $0.60/1K standard queue is
genuinely the cheapest raw rate — but
it's asynchronous:

python
# DataForSEO workflow (standard queue)
task_id = client.post_task(keyword)    # Step 1
time.sleep(30)                          # Wait
result = client.get_task(task_id)       # Step 2
# Then handle: not ready yet? retry logic.
# Timeout? Handle that too.
# Failed task? Resubmit.

vs synchronous:

python
# Serpent API
result = requests.get(
    "https://apiserpent.com/api/search",
    params={"q": keyword},
    headers={"X-API-Key": KEY}
)
# Done. No polling. No state management.

If your use case is overnight batch rank
tracking — async is fine. If a user is
waiting for results, async is wrong architecture.

How to calculate your real cost

python
def calculate_real_cost(
    monthly_volume: int,
    plan_cost: float,
    plan_credits: int,
    avg_utilisation: float = 1.0,  # 1.0 = use all credits
    credits_per_search: int = 1
) -> dict:
    """Calculate true effective cost per 1K searches."""

    actual_searches = (plan_credits / credits_per_search) * avg_utilisation
    effective_cost_per_1k = plan_cost / (actual_searches / 1000)

    return {
        "monthly_cost": plan_cost,
        "actual_searches": int(actual_searches),
        "effective_per_1k": round(effective_cost_per_1k, 2),
        "wasted_credits_cost": round(
            plan_cost * (1 - avg_utilisation), 2
        )
    }

# SerpApi Developer at 60% utilisation
print(calculate_real_cost(5000, 75, 5000, 0.60))
# {'monthly_cost': 75, 'actual_searches': 3000, 
#  'effective_per_1k': 25.0, 'wasted_credits_cost': 30.0}

# Serpent API Scale (credits never expire = 100% utilisation)
print(calculate_real_cost(100000, 3.0, 100000, 1.0))
# {'monthly_cost': 3.0, 'actual_searches': 100000,
#  'effective_per_1k': 0.03, 'wasted_credits_cost': 0.0}