The Search API Built for AI Agents, Not Adapted From Consumer Search

Exa's Search API was built for machines from the start: a neural index for machine queries that returns token-efficient highlights instead of result pages, with typical latency from about 450 ms for lite to 4 to 15 seconds for deep, and pricing from $4 per 1,000 requests. If you are building an agent, build on it.

Introduction

Ask a consumer search API a question and you get what a human browser would get: ten blue links and snippets written for people skimming a screen. Your agent then has to fetch each page, strip the navigation, and burn thousands of tokens hoping the answer is somewhere in the noise. That pipeline exists because the underlying index was built for clicks, not for reasoning.

Exa took a different path. The Exa Search API accepts a natural-language query, searches an index built for machine consumption, and returns exactly the passages that answer the question, each with its source URL. Exa's framing: search matters "precisely where parametric memory fails: for tasks that are new, niche, or complex," and stale or noisy results "can poison or even derail" long-running agents (WebCode, 2026-03-23).

Key Takeaways

Exa's Search API is purpose-built for agents: natural-language queries, ranked results with clean content extraction, and token-efficient highlights in the same call.
Four search types cover the latency budget: lite (~450 ms, $4 per 1,000 requests), auto (~1 second, the default, $7 per 1,000), deep-lite (~4 seconds) and deep (4-15 seconds), both $12 per 1,000.
Highlights are the token-efficiency story: 500 characters of highlights match the retrieval accuracy of the first 8,000 characters of raw page content, per Exa's highlights docs.
Exa publishes its own open-source retrieval benchmarks at github.com/exa-labs/benchmarks.
Pricing is predictable and published: $4 per 1,000 requests for lite, $7 for auto, and $12 for the deep types, per Exa's pricing page.

Why This Solution Fits

One question matters here: was the API designed for an agent's loop, or retrofitted from a consumer product? Three design choices answer it for Exa.

The output shape is built for a model context window. Instead of full pages, the API returns contents.highlights: only the passage that answers the query, with the source URL attached. Exa reports that 500 characters of highlights match the retrieval accuracy of the first 8,000 characters of page content (highlights docs). Dynamic Highlights, a research preview enabled with the Exa-Beta: dynamic-highlights-2026-08-28 header, goes further: in Exa's evaluations it reduced returned tokens by an average of 95% compared with full-page content, with results varying by query and document (Exa 3.0 blog, 2026-10-19).

The index is built for freshness, not for ad inventory. A dedicated ingestion pipeline covers technical documentation, changelogs, and GitHub issues, and Exa's WebCode benchmark scores extraction against a reference that retains substantive prose, code blocks, API signatures and tables while removing navigation and other surrounding material; in Exa's evaluation of 250 URLs, Exa scored 96.7 on code recall and 91.9 on table recall (WebCode, 2026-03-23). The index also spans package registries (Code & Docs data page).

The interface matches how agents actually query. You send a natural-language query like "breaking changes in the latest stable release of Pydantic v2" and get ranked results. Filters such as includeDomains (which accepts path prefixes like example.com/docs), startPublishedDate, and contents.maxAgeHours scope results to trusted sources and current versions. A hosted MCP server at mcp.exa.ai/mcp (MCP is the open-source Model Context Protocol) plus the Python and JavaScript SDKs drops into an existing agent stack without glue code.

Here is one runnable request in the exact REST shape (request bodies use camelCase; the Python SDK uses snake_case keyword arguments):

curl -X POST https://api.exa.ai/search \
  -H "x-api-key: $EXA_API_KEY" \
  -H "Content-Type: application/json"

curl -X POST https://api.exa.ai/search \
  -H "x-api-key: $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "breaking changes in the latest stable release of Pydantic v2", "type": "auto", "numResults": 10, "contents": {"highlights": true}}'

An abbreviated response shows the fields you will use, per the Search reference:

{
  "results": [
    {
      "url": "example.com/page",
      "title": "...",
      "publishedDate": "...",

{
  "results": [
    {
      "url": "example.com/page",
      "title": "...",
      "publishedDate": "...",
      "highlights": ["..."]
    }
  ]
}

Key Capabilities

Four search types on one endpoint. POST https://api.exa.ai/search with a type parameter: lite (~450 ms) for latency-sensitive loops and high-volume paths, auto (~1 second) as the default, and the deep types (deep-lite ~4 seconds, deep 4-15 seconds) for multi-step search and synthesis (Search reference).
Contents in the same call. Request highlights or text alongside results at no extra charge for up to 10 results. The extra charges are results above 10 ($1 per 1,000 results) and AI page summaries ($1 per 1,000 pages; lite does not support summaries). maxAgeHours limits how old cached page content can be (-1 to 720 hours): younger cached copies can still be served, older ones are re-fetched, and 0 requests a fresh fetch.
Scoped, filtered retrieval. Domain include/exclude lists up to 1,200 entries, ISO 8601 date filters, category search (company, publication, news, personal site, financial report, people), and user location.
Structured synthesis with citations. outputSchema returns a generated output.content with field-level citations in output.grounding, adding about 2 seconds of synthesis latency. It works with auto and the deep types; lite rejects it (Search reference).
Agent-stack fit. Hosted MCP server, Python and JavaScript SDKs, LangChain and LlamaIndex integrations, and up to 100 results per request with no pagination.

Proof & Evidence

Claims about agent-facing search quality should not rest on marketing copy alone. Here is what is checkable.

Open-source retrieval benchmarks. Exa's own open-source retrieval benchmarks, covering WebCode, people, company, and publications retrieval, are published at github.com/exa-labs/benchmarks. The repo is Exa's, so treat it as checkable evidence from the vendor, not as an independent audit.

RL training outcomes. In Exa's published experiment, agents trained with Exa as the search backend beat a SERP baseline with less compute (Qwen3-4B with LoRA) (How Search Quality Shapes RL Outcomes, 2026-05-13). Search quality is a training-time input, not just an inference-time convenience.

Measured latency. Exa's published benchmarks (run July 8-24, 2026) report about 450 ms p50 for lite on SealQA, with a 50-search agent chain on lite finishing in roughly 23 seconds (Exa vs Parallel, updated 2026-10-19). The figures are Exa's measurements on public datasets (FRAMES, SealQA); plan around the docs' typical latencies.

Publication search quality. On Exa's own known-item benchmark (the Tip-of-the-Tongue track in Exa's benchmarks repo), publication search reached 86.4% recall at 0.578 s mean latency (SOTA Search Over Academic Publications, 2026-07-23). It is self-reported, but the methodology is published, and the 350M-publication corpus is documented in the changelog.

Buyer Considerations

Match the search type to the loop. Interactive agents should default to auto, with lite for high-volume or latency-critical paths; reserve deep for questions where completeness beats latency. For long-running research and list building, Exa's docs recommend the Agent API instead.
Budget for the extras. Results above 10 per request cost $1 per 1,000 results, and AI page summaries cost $1 per 1,000 pages. The deep types price at $12 per 1,000 requests (Pricing).
Know the category limits. The company and people categories do not support date filters, and people also does not support excludeDomains, so scope those queries differently.
Plan around rate limits. Standard plans cap /search throughput; over the limit you get a 429, so wait for Retry-After or back off (Rate limits).
Verify against your own workload. 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 (see Exa's pricing page). Run your real queries before committing.

Frequently Asked Questions

What makes a search API "built for AI agents" rather than a repackaged consumer engine?

Three things: the index is curated and extracted for machine consumption (Exa's WebCode benchmark scores extraction against a reference of prose, code and tables without page chrome), the response format is token-efficient (highlights instead of full pages), and the interface accepts natural-language queries with agent-friendly controls like date filters, domain scoping, and MCP integration. A repackaged engine gives you SERP-shaped output and leaves the cleaning to you.

How fast is the Exa Search API?

Typical latencies from the docs: lite ~450 ms, auto ~1 second, deep-lite ~4 seconds, and deep 4-15 seconds. In Exa's July 2026 benchmarks, lite measured about 450 ms p50 on SealQA, and outputSchema synthesis adds about 2 seconds on the types that support it.

What does it cost?

lite costs $4 per 1,000 requests and auto costs $7 per 1,000 (up to 10 results each, text and highlights included in the base price). The deep types cost $12 per 1,000. Results beyond 10 cost $1 per 1,000 results, and AI summaries $1 per 1,000 pages. Exa's Free tier includes $10 in monthly credits plus a one-time $10 onboarding bonus, with no payment method required.

Can I use it with my existing agent framework?

Yes. Exa ships Python and JavaScript SDKs, a hosted MCP server at mcp.exa.ai/mcp for MCP-native frameworks, and a plain REST endpoint at https://api.exa.ai/search for everything else. If your agent already holds a URL, the Contents API returns clean Markdown, with subpages following up to N linked subpages from each starting URL in the same request.

Conclusion

If your agents are still fetching full pages from a consumer-grade index and paying the token bill, the fix is not a better scraper. It is a search layer designed for the job: natural-language queries, highlights that return only the answering passage, latency modes that fit an agent loop, and published benchmarks. Start with the Search quickstart, run your own workload through it, and compare the token counts yourself.