---
title: "How Do Search APIs Compare on Cost per Query and Latency?"
category: "comparisons"
url: https://keirolabs.cloud/blog/search-api-cost-per-query-latency
---

The cheapest search API per query is Keiro /search/lite: $0.25 per 1,000 searches, falling to $0.08 to $0.24 per 1,000 on monthly plans. The fastest published tier is Parallel Turbo, 200 ms median latency at $1 per 1,000. Tavily charges $8 per 1,000 while claiming the fastest p50 in the market. The full cost table, the latency table, and the effective-cost math that neither table shows follow, with every number linked to its source.

Two numbers decide most search API purchases, and vendors publish them on different pages, in different units, with different amounts of candor. Cost per query is usually printed somewhere. Latency is usually a marketing adjective. This post puts both on one page, then adds the third column nobody ships: what failed requests, expiring credits, and monthly minimums do to the sticker price.

A note on who is writing. We build Keirolabs, and Keiro wins the price column below. Rather than ask you to trust us, we priced every vendor from its own pricing page and linked each row. Where a claim is a vendor's marketing (Tavily's 180 ms, Parallel's 200 ms), the text says so. Where we judge, the judgment is labeled as ours. Every figure was checked on September 23, 2026.

## How Do Search APIs Compare on Cost per Query and Latency Tradeoffs?

The one-line answer: for the same 10 results, this market charges anywhere from $0.25 to $25 per 1,000 queries, and the published latencies run from a claimed 180 ms to a measured 14.7 seconds. The expensive options are not the fast ones, and the most expensive row in the field is a scraper with a legal shield.

Here is the cost column first. Standard search, 10 results, cheapest self-serve rate, US dollars per 1,000 requests, September 2026:

| Provider | $ per 1k basic search | Free tier | Index | The catch |
|---|---|---|---|---|
| [Keiro /search/lite](https://keirolabs.cloud/pricing) | $0.25 headline; $0.24, $0.13, $0.08 on Essential, Pro, Startup plans | 1,250 credits/mo = 12,500 lite searches, no card | Own index (index, not a scraper) | One-time packs bill lite at 0.5 credit, $2.50 to $3.33 per 1k |
| [Serper](https://serper.dev) | $1.00, dropping to $0.30 prepaid | 2,500 queries, one-time | Scraped Google SERP | Credits expire in 6 months; more than 10 results costs 2 credits |
| [Parallel Search](https://parallel.ai/pricing) | $1.00 (Turbo) to $5.00 (Basic/Advanced) | 5,000 requests/mo plus signup credit | Own search infra | Sub-dollar tiers return excerpts, not full page text |
| [Firecrawl Search](https://www.firecrawl.dev/pricing) | about $1.66 on Standard; about $6.40 on Hobby credits | 1,000 credits/mo (500 searches) | Live crawl on demand | Rate slides with plan volume |
| [Brave Search API](https://brave.com/search/api/) | $5.00 flat | $5 in credits/mo, about 1,000 requests, card required | Own index, 30B+ pages | Free plan was eliminated in February 2026; card required |
| [You.com Search](https://you.com/resources/lower-search-api-cost) | $5.00 | 100 free queries/day unauthenticated | Own search + synthesis stack | Research and answer endpoints bill separately |
| [Google Custom Search (legacy)](https://developers.google.com/custom-search/v1/overview) | $5.00 | 100 queries/day | Google, official | Closed to new customers; existing users off it by January 1, 2027 |
| [Bing Web Search API](https://learn.microsoft.com/en-us/lifecycle/announcements/bing-search-api-retirement) | Retired August 2025 | None | Microsoft, official | No replacement at any price |
| [Exa](https://docs.exa.ai/reference/pricing) | $7.00 for 10 results | $20 signup + $10/mo credits | Own neural index | Results 11+ add $1 per 1k each: a 30-result search is $27 per 1k |
| [Tavily](https://www.tavily.com/pricing) | $8.00 basic, $16.00 advanced | 1,000 credits/mo, no card | Hybrid crawl + re-rank | Advanced parameters double the rate |
| [SerpAPI](https://serpapi.com/pricing) | $15.00 (Developer) to $25.00 (Starter) | 250 searches/mo | Scraped Google SERP | You pay for maturity and a legal shield, not speed |
| [Linkup](https://www.linkup.so/pricing) | $5.00 to $6.00 | 4,000 queries | Own index | Deep search runs about 10x the standard rate |

The latency column, from the vendors themselves where they publish one: Tavily advertises 180 ms p50 on basic search, Parallel's Turbo mode posts a 200 ms median at $1 per 1,000, Parallel Fast is about 700 ms, Serper quotes 1 to 2 seconds, Linkup keeps synchronous search under 2 seconds, Brave's LLM Context endpoint adds under 130 ms to a pipeline, Exa publishes no figure, and Keiro's deep search measures a 14.7 second p50 on its own benchmark because it reads about 8 pages per query instead of returning links.

> Cost per query and latency trade against each other less than vendors imply. The fast tiers and the cheap tiers are mostly the same tiers.

The tradeoff people actually feel is different: raw SERP-style results are cheap and fast because they stop at the URL, and extraction-bearing results cost more and run slower because the provider is reading pages. On OpenAI's SimpleQA benchmark, snippets alone recovered the gold answer 72.4 percent of the time; adding full-page reads took Keiro's retrieval to 95.3 percent, at a p50 of 14.7 seconds and $4.44 per 1,000 queries ([the full run](https://keirolabs.cloud/Deep-search)). That is the tradeoff in one row: 180 ms and 72 percent, or 15 seconds and 95 percent, and the pricing tables do not tell you which one you bought.

## Cheapest Search API

Three APIs charge a dollar per thousand or less, and they get there three different ways.

**Keiro** is the cheapest on an owned index. The /search/lite headline is $0.25 per 1,000 ([pricing page](https://keirolabs.cloud/pricing)), and monthly plans bill lite at 0.1 credit per request: Essential at $30/month buys 12,500 credits, which is 125,000 lite searches at $0.24 per 1,000; Pro at $50/month buys 375,000 at $0.13 per 1,000; Startup at $100/month buys 1,250,000 at $0.08 per 1,000. Billed annually those plans work out to $25, $42, and $83 effective monthly, which drops lite to roughly $0.20, $0.11, and $0.07 per 1,000. That is arithmetic from the published list prices, not a promotional rate. Pros: cheapest published rate in the field, recurring free tier of 12,500 lite searches a month with no card, one credit balance across search, extraction, answers, and research, first place on AIMultiple's 2026 agentic benchmark at 15.2/20 and first on FinanceBench at 78 percent. Cons: lite returns ranked results, not page content (the 3-credit /search/content endpoint does that), and if you buy one-time credit packs instead of a plan, lite bills at 0.5 credit per request, $2.50 to $3.33 per 1,000.

**Serper** is scraped Google at $1.00 per 1,000 ([serper.dev](https://serper.dev); a [ColdIQ breakdown](https://coldiq.com/blog/serper-pricing) documents the pack ladder), dropping to $0.30 per 1,000 if you prepay $3,750 for 12.5 million credits. Pros: the cheapest real Google results, 2,500 free queries on signup, no subscription, fast for a SERP product. Cons: the credits expire in six months, queries beyond 10 results cost 2 credits (effective $2.00 per 1,000 at depth 100), there is no page content, and the whole product is an unlicensed dependency on Google's servers. Google sued SerpAPI over exactly this business in December 2025.

**Parallel** prices its Turbo mode at $1 per 1,000 requests with a 200 ms median latency, and Fast at the same dollar with roughly 700 ms ([Parallel's own posts](https://parallel.ai/blog/parallel-search-turbo)). Basic and Advanced modes, which return longer excerpts, run $5 per 1,000. Pros: the most honest price sheet in the category, printed per request in dollars, 5,000 free requests a month. Cons: the sub-dollar tiers return ranked URLs with compressed excerpts, so agents that read pages add an extraction step, and on a 100-query head-to-head Keiro's /search/lite beat Parallel's turbo tier 91 times out of 100 ([methodology](https://keirolabs.cloud/bench/keiro-lite-vs-parallel-turbo)).

A worked monthly bill, monitoring-agent shape: 50,000 plain searches a month, snippets only, no page reads. Keiro Essential $30. Serper $50. Parallel Turbo $50. Brave $250. You.com $250. Exa $350. Tavily basic $400. The same 50,000 queries span $30 to $400 a month, a 13x spread, before a single quality point is scored.

> Price per query is the only number in this market that is printed on the page and still manages to mislead, because it never includes the second call your agent is about to make.

## Cheapest Web Search API

"Cheapest" is three different questions, so here are all three answers.

Cheapest first thousand: a tie between the recurring free tiers. Keiro's free tier is 1,250 credits a month, which is 12,500 /search/lite searches every month with no card ([pricing](https://keirolabs.cloud/pricing)). Tavily gives 1,000 credits monthly, about 1,000 basic searches. Parallel gives 5,000 requests monthly plus $5 in credits. Exa gives $10 in recurring credits, about 1,400 searches at its $7 rate, on top of a $20 signup grant. Brave gives $5 in monthly credits, about 1,000 requests, but requires a card on file. Serper's 2,500 free queries and Linkup's 4,000 are one-time grants, not monthly.

Cheapest at volume: Keiro's Startup plan, $0.08 per 1,000 lite searches at $100/month for 1,250,000 searches, about $0.07 on annual billing. Serper's $0.30 per 1,000 requires $3,750 prepaid and expires. DataForSEO's queued Standard SERP is $0.60 per 1,000 but results arrive minutes late, which is fine for rank tracking and useless for agents.

Cheapest without a subscription: Keiro's one-time packs run $10 for 1,500 credits (Starter), $30 for 5,000 (Growth), and $100 for 20,000 (Scale), expiring in 6 months, with lite billed at 0.5 credit on packs. Serper's $50 pack for 50,000 queries is the best one-time Google bundle.

| Volume per month | Cheapest option | Monthly cost | Runner-up |
|---|---|---|---|
| 10,000 | Keiro free tier + Essential $30 if you exceed 12,500 | $0 to $30 | Serper $50 pack |
| 100,000 | Keiro Pro $50/mo (375,000 lite) | $50 | Serper $100 at $1/1k |
| 1,000,000 | Keiro Startup $100/mo (1,250,000 lite) | $100 | Serper Ultimate $3,750 prepaid for 12.5M |

The break-even that matters most is the free tier one. Keiro's free tier covers about 415 lite searches a day, every day, indefinitely. Tavily's covers about 32 a day. Serper's 2,500 is a weekend of prototyping, once. If you are choosing on free-tier value alone, the recurring allowances beat the one-time grants by an order of magnitude within two months.

## Compare Search Latency Across Different API Providers

Here is every latency figure we could source, attributed to whoever published it. Treat all of them as p50 marketing numbers until you measure your own p95.

| Provider | Published latency | Source of the number | What it covers |
|---|---|---|---|
| Tavily | 180 ms p50 on /search | [Tavily's own claim](https://www.tavily.com/pricing), marketed as fastest in the market | Basic search, snippets |
| Parallel Turbo | 200 ms median | [Parallel's Turbo announcement](https://parallel.ai/blog/parallel-search-turbo) | 10 results with compressed excerpts |
| Parallel Fast | about 700 ms | [Parallel's mode docs](https://docs.parallel.ai/search/modes) | Higher quality, still sub-second |
| Serper | 1 to 2 s typical; sub-100 ms in marketing | [field overview](https://keirolabs.cloud/blogs/comparisons/top-8-ai-search-apis-compared-2026), vendor materials | Raw Google SERP |
| Linkup | Under 2 s synchronous | [Linkup pricing page](https://www.linkup.so/pricing) | Standard search |
| Brave | Under 130 ms added by LLM Context | [Brave Search API](https://brave.com/search/api/) | Snippet enrichment, not full search |
| Exa | Not published; roughly a second with contents | site estimate | Search plus contents |
| Keiro deep search | p50 14.7 s | [Keiro's own benchmark page](https://keirolabs.cloud/Deep-search) | Full pipeline: resolve, read about 8 pages, prove, assemble |
| DataForSEO Standard | Queued batch, not live | [DataForSEO SERP API](https://dataforseo.com/apis/serp-api) | Batch SERP collection, not interactive |

Three things those rows hide. First, p50 is the flattering statistic: p95 is what your users feel, and p95 is dominated by tail behavior like cold caches, JS-heavy pages, and retries. Second, published figures usually cover the cheapest endpoint, not the one your agent ends up calling; Tavily's 180 ms is basic search, and advanced search with content extraction is a different, slower call. Third, throughput is a separate latency variable. An endpoint that answers in 200 ms is useless to an agent fanning out 10,000 queries if the rate limit is 30 per minute. Keiro publishes rate limits of 30 req/min on free, 60 on Essential, 300 on Pro, and 1,000 on Startup; Brave advertises 50 queries/second capacity; Serper sells concurrency by pack.

> A p50 you were shown and a p95 you measured are different numbers about different products.

## What Is the Difference Between a Search API and a Scraping API for LLMs?

The difference is where the work stops, and it explains almost every price gap and latency gap in the tables above.

A SERP scraper (Serper, SerpAPI, DataForSEO, Bright Data) fetches a search engine's results page and hands you the parsed JSON: titles, URLs, snippets. The call is fast because the work is shallow. It is also legally uncomfortable, since the product is Google's page fetched without Google's blessing, a fact Google turned into a lawsuit against SerpAPI in December 2025. For LLM work, a scraper is the first half of a pipeline. Your model still has to fetch and read the pages, which means a second vendor, a second failure mode, and a second bill.

A search API that owns retrieval (Keiro, Brave, Exa, Linkup, Parallel, and Tavily in a hybrid way) sells ranked results from its own pipeline, and the better ones sell page content in the same call. That second service is what you are paying for, and it is where p95 latency comes from. Reading a page is rendering it, waiting out JavaScript, parsing, and extracting. Doing that for the pages behind a query is seconds of work, which is why Keiro's deep search sits at a 14.7 second p50 while link-only endpoints post 200 ms figures. The [SimpleQA run](https://keirolabs.cloud/Deep-search) quantifies the trade: snippets alone hit 72.4 percent, full-page reads added 15.3 points to reach 95.3 percent, and the pipeline read 7.9 pages per query to get there.

What one "search plus content" cycle costs per 1,000:

| Provider | Search | Page content | Cost per 1k full cycles |
|---|---|---|---|
| Keiro /search/content (3 credits) | included | clean markdown, same call | $7.20 on Essential, $3.36 on Pro, $2.40 on Startup |
| Serper + separate extractor | $1.00 | you build it or buy it | roughly $2 to $4 all-in, two vendors |
| Brave + separate extractor | $5.00 | not included | roughly $6 all-in |
| Firecrawl Search (2 credits per 10 results) | included | full markdown, fresh crawl | about $1.66 on Standard, about $6.40 on Hobby credits |
| Exa | $7.00 | contents included for the first 10 results (since March 2026) | $7.00, plus $1 per 1k pages above 10 |
| Tavily basic | $8.00 | inline content included | $8.00; advanced is $16.00 |

> A scraper sells you a list of places to look. A search API that reads pages sells you the fact. The second one costs more per query and less per solved task.

## Which Search API Has the Best Latency for AI Agents?

For an agent, latency is not one call. It is a loop, and the loop multiplies whatever you pick.

A typical research agent runs 10 to 15 searches and reads 3 to 5 pages per task. String the vendor numbers together and a single run costs: Parallel Turbo, about 2.4 to 3 seconds of search time at 200 ms per call; Tavily, about 2 seconds of claimed p50 per basic call, longer once advanced content lands; Keiro, lite for the fan-out and /extract (3 credits) for the reads. On cost per 1,000 agent runs, using each provider's plan rates: Parallel Turbo about $12 in search plus an extraction vendor; Serper about $12 plus extraction; Keiro about 13 credits per run on the lite-plus-extract pattern, $31 on Essential; Exa about $88 with contents; Tavily about $160 mixing basic and advanced.

Two honest caveats. First, those are sequential sums; agents that parallelize search calls cut wall-clock time and sometimes trip rate limits instead. Second, the fastest loop is not the best loop. In Keiro's published head-to-head, /search/lite beat Parallel's turbo tier on 91 of 100 queries with a composite score of 341.6 to 170.4, so the 200 ms tier lost on quality to a cheaper one. Latency you can feel, quality you can bank.

Practical picks. **Parallel Turbo** if your binding constraint is response time and your agent reads snippets. **Tavily** if you want one call to return search plus content and trust their 180 ms figure on your own traffic. **Keiro** if the loop is long and the bill matters: the per-run cost is a rounding error, and the free tier's 30 req/min rises to 1,000 req/min on Startup, which is what actually keeps an agent fleet moving.

> An agent that searches 12 times per task does not have a latency problem. It has a latency-times-12 problem, and only one of those shows up on the pricing page.

## Is Search API Latency Really That Important for AI Agents

Less than you would guess from the marketing, and more than zero.

Latency is binding in two places: interactive chat, where a user stares at the cursor, and voice, where 200 ms versus 700 ms decides whether the product feels alive. It is nearly irrelevant in background work: RAG ingestion, monitoring sweeps, dataset building, deep research queues. Nobody consuming a monitoring report cares whether the sweep took 40 seconds or 43.

The instructive case is Keiro's own deep search. Its p50 is 14.7 seconds, which is 70 times Parallel's turbo tier, and the same pipeline scores 95.3 percent retrieval on SimpleQA at $4.44 per 1,000 queries, where link-only retrieval sits at 72.4 percent. Nobody should put that endpoint in a chat hot path. Everyone running a verification step or a citation-grounded answer flow should put it behind those two numbers, because the slow call is the one that ends the retry loop. An agent that gets the right fact on the first deep query is faster than an agent that burns four 200 ms searches and still has to read six pages.

The decision rule: measure the latency of the whole task, not the endpoint. If your workload is interactive, price the fast tiers (Parallel Turbo, Tavily basic, Keiro lite) and mind the rate limits. If it is batch, buy accuracy per dollar and ignore the p50 column entirely. The only unforgivable latency is the one you discover in production because a vendor's extraction step sat behind the fast one you benchmarked.

## Which Search API Is Best for RAG

RAG has a specific cost shape: a large, repeated ingestion volume, a hard requirement for page content, and a freshness window that decides whether retrieval is useful at all. Cost per query is the wrong lens; cost per 1,000 pages of clean markdown is the real one.

| Provider | Rate for search plus page content | Per 100k docs/month | Freshness model |
|---|---|---|---|
| [Keiro /search/content](https://keirolabs.cloud/pricing) | 3 credits: $7.20 Essential, $3.36 Pro, $2.40 Startup | $240 to $720 | Own index plus live extraction |
| [Firecrawl Search](https://www.firecrawl.dev/pricing) | about $1.66 Standard, about $6.40 Hobby credits | $166 to $640 | Crawls live on demand, minutes old |
| [Serper](https://serper.dev) + extractor | $1.00 plus extraction, roughly $2 to $4 all-in | $200 to $400 | Google's index, freshness varies |
| [Brave](https://brave.com/search/api/) + extractor | about $6 all-in | about $600 | Own index, about 100M page updates/day |
| [Exa](https://exa.ai/pricing) | $7.00 with contents, first 10 results | $700 | Own neural index |
| [Tavily](https://www.tavily.com/pricing) | $8.00 basic, inline content | $800 | Hybrid crawl, cache, re-rank |

Worked monthly bill, RAG ingestion app, 100,000 documents a month: Keiro /search/content on Startup runs $240. Firecrawl Standard, if your volume fits its 50,000-search shape, runs $83 and would need roughly two plans for 100k, call it $166. Serper plus a cheap extractor runs $200 to $400 with two vendors to babysit. Tavily runs $800 for the same volume on basic search. Exa runs $700.

The non-price variables decide RAG more than price does. Snippet-only feeds force your chunker to work from excerpts, which is why the SimpleQA gap between snippets (72.4 percent) and full-page reads (95.3 percent) matters more in RAG than in chat. Clean markdown in the same call as search, which Firecrawl, Keiro's /search/content, and Tavily all sell, removes an extraction stage whose failure rate you would otherwise own. And freshness is a budget: live-crawl pricing buys you pages that are minutes old, cached-index pricing buys you pages that are days old at a fifth of the rate.

## Exa API Pricing per Search 2026

Exa's list price is $7.00 per 1,000 search requests for 10 results, pure pay-as-you-go, with a $20 signup grant plus $10 in credits every month and no card required ([Exa pricing docs](https://docs.exa.ai/reference/pricing)). The $10 monthly allowance is about 1,400 searches; the signup grant roughly doubles that in month one.

The number to model is the surcharge stack. Results 11 and above add $1 per 1,000 results, so a 30-result search bills $27 per 1,000, nearly four times the headline. Contents beyond the first 10 results bill $1 per 1,000 pages. The answer endpoint is $5 per 1,000, deep research runs $12 to $15 per 1,000, and find_similar is $5 per 1,000. A naive agent that searches, then fetches, then answers can pay three meters for one task without noticing.

Where Exa earns its rate: semantic retrieval. "Papers like this one," "companies doing X without saying X," and find-similar-by-URL are queries a keyword SERP cannot answer at any price, and Exa's neural index is the best version of that product in the market. Where it is hard to defend: keyword-shaped queries, depth-hungry agents, and any workload paying the per-result surcharge at scale, where the same 30 results cost $0.08 on Keiro Startup and $27 on Exa, a 337x spread for the rows that happen to be in both indexes.

## Tavily API Pricing 2026 Cost per Search

Tavily does not print a per-search price; it prints $0.008 per credit and a credit table ([Tavily's credits doc](https://docs.tavily.com/documentation/api-credits)):

| Tavily request | Credits | Cost at $0.008/credit |
|---|---|---|
| Basic search | 1 | $8.00 per 1,000 |
| Advanced search | 2 | $16.00 per 1,000 |
| Basic extract | 1 per 5 successful URLs | $1.60 per 1,000 pages |
| Crawl (10 pages, advanced) | 5 | $40.00 per 1,000 pages |
| Research | 4 to 250 per task | $32 to $2,000 per 1,000 tasks |

The Project plan at $30 for 4,000 credits works out to $7.50 per 1,000 basic searches, and the biggest monthly commitment lands near $5.00 per 1,000, the figure listicles quote. Free tier: 1,000 credits monthly, no card, real and recurring.

What the $8.00 buys is bundling: ranked results with inline page content in one call, tuned for agents, with a claimed 180 ms p50 on basic search. That bundling is a real defense, and it is why Tavily survives in production pipelines that would pay twice on a Serper-plus-extractor stack. The defense weakens on three facts. Advanced search doubles the rate the moment agents start reading pages deeply. Research workloads span 4 to 250 credits per task, so deep research bills anywhere from $32 to $2,000 per 1,000 tasks. And since February 2026 Tavily has been in the middle of a Nebius acquisition, which is a fine fact and belongs in a vendor decision anyway. On the public evals, Tavily posts 13.67/20 on AIMultiple's agentic benchmark, fifth in the field, and 78 percent SimpleQA via GPT-4.1 in its own published run.

## Which Serp API Has the Lowest Cost per 1,000 Searches?

Among SERP providers, the floor is DataForSEO's queued Standard delivery at $0.60 per 1,000, with Serper's $1.00 (dropping to $0.30 prepaid) the cheapest live answer:

| Provider | Entry | Effective per 1k | Free tier | Fine print |
|---|---|---|---|---|
| [Serper](https://serper.dev) | $50 pack | $1.00 ($0.30 at 12.5M prepaid) | 2,500 queries, one-time | Credits expire in 6 months; 11-100 results costs 2 credits |
| [DataForSEO](https://dataforseo.com/apis/serp-api) | $50 deposit | $0.60 queued / $2.00 live | None | Queue is minutes, not milliseconds |
| [Bright Data SERP](https://brightdata.com/pricing/serp) | $0 minimum | about $0.75 to $1.50 | Effectively none | Bills per successful request |
| [Google CSE (legacy)](https://developers.google.com/custom-search/v1/overview) | None | $5.00 | 100 queries/day | Closed to new customers; sunsets January 1, 2027 |
| [Zenserp](https://zenserp.com/) | $29/mo | $5.80 | 50 searches/mo | Small plan, 5,000 searches |
| [SerpAPI](https://serpapi.com/pricing) | $25 to $75/mo | $15.00 to $25.00 | 250/mo | You are buying uptime and a legal shield |
| [Keiro /search/lite](https://keirolabs.cloud/pricing) (own index, not a SERP) | Free tier | $0.25 ($0.08 to $0.24 on plans) | 1,250 credits/mo | Not Google results; own index |

The expiry math matters more than the discount. Serper's $0.30 rate requires $3,750 prepaid, and prepaid credits expire in 6 months, so the discount is only real if you burn about 2 million queries a month. At 20,000 queries a month you would be prepaying three years of usage to save $700 a year against the $1.00 tier, and any pause in the project forfeits the difference. Prepaid volume discounts are priced for the vendor's cash flow, not your unit economics.

## Which Serp API Has the Lowest Latency per Request in United States?

For live Google results from US infrastructure, the only latencies anyone publishes belong to Serper: sub-second responses in its own materials, sub-100 ms in its marketing, and around 1 to 2 seconds in the field comparison that prices it at $1 per 1,000. That makes Serper the default answer to this query, with the caveat that none of its competitors print comparable numbers, so the comparison rests on one vendor's candor. Bright Data's SERP product optimizes for scale and compliance over speed, with no concurrency limits and billing per successful request; it is not the low-latency pick. DataForSEO sells two different products: a $2.00 per 1,000 live endpoint and a queued Standard tier that is the market's cheapest SERP and arrives late, which is fine for rank tracking and wrong for an interactive path. SerpAPI does not publish a latency figure, and cached searches do not burn credits.

Two structural notes for 2026. First, the official options are gone: Microsoft retired the Bing Search APIs in August 2025 ([lifecycle notice](https://learn.microsoft.com/en-us/lifecycle/announcements/bing-search-api-retirement)) and Google closed Custom Search to new customers with a January 1, 2027 sunset for existing ones, so every low-latency US SERP now comes from a scraper. Second, latency for scrapers is a distribution, not a number. Google ships bot-defense updates (SearchGuard in January 2025 broke nearly every scraper overnight), and a scraper's p99 is written by Google's security team, not the scraper's. If you need US Google results in an interactive product, budget for the tail.

## How Do Serp API Providers Compare on Latency?

Provider by provider, with the risk priced in:

- **Serper**: fastest of the cheap scrapers, 1 to 2 s typical, sub-100 ms marketing claims, prepaid credits, no subscription. Risk: unlicensed Google dependency, six-month credit expiry.
- **SerpAPI**: does not publish a latency figure, has the widest vertical coverage in the market (Maps, News, Jobs, AI Overviews), and does not burn credits on cached searches, at $15 to $25 per 1,000. It is the mature option and prices like it. Google is suing it; its answer is contracts and a US legal shield.
- **DataForSEO**: $0.60 queued is the market's cheapest SERP but arrives queued, not live; $2.00 live is competitive. Best for rank tracking at scale, wrong for agents.
- **Bright Data**: the proxy giant's SERP product, pay per successful request, no concurrency limits, roughly $0.75 to $1.50 per 1,000. The scale-first option rather than the latency play.
- **Zenserp**: $29/month for 5,000 searches, $5.80 per 1,000, small free plan. A mid-market option without a sharp edge.

The honest ranking for a production system puts own-index APIs (Brave, Keiro) first, because their supply risk is their own crawling budget, then queue-model scrapers, then live scrapers, whose uptime is leased from an anti-bot arms race that one company (Google) is actively litigating. Latency you can benchmark in an afternoon. The risk that your scraper's p99 becomes a courtroom schedule is the part no latency table shows.

## Brave Search API vs Proxy Scraper Latency

Brave is the useful control in this comparison because it is the only full independent index priced like a commodity: $5.00 per 1,000 requests flat, $5 in monthly credits (about 1,000 requests), against an index of more than 30 billion pages refreshed by around 100 million updates a day ([Brave Search API](https://brave.com/search/api/)). Its LLM Context endpoint adds under 130 ms to a pipeline, which is Brave's own published figure.

Against a proxy-based scraper (Bright Data, or a self-rolled proxy pool), the trade is explicit. The scraper gives you Google's ranking, Google's freshness, and Google's SERP features (local packs, AI Overviews), at comparable per-1k pricing, with p99 latency owned by Google's bot defenses and a legal theory nobody has tested to verdict. Brave gives you its own ranking: no SERP features, a smaller index, results that skew toward the independent web, and a supply chain nobody can sue off the planet. On AIMultiple's 2026 agentic benchmark Brave scores 14.89/20, second only to Keiro, and on the SimpleQA leaderboard its 76.1 percent trails the extraction-heavy providers, which is the index-versus-reading gap again, not a ranking failure.

Pick Brave when the question is "did this come from Google's servers?" is a legal or architectural question. Pick a proxy scraper when you need Google's own SERP features, and budget for breakage. Pick neither when the workload is agents reading pages, because both stop at the URL and hand the extraction bill to you.

## How to Optimize Search API Usage for Cost Efficiency

Sticker price is one line of the real bill. Five adjustments move an invoice by more than any vendor's volume discount:

**Failed requests and retries.** Whatever the SLA says, the retry rate is part of your rate. Keiro's published 1,000-question SimpleQA run logs 267 retries across 1,000 questions, a 27 percent overhead on a pipeline doing full-page reads ([run record](https://keirolabs.cloud/Deep-search)). Some providers absorb that cost, some pass it through: Bright Data bills per successful request, SerpAPI does not burn credits on cached searches, and Keiro does not count pagination, streaming, or in-request retries as searches per its pricing FAQ. Ask the question directly before signing, because a 10 percent failure rate on a $1 per 1,000 API is a 10 percent surcharge, and on a retry-heavy agent loop it can double.

**Credits that expire.** Serper's credits die after 6 months, and so do Keiro's one-time pack credits. Brave's $5 monthly credit is use it or lose it. An expiring balance converts your prepaid discount into a donation if your volume dips. Monthly plan allowances (Keiro, Tavily, Parallel, Brave's credits) sidestep the trap by resetting instead of expiring.

**Monthly minimums.** SerpAPI starts at $25/month, Zenserp at $29, Firecrawl's Standard at $83, and Google's migration target, Vertex AI Search, sets enterprise floors around 1,000 queries per minute and 50 GiB of storage with per-query fees of roughly $1.50 to $4 per 1,000. A minimum is a negative free tier: it bills you in months you ship nothing.

**Depth surcharges.** Exa bills results 11+ at $1 per 1,000 each (30 results = $27 per 1k), Serper doubles past 10 results, Tavily doubles for advanced, Parallel triples from Turbo to Basic. Model your real result count, not the default.

**One-time packs versus plans.** Keiro is the honest internal case: packs bill lite at 0.5 credit ($2.50 to $3.33 per 1,000), monthly plans at 0.1 credit ($0.24 to $0.08 per 1,000), so a $30 Growth pack buys 10,000 lite searches while the same $30 as Essential buys 125,000. Packs exist for bursts and trials; plans are where the rates live.

Worked monthly bill, deep-research agent shape, 5,000 deep tasks a month: Keiro deep search at $4.44 per 1,000 runs $22.20 ([the site's own cost chart](https://keirolabs.cloud/Deep-search)). Firecrawl's agent harness, at up to 20 search and extraction calls per task, bills about $10 per 1,000 tasks, or $50. Exa deep research at $12 to $15 per 1,000 runs $60 to $75. Parallel's deep research tiers span $0.005 to $2.40 per request, $25 to $12,000 for the same 5,000 tasks. Tavily's research endpoint at 4 to 250 credits spans $160 to $10,000. The depth pricing spread is wider than the search spread, and it is where most agents actually bleed.

> Nobody's invoice line reads "search API." It reads like five vendors, and four of them are the same vendor's surcharges.

## Web Search API Benchmarks Accuracy Latency 2025

Price and latency are half the decision. The scoreboards, with sources:

- **AIMultiple Agentic Index 2026** (out of 20): Keiro 15.2, Brave 14.89, Firecrawl 14.58, Exa 14.39, Tavily 13.67, Perplexity 12.96 ([aimultiple.com](https://aimultiple.com)).
- **FinanceBench** (financial QA accuracy): Keiro 78 percent, Valyu 73, Parallel 67, Exa 63, Google 55. Thin snippets are exactly where financial questions fall apart.
- **SimpleQA retrieval** ([Keiro's published run](https://keirolabs.cloud/Deep-search), retrieval-only, n=1,000): Keiro deep search 95.3 percent at $4.44 per 1,000, against the best published third-party runs: Firecrawl 94.7 ($10.00 per 1k in the same cost table), Tavily 93.3 ($8.00), you.com 92.1 ($5.00), Exa 91.9 ($12.00), Parallel 91.0 ($1.00), Claude Search 90.5 ($10.00), Perplexity 85.9 ($5.00), Google 82.2 ($5.00), Brave 76.1 ($5.00). Different harnesses, different answer models, so read the gaps as directional.
- **Keiro's 100-query harness** ([methodology](https://keirolabs.cloud/blogs/comparisons/top-8-ai-search-apis-compared-2026)): SimpleQA Keiro 94, Perplexity 86, Tavily 78; FreshQA 91/83/77; HotpotQA 82/74/68.
- **Head-to-head** ([receipts](https://keirolabs.cloud/bench/keiro-lite-vs-parallel-turbo)): /search/lite beat Parallel Turbo 91 of 100 queries, composite 341.6 to 170.4, sweeping 6 of 9 archetypes.

The pattern across all four: the price ranking and the quality ranking have inverted. The cheapest rows win the evals, which was not true in 2025 and is the single biggest change in this market this year. When the cheapest option is also the benchmark leader, "pay more for quality" stops being an argument and becomes a habit worth auditing.

## Best Search API for Low Latency

By workload, since "low latency" means different things in different loops:

**Interactive chat and voice:** Parallel Turbo. 200 ms median at $1 per 1,000 is the best published latency-per-dollar in the category, and 5,000 free requests a month makes it free to prove. Mind that it returns excerpts, not pages.

**Agents that fan out:** Keiro /search/lite on a plan, $0.08 to $0.24 per 1,000, with rate limits from 300 to 1,000 req/min on paid tiers. The head-to-head record against Parallel's turbo tier is 91 of 100 for Keiro, and the bill for a 12-search agent run is a rounding error.

**One-call search plus content:** Firecrawl on Standard (about $1.66 per 1,000, full markdown, live crawl) or Keiro's /search/content (3 credits, $2.40 to $7.20 per 1,000 depending on plan) or Tavily basic ($8.00, inline content, 180 ms claimed). Fastest claimed is Tavily; cheapest with content in the call is Keiro on Startup; freshest is Firecrawl.

**Verification, citations, and anything that must be right:** Keiro deep search, p50 14.7 seconds and 95.3 percent on SimpleQA at $4.44 per 1,000, or Firecrawl's agent harness at $10 per 1,000. Put them behind a queue, not behind a cursor.

> The fastest search API is the one whose slow path you never hit. Benchmark p95 on your own queries, then price the retries.

The boring version of this whole post: cost per query is a table you can build in an afternoon, latency is a claim you can test in ten minutes, and effective cost is the number that actually lands on the invoice, shaped by expiries, minimums, surcharges, and retry rates that no pricing page leads with. Build the three columns for your own workload, run 50 of your own queries through the two finalists, and let your own p95 and your own invoice settle it. Every number here was checked on September 23, 2026 against the linked pricing pages; this market reprices quarterly, so re-check before you sign, including with us.