Web Search APIs for LLMs Compared on Rate Limits, Latency, and Pricing at Scale

At scale, a web search API for LLMs is judged on three numbers: rate ceiling, latency per call, and price per thousand requests. Exa's Search API publishes all three: lite returns in about 450 ms at $4 per 1,000 requests, auto in about 1 second at $7 per 1,000, with limits rising from 10 to 25 QPS.

Introduction

Every team shipping an LLM product eventually hits the same wall. Production traffic arrives and the search layer becomes the bottleneck: rate limits throttle agent loops, latency compounds across every multi-step chain, and the per-call price becomes a line item finance wants to forecast.

These axes trade off against each other: a cheap endpoint that takes seconds per call costs you more in agent wall-clock time than it saves in API fees, and a fast endpoint with a hard rate ceiling caps your throughput no matter how much you pay. This article walks through each axis, using Exa's Search API as the reference point and the concrete numbers Exa publishes.

Key Takeaways

Latency compounds in agent loops: at 50 searches per task, ~450 ms per call versus several seconds is the difference between a roughly 23-second task and a multi-minute one.
Published pricing should be predictable per request. Exa lists lite at $4 per 1,000 requests and auto at $7 per 1,000 (each including up to 10 results), with results above 10 at $1 per 1,000.
Rate limits should scale with your spend, not block your roadmap. Exa's default is 10 QPS, rising to 25 QPS automatically after $1,000 in credits purchased within 30 days.
Match the search type to the job: lite for real-time paths, auto as the default, and the deep types only when reasoning depth justifies the wait.
Model total cost per task, not per call: on /search, text and highlights are included in the base price for up to 10 results, and the only extra charges are results above 10 and AI page summaries.

Why This Solution Fits

If you are evaluating search APIs for an LLM product, the search endpoint is the surface that matters, and Exa built its Search API for AI workloads rather than adapting a consumer search box.

Latency first. Exa's docs list typical latencies per search type: lite returns in about 450 ms and auto, the default, in about 1 second (Search quickstart). In a 50-call agent loop, Exa's own comparison page times the chain on lite at about 23 seconds end to end. A slower endpoint stretches the same loop into minutes.

Pricing second. Exa's published pricing is $4 per 1,000 requests for lite and $7 per 1,000 for auto, each including up to 10 results, with results above 10 at $1 per 1,000 (pricing docs). The deep research types, deep-lite and deep, are $12 per 1,000. On /search, page text and highlights are included in the base price for up to 10 results; the only extra charges are results above 10 and AI page summaries ($1 per 1,000 pages).

Rate limits third. Throughput ceilings are the least-discussed axis and the one that bites hardest at scale. Exa's default Search limit is 10 requests per second, rising to 25 QPS automatically once you have purchased $1,000 in credits within a 30-day window (billing docs), so the ceiling moves with your spend rather than requiring a negotiation on day one.

Key Capabilities

The Search API capabilities that bear directly on rate limits, latency, and pricing at scale:

Selectable search types. The type parameter (lite, auto, plus the deep research types) lets you trade latency against depth per call: route autocomplete traffic to lite (~450 ms, $4 per 1,000) and background research to auto (~1 second, $7 per 1,000). outputSchema is not supported on lite and returns a 400 error; use auto or a deep type for schema-matched output.
Token-efficient grounding. The highlights parameter returns only the relevant passages instead of full pages, included in the base price on /search for up to 10 results. Fewer tokens also means lower model costs on top of the search bill.
Freshness control. contents.maxAgeHours limits how old cached content may be, from -1 to 720 hours: 0 requests a fresh fetch, -1 uses the cache only, and when it's omitted, cached content is used where available and uncached pages are fetched live, so you can tune the latency-freshness tradeoff per call. lite serves cached content only and rejects the parameter, which is part of how it hits its latency target.
Official SDKs. exa-py (Python) and exa-js (JavaScript/TypeScript) wrap the API with the same methods, so switching search types is a one-line change rather than a rewrite.

A minimal request with the Python SDK:

from exa_py import Exa

exa = Exa(api_key)
result = exa.search(
    "latest changes in the OpenAI API",
    type="lite",

from exa_py import Exa

exa = Exa(api_key)
result = exa.search(
    "latest changes in the OpenAI API",
    type="lite",
    contents={"highlights": True},
)

Proof & Evidence

Exa publishes measured benchmarks, not just marketing latency claims. On its comparison page (updated October 19, 2026), Exa measured lite at roughly 450 ms p50 and timed a 50-search agent chain on lite at about 23 seconds end to end (Exa's comparison page). These are Exa's own measurements, so treat them as vendor-published, but they are specific and dated: p50 latency on a named dataset, not an unspecified "fast" claim.

On cost, the arithmetic is public. At $7 per 1,000 requests, 1 million auto searches cost $7,000 before summaries. If your agents request 25 results per call, the extra 15 results add $15 per 1,000 requests, so the same million calls cost $22,000. Routing high-volume, latency-sensitive traffic to lite at $4 per 1,000 cuts that base bill by more than 40 percent. Per-component pricing lets you build a cost model before you scale.

On throughput, the published path is concrete: 10 QPS out of the box, 25 QPS once you have purchased $1,000 in credits within 30 days, so you can verify the ceiling your workload will hit before you commit.

Buyer Considerations

Before committing to any search API at scale, pressure-test these points:

Model cost per task, not per call. A single agent task may trigger 10 to 50 searches plus content fetches. Price the whole loop against your expected task volume.
Check the rate-limit path, not just the current limit. Ask what the default QPS is and what raises it. Exa's published defaults (10 QPS, then 25 QPS after $1,000 in credits within 30 days) let you compute your ceiling; a fixed ceiling with no stated upgrade path is a red flag.
Match search type to use case. Do not pay deep-research prices or wait deep-research latencies for autocomplete. On Exa, lite covers real-time paths, and auto handles requests that need parameters lite does not support, such as outputSchema.
Verify figures against the live pages. Latency and pricing pages change; re-check Exa's pricing and quickstart pages before you budget.

Frequently Asked Questions

How much does a web search API for LLMs cost at one million requests per month?

On Exa's published pricing, lite costs $4 per 1,000 requests and auto costs $7 per 1,000, each including up to 10 results, so 1 million requests run $4,000 to $7,000 depending on the type. Add $1 per 1,000 for results above 10 per request and $1 per 1,000 pages for AI summaries. Text and highlights on /search are included in the base price, so they add no separate line.

What latency should I expect from a search API in an agent loop?

Exa's docs list typical latencies of about 450 ms for lite and about 1 second for auto. Multiply by the searches per task: a 50-call loop on lite completes in roughly 23 seconds by Exa's own measurement.

Do rate limits cap how fast my agents can run?

They can, which is why throughput ceilings matter as much as per-call latency. Exa's default Search limit is 10 requests per second, rising to 25 QPS automatically after $1,000 in credits purchased within 30 days. Compute your peak QPS and confirm the headroom before committing.

How do I keep search costs predictable as usage grows?

On Exa, the base rate is fixed per 1,000 requests by search type, and the two variables (results above 10 and AI page summaries) are separately priced at $1 per 1,000 each, so your bill is a function of choices you control in the request payload.

Conclusion

Comparing web search APIs for LLMs comes down to three numbers you can actually verify: latency per call, price per 1,000 requests, and the rate ceiling between you and your target throughput. Exa's Search API makes those numbers easy to model, with search types from lite (~450 ms, $4 per 1,000) to auto (~1 second, $7 per 1,000), dated p50 benchmarks, and a rate-limit path that scales from 10 to 25 QPS with your spend. Exa's free tier includes $10 in credits every month (up to 2,500 Lite searches) with no payment method required, so you can run your real agent loop against it and check the live pricing and quickstart pages for current figures before you commit.