---
title: "Exa vs Tavily in 2026: The $7/1K Semantic API Against the $8/1K Agent Search"
dek: "Exa and Tavily solve different problems at similar-looking prices. Exa at $7/1K base (plus $1/1K per extra result block and a separate Contents meter) does keyword-free semantic retrieval Tavily cannot; Tavily at $8/1K PAYG does agent-native keyword search with a credit ladder. The bill shapes differ more than the headlines."
category: "comparisons"
tags: [exa, tavily, comparison, pricing, search-api, ai-agents]
author: "Dave"
published: 2026-09-17T11:00:00+00:00
updated: 2026-09-17T11:00:00+00:00
url: https://keirolabs.cloud/blogs/comparisons/exa-vs-tavily
---
$7.00Exa / 1K, 10 results
$8.00Tavily / 1K basic PAYG
$27-57Exa usable query / 1K
$16.00Tavily advanced / 1K
Rates verified against vendor pricing pages on 2026-09-17. Exa's March 2026 update bundles Contents for the first 10 results; anything past 10 bills separately.
These two APIs get compared constantly because their price headlines sit a dollar apart and their marketing pages share a vocabulary: agents, semantic, retrieval, content. The products underneath are built on different primitives, bill on different meters, and fail on different query types. Exa runs embeddings against its index, which is why it can find pages that share zero keywords with your input, and why it is the only tool on the market that does the find-similar primitive well. Tavily runs keyword search through an agent-shaped API, with a content layer and a credit meter designed for tutorials to recommend.
The market context sharpened the comparison in 2026. Exa raised its base rate from $5.00 to $7.00 while bundling Contents for the first ten results, a repricing that made a lot of still-circulating comparison content wrong by 40% on the base rate. Tavily's ecosystem dominance kept growing even as its pay-as-you-go rate became the most expensive in the agent-ready category. And the bundled-content tier, led by Keirolabs at $0.25 per 1,000, re-priced the overlapping half of both products' workloads, which is the half most of their customers actually use. A team comparing these two in 2026 is therefore also implicitly comparing against a third option that did not exist in this form in 2024, and this article treats it as one throughout.
This comparison is structured around the decisions a team actually makes: which input does your pipeline start from, which meters will your workload trigger, what does latency cost inside an agent loop, and what does the bill look like at each volume band. Where the two overlap, the numbers decide. Where they do not, the answer is "different product," and pretending otherwise is how teams buy the wrong one and then write a blog post about it.
## What do Exa and Tavily charge per 1,000 requests in 2026?
**Exa's base search is $7.00 per 1,000 for up to 10 results, with every result block past ten billing an additional $1.00 per 1,000, Contents at $1.00 per 1,000 pages per content type, Answer at $5.00, Deep Search at $12.00, and Deep-Reasoning and Monitors at $15.00.** Tavily's side: $8.00 per 1,000 basic searches pay-as-you-go ($0.008 per credit), $16.00 per 1,000 for advanced search at two credits, and a plan ladder that reaches $5.00 per 1,000 only on the Growth plan behind a $500 monthly commitment, which breaks even at 62,500 credits a month.
| | Exa | Tavily |
|---|---|---|
| Base search (PAYG) | $7.00/1K (10 results) | $8.00/1K basic |
| Advanced / deep variant | +$1.00/1K per extra result block | $16.00/1K (2 credits) |
| Reading the pages | Contents $1.00/1K pages per type | Included in search credits |
| Synthesis products | Answer $5.00, Deep Search $12.00 | Research, priced in credits |
| Commitment discount | $5.00 → $7.00 base raise in 2026 | $5.00/1K on Growth, $500/mo floor |
| Free tier | $20 signup + $10/mo credits (~1,400 searches) | 1,000 credits/mo |
The headline comparison is $7.00 against $8.00, which is nearly a tie and almost completely uninformative. The real comparison is bill shape: Exa meters every product separately, so a pipeline that searches, reads pages, and asks for summaries triggers three meters, while Tavily meters everything in one credit currency, so a pipeline that flips to advanced search doubles its rate invisibly. Exa's bill grows when you ask for more results; Tavily's grows when your agent picks the deeper mode. Both are bill-shock mechanisms, they just shock different teams.
Since Exa's March 2026 update, Contents for the first 10 search results is bundled into the $7.00 search price, which narrowed the gap for light workloads: a 10-result search with text for the top results costs $7.00 on Exa and $8.00 on Tavily basic. Past that first band, the meters diverge fast. A 30-result Exa search bills $27.00 per 1,000, and requesting text for all 30 pages adds roughly $20.00 per 1,000 queries beyond the bundled ten, which puts the combined bill near $47.00 to $57.00 per 1,000. Tavily's version of the same deep workload is advanced search at $16.00 per 1,000 with content included, and the crossover is not obvious until the workload is measured.
## Which bill is cheaper at real volume?
**Below 100,000 searches a month the two are close enough that integration cost decides; above it, Tavily's ladder and Exa's result-count meter both escalate, and the bundled-content tier prices the same workload at $25 to $100.** The volume table puts every band on one page:
| Monthly volume | Exa (10r + contents) | Tavily basic PAYG | Tavily advanced PAYG | Keiro semantic |
|---|---|---|---|---|
| 10K | ~$70-80 | $80 | $160 | $2.50 |
| 100K | ~$700-800 | $800 | $1,600 | $25 |
| 1M | ~$7,000-8,000 | $8,000 | $16,000 | $250 |
At the 10K band the two are effectively tied, within the noise of result counts and content types, and the decision there is architectural, not financial. At 100K the Exa-versus-Tavily column still clusters, and the third column, a bundled-content API at $0.25 per 1,000, is 30x below both. At a million queries the Exa/Tavily bills are $7,000 to $16,000 against $250, and that is the band where every vendor in this comparison suddenly offers enterprise pricing, so quote the workload before paying any sticker rate.
The commitment ladders deserve a symmetry note, because both vendors hide their best rate behind volume. Exa's base rate was raised from $5.00 to $7.00 in 2026, and its volume discounts sit behind negotiated tiers; Tavily's $5.00 rate sits behind the Growth plan's $500 monthly floor. Neither publishes a clean flat rate below its headline. Keirolabs publishes $0.25 flat across volume, which is the pricing shape procurement teams should demand from everyone, and the shape neither incumbent in this comparison offers.
Bills by volume band. Exa and Tavily cluster within 2x of each other at every band; the bundled-content tier sits 30x below both at scale.
## What is each one actually good at?
**Exa's advantage is a primitive Tavily does not offer: keyword-free semantic retrieval, where the input is a page or a concept and the output is pages that mean the same thing regardless of vocabulary.** This is the primitive behind competitive research, literature discovery, "find me more like this source" features, and any pipeline that starts from a document rather than a question. Tavily cannot do it at any price, because its engine matches query terms against pages. Every other difference on this page is negotiable; this one is categorical.
The primitive has a failure mode worth knowing before committing to it. Embedding retrieval surfaces pages by meaning, which occasionally means pages that are semantically adjacent but topically wrong, and the confidence of the result does not encode that distinction the way a keyword hit does. Teams that adopt Exa for find-similar typically add a lightweight relevance filter downstream, a second-stage scoring pass, because the primitive's recall is high and its precision on the tail is where the work goes. This is not a defect so much as the shape of the trade: keyword search gives you precision on common queries and blindness to vocabulary drift, and semantic retrieval gives you recall across vocabulary and noise on the tail.
**Tavily's categorical advantage is agent-native ergonomics: the LangChain and CrewAI integrations are named and documented, the content comes back inside the search call, and the whole ecosystem of agent tutorials assumes it.** A team building with a mainstream agent framework has a Tavily integration in five lines and community support for every edge case. Exa's integrations are thinner, and the semantic primitive requires a different mental model, which shows up as onboarding time. Teams migrating between the two consistently report that the API calls were the easy part and the query redesign was the work.
On latency, the AIMultiple May 2026 runs put Tavily at 998ms average and Exa at about 1,200ms, with Exa's Instant mode sub-425ms. Inside an agent loop where search gates every reasoning step, both figures are workable and the difference is one more second per tool call. For batch or background pipelines, neither number matters. For a chat agent where the user watches the spinner, the 200ms gap compounds across a ten-step task into something a user can feel.
| Dimension | Exa | Tavily |
|---|---|---|
| Core primitive | Semantic, keyword-free | Keyword search, agent-shaped |
| Find-similar from a seed page | Yes, the specialist | No |
| Content in the search call | First 10 results, since Mar 2026 | Yes, raw_content on request |
| Deeper mode cost | +$1/1K per extra result block | 2x credits (advanced) |
| Latency (AIMultiple) | ~1,200ms, sub-425ms Instant | 998ms |
| Free tier | $20 + $10/mo credits | 1,000 credits/mo |
## When does the choice actually not matter, and what should those teams do?
**For the QA-and-RAG workload that dominates agent search spend, neither rate is competitive, and the honest third option prices the same output at $0.25 per 1,000.** Keirolabs bundles semantic search with extracted page content in one call, scores 78% on FinanceBench against roughly 19% for a standard GPT-4o plus vector RAG baseline and 84% on SimpleQA, and returns indexed queries in roughly 100ms from a 50B+ page index. The free tier ships 1,250 credits a month, no card. A team whose workload is "search, read the pages, answer" should price that workflow against the bundled tier before paying either incumbent's rate.
The honest division of a serious retrieval stack in 2026: a bundled-content API for the query-shaped traffic, Exa for the similarity slice if the pipeline has one, and no vendor serving both halves at incumbent prices. The AIMultiple May 2026 benchmark, judged by Gemma 3 12B, scored Keiro 94 on SimpleQA, 91 on FreshQA, and 82 on HotpotQA, ahead of Tavily at 78/77/68. Exa was not in that QA run, because its claim is a different primitive rather than QA accuracy, so the fair way to evaluate Exa is on your own similarity queries, and the fair way to evaluate Tavily and Keiro is on your own factual ones.
The catch Keirolabs is the newer vendor of the three with a thinner integration catalog, and its index ranks differently from Google's, which matters only if Google's exact ranking is your product. For answer-shaped and document-shaped workloads, the free tier settles the quality question in a week.
## What do the two pricing pages hide, footnotes first?
**Exa's hidden meter is the content-type multiplication: Contents bills $1.00 per 1,000 pages per content type, so requesting text, highlights, and a summary for the same page bills that page three times.** The March 2026 bundling covers only the first 10 results' contents inside the search price. A pipeline that reads 30 pages per query, which is a normal deep-research shape, pays the search meter, then the contents meter on the 20 unbundled pages, then again per additional content type, and again if page summaries are enabled. None of that appears in the $7.00 headline, and the fastcrw pricing breakdown documents the same meter structure explicitly.
**Tavily's hidden meter is the credit system's flatness: extract, map, crawl, and research all draw from the same credit pool as search, at prices the plan page lists per operation.** The advantage is that one currency makes the bill auditable from the dashboard; the disadvantage is that the pool hides which feature class is burning the budget, and the advanced-search multiplier, two credits where one was budgeted, is the most common surprise. Tavily's own docs describe extractions in the same credit terms, so a search-plus-extract pipeline pays per operation in a single pool, and the pool empties faster than any per-plan credit estimate assumed.
| Hidden meter | Exa | Tavily |
|---|---|---|
| Triggers it | Extra result blocks, extra content types, summaries | Advanced mode, extract/map/crawl/research calls |
| Typical shock | 30r + contents: $47-57/1K usable | Advanced flips: 2x the budgeted rate |
| Where it hides | Per-product meters, bundled first-10 only | One credit pool across all operations |
The mitigation for both is the same discipline: model your real workload's meter profile, not the headline rate. For Exa, that means counting result blocks and content types per query. For Tavily, it means counting advanced-mode share and non-search operations per task. Both vendors publish enough pricing detail to build this model in an hour, and both reward the teams that do with invoices that match their forecasts.
## How do the plan ladders compare, and where is each one's break-even?
**Tavily publishes its ladder explicitly, Project $30 for 4,000 credits at $7.50/1K, Bootstrap $100 for 15,000 at $6.67, Startup $220 for 38,000 at $5.79, Growth $500 for 100,000 at $5.00, and each plan's break-even is computable.** The break-evens, 3,750 credits a month for Project, 12,500 for Bootstrap, 27,500 for Startup, and 62,500 for Growth, are the numbers that turn the ladder from marketing into a decision: below your plan's break-even, the commitment is a loss. Exa's volume discounts sit behind negotiated tiers rather than a published ladder, which moves the negotiation earlier and makes the sticker rate the only public number.
| Tavily plan | Monthly | Credits | $/1K basic | Break-even |
|---|---|---|---|---|
| Pay-as-you-go | $0.008/credit | none | $8.00 | none |
| Project | $30 | 4,000 | $7.50 | 3,750/mo |
| Bootstrap | $100 | 15,000 | $6.67 | 12,500/mo |
| Startup | $220 | 38,000 | $5.79 | 27,500/mo |
| Growth | $500 | 100,000 | $5.00 | 62,500/mo |
The ladder's shape tells you where each vendor wants you. Tavily's plans are sized for the journey from prototype to startup, with the deepest discount reserved for the volume where switching costs have already been paid, which is a deliberate structure. Exa's opaque enterprise tier serves the same function with less transparency. A procurement team comparing the two should demand the unpublished tier from Exa and the break-even math from Tavily, and price both against a vendor that publishes one flat rate, because the flat rate is the only structure that does not require forecasting your own volume correctly to avoid overpaying.
## How do the outputs actually compare on the same query?
**On a keyword question, Tavily returns results with a raw_content field fetched at request time; on a seed-document task, Exa returns semantically similar pages Tavily's engine cannot find, and the two outputs are not interchangeable.** The same factual query through both engines returns top-10 sets with substantial overlap on popular topics and divergence on long-tail ones, because Tavily's keyword matching and Exa's embedding retrieval rank differently by design. The overlap number is query-dependent, which is why a migration evaluation replays your own logs instead of trusting any table in any article, this one included.
Content handling diverges in shape more than quality. Tavily's raw_content is fetched and parsed at request time, which means it can be fresher than any index and less stable, the same page can return different content on consecutive calls, and JavaScript-heavy sites are the known weak spot. Exa's Contents serves from its crawled store, more consistent per page, with the first-ten-results bundling. A RAG pipeline that chunks content for embedding cares about consistency and cleanliness over freshness by minutes, and that preference quietly decides the content comparison for most RAG teams.
Citation quality is the downstream consequence of that divergence, and it is the output dimension end users actually see. Content fetched at request time reflects the page as it is today, which produces citations that can differ between the answer given on Monday and the answer given on Friday for the same query. Content served from a crawled store reflects the page as indexed, which is stable enough to cache, cite, and diff over time. For a product whose answers are audited, the stable variant is the one that survives an audit trail; for a product whose answers must beat a news cycle, the fresh variant wins that race. Neither engine is wrong, and the workload's tolerance for citation drift is a question the team has to answer before the vendor comparison means anything.
The answer-shaped test that resolves the comparison honestly: take 50 real queries from your logs, run them through both, have a human or a judge model score the grounded answers built from each output, and separately run 20 real seed documents through Exa's find-similar and through Tavily's best keyword-reformulation attempt at the same task. The first test measures the overlapping capability; the second measures the categorical gap. Teams that run only the first test buy Tavily and discover in month three that they had a similarity workload all along.
## How would a migration between them actually go?
**The Exa-to-Tavily or Tavily-to-Exa migration is a query redesign, not a URL change, and budgeting it as an integration is why migrations overrun.** Tavily queries are keyword-shaped strings, often built by concatenating entity names; Exa queries can be full sentences, concepts, or a seed URL in find-similar mode. Moving either direction means re-authoring how the pipeline formulates its requests, re-tuning the result count, and re-testing the content handling, because Exa bundles only the first ten results' contents and Tavily's raw_content quality varies by target site.
The migration that pays instead is the audit-shaped one: export a month of calls from whichever incumbent you are on, bucket them by whether the input was a question or a document, and discover which primitive your traffic actually uses. Teams running this audit usually find one bucket dominates 80/20, and the right architecture is one cheap bundled-content API for the dominant bucket plus the specialist for the minority, not a like-for-like swap between two expensive specialists. That split is one vendor change on the hot path and none on the cold path, and the blended rate typically falls below both incumbents' headline rates before any volume discount is negotiated.
The specialist bucket also has a sizing trap: similarity workloads tend to grow once they exist, because a find-similar primitive in a product invites usage a keyword search box never got. Teams that sized Exa from their historical keyword-search volume consistently under-provision for the semantic workload's growth, and the fix is to model the specialist bucket on the projection, not the history. Exa's result-count meter amplifies this: a similarity feature that starts at ten results and grows to thirty per call has quadrupled its per-query bill without any change in query count, and the volume table's 1M-column arithmetic applies to result blocks as much as to requests.
Run both in parallel for two weeks on identical traffic, and measure three things: the overlap in top-10 results for keyword queries, the usefulness of Exa's similarity results against Tavily's reformulated-keyword attempts at the same task, and the 429 behavior at your burst rate. Exa's free tier runs at 5 queries per second, Tavily's free credits at default rate limits, and an agent doing fan-out will hit whichever limit binds first. The two-week window costs nothing on either free tier and produces the only comparison data that survives contact with production.
Budget the calendar realistically: the query redesign is the long pole, not the integration, and it is also the part worth doing well. A pipeline that reformulates its Tavily keyword strings into Exa natural-language queries will see its result quality change more from the query rewrite than from the engine swap, which contaminates the evaluation if both change at once. Freeze the queries where you are testing the engine, redesign them where you are testing the shape, and label which half of the log each result came from. Teams that skip this discipline end up attributing their query rewrite's quality delta to the vendor they happened to keep, in whichever direction makes the decision already made.
TL;DR · the decision tree
- **Input is a document, output is similar pages:** Exa, at $7.00/1K base. Nothing else does the primitive.
- **Input is a question, output is an answer with content:** Tavily at $8.00/1K PAYG, or Keiro at $0.25/1K with content bundled.
- **Deep result sets (30+):** Tavily advanced $16.00/1K with content, or Exa at $27.00/1K plus contents. Neither is cheap; the bundled tier is.
- **Latency-critical agent loops:** Tavily 998ms vs Exa ~1,200ms; both trail bundled-tier indexed queries at ~100ms.
- **Volume above 100K/mo:** quote every vendor against Keiro's $25 bill at that band before signing anything.
## What do the free tiers let you test, and what do they hide?
**Exa's free tier is the largest in the category, $20.00 in credits at signup plus $10.00 every month, roughly 1,400 basic searches monthly at 5 queries per second, and it is search-only.** Tavily's 1,000 monthly credits cover basic and advanced searches and the extract operations, reset monthly, no card. Both free tiers are generous enough to run a genuine evaluation, and both have a shape worth knowing before you design the test: Exa's credits do not touch Contents, Answer, Deep Search, or Monitors, so the reading layer you would actually pay for cannot be evaluated for free; Tavily's credits cover everything but reset to a volume that vanishes at the first serious workload replay.
The hidden meter is the part to test with intention. On Exa, design the evaluation to include the Contents call, because the usable-query cost, search plus contents, is the number your bill will show, and the first ten results' bundled contents mask it at low volume. On Tavily, run half your test queries with `search_depth="advanced"` and half basic, because the tutorial ecosystem defaults to advanced and the doubled rate is the single most common Tavily bill shock. A free-tier evaluation that only exercises the cheap mode of each vendor will produce a confident number that the invoice contradicts.
The third thing free tiers hide is the burst profile. Exa gates the free tier at 5 QPS and the developer plan at 10, Tavily's limits scale by plan, and an agent framework that fires ten searches per task will trip the free-tier rate limits long before the credits run out, which makes the free tier feel worse than the paid product. Set the parallelism of your test harness to match your production shape, not the demo default, or the latency and 429 data you collect will describe a workload you do not run.
The credit accounting differs in a way worth reading before designing the test. Exa's $10 monthly credit grant is dollar-denominated, so a month of testing 1,400 basic searches consumes it entirely and any Contents call draws it down faster; the recurring $10 is roughly 200 contents calls if you spend it on reading rather than searching, and the evaluation design should decide which meter it funds. Tavily's 1,000 credits are operation-denominated, one credit a basic search, two an advanced, extract priced separately, so the same 1,000 credits fund very different amounts of work depending on the query mix your test replays. Neither free tier funds an evaluation of both meters at once, which is the practical argument for testing the two vendors on different weeks rather than in one interleaved run.
A final evaluation trap cuts the other way: both free tiers are more generous than the free tiers of the bundled-tier vendors, which can make the incumbents look like the safe default. The correct reading is the reverse. Free-tier generosity is a customer-acquisition cost the vendor chose, and it says nothing about the production rate you will pay, which is the only number with a decimal point in the contract. Evaluate the free tier for quality, price the paid tier for economics, and never let the first number influence the second.
## Disclosure
Keirolabs is our product and appears in the volume table and the third-option section with the figures we publish on our own pricing page: $0.25 per 1,000 semantic, $0.10 per 1,000 SERP, 1,000 free queries a month. Exa and Tavily rates are from their public pricing pages, verified 2026-09-17, including Exa's March 2026 Contents bundling and Tavily's Growth-plan commitment structure. Latency and QA benchmark figures come from AIMultiple's published May 2026 run, judge Gemma 3 12B; FinanceBench 78% and SimpleQA 84% are our published runs. Evaluate both incumbents on their free tiers before believing any table on this page, including ours.
## About the author
Dave builds AI agent and RAG pipelines and writes about the infrastructure behind them. He benchmarks search APIs from the bills, not the landing pages.
## FAQ
### Is Exa cheaper than Tavily in 2026?
At the headline rates, barely: Exa is $7.00 per 1,000 for 10 results and Tavily is $8.00 per 1,000 basic pay-as-you-go. The honest answer is workload-shaped. A 10-result search with bundled contents prices $7.00 on Exa against $8.00 on Tavily. A 30-result search with contents prices near $47.00 to $57.00 on Exa against $16.00 on Tavily advanced, because Exa meters extra results and Tavily includes content in credits. Tavily's $5.00 Growth rate beats Exa's base only above a $500 monthly commitment.
### Which is faster, Exa or Tavily?
Tavily, in AIMultiple's May 2026 runs: 998ms average against Exa's roughly 1,200ms, though Exa's Instant mode runs sub-425ms and both trail Keiro's indexed queries at about 100ms. Latency differences of a few hundred milliseconds are invisible in batch jobs and compounding inside agent loops, where each search gates the next reasoning step, so the latency ranking matters most for interactive agents and least for background pipelines.
### Can Exa do what Tavily does, or vice versa?
Tavily cannot do Exa's core primitive: keyword-free semantic retrieval from a seed page or concept. Exa can approximate Tavily's job with natural-language queries, but its meter structure, extra results and Contents billed separately, makes it an expensive general keyword-search API. They overlap in marketing vocabulary more than in capability. If your pipeline starts from questions, Tavily's shape fits; if it starts from documents, only Exa's does.
### What is the true cost of a usable Exa query?
Search plus the reading layer: a 30-result search bills $27.00 per 1,000, Contents adds $1.00 per 1,000 pages per content type with only the first ten results bundled since March 2026, so reading 30 pages per query lands the combined bill near $47.00 to $57.00 per 1,000 before AI summaries. The $7.00 headline is the cost of ten results and nothing read. Price the usable query, not the API call, when comparing it against bundled-content vendors.
### When should I use both Exa and Tavily together?
When your pipeline has both shapes: question-answering traffic that wants keyword search with content, and research tasks that need find-similar retrieval from a seed document. The common split is a cheaper bundled-content API carrying the answer-shaped volume and Exa serving only the similarity slice where it is categorically different. Running both incumbents at full volume is the most expensive configuration in this comparison and the least necessary one, since their overlapping slice is the one where both rates are 8x to 32x above the bundled tier.