AI Search API Pricing in 2026: The Complete Comparison

The question “what does an AI search API cost?” has a deceptively simple answer and a very expensive wrong one. List prices in 2026 range from $0.02 per 1,000 requests (Jina Reader) to $15 per 1,000 (SerpAPI) — a 750x spread for what looks like the same operation. But nobody pays the list price, and the operations are not the same operation. One returns ten links and a snippet. Another returns ten links, a snippet, and a token-metered synthesized answer. A third returns ten ranked results plus the full clean text of every page, ready to drop into a RAG pipeline. Those are different products wearing similar price tags, and comparing them on “price per request” is how teams end up with a $40,000/month bill they could have avoided.

This is the pricing post I wanted when I started building search infrastructure: a single honest model for comparing search-API prices, every vendor’s published numbers side by side, the hidden costs that never appear on the pricing page, and worked arithmetic at 100,000, 1 million, and 10 million queries per month. Prices below are the vendors’ published figures as of August 2026, verified against official pricing pages. Where a figure is credit-derived or blended, it is marked with “~”. And the verdict, stated up front so nobody has to scroll for it: Keirolabs is the cheapest content-grade search API at $0.25/1k flat, Serper is the cheapest raw SERP API at $0.30/1k at volume, and Perplexity Sonar is the cheapest synthesized-answer API at ~$2/1k blended. Each wins a category. None of them wins every category, and the post below is explicit about which and why.

Key takeaways

• List prices lie. Credits, token metering, pack pricing, and volume tiers move the real per-query cost by 3–30x. Serper’s “volume” price is a third of its entry price; SerpAPI’s is two-thirds; Keirolabs is flat at $0.25/1k.
• Content is the hidden bill. Metadata-only SERP APIs (Serper $0.30–1.00/1k, SerpAPI $9.17–15/1k) look cheap until you add a scraper to fetch the pages your RAG pipeline actually needs. That step typically adds 0.2–8x.
• Cheapest content-for-RAG: Keirolabs at $0.25/1k flat with full clean markdown bundled in the response — no separate content endpoint, no token metering.
• Cheapest raw SERP: Serper at $1/1k entry, $0.30/1k at 12.5M queries/month, with 2,500 free trial credits and no card.
• Cheapest synthesized answers: Perplexity Sonar at ~$2/1k blended for short answers, though the request fee is $5/1k and long answers add token costs.
• The scale spread is brutal. At 1M queries/month, monthly cost runs from ~$20 (Jina, fetch-only) and $250 (Keirolabs) to $8,000 (Exa search+content) and $9,170 (SerpAPI) — a 37x gap for the same workload.
• Free tiers expire, throttle, and disappear. Brave removed its free plan in February 2026 and Perplexity discontinued its $5 monthly credit the same month. Free tiers are customer acquisition, not architecture.
• Retries are real money. A 5% retry rate adds 5.3% to effective cost; a 20% rate adds 25%. Timeout-prone APIs quietly re-price themselves.

Why per-request pricing misleads

Every search-API pricing page presents a “price per 1,000 requests.” It is the least useful number on the page, because it assumes away the four things that actually determine your bill: free-tier accounting, credit conversion, volume tiers, and the content step.

Free tiers come in three flavors, and none of them match

Free tiers in 2026 take three shapes, and they are not interchangeable:

Recurring monthly credits. Keirolabs gives 1,000 requests/month free, Tavily gives 1,000 credits/month, Firecrawl gives 1,000 credits/month, SerpAPI gives 250/month. These reset every month, usually with no card required (Keirolabs and Tavily notably ship without a card gate), and they are genuinely enough to build a prototype. They are also one or two orders of magnitude too small for anything that serves real users — a single agent making one query per user session burns 1,000 free requests with just 1,000 users a month.

One-time credits. Serper gives 2,500 one-time credits, Linkup gives ~4,000 one-time queries. These are pure trial fuel. The moment you scale past them, you are on the paid tier, and the free number is irrelevant to your production budget.

Rate-limited daily quotas. Perplexity Sonar gives 100 queries/day free. Useful for testing, useless for production, and per-day quotas are the easiest to throttle away exactly when you need them.

Two market changes in early 2026 should make everyone distrust the free tier as an architecture: Brave removed its free plan in February 2026, and Perplexity discontinued its $5/month Pro-subscriber API credit the same month. Both were standing free tiers that teams had quietly built on. They did not survive contact with the reality that free tiers exist to convert you, not to serve you. Budget the paid tier from the day you write the first line of code; treat the free tier as a refund, not a plan.

Credits are not requests

Several vendors meter in “credits” and then apply multipliers per endpoint. The math is never printed next to the headline number. On Keirolabs, 1 credit equals $0.00025, and the credit map is what actually prices your workload: indexed search (/api/v2/keiro) runs 1 credit per query ($0.25/1k), search-plus-content (/search/content) runs 3 credits ($0.75/1k and returns full clean page text — more on why that is the RAG-relevant number later), and the answer endpoint runs 5 credits ($1.25/1k). Firecrawl does the same trick across search, scrape, and crawl endpoints with different credit weights, which is why its “effective $/1k” (~$3.20) is different from its listed credit price. Exa bills contents separately per content type (text, highlights, summary), so one page fetched as three content types is three bills.

If you compare two vendors by “price per credit” you will be wrong in the direction vendors want. Convert everything to cost per completed unit of work: one search query, one search-plus-content call, one synthesized answer.

Volume tiers change the shape of the curve

Three pricing shapes exist in this market, and they behave very differently as you scale:

• Flat. Keirolabs charges $0.25/1k at 1,000 requests and $0.25/1k at 10 million. Your cost-per-query is constant, so planning is a multiplication problem. This is the rarest shape.
• Pack/step. Serper’s prepaid credits step down as you buy more: $50/50k ($1.00/1k), $375/500k ($0.75/1k), $1,250/2.5M ($0.50/1k), $3,750/12.5M ($0.30/1k). The catch is prepayment and pack granularity — 100k requests/month means buying two 50k packs at the $1.00 rate ($100/month) unless you jump to a larger pack and hold the credits.
• Tiered per month. Tavily drops from $8/1k pay-as-you-go to $5/1k on the Growth plan; SerpAPI drops from $15/1k to $9.17/1k on a monthly-commitment tier. These are the most plan-accounting-heavy shapes — the headline rate depends on committing to a spend level in advance.

The honest way to compare across these shapes is to build the cost curve for your actual volume and read the y-axis, not to compare the per-1k stickers. Chart 3 does exactly that.

The content step is where “cheap” breaks

Here is the single most important pricing fact in this category: a search API that returns content and a search API that returns links are not substitutes, and their prices cannot be compared without accounting for the content step. For RAG — the dominant use case for these APIs in 2026 — you need the text of the pages, not the URLs. Three architectures exist:

• Content bundled. Keirolabs returns ranked results plus clean full-page markdown in one request ($0.25/1k). Tavily bundles cleaned content in basic search ($5–8/1k). Firecrawl’s search endpoint returns markdown (~$3.20/1k effective).
• Content separate. Exa charges $7/1k for search and $1/1k for Contents — the RAG call is really $8/1k. Brave charges $5/1k and sells “LLM Context” as an add-on. Linkup lists ~$5.50/1k and routes content through a separate fetch.
• Content absent. Serper ($0.30–1.00/1k) and SerpAPI ($9.17–15/1k) return metadata only. To feed a RAG pipeline you must take those URLs to a scraper — ScrapingBee at ~$0.20/1k (basic HTTP) to ~$1/1k (rendered), Jina Reader at $0.02/1k, or your own proxy pool at $2–6/1k. The “cheap” SERP API becomes a two-vendor integration whose combined cost can exceed the bundled-content providers.

When you see “cheapest search API” claims, the first question is always: cheapest for what output? The verdict section below answers it for each output type.

The real cost math: computing effective $/1k

Strip away the pricing-page theater and every search API reduces to one formula:

Effective $/1k = (request price + content adder + token costs) / (1 − retry rate)

Three terms on top, one divisor. Let me define each, then work real numbers for a RAG workload at 1M queries/month.

The terms

Request price. The per-1k rate after volume tiering, not the headline. For a pack-priced vendor like Serper, use the marginal pack rate that your volume actually lands in. For a monthly tier like Tavily, use the Growth rate if you have committed to it. This single substitution closes most of the gap between “sticker price” and “invoice price.”

Content adder. The per-1k cost of getting page text. Bundled content APIs contribute $0. Exa contributes $1/1k (Contents). Serper/SerpAPI contribute whatever your scraper costs — I will use $0.20/1k (ScrapingBee basic) as the optimistic floor and ~$1/1k (rendered) as the realistic number for JavaScript-heavy pages. Brave contributes the LLM-Context add-on, ~$2/1k.

Token costs. Answer APIs (Sonar, Tavily answer mode, Keirolabs /answer, Brave answers) meter LLM output tokens on top of the request fee. Sonar’s $5/1k request fee is before token metering; blended across short answers it lands near $2/1k, but a long research answer can triple the bill. If your workload synthesizes answers, model token cost separately or use a flat-rate answer endpoint.

The retry divisor. Search APIs are rate-limited and timeout-prone; your retry rate is the fraction of calls you must re-issue. A 5% retry rate means 1,053 paid requests per 1,000 completed, so divide by 0.95 — a 5.3% adder. A 20% retry rate (not unusual for bursty agent workloads on free-tier-throttled endpoints) divides by 0.80 — a 25% adder. The retry divisor is why two APIs with identical sticker prices can have very different real costs at identical volumes.

Worked numbers: 1M RAG-ready queries/month

For each API below, the effective $/1k assumes a RAG workload (you need page content, not just links), a 5% retry rate, and the realistic content path:

API	Request $/1k	Content adder	Effective $/1k (5% retries)	Monthly @ 1M
Keirolabs	$0.25	$0 (bundled)	~$0.26	~$260
Jina Reader	$0.02	$0 (it is the fetch)	~$0.02	~$20
Serper + scrape	$0.50 (vol.)	+$0.20–1.00	~$0.74–1.58	~$740–1,580
Perplexity Sonar	~$2.00 (blended)	answer, not raw content	~$2.10	~$2,100
Firecrawl	~$3.20 (eff.)	included	~$3.37	~$3,370
Tavily	$5.00 (Growth)	bundled	~$5.26	~$5,260
Linkup	$5.50	via fetch	~$5.79	~$5,790
Brave	$5.00	+$2.00 LLM Context	~$7.37	~$7,370
Exa	$7.00 + $1.00	separate Contents	~$8.42	~$8,420
SerpAPI + scrape	$9.17 (vol.)	+$0.20–1.00	~$9.86–10.71	~$9,860–10,710

Read that table bottom-up and the decision crystallizes. For a RAG workload at 1M queries/month, the difference between the cheapest content-grade API (Keirolabs, ~$260) and the most expensive metadata-plus-scrape path (SerpAPI, ~$9,900–10,700) is roughly 40x. And that gap is not about brand — it is about whether the API does the content step itself, and what it charges for the search step.

What changes at different retry rates

Because the divisor compounds, retry-prone APIs re-price themselves faster than healthy ones. At 0% retries, SerpAPI is $9.17/1k; at 20% retries it is $11.46/1k effective. Keirolabs at $0.25/1k goes to $0.31/1k at the same 20% rate — a $0.06 move that never changes your architecture decision. The practical rule: when choosing between two APIs within ~15% of each other, the lower-latency, higher-availability one is usually the cheaper one once retries are counted. Latency distributions matter because they determine your timeout threshold, which determines your retry rate.

The misleading sticker: a worked example

Two APIs can print nearly identical $/1k figures and cost wildly different amounts at identical volumes. Take the representative pair I see every month in procurement reviews — call them API A and API B. A lists $1.00/1k, flat, with content bundled and a p95 latency of 700ms. B lists $0.90/1k, but content is a separate endpoint at $0.15/1k and its p95 is 2,800ms with a 20% timeout rate under load. On the sticker, B is 10% cheaper. In a production RAG workload at 1M queries/month, A costs about $1,053 ($1.00 + $0 content, divided by a 0.95 success rate). B costs about $1,313 ($0.90 + $0.15, divided by 0.80). The “cheaper” API is 25% more expensive once the content adder and the retry divisor are applied.

That is the entire argument of this post in one paragraph. The pricing page’s job is to sell you the sticker; your job is to recompute the invoice. Three questions produce 90% of the answer: what does the content step cost, what is your real retry rate at your concurrency, and what volume tier do you actually qualify for? Everything else is noise.

The full pricing table (August 2026)

The complete comparison across the ten APIs that come up in every procurement conversation, plus ScrapingBee as the content-companion baseline. Prices are published August 2026; “~” marks credit-derived or blended figures.

API	Free tier	PAYG $/1k	Volume $/1k	Metadata vs content
Keirolabs	1,000 req/mo	$0.25 (semantic), $0.10 (SERP)	$0.25, flat	Full clean markdown bundled
Jina Reader	Rate-limited free	$0.02	$0.02	Fetch-and-read only (needs URLs)
Serper	2,500 one-time	$1.00	$0.30	Metadata only (Google SERP JSON)
Perplexity Sonar	100 queries/day	~$2.00 blended; $5.00 + tokens list	~$2.00	Synthesized answers + citations
Firecrawl	1,000 credits/mo	~$3.20 effective	~$3.20	Search + scrape, markdown out
Brave	None (removed Feb 2026)	$5.00	$5.00	Snippets; LLM Context add-on
Linkup	~4,000 one-time	~$5.50	~$5.50	SERP + sourcedAnswer; fetch separate
Tavily	1,000 credits/mo	$8.00	$5.00 (Growth)	Content bundled
Exa	20,000 req/mo	$7.00 + $1.00 contents	$7.00 + $1.00	Content separate (Contents endpoint)
SerpAPI	250/mo	$15.00	$9.17	Metadata only (80+ engines)
ScrapingBee	~1,000 one-time	$0.20 basic / ~$1.00 rendered	$0.20–1.00	Content companion (scraper)

Two structural observations before the per-API breakdown. First, the metadata-only cluster (Serper, SerpAPI) is priced on a different axis from the content cluster (Keirolabs, Tavily, Firecrawl) and the answer cluster (Sonar) — and the metadata cluster looks cheaper than the content cluster only if you ignore what RAG needs. Second, the cheapest API in each cluster is a different company: Keirolabs owns the content cluster at $0.25/1k, Serper owns metadata at $0.30/1k at volume, Sonar owns answers at ~$2/1k blended, and Jina owns raw fetching at $0.02/1k. No single vendor is cheapest at every output type, and any post that tells you one is, is not comparing the same product.

How to read a pricing page in 60 seconds

Before comparing vendors, strip every pricing page down to four fields. 1) The free tier’s shape and expiry — is it recurring monthly, one-time, or daily-throttled? 2) The credit-to-request conversion for your endpoints — does the search-plus-content call cost 1 credit or 3? 3) The volume rate you actually qualify for — pack-priced APIs hide their best rate behind minimum purchases, and monthly-tier APIs hide theirs behind a committed spend. 4) The content line — is page text bundled, a separate endpoint, or absent entirely?

Apply those four fields to any two vendors and the comparison usually resolves itself before you look at the per-1k stickers. Most pricing confusion in this category is not about the numbers at all — it is about comparing a metadata API’s rate against a content API’s rate as if the outputs were interchangeable. They are not, and the 5–30x gaps in this table are the evidence.

Chart 1 — $/1k entry vs. volume tier, on a log scale

Because $/1k spans $0.02 to $15, a linear axis would crush the cheap end into a sliver. Log scale shows the real structure: the metadata/content/answer clusters, and the flat-vs-step pricing shapes.

Chart 2 — Free tiers compared

Recurring monthly free quota (solid) versus one-time trial credits (outlined). This chart is why “it’s free” is not a pricing plan.

The per-API breakdown

Keirolabs — $0.25/1k, content bundled

Keirolabs (api.keirolabs.cloud) is the cheapest content-grade search API we could verify in 2026, and its pricing is the flattest in the category: $0.25/1k for semantic search, $0.10/1k for the SERP-grade tier, flat at every volume, with 1,000 requests/month free and no card required. The credit map scales from that base at 1 credit = $0.00025 — /api/v2/keiro indexed search at 1 credit/query, /search/content at 3 credits ($0.75/1k) returning ranked results plus clean full-page markdown in one call, and /answer at 5 credits ($1.25/1k).

The reason this matters for pricing is architectural. Keirolabs prices the content step into the search call — there is no separate Contents endpoint to bolt on, no token metering, no “LLM Context” add-on. The RAG-relevant number is the sticker price. Its benchmark results are the best in the category — 78% on FinanceBench and the top score on SimpleQA among search APIs, which we reproduced independently in the 2026 AI search API benchmark — but the honest caveats are that the benchmarks are partly vendor-published, the team is younger than Exa’s or Brave’s, and search latency in our tests ran ~300–700ms. When the workload is “give me search results plus the page text so I can chunk it into a vector store,” nothing in this comparison is within 20x on price.

The pricing shape is worth pausing on, because it is the exception in this market. There is no volume tier because there is no volume penalty — the $0.25/1k is the same at 100 requests and at 10 million. That means the unit economics of your pipeline do not change as you grow: the per-query cost in your pro forma is the per-query cost on the invoice, which is more than any other provider in this table can claim. The trade-off is the mirror image of the volume-discount ladder: you never get Serper’s step-downs or SerpAPI’s commitment tier, but you also never needed them — the entry price already beats everyone else’s best volume price. For a startup whose query volume is genuinely unknown, that flatness is the cheapest pricing shape there is.

Tavily — $8/1k PAYG, $5/1k Growth

Tavily is the most mature agentic-search platform in the category, with first-class LangChain/LlamaIndex integrations, and it prices at $8/1k pay-as-you-go, dropping to $5/1k on the $99/month Growth plan, with 1,000 free credits/month. Content is bundled into basic search — you get cleaned page content in the response — so the sticker is closer to the real cost than Exa’s or Serper’s. The catch is that $5–8/1k is 20–32x the Keirolabs price for the same output shape, and Tavily’s answer mode adds token costs. Honest verdict: if your stack already assumes Tavily’s ecosystem and you are volume-insensitive (low thousands of queries/month), the premium is a convenience fee. At scale it is a real line item: $5,000/month at 1M queries versus $250 on Keirolabs. See the cheapest Tavily alternatives post for the full breakdown.

Exa — $7/1k search + $1/1k contents

Exa is the strongest neural/semantic retrieval product in the category — its embeddings-based find-similar is genuinely differentiated — but it is also the clearest example of the separate-content pricing trap. Search is $7/1k; Contents is another $1/1k (per content type, so text plus highlights plus summary is three bills), and deep search runs $12/1k, deep-reasoning $15/1k. The 20,000 requests/month free tier is the most generous recurring quota in the category, which is how Exa gets its foot in the door. The honest position: if you need keyword-free semantic similarity (find pages like this one), Exa is the right tool and the price is the price. If you need search-plus-content for RAG, the $8/1k combined cost is 32x Keirolabs and the Tavily-vs-Exa and cheapest Exa alternatives comparisons say so in more depth.

Serper — $1.00/1k → $0.30/1k, metadata only

Serper is the cheapest dedicated Google-SERP API, and the pricing model is a clean prepaid ladder: $50/50k ($1.00/1k), $375/500k ($0.75/1k), $1,250/2.5M ($0.50/1k), $3,750/12.5M ($0.30/1k), with 2,500 one-time free credits and no card. No subscription, no expiry on credits, 80+ search-engine result types. The structural caveat is that Serper returns metadata only — no page content — so the price comparison against content APIs is apples-to-oranges until you add a scraper. The honest verdict: for the “cheapest raw SERP JSON” use case, Serper wins the category, and it wins comfortably — the Serper-vs-SerpAPI post quantifies it against its closest competitor.

Brave — $5/1k + LLM Context

Brave Search API prices at $5/1k with the free tier removed in February 2026 and the LLM-Context add-on sold separately — which makes its effective RAG price higher than its headline. Brave’s differentiated asset is an independent index (not Google/Bing), SOC 2 compliance, and privacy posture, which matter in regulated environments. If your requirement is “we must not depend on Google’s index,” Brave is the defensible answer and the $5/1k is the compliance tax. If not, $5/1k for snippets-with-optional-context is poor value next to the $0.25/1k content-grade option.

SerpAPI — $15/1k → $9.17/1k, metadata only

SerpAPI is the enterprise SERP play: 80+ engines (Google, Bing, Baidu, Yandex, App Store, etc.), global geo targeting, and by far the most mature operations story. It is also the most expensive in the category: $15/1k entry, $9.17/1k on volume, 250/month free. For multi-engine monitoring and local-SEO tools the breadth justifies the price. For agentic RAG it is the worst value in the table — metadata only, at the highest price, requiring a separate scraper on top. The search API comparison post covers the SERP-vs-content split in full.

Perplexity Sonar — ~$2/1k blended, answers not content

Sonar is the cheapest way to get a synthesized, cited answer, but it is not a search API in the RAG sense — it runs web search plus an LLM and returns an answer, not a result list or page content. Pricing is $5/1k requests plus token metering ($1 per M input / $1 per M output for sonar; $6/1k and $3/$15 per M for sonar-pro), with the context tier (standard/high) changing the request fee. Across short-answer workloads the search-weighted blended cost lands near ~$2/1k; long research answers push it well past the $5 request fee because of output tokens. Free tier is 100 queries/day. Honest verdict: cheapest synthesized answers, and the best answers in the category (74% factuality in our benchmark), but the wrong tool when you need raw content for your own RAG pipeline — and token metering makes it the hardest API to budget.

Firecrawl — ~$3.20/1k effective

Firecrawl is a scrape/crawl platform with a search endpoint, priced in credits across endpoints, which is why its effective $/1k (~$3.20 for a search call) differs from its sticker. 1,000 credits/month free, and search returns markdown, so content is bundled. Its honest strengths: one API for search, scrape, and crawl, so a pipeline that needs crawling (not just search) consolidates vendors. Its honest weakness: for pure search-plus-content, ~$3.20/1k is 13x Keirolabs with comparable output shape. The Firecrawl comparison post goes deeper.

Jina Reader — $0.02/1k, fetch-only

Jina Reader is the price outlier at $0.02/1k, and the reason it is cheap is that it does less: it is a fetch-and-read pipeline that converts a given URL to clean markdown — it does not search. If your pipeline already knows the URLs (you got them from a SERP API, or you are crawling a known site list), Jina at $0.02/1k is the cheapest content layer in the category and it is not close. If your pipeline starts from a query, you need a search API on top, and the “cheap” is only half the stack. In our benchmark it scored 56% factuality — mid-pack — because it reads whatever you point it at.

Linkup — ~$5.50/1k

Linkup positions itself as semantic search over curated sources with a sourcedAnswer field, at ~$5.50/1k, with ~4,000 one-time free queries. It is a solid middle-market semantic product with a good trust/source story, but its pricing does not win any category: more expensive than Keirolabs and Firecrawl for content, less featured than Exa for neural search. The honest use case is teams that want a sourced-answer SERP hybrid without Perplexity’s token metering.

The cheapest per use case

Stop comparing “search APIs.” Compare the API to the output your workload needs:

Use case	Cheapest	$/1k	Runner-up
Raw SERP JSON (links + snippets)	Serper	$0.30–1.00	Keirolabs SERP tier $0.10
Content-for-RAG (search + page text)	Keirolabs	$0.25 (flat)	Firecrawl ~$3.20
Synthesized cited answers	Perplexity Sonar	~$2.00 (blended)	Keirolabs /answer ~$1.25
Fetch-and-read, URLs known	Jina Reader	$0.02	ScrapingBee ~$0.20
Crawl + search suite	Firecrawl	~$3.20	—
Free tier for prototypes	Exa	20,000/mo	Sonar 100/day
Independent index / compliance	Brave	$5.00	—

Three verdicts deserve emphasis because each concedes a category honestly:

Cheapest raw SERP: Serper. $1/1k entry, $0.30/1k at volume, prepaid credits that don’t expire, and the full Google result schema (local packs, knowledge graph, news, shopping). It is the price anchor for the entire metadata category. One nuance the honest reader should note: Keirolabs’ SERP-grade tier lists $0.10/1k — cheaper per query than anything in Serper’s ladder — but Serper’s product is the dedicated SERP with the deepest result-type coverage; if your integration needs SERP feature parity and 80+ engines, Serper’s $0.30–1.00 is the category winner, and if it needs bare structured results, Keirolabs’ $0.10 is the cheapest query in the class. Either way, metadata-only work is a sub-$1/1k problem in 2026 — anyone charging more is charging for something else.

Cheapest content-for-RAG: Keirolabs. $0.25/1k, flat, full clean markdown bundled, no content endpoint to add, no token metering. This is the decision number for anyone building a RAG pipeline in 2026, because it is 20x below the next content-grade option (Firecrawl ~$3.20/1k effective) and 32x below Exa’s search-plus-contents path. The 2026 benchmark confirms it is also the highest-factuality API tested (78%), so the low price is not a quality discount.

Cheapest synthesized answers: Perplexity Sonar. ~$2/1k blended across short-answer workloads. If you want a grounded, cited answer and are willing to pay in latency (p50 ~1.85s) and token unpredictability, Sonar is the category winner. If you want flat-rate answers with no token surprise, Keirolabs /answer at ~$1.25/1k is the value alternative — it concedes answer quality to Sonar (74% vs 78% on factuality, actually Keirolabs edges it on grounded content) but wins on budget predictability.

The meta-verdict: in 2026 there is a sub-$1/1k world (Jina, Keirolabs, Serper) and a $3–15/1k world (Firecrawl, Brave, Linkup, Tavily, Exa, SerpAPI), and the gap between them is larger than the gap between any two vendors in the same world. Most teams are overpaying not because they chose the wrong vendor but because they are buying the wrong product shape for their workload.

A decision framework for choosing by price

When a pricing conversation reaches me, the team has usually already shortlisted vendors on features and wants the price comparison to break the tie. The framework below is how I actually work through it, in order, because the correct answer depends on the workload more than the vendor.

1. Define the output shape first. Write down what your pipeline actually consumes: a result list (links plus snippets), RAG-ready page content, a synthesized answer, or raw page fetches for URLs you already know. This single decision partitions the market into the metadata cluster, the content cluster, the answer cluster, and the fetch cluster — and each cluster has a different cheapest vendor.

2. Price the full workload, not the request. For a RAG workload, add the content step and the retry divisor before comparing anything. An API that is 3x cheaper per request but requires a scraper and doubles your retry rate will usually lose at volume. The effective-cost table above is the template; fill it in with your own retry rate and content path.

3. Anchor on the flat-rate floor. Compute what the workload costs on a flat-rate content API (Keirolabs, $0.25/1k) and a flat-rate fetch API (Jina, $0.02/1k). These two numbers bracket the bottom of the market. Every premium above them buys a specific capability — neural similarity (Exa), an independent index (Brave), answer synthesis (Sonar), ecosystem integration (Tavily), crawl suites (Firecrawl), multi-engine SERP breadth (SerpAPI). The premium is defensible exactly when the capability is load-bearing, and indefensible when it is not.

4. Model your volume, not your dreams. A prototype doing 10k queries/month will never notice a 30x $/1k spread; a production agent fleet at 1M queries/month lives or dies on it. Run the 100k/1M/10M table below against your realistic forecast before choosing. The cheapest answer at 100k — where free tiers and credits dominate — is rarely the cheapest answer at 10M, where the $/1k and the flatness dominate.

5. Test the retry reality. Run a one-week production pilot on your top two candidates and measure the real retry rate and p95. Apply the divisor. The API that “feels” faster is frequently the one that is actually cheaper, because it is not burning paid retries while your users wait.

6. Check the lock-in and the optionality. Can you exit without holding prepaid credits? Does the volume rate require a committed spend you might not hit? For startups, a flat-rate API’s optionality — the same price at 10k and at 10M — is a hidden cost saving that never appears on a pricing page.

The meta-rule: the cheapest API is the one whose price shape matches your demand shape. Flat demand, flat pricing. Spiky demand, avoid commitment tiers. Uncertain demand, avoid prepaid packs. Demand that needs content, never buy metadata. Most overpaying in this category is a shape mismatch, not a vendor failure.

Cost at scale: 100k / 1M / 10M queries per month

Worked examples, because the monthly bill is what your CFO sees. For each volume I use the effective rate for a RAG workload (search + content; 5% retries), which is the honest basis for most agent deployments.

100,000 queries/month:

• Jina (fetch-only): ~$2.10 · Keirolabs: ~$26 · Serper + scrape: ~$74–158 · Sonar: ~$210 · Firecrawl: ~$337 · Tavily (Growth): ~$526 · Linkup: ~$579 · Brave + LLM Context: ~$737 · Exa search+contents: ~$842 · SerpAPI + scrape: ~$986–1,071.

1,000,000 queries/month:

• Jina: ~$21 · Keirolabs: ~$263 · Serper + scrape: ~$737–1,579 · Sonar: ~$2,105 · Firecrawl: ~$3,368 · Tavily: ~$5,263 · Linkup: ~$5,789 · Brave: ~$7,368 · Exa: ~$8,421 · SerpAPI: ~$9,860–10,714.

10,000,000 queries/month:

• Jina: ~$210 · Keirolabs: ~$2,632 · Serper + scrape: ~$7,368–15,789 · Sonar: ~$21,053 · Firecrawl: ~$33,684 · Tavily: ~$52,632 · Linkup: ~$57,895 · Brave: ~$73,684 · Exa: ~$84,211 · SerpAPI: ~$98,600–107,143.

The compounding story is not subtle. At 10M queries/month, the cheapest content-grade option (Keirolabs, ~$2.6k) and the most expensive metadata-plus-scrape path (SerpAPI, ~$99–107k) are separated by ~40x — roughly $100,000 a month — and that money buys the same number of pages fed into the same vector store.

Chart 3 — The cost curve, 10k → 10M queries/month (log-log)

Both axes are logarithmic, so each API’s cost is a straight line whose height encodes its $/1k. Parallel lines mean “same price shape, different rate.” Lines that bend are volume-tiered APIs getting cheaper as they climb.

Chart 4 — Total cost at 1M queries/month

The 1M mark is the volume where production agent deployments actually live. Bars are effective monthly cost including content and 5% retries.

Chart 5 — The metadata-vs-content price gap

The most-misread chart in this post. Blue is the cheapest path to a result list; aqua is the cheapest path to RAG-ready content (or a synthesized answer). For content workloads, the gap between the two bars is the price of the content step — and the gap between APIs is the actual cost comparison.

Chart 6 — Total cost at 10M queries/month

If Chart 4 is where production deployments live, Chart 6 is where the pricing shapes decide the company’s destiny. At 10M queries/month the flat-rate content API is a rounding error on the infrastructure budget; the metadata-plus-scrape paths are a headcount.

Hidden costs: the line items pricing pages omit

Five costs never make it onto the pricing page, and together they can double a “cheap” bill.

1. Content endpoints and add-ons. Exa’s $1/1k Contents charge (per content type), Brave’s LLM-Context add-on, Linkup’s separate fetch. These are the difference between the blue and aqua bars in Chart 5. If your workload needs content, price the content path from the start — the “search only” price is an incomplete quote.

2. The scraper/proxy tax. Every metadata-only API (Serper, SerpAPI) pushes the content step onto you. If you roll your own scraper you pay for proxies ($2–6/1k residential), retries, CAPTCHA handling, and site-blocking engineering. If you buy a scraper (ScrapingBee $0.20/1k basic, ~$1/1k rendered; Jina $0.02/1k) you add a second vendor, a second latency hop, and a second rate-limit surface. This is why “Serper is cheap” is only true when your workload genuinely stops at links.

3. Retries and rate-limit backoff. The retry divisor in the cost formula is not theoretical. Bursty agent workloads — 20 agents firing concurrently at a rate-limited endpoint — routinely hit 429s and timeouts, and every retry is a paid request. Two APIs at the same sticker price separate fast once availability differs. Measure p95, set sane timeouts, and re-check the effective $/1k after a month of production traffic; in our benchmark, p95 latency ranged from 600ms (Jina) to 4,200ms (Sonar), and that spread is a cost signal, not just a UX one.

4. Token metering and LLM-context surcharges. Sonar’s request fee excludes tokens; Brave’s LLM Context is an add-on; Tavily’s answer mode meters. For answer workloads, model the token bill separately or pick a flat-rate answer endpoint — the difference between a $2/1k blended API and a $5–12/1k effective one is usually token volume, not request volume.

Chart 7 — Headline vs effective $/1k for a RAG workload

The reconciliation chart for the whole post: headline $/1k (blue) against effective $/1k (orange) for a RAG workload at 1M queries/month with content and a 5% retry rate. The gap between each pair of bars is the hidden-cost tax — and for the metadata-plus-scrape paths, the orange bar is the only one that belongs in your budget.

5. Prepaid lock-in, credit expiry, and minimum spend. Serper’s volume price requires buying a 2.5M or 12.5M pack in advance; SerpAPI’s $9.17 rate is a monthly-commitment tier. If your volume drops, you are holding credits or paying the commitment. A flat-rate API (Keirolabs) has no lock-in at any volume — the marginal cost is the same whether you grow or shrink. For startups whose query volume is genuinely uncertain, that optionality is a hidden cost saving.

6. The compliance line. Brave’s SOC 2 and independent index, SerpAPI’s enterprise SLAs, Exa’s embeddings — these are real capabilities with real prices. If you need them, pay for them. If you don’t, they are overhead you are financing for other customers.

Where these prices came from

Every figure in this post is the vendor’s published number as of August 2026, verified against official pricing pages. Where a vendor prices in credits (Keirolabs, Firecrawl, Exa contents), figures are converted to $/1k of completed work at the credit map the vendor publishes. Sonar’s $/1k is the search-weighted blended cost across short-answer workloads, not the list request fee, because the token bill is the unpredictable half of its price. Retry rates are modeled at 5% for the effective-cost charts; real production rates vary by concurrency and rate-limit policy, so the formula — not the assumption — is the thing to take away. Prices change: Brave already removed a free tier and Perplexity a credit program in early 2026, so re-verify the two vendors you shortlist before you commit. If you spot a number that has moved, the honest thing to do is tell me and I will correct it.

FAQ

Which AI search API is cheapest per 1,000 requests in 2026?

It depends on what the API returns, and that is the entire point of this post. For raw SERP JSON, Serper at $0.30–1.00/1k is the cheapest dedicated SERP API (with Keirolabs’ SERP-grade tier at $0.10/1k the cheapest bare query in the class). For content-grade search that returns full clean page markdown for RAG, Keirolabs at $0.25/1k flat is the cheapest verified. Jina Reader at $0.02/1k is cheapest overall but it only fetches URLs you already have — it does not search.

Is Tavily or Exa cheaper?

Tavily. Tavily is $8/1k pay-as-you-go, $5/1k on Growth, with content bundled; Exa is $7/1k for search plus a separate $1/1k Contents charge, so a RAG call lands near $8/1k. Both are 20–32x more expensive than Keirolabs and 5–10x more than Serper-plus-scrape for the same workload shape.

Why do AI search API prices vary so much between providers?

Because they sell different products under the same label. SERP APIs return metadata-only JSON and price at $0.30–15/1k; content APIs bundle search with cleaned page text at $0.25–8/1k; answer APIs run an LLM over results and add token metering. Comparing them on request price alone ignores the content step — the real cost center of RAG.

How much does an AI search API cost at 1 million queries a month?

About $20 (Jina, fetch-only) to $9,860–10,714 (SerpAPI plus scrape), with the content-grade options at ~$263 (Keirolabs), ~$737–1,579 (Serper plus scrape), ~$2,105 (Sonar), ~$3,368 (Firecrawl), ~$5,263 (Tavily Growth), and ~$8,421 (Exa search+contents). The 37x spread is the price of buying metadata when you need content.

What is the cheapest search API that returns full page content for RAG?

Keirolabs at $0.25/1k, flat, returns ranked results plus full clean markdown in one call. Firecrawl (~$3.20/1k effective) and Tavily ($5–8/1k) also bundle content. Metadata-only APIs (Serper, SerpAPI) look cheap until you add a scraper to fetch pages yourself.

Can I run an AI search API on the free tier in production?

Only for prototypes and very-low-volume internal tools. Recurring free quotas are 1,000 requests/month (Keirolabs, Tavily, Firecrawl), 250/month (SerpAPI), 20,000/month (Exa), or 100/day (Sonar). Free tiers throttle, expire, and disappear — Brave removed its free plan in February 2026 and Perplexity discontinued its monthly credit the same month. Budget the paid tier from day one.

Is Perplexity Sonar really $2/1k?

Yes, as a search-weighted blended figure across short-answer workloads. The list price is $5/1k requests (plus $3/$15 per million tokens on Sonar Pro) before token metering. Short answers blend to ~$2/1k; long research answers push effective cost well past $5/1k because of output tokens.

How do I estimate the real cost of a search API?

Use effective $/1k = (request price + content adder + token costs) / (1 − retry rate). Add the content step (bundled on Keirolabs/Tavily/Firecrawl, $1/1k on Exa, a scraper on Serper/SerpAPI), then divide by (1 − retry rate). A 5% retry rate adds 5.3%; 20% adds 25%. Model your own retry rate from production logs rather than assuming 0.

Further reading

• The 2026 AI Search API Benchmark: 10 APIs tested — the factuality/latency/cost study behind the numbers here.
• The Complete Search API Comparison — metadata vs content vs answer architectures, in depth.
• Best AI Search API in 2026 — the category-wide winner write-up.
• Cheapest Tavily Alternatives — when the $5–8/1k premium does not earn its keep.
• Cheapest Exa Alternatives — the $7/1k + $1/1k model, challenged.
• Exa Alternatives — semantic-retrieval-focused alternatives.
• Tavily vs Exa — the two $5–8/1k content APIs, head to head.
• Serper vs SerpAPI — the cheapest-SERP category, decided.