DEV Community

Cover image for Which web search API is fast enough for an AI agent that makes many calls in a row?
Ricardo Batista for cloro

Posted on Edited on

Which web search API is fast enough for an AI agent that makes many calls in a row?

For an agent that searches many times in a row, Exa was the fastest of six web search APIs in an open benchmark, at 0.74 seconds per search at the median. Brave took 1.21 seconds, Tavily 2.00 and Parallel 2.99 in its default mode. Parallel's turbo and Linkup's flash modes document about 200 ms, but the benchmark did not measure them. The two Google SERP APIs in that test, cloro and SerpApi, took about 8 seconds per search, so neither is the fast choice. They are the better choice when the agent runs in the background and has to answer hard, multi-hop questions correctly.

  • Latency adds up in a loop. Ten searches in a row take about 7 seconds of search time on Exa and about 80 seconds on a Google SERP API.
  • Rate limits are rarely the first limit. Exa, Linkup, Parallel, Tavily, Brave and Perplexity's Search API allow 10 to 50 searches per second on paid plans. An hourly cap (SerpApi) or a concurrency cap on an 8-second API binds sooner.
  • Speed costs accuracy on hard questions. On 824 multi-hop questions, the two slow APIs answered 80.2% and 77.4% from one search. Exa answered 64.0% and Tavily 48.4%.

How fast is each web search API per call?

The first column is measured: the median time of the search request alone, without the model, from the benchmark run in November 2026. The second column is what each vendor documents for its speed modes. Those figures are vendor claims that this article did not measure.

API Measured median, default mode Documented latency by mode
Exa 0.74 s lite about 300 ms, auto about 1 s, deep 4 to 15 s
Brave Search API 1.21 s Not stated
Tavily 2.00 s Relative only: ultra-fast lowest, fast low, basic medium, advanced higher
Parallel 2.99 s turbo about 200 ms, fast about 700 ms, basic about 1 s, advanced (default) about 3 s
cloro 7.96 s Not stated
SerpApi 8.20 s Not stated
Linkup Not tested flash under 200 ms, fast about 1 s, standard 1 to 3 s, deep 5 to 30 s
Jina s.jina.ai Not tested 2.5 s average
Serper Not tested "1-2 seconds" on its homepage

The measured and documented figures agree where both exist. Parallel ran in its default advanced mode and took 2.99 seconds, close to its documented 3 seconds. Exa ran in auto and was a little faster than its documented 1 second.

Speed modes change the picture. When Parallel launched its Search API, one Hacker News comment called a 5-second basic tier "a deal breaker" if it applied per request. Parallel now documents basic at about 1 second and turbo at about 200 ms (Parallel modes). Perplexity's Search API sells a search_type: "fast" mode for agent loops at $1.00 per 1,000 requests, without a latency figure (Perplexity Fast Search).

What happens when an agent calls search many times in a row?

In a sequential loop, each search waits for the one before it. Search time is roughly the number of calls times the latency, before any model time:

API 1 call 5 calls 10 calls
Exa 0.7 s 3.7 s 7.4 s
Brave 1.2 s 6.1 s 12.1 s
Tavily 2.0 s 10.0 s 20.0 s
Parallel (advanced) 3.0 s 15.0 s 29.9 s
Google SERP APIs 8 s 40 s 80 s

These are medians multiplied, so treat them as estimates. A user who waits for an answer notices the difference between 7 seconds and 80. A nightly research job does not.

When the queries do not depend on each other, send them at the same time. Then the wall-clock time is about one call, and the rate limit or the concurrency cap becomes the limit:

import asyncio

async def search_all(queries, search, max_in_flight=10):
    sem = asyncio.Semaphore(max_in_flight)  # keep under the vendor's cap
    async def one(q):
        async with sem:
            return await search(q)
    return await asyncio.gather(*(one(q) for q in queries))
Enter fullscreen mode Exit fullscreen mode

What are the rate limits and QPS caps of each vendor?

Each row is the default limit from the vendor's own docs or pricing page, read on November 16, 2026.

API Default limit Raise it by
Exa 10 QPS on /search (5 QPS for deep types), 100 QPS on /contents 25 QPS for 90 days after $1,000 of credits in 30 days; Enterprise
Brave 50 queries per second on the Search plan, counted in a 1-second sliding window Enterprise
Perplexity Search API 50 query units per second on every tier; one unit per query in a multi-query request Not stated
Linkup 10 queries per second per organization Custom plans
Tavily 100 requests per minute free; 1,000 on pay as you go and smaller plans; 1,500 on Growth and Scale Enterprise
Parallel 600 searches per minute Ask support
Firecrawl /search: 10 per minute free, 100 Hobby, 500 Standard, 5,000 Growth Higher plan
SerpApi Per hour: 1,000 on Developer ($75), 20,000 on Searcher ($725) Higher plan
cloro Concurrent requests by plan: 1 free, 20 Hobby, 50 Starter, 100 Business; 1,000 requests per second per endpoint Higher plan

Two kinds of limit hide in this table. A per-second or per-minute cap (Exa, Brave, Tavily, Parallel) does not care how slow each request is. A concurrency cap does: throughput is the number of slots divided by the latency. With 20 slots and 8 seconds per search, a Google SERP API on that plan runs about 2.5 searches per second, or 150 a minute. Exa's default 10 QPS is 600 a minute. An hourly cap works the same way: 1,000 searches an hour is about one search every 3.6 seconds, averaged over the hour.

When is the slower API still the right choice?

Pick by who waits for the answer.

A person waits. Chat, voice and coding assistants that answer in a few seconds need a sub-second API. Exa, Brave, Parallel in fast or turbo, and Linkup in flash or fast fit. On short factual questions this costs nothing in accuracy: Parallel (97.8%), Exa (97.3%) and cloro (96.9%) tied within the margin of error on 1,000 SimpleQA Verified questions.

Nobody waits. Background research, monitoring, enrichment and batch jobs can take 8 seconds per search. There, accuracy and cost per correct answer weigh more. Parallel's own docs recommend its slowest Search mode for "multi-hop background agents that can tolerate extra latency".

The question is multi-hop. On FRAMES, Parallel, Exa, Brave and Tavily replied "not found" on 151 to 295 of the 824 questions, because their 10 results did not hold every fact. Each "not found" means another search or a failed task.

Be fair to the fast APIs here. Three Exa searches at 0.74 seconds still finish before one search at 8 seconds. The benchmark gave every API one search per question, so it does not show whether three fast searches would reach the same accuracy. That is an open question, and your own questions are the best test.

The agent needs Google's page. Rank checks, AI Overview citations and results for one country need a Google SERP API, whatever its speed.

Your agent Pick
Answers while a user waits Exa, Brave, or Parallel in fast
Makes many independent searches Any API, sent in parallel, under its cap
Runs multi-hop research in the background A Google SERP API, or Parallel in advanced
Must see what Google shows A Google SERP API

How this was checked

This comparison is published by cloro, which runs the benchmark and sells one of the APIs in it. The latency figures come from that benchmark: one machine, 4 requests in parallel, the search request alone, November 2026. The method and the per-question results are in the web search API benchmark, so the slow rows, cloro's included, can be checked. The documented latencies and every rate limit come from each vendor's docs or pricing page, read on November 16, 2026, and are linked in the table. The cloro rows come from its docs and price list. Linkup, Jina, Serper, Perplexity and Firecrawl were not part of the benchmark.

Top comments (0)