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

> Source: <https://dev.to/cloro/which-web-search-api-is-fast-enough-for-an-ai-agent-that-makes-many-calls-in-a-row-41oj>
> Published: 2026-11-16 11:14:00+00:00

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.

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](https://news.ycombinator.com/item?id=45838355) 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](https://docs.parallel.ai/search/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](https://docs.perplexity.ai/docs/search/fast-search)).

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:

``` python
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))
```

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](https://exa.ai/docs/admin/billing) | 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](https://brave.com/search/api/) | 50 queries per second on the Search plan, counted in a 1-second sliding window | Enterprise | 
| [Perplexity Search API](https://docs.perplexity.ai/docs/admin/rate-limits-usage-tiers) | 50 query units per second on every tier; one unit per query in a multi-query request | Not stated | 
| [Linkup](https://docs.linkup.so/pages/documentation/platform/rate-limits) | 10 queries per second per organization | Custom plans | 
| [Tavily](https://docs.tavily.com/documentation/rate-limits) | 100 requests per minute free; 1,000 on pay as you go and smaller plans; 1,500 on Growth and Scale | Enterprise | 
| [Parallel](https://docs.parallel.ai/getting-started/rate-limits) | 600 searches per minute | Ask support | 
| [Firecrawl](https://docs.firecrawl.dev/rate-limits) | `/search` : 10 per minute free, 100 Hobby, 500 Standard, 5,000 Growth | Higher plan | 
| [SerpApi](https://serpapi.com/pricing) | 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.

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 | 

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](https://cloro.dev/blog/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.
