Default to Exa for agents that need web access, use Brave only if your agent never keeps what it retrieves, test Perplexity's API as the challenger, and skip Tavily unless you negotiate its data terms. The list prices sit within a few dollars per thousand queries of each other. The bill that separates them is the page text each API hands your model, which at frontier-model input prices can cost 6 to 20 times the search fee.
Every price below was checked on the vendor's own pricing page or docs on October 16, 2026.
| Exa | Brave Search API | Perplexity Search API | Tavily | |
|---|---|---|---|---|
| List price per 1,000 searches | $7 (auto/fast), $4 (instant) |
$5 | $5 | $8 pay-as-you-go, $5 on the $500/month plan |
| Page content | $1 per 1,000 pages, per content type | Snippets plus "LLM context", no full page | Extracted text, capped by max_tokens_per_page |
~500-character chunks included; raw page optional |
| Index | Own crawl | Own index, 40B+ pages (vendor claim) | Own index, "hundreds of billions" of pages (vendor claim) | Own index plus third-party providers such as Google |
| Zero data retention | Enterprise plan | Enterprise plan | Eligible accounts, not default | Not mentioned in the privacy policy |
| Verdict | Default pick | Pick for snippet-only grounding | Run it as the challenger | The loser |
Which Search API Should an Agent Team Pick in 2026?
Exa, because it is the only one of the four that lands near the top of both independent benchmarks published this year, it runs its own crawl, and its per-page content billing makes the token decision explicit instead of hiding it.
A web search API for agents is a service that takes a query from your model and returns ranked URLs with some amount of page text, so the model can answer from live sources instead of its training data. The four APIs here all do that. They differ in how much text comes back, who owns the index behind it, and what happens to your queries afterwards.
The two independent benchmarks disagree badly on order. AIMultiple's agentic search benchmark (100 real queries, a December 2025 snapshot, graded by an LLM judge with about 10% checked by hand) put Brave first at 14.89, Exa at 14.39, Tavily at 13.67 and Perplexity lowest of the four at 12.96. OpenBenchmarks (whose page does not say who runs or funds it; 100 developer tasks, measured September 15, 2026, where a task passes only if the agent's patch passes its checks and cites a retrieved source) reversed it: Perplexity first at 77.3% task completion, Exa fast at 66.3%, Tavily basic at 51.0% and Brave last of 14 configurations at 38.0%.
Brave and Perplexity swing from top to bottom depending on the test. Exa stays near the top on both. When two methods disagree that much, the product that survives both is the safer default for workloads you have not measured yet. AIMultiple itself says its top four (Brave, Firecrawl, Exa and Parallel) are statistically indistinguishable, and the only gap it calls meaningful is Brave's lead over Tavily.
How Much Does Each Search API Cost per 1,000 Queries?
On list price alone, Brave and Perplexity are cheapest at $5 per 1,000, Exa costs $7 before content, and Tavily costs $8 at pay-as-you-go rates.
Exa charges $7 per 1,000 requests for auto and fast search and $4 for instant, with up to 10 results included and $1 per 1,000 for each result above 10. Page text, highlights and summaries are each $1 per 1,000 pages, billed per content type. Deep search runs $12 to $15 per 1,000. The free tier resets to $10 of credit each month. Enterprise adds custom rate limits, SLAs and zero data retention at unpublished prices.
Brave Search API charges $5 per 1,000 requests on its Search plan, with $5 of free credit each month and a 50 queries per second limit. The Answers plan is $4 per 1,000 requests plus $5 per million input and output tokens, capped at 2 queries per second. Enterprise terms are negotiated.
Perplexity charges $5 per 1,000 requests for its Search API and $1 per 1,000 for Fast Search. Sonar, its answer-generating API, stacks token and request fees: Sonar is $1 per million input and output tokens plus $5 to $12 per 1,000 requests depending on search context size, and Sonar Pro is $3 input and $15 output per million tokens plus $6 to $14 per 1,000 requests.
Tavily sells credits. A basic or fast search costs 1 credit and an advanced search costs 2. A credit is $0.008 pay-as-you-go, falling to $0.005 on the Growth plan ($500 a month for 100,000 credits). The free Researcher tier gives 1,000 credits a month. Extract costs 1 credit per 5 successful URLs at basic depth.
Tavily's per-call price includes text, which the others either charge for or don't return. Its search endpoint returns up to 3 chunks per result, about 500 characters each at basic depth and about 800 at advanced, and can return full page markdown through include_raw_content. An Exa call with highlights on 10 results costs $7 plus $10 in content fees, so on price-with-content Tavily is the cheaper of the two. That is Tavily's strongest case, and it still loses below on index, terms and measured quality.
What Does a Search Actually Cost Once the Model Reads It?
The token bill for the returned text is the bigger number, and it can be twenty times the search fee when you feed full pages to a frontier model.
Here is the workload: 1,000 answered questions, 3 searches per question, 10 results per search, read by Claude Sonnet 5.5 at $2 per million input tokens. Two assumptions, stated so you can swap in your own: about 4 characters per token for English text, and about 5,000 tokens of extracted text per full web page.
| Per 1,000 answered questions | Search fees | Tokens the model reads | Token cost at $2/M | Total |
|---|---|---|---|---|
| Brave, snippets | $15 | ~11M | ~$22 | ~$37 |
| Tavily basic, 3 chunks per result | $24 | ~11M | ~$22 | ~$46 |
| Exa, highlights on 10 results | $51 | ~11M | ~$22 | ~$73 |
| Any API, full page text | $15 to $51 | ~150M | ~$300 | $315 to $351 |
The excerpt rows assume each search returns about 15,000 characters (10 results times 3 chunks of 500), which is Tavily's basic default, and apply the same size to all three so the rows compare. At that size, search fees and token costs are roughly equal, and Brave wins on price. Switch on full page text and the token line jumps to about $300, which is 6 times Exa's search bill and 20 times Brave's.
The real number is higher than that table. An agent loop re-sends earlier tool results on every turn, so a three-turn loop reads the first search's text three times. Prompt caching cuts those re-reads to $0.10 per million tokens on Sonnet 5.5, so turn it on before you compare vendors. Every retry also costs a second search fee and a second batch of tokens, so an API that returns weak results on the first call costs you twice.
Dropping to a cheap model does not remove the problem. Claude Haiku 5.5 costs $0.10 per million input tokens for prompts up to 100,000 tokens and $0.50 above that, so a 150,000-token full-page context lands in the higher tier and costs about $75 per 1,000 questions, still more than any search fee in the table. We walked through the same arithmetic for retrieval in long context vs RAG cost.
So the control that matters most is the content budget, and the APIs differ here. Perplexity's Search API exposes max_tokens and max_tokens_per_page, a hard cap in the unit you are billed in. Exa's text is off by default and maxCharacters caps it when you set it. Tavily's chunks_per_source goes from 1 to 3. Brave returns snippets and its LLM context, with up to five extra snippets per result, and no full page at all.
Who Owns the Index After Bing Shut Its API?
Brave, Exa and Perplexity run their own indexes; Tavily partly relies on others, which is the continuity risk Microsoft just demonstrated.
Microsoft retired the Bing Search APIs on August 11, 2025, decommissioned every existing instance, and pointed customers to Grounding with Bing Search, which works only inside Azure AI Agents. Any product built on resold Bing results had to migrate on Microsoft's schedule.
Brave claims more than 40 billion pages with over 100 million updates a day in an index it builds itself. Perplexity says its Search API runs on the same infrastructure as its answer engine, with an index covering hundreds of billions of pages. Exa crawls the web and embeds pages into its own vector index, as MIT Technology Review described in 2024. Treat every page count as a vendor claim; none is audited.
Tavily's privacy policy says query data may be passed to third-party search index providers, naming Google, when Tavily's own index cannot retrieve the content. That tells you two things: part of your coverage depends on a supplier Tavily does not control, and your queries may leave Tavily to reach it.
What Happens to Your Queries and the Results?
Only Brave publishes a retention cap on its standard plan; zero data retention is an enterprise contract at every vendor that offers it.
Brave keeps a record of Search API queries for a maximum of 90 days for billing and troubleshooting. Brave announced zero data retention in January 2026 for custom enterprise plans. Brave's terms of service are the strictest on results: you may not "store, cache, or create a database of Search Results" beyond transient storage your application needs, may not use them to train or fine-tune models, and must destroy them on termination.
Exa is SOC 2 Type II certified and offers zero data retention on its Enterprise plan. Its security page does not say how long standard-plan queries are kept or whether they are used for training, so get both in the data processing agreement before you send customer data.
Perplexity says zero data retention is available only to eligible customers through an account-level setting and is not the default. The page does not name the Search API specifically, so confirm coverage in writing.
Tavily keeps query data "for the period necessary to provide and improve the Services" and, unless your contract says otherwise, may use parts of it "to improve our responses to future queries", per its privacy policy. The policy does not mention zero data retention.
If your agent sends customer names, ticket text or deal terms as search queries, those queries are data leaving your perimeter. Treat the search API as a subprocessor and review it like one.
Does the Nebius Deal Change the Tavily Buy?
It adds a question to the contract, and nothing yet changes the price list.
Nebius announced on February 10, 2026 that it would acquire Tavily, saying Tavily would keep its brand, keep serving existing customers and stay under founder Rotem Weiss. SiliconANGLE reported, citing Calcalist, a $275 million initial payment that could rise to $400 million on milestones. The announcement says nothing about pricing.
A cloud provider that buys a search API usually wants it to pull customers onto its compute. That can mean better bundled pricing for Nebius customers, or roadmap attention shifting toward them. Neither has happened that we can document. If you sign a multi-year Tavily commitment, put a price cap and a change-of-control termination right in it.
Who Should Not Pick Each Option?
Each of these products is the wrong buy for a specific team, and the reasons are written in the vendors' own terms.
Skip Exa if your engineers will set text: true with no maxCharacters, because per-page content fees plus uncapped page text make it the most expensive row in the table. Skip it too if you need zero data retention without an enterprise contract, or if your agent needs only snippets at high volume, where Brave and Perplexity are $2 cheaper per 1,000.
Skip Brave if your agent keeps what it retrieves: a RAG cache, agent memory, retrieved text in your logs, or anything used for fine-tuning. Its terms forbid storing results beyond transient use. Also skip it for coding or research agents that need full page text; it finished last of 14 configurations on OpenBenchmarks' task completion test.
Skip Perplexity's Search API if you need zero data retention on a self-serve account. Skip Sonar if you already have your own model writing the answer, because you would pay Perplexity's token and request fees and then your own model's tokens on the same text. AIMultiple ranked it last of these four, though its 11-second latency suggests that test hit an answer-generating endpoint rather than the raw Search API; that is our inference, not the benchmark's statement.
Skip Tavily if you handle regulated data and cannot negotiate the default "improve our responses" clause away, or if a supplier you can't see in the contract is a problem for you. Teams already deep in its extract, crawl and map endpoints, which share one credit pool, have a real reason to stay; a team choosing fresh has much less of one.
Why Tavily Is the Loser
Tavily has the most convenient developer bundle and competitive price-with-content, and it still trails on everything a buyer has to defend later.
It is the only product in this group that discloses relying on another company's index, the dependency Bing's shutdown showed the risk of. Its default terms allow query reuse and its privacy policy does not mention zero data retention, where Brave and Exa publish an enterprise ZDR option. The only statistically meaningful gap AIMultiple reports is Brave's lead over Tavily. In OpenBenchmarks it completed 51.0% of tasks against Exa's 66.3%. And it agreed to a sale to Nebius eight months ago, with no public statement yet on pricing.
Any one of those is negotiable. All five together mean you would be choosing Tavily for convenience and accepting the most contract risk in the field. If you want a single vendor for search plus crawling, compare it against Firecrawl before you sign; we covered other agent-native entrants in Octen's agent search API and Parallel Web Systems.
What Predicts Regret, and What Changes the Answer?
Most regret here comes from five decisions made before anyone looks at result quality.
- Do you store results? If yes, Brave is out on its terms, and every other vendor's retention clause becomes a review item.
- How much text reaches the model per call? Set a hard per-page budget before you compare vendors. Without one, the token line swamps every fee in this article.
- What do the default data terms allow? Brave caps retention at 90 days. The others need a contract to get to zero.
- Who owns the index? Resold supply can disappear on someone else's schedule, as Bing's did.
- What do your own queries say? Public benchmarks reversed each other on two of these four vendors.
The answer changes in two cases. If your agent answers short factual questions from snippets and stores nothing, Brave becomes the default on price and latency. If Perplexity wins your own bake-off by the margin it showed on OpenBenchmarks, its $5 price and token-budget controls make it a better default than Exa.
Run 100 of Your Own Queries Before You Sign
No public benchmark measures these APIs on your query mix, so the only number worth trusting is the one you produce.
This Week:
- Pull 100 real search calls from your agent traces, not invented prompts. Weight them toward the questions your users actually ask.
- Sign up for the free tiers. Tavily's 1,000 monthly credits, Exa's $10 and Brave's $5 each cover 300 searches with room for retries; on Perplexity, 300 searches at $5 per 1,000 cost $1.50.
This Month:
- Run each query through the same agent and model with each API, holding the content budget fixed (for example, 3 chunks or 2,000 tokens per page).
- Grade the final answers, not the result lists: is the answer correct, and does a retrieved source support it? Build the grading set the way we laid out in our RAG eval dataset guide.
- Log input tokens per answer, then compute cost per correct answer: search fees plus token cost, divided by correct answers. That is the number that goes in the business case.
- For Brave, grade within the run and keep your scores, since its terms bar storing results beyond transient use.
Before You Sign:
- Send your data processing questions to the winner in writing: retention period, training use, subprocessors, and zero data retention price.
- For any vendor that resells an index or has changed owners, add a price cap and a termination right on change of control.
The Bottom Line
Search APIs repeat the cloud egress pattern, where buyers compared per-unit prices and the bill came from the volume behind them. Pick Exa as the default, cap the text it returns, and let your own 100 queries decide whether Perplexity or Brave displaces it.
Set the per-page token budget first, then run the bake-off.
Continue Reading
- Long Context vs RAG Cost: Cached, Each Answer Still Costs 5x
- RAG Eval Dataset: 200 Hand-Written Questions Beat Synthetic Ones
- Octen's $10M Bet: Search Built for Agents, Not Humans
- Parag Agrawal's $2B Bet: AI Agents Need Their Own Web
- A Demo Vendor Is Perplexity's #3 Source. Rank the Domains.
- Cohere vs Voyage vs BGE Rerankers: Chunk Length Sets the Bill