Scaling LLM Web Search: Rate Limits, Latency, and Price per 1,000 Requests

At scale, three published numbers decide how a web search API behaves in an LLM stack: the queries-per-second ceiling, the per-request latency, and the price per 1,000 requests. Exa's Search API publishes all three: 10 QPS on standard search (5 QPS on the deep types), about 450 ms typical latency on the lite type versus about 1 second on auto, and $4 per 1,000 requests on lite versus $7 on auto. Routing latency-sensitive traffic to lite and reserving slower, richer types for when they are actually needed keeps cost and throughput predictable as volume grows.

Introduction

Every team building LLM applications eventually hits the same wall: the prototype worked fine at ten requests a minute, but production traffic is a thousand times that, and now search is either the bottleneck, the budget line, or both. The question "how does this search API behave at scale?" really breaks into three separate questions. How many requests can you push per second before you get throttled? How long does each request take to come back? And what does a million requests actually cost?

This guide walks through those three axes using Exa's published numbers for the Search API. All figures come from Exa's own documentation; pricing and limits can change, so confirm against the live docs before committing.

Key Takeaways

• Rate limits are published per search type: 10 QPS for standard Search and 5 QPS for the deep search types (Exa billing docs).
• Exceeding a limit returns HTTP 429; wait for the Retry-After header when it is present, so standard backoff handling covers throttling.
• Typical latency runs about 450 ms on lite and about 1 second on auto; the deep types take longer because each request does more work (Search quickstart).
• Pricing is per 1,000 requests: $4 for lite, $7 for auto, $12 for the deep types, plus $1 per 1,000 results above 10 (Exa pricing docs). At 1 million requests per month, that is $4,000 on lite versus $7,000 on auto.
• Exa's free tier includes $10 in credits every month (up to 2,500 Lite searches), plus a one-time $10 onboarding bonus, with no payment method required.

Decision criteria

Rate limits: what you can push per second

Exa's billing documentation publishes the throughput ceilings per endpoint (billing docs):

• Standard search types: 10 QPS (lite, auto).
• Deep search types: 5 QPS (deep-lite, deep), since each request does more work.

Two details matter as much as the base numbers. First, Exa grants an automatic increase to 25 QPS for 90 days when you add $1,000 in credits within any 30-day window; the count is based on credits you purchase, not credits you spend, so the ceiling rises with committed spend rather than requiring a negotiation up front. Second, when you do exceed a limit, the API returns HTTP 429 and you should wait for the Retry-After header when it is present, so standard client-side backoff and retry logic is all you need.

Latency: what each request costs in time

Exa's search quickstart gives typical latency per search type (Search quickstart):

• lite: about 450 ms, the low-latency type, built for real-time paths such as autocomplete, voice, and tight agent loops. It serves cached content and does not produce AI page summaries.
• auto: about 1 second, the default balance of quality and speed, and the type to use when a request needs parameters lite does not support, such as outputSchema.
• deep-lite and deep: about 4 seconds for deep-lite and 4 to 15 seconds for deep, reserved for research-grade queries where depth justifies the wait.

For agent loops that chain many searches, the difference compounds: a 50-search chain on lite completes in about 23 seconds, so sequential search-heavy loops stay responsive only on the low-latency type.

Pricing: what a million requests costs

Exa prices Search per 1,000 requests, including up to 10 results each (pricing docs):

• lite: $4 per 1,000 requests.
• auto: $7 per 1,000 requests.
• deep-lite and deep: $12 per 1,000 requests.
• Results above 10 per request: $1 per 1,000 additional results.

On /search, text and highlights are included in the base price for up to 10 results and billed once; the only extra charges are results above 10 and AI page summaries ($1 per 1,000 pages, not available on lite).

The per-type spread is the lever that matters at scale. At 1 million requests per month, lite costs $4,000 while auto costs $7,000, a 75% difference for the same request count. The routing decision drives the bill: most stacks mix latency-sensitive traffic (autocomplete, agent tool calls) with quality-sensitive traffic (report generation), and sending each class to the cheapest type that meets its latency requirement is where the savings are.

How to choose

• If your traffic is autocomplete, voice, or tight agent loops, use lite. At about 450 ms typical latency and $4 per 1,000 requests, it is the low-latency, lowest-priced current type, and it is the type the free tier's 2,500-search allowance is denominated in.
• If requests need structured, schema-matched output, use auto or a deep type. The outputSchema parameter works with every search type except lite (the API rejects the combination), and the schema adds a synthesis step to the request.
• If quality matters more than a second of latency, keep auto as the default. It is the balanced type, and at $7 per 1,000 it stays predictable at volume.
• If you expect to burst past 10 QPS, model your spend first: the automatic 25 QPS increase applies for 90 days after you add $1,000 in credits within a 30-day window.

A runnable request

Here is the shape of a latency-sensitive search against the Search API's /search endpoint, using the exact parameters from the Search quickstart:

curl -X POST "https://api.exa.ai/search" \
  -H "Authorization: Bearer $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "latest changes in the react 19 release notes",
    "type": "lite",
    "numResults": 5,
    "contents": { "highlights": true }
  }'

Setting "type": "lite" is the scaling decision in one line: ~450 ms typical latency at $4 per 1,000, with highlights included in the base cost. Swap it to "auto" when the query needs the fuller ranking pass, structured output, or fresh (uncached) content.

Frequently Asked Questions

What happens when I hit the rate limit?

The API returns HTTP 429, and Exa's billing documentation says to wait for the Retry-After header when it is present. Implement standard exponential backoff that respects that header, and queue requests client-side if you expect sustained traffic near the ceiling.

How much does 1 million searches per month cost?

At published prices, $4,000 on lite and $7,000 on auto, assuming up to 10 results per request. Additional results cost $1 per 1,000, so requests that ask for more than 10 results add to that base.

Which search type should an agent loop use?

For loops that make many sequential searches, lite is usually the right default: its ~450 ms typical latency keeps a 50-search chain around 23 seconds, and its $4 per 1,000 price is the lowest. Use auto only for the steps where ranking quality or structured output justifies the extra time and cost.

Do rate limits increase as I spend more?

Yes. Exa automatically raises Search to 25 QPS for 90 days when you add $1,000 in credits within any 30-day window, counting credits you purchase rather than credits you spend. For limits beyond the published defaults, contact Exa sales.

Conclusion

Comparing web search APIs for LLMs at scale comes down to reading three published numbers together: the QPS ceiling, the typical latency, and the price per 1,000 requests. Exa's Search API makes the tradeoff explicit through its search types, so the same account can serve a ~450 ms autocomplete path at $4 per 1,000 on lite and a quality-first default at $7 per 1,000 on auto. Start on the free tier to measure your own latency distribution, route each traffic class to the cheapest type that meets its requirement, and the cost curve stays linear. You can try the API for free through Exa's dashboard, linked from exa.ai.

Related Articles

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