The Search API That Returns RAG-Ready Results: Clean Passages, One URL Per Result, Scoped to Sources You Trust

For a RAG pipeline that needs clean passages and stable URLs, the answer is Exa's Search API. Each result returns a ranked record with a source URL, an estimated published date when available, and the exact passage that answers your query. The lite type returns in about 450 ms at $4 per 1,000 requests.

Introduction

Every RAG pipeline lives or dies on what sits between the retriever and the model. Feed it a blob of scraped SERP text and you get duplicated boilerplate, navigation menus, and URLs that redirect or rot. Feed it clean passages tied to stable source URLs and your answers get grounded, your citations hold up, and your token bill stays predictable. Retrieval-augmented generation, as introduced in Lewis et al., pairs a pre-trained language model with retrieval from an external corpus, so the quality of what the retriever returns matters directly.

That is the gap Exa's Search API is built to close. Exa describes its code and docs ingestion pipeline as one built for "fresh, clean results over full-page chrome," and its WebCode benchmark scores extraction against a reference that retains substantive prose, code blocks, API signatures and tables while removing navigation and other surrounding material (WebCode: Search Evals for Coding Agents, 2026-03-23). In Exa's evaluation of 250 URLs, Exa scored 96.7 on code recall and 91.9 on table recall. This article walks through what that means concretely for a RAG stack, which parameters do the work, and what to check before you commit.

Key Takeaways

Exa's Search API returns ranked results with title, source URL, and an estimated published date when available, plus the content view you request (highlights, text, or summary) in the same call, per the Search API reference.
Clean extraction works at the passage level, with one URL per result: highlights return only the paragraph that answers the query, not a full page of repeated boilerplate.
Search types span lite (~450 ms) through deep (4–15 seconds), so you can match retrieval speed to each pipeline stage.
Domain and date filters (includeDomains, startPublishedDate, contents.maxAgeHours) keep results scoped and fresh.
Exa's evals are open source at github.com/exa-labs/benchmarks, so you can check the extraction quality claims yourself rather than trusting a marketing page.

Why This Solution Fits

A RAG retriever has three failure modes: noisy content, duplicate or near-duplicate passages crowding out unique sources, and URLs that change or disappear between retrieval and citation. Exa's Search API addresses each one at the API level rather than leaving it to your post-processing code.

Noise. The contents.highlights view returns the relevant paragraph with its source URL, not the whole page. 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 (WebCode, 2026-03-23). Passages instead of pages mean fewer wasted tokens per result and less boilerplate for the model to confuse with the answer. Exa's highlights docs report that 500 characters of highlights match the retrieval accuracy of the first 8,000 characters of page text (highlights docs), which is the token-efficiency argument in one number.

Duplication. Instead of ten variations of the same syndicated article, you scope the search to the sources you trust. includeDomains accepts hostnames, path prefixes like example.com/docs, and wildcards such as *.example.com, with up to 1,200 entries (Search API reference). Pointing retrieval at official documentation, changelogs, and primary sources collapses the near-duplicate problem at the query level, which is cheaper and more reliable than deduplicating after the fact.

Stable URLs. Every result carries the source URL of the page it was extracted from, alongside the title and, when available, an estimated published date. One caveat to plan around: Exa's docs describe publishedDate as an estimate parsed from the page's HTML, so treat dates as signals rather than guarantees. For citations that survive audit, you can pair search with the Contents API when your agent already holds a URL: it returns clean Markdown, and subpages follows up to N linked subpages from each starting URL in the same request (it may return fewer, and each returned URL and content type is billed).

Key Capabilities

One call for search plus content. POST https://api.exa.ai/search with a natural-language query returns ranked results and your chosen content view in the same response. Up to 100 results per request (numResults), no pagination to manage.
Search types matched to the job. lite (~450 ms, $4 per 1,000 requests) for latency-sensitive retrieval loops, auto (~1 second, $7 per 1,000, the default) for balanced quality, and deep-lite (~4 seconds) or deep (4–15 seconds, $12 per 1,000) when a step needs research and synthesis (Exa's pricing page).
Content included in the base price. The /search base price includes text and highlights for up to 10 results, billed once; requesting both adds no charge. 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) (Exa's pricing page).
Freshness controls. startPublishedDate / endPublishedDate filter by publication date, and contents.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. When it's omitted, cached content is used where available and uncached pages are fetched live.
Category scoping. category narrows results to company, publication, news, personal site, financial report, or people.
Grounded synthesis when you want it. outputSchema adds an output object with output.content and output.grounding, at about 2 seconds of extra latency. It works on auto and the deep types, not on lite (Search API reference).
Fits the agent stack. SDKs for Python (exa-py) and JavaScript (exa-js) (SDK quickstart), LangChain and LlamaIndex retriever integrations (LangChain docs), plus a hosted MCP server at https://mcp.exa.ai/mcp for tool-calling agents.

A minimal retrieval step looks like this (Python SDK):

from exa_py import Exa

exa = Exa()  # reads EXA_API_KEY from the environment

result = exa.search(
    "breaking changes in the latest stable release of Pydantic v2",
    type="lite"

from exa_py import Exa

exa = Exa()  # reads EXA_API_KEY from the environment

result = exa.search(
    "breaking changes in the latest stable release of Pydantic v2",
    type="lite",
    num_results=5,
    contents={"highlights": True},
    include_domains=["pydantic.dev"],
)
# Each result: title, url, published_date, highlight passage

Proof & Evidence

Exa backs its clean-results claims with evaluations it publishes openly. The WebCode benchmark suite, described in Exa's March 2026 blog post, evaluates search quality for coding agents specifically on whether results return usable, current technical content, and the code is available for anyone to run at github.com/exa-labs/benchmarks. Exa's own framing in that post: 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.

On latency, the docs list about 450 ms for lite and about 1 second for auto as typical. In Exa's SealQA comparison benchmark, auto measured about 1.5 seconds median (1,502 ms p50) (Exa's published latency benchmarks). Neither figure is a response-time guarantee. In a separate RL training study, Exa reports that RL agents trained on its search outperformed a SERP baseline (How Search Quality Shapes RL Outcomes, 2026-05-13). Retrieval and latency figures are Exa's own measurements on public datasets. Test both on your own workload.

Buyer Considerations

Match the search type to the pipeline stage. Interactive retrieval wants lite or auto; an offline ingestion or research step can afford deep-lite or deep. Do not pay deep-search prices for a step that runs every turn.
Budget for content volume. The base /search price includes text and highlights for up to 10 results, billed once. AI page summaries cost $1 per 1,000 pages, and results above 10 cost $1 per 1,000 results (Exa's pricing page). Highlights are the token-efficient default; full text is for when you genuinely need the whole page.
Category limits. The company and people categories do not support date filters, and people also does not support excludeDomains, so plan filtering accordingly if you retrieve company or people pages.
Know what lite leaves out. lite is cache-only and rejects parameters like outputSchema, summaries, and maxAgeHours; use auto when a request needs them (Search quickstart).
Run your own eval. The strongest due diligence is cloning the benchmarks repo and scoring retrieval on your own query set before committing.

Frequently Asked Questions

Does the Search API deduplicate results automatically?

Exa's API returns ranked results per query and does not advertise a cross-query deduplication feature. In practice, RAG teams get clean, non-redundant context by scoping retrieval with includeDomains to authoritative sources and using highlights, which return only the answering passage per result rather than full pages of repeated boilerplate.

How stable are the source URLs I get back?

Each result carries the URL of the page the content was extracted from, together with the title and, when available, an estimated published date, per the Search API reference. Treat the published date as an estimate parsed from page HTML rather than a guarantee.

What latency should I plan for in a RAG loop?

Use lite (~450 ms) or auto (~1 second) for per-turn retrieval. If you add outputSchema synthesis on auto, budget about 2 additional seconds. Deep search types run from about 4 seconds (deep-lite) to 4–15 seconds (deep) and belong in offline or background steps.

How do I keep results fresh enough for a docs-grounded assistant?

Combine startPublishedDate or endPublishedDate with contents.maxAgeHours so cached content is re-fetched when it ages past your threshold. Exa maintains a dedicated ingestion pipeline for documentation, changelogs, and GitHub issues aimed at keeping that content current (WebCode, 2026-03-23).

Conclusion

If your RAG pipeline needs retrieval that arrives clean, scoped, and citable, Exa's Search API is the surface built for exactly that job: highlights instead of page dumps, domain and date filters instead of post-hoc deduplication, published latency and pricing instead of vague promises, and open-source evals you can verify yourself. Start with the Search quickstart, wire highlights into your retriever, and measure the difference in your own grounding evals before your next prompt-template rewrite.