# Exa vs Tavily: which search API for your agent

> Exa vs Tavily compared for agent builders on price per 1,000 searches, result caps, full page text, filters, extract and crawl, with guidance on when each is the better pick.

Canonical: https://getmux.io/compare/exa-vs-tavily


Exa and Tavily are both web search APIs built for programs rather than people, and the practical difference is what you get back and how you pay. Exa is a neural search engine that returns up to 100 results per request with full page text inline, priced per request from $4 to $12 per 1,000. Tavily is a credit-based search, extract and crawl product with a free tier, a 20-result cap, and a pay-as-you-go rate that works out to $8 per 1,000 basic searches. Pick Exa when you want deep semantic retrieval and whole pages in one call; pick Tavily when you want search plus extraction plus crawl from one vendor, or your volume fits its free or monthly plans.

This page compares the two as of October 2026 using each vendor's public pricing. Exa is also available through Mux as [`exa/auto`](https://getmux.io/models/exa/auto) and three other tiers at the same list price; Tavily is not, so the Tavily figures are what you would pay Tavily directly.

## The short version

| | Exa | Tavily |
|---|---|---|
| Pricing model | per request, 10 results included | credits, 1 or 2 per search |
| Cheapest search | $4 per 1k (`lite` direct, `exa/instant` via Mux) | $8 per 1k basic on pay-as-you-go |
| Default search | $7 per 1k (`auto`) | $8 per 1k basic, $16 per 1k advanced |
| Deepest search | $12 per 1k (`deep`) | $16 per 1k advanced, or Research at 4 to 250 credits |
| Max results per request | 100 | 20 |
| Extra results | $1 per 1k results beyond 10 | n/a, cap is 20 |
| Full page text | inline, `content: "full"` through Mux | `include_raw_content` on search, or the extract endpoint |
| Date filters | `published_after`, `published_before` | `time_range`, `start_date`, `end_date` |
| Domain filters | include and exclude | include up to 300, exclude up to 150 |
| Extract and crawl | contents endpoint direct; not via Mux | extract, crawl and map endpoints |
| Free tier | $10 in credit per month on signup | 1,000 credits per month |

Sources: [exa.ai/pricing](https://exa.ai/pricing), [tavily.com/pricing](https://www.tavily.com/pricing), [Tavily API credits](https://docs.tavily.com/documentation/api-credits) and the [Tavily search reference](https://docs.tavily.com/documentation/api-reference/endpoint/search).

## How each one prices a search

Exa's price is per request. As of October 2026 its [pricing page](https://exa.ai/pricing) lists `lite` at $4 per 1,000 requests, `auto` at $7, and `deep` at $12, each including 10 results, with $1 per 1,000 for results beyond the tenth. Contents such as page text, highlights and summaries are billed at $1 per 1,000 pages per content type when you call Exa directly. Through Mux the four tiers are [`exa/instant`](https://getmux.io/models/exa/instant) at $4, [`exa/fast`](https://getmux.io/models/exa/fast) and [`exa/auto`](https://getmux.io/models/exa/auto) at $7, and [`exa/deep`](https://getmux.io/models/exa/deep) at $12, with the same extra-result rate, and `content: "full"` does not add a charge. The full math, including what 25 and 100 results cost, is in [Exa pricing explained](https://getmux.io/guides/exa-pricing-explained).

Tavily's price is in credits. Its [pricing page](https://www.tavily.com/pricing) lists a free Researcher plan with 1,000 credits per month, pay-as-you-go at $0.008 per credit, a Project plan at $30 per month for 4,000 credits, and custom enterprise terms. A basic, fast or ultra-fast search costs 1 credit and an advanced search costs 2, so pay-as-you-go is $8 per 1,000 basic searches or $16 per 1,000 advanced. Monthly plans bring the per-credit rate down, so a team doing a steady volume should price its plan rather than the pay-as-you-go rate.

Two things decide which is cheaper for you. At low volume Tavily's free 1,000 credits per month beat anything Exa offers except its own $10 monthly free credit, which covers up to 2,500 `lite` searches. At higher volume Exa's `auto` at $7 per 1,000 undercuts Tavily's pay-as-you-go basic rate, and `lite` or `exa/instant` at $4 is about half of it. Whether Tavily's monthly plans close that gap depends on your tier, so check the page.

## Result count and page text

Exa returns up to 100 results per request. Tavily's `max_results` tops out at 20. For agents that cast a wide net and rank locally, or for building a candidate list of sources, that is a real difference. Note that on Exa the extra results add up: 100 results on `exa/auto` cost $0.097 rather than $0.007, so wide queries are not free on either side.

Both can hand you page text. Exa does it inline. Through Mux, `content: "full"` on any Exa model fills `results[].content` with the full page at no extra charge; direct from Exa, text is a contents item billed per page. Tavily has `include_raw_content` on the search call, which returns page content as markdown or text and may add latency, and a separate extract endpoint billed at 1 credit per 5 successful URLs for basic extraction. If you often want text for a handful of results rather than all of them, Tavily's extract is the cheaper shape. If you want text for every result on every search, Exa's inline model is simpler.

## Filters and query style

Tavily exposes more knobs. Its search takes `topic` (general, news or finance), `time_range` shorthands like `week` and `month`, explicit `start_date` and `end_date`, up to 300 include domains and 150 exclude domains, a country bias, and an `include_answer` flag that returns a short LLM-written answer alongside results. Exa's filters cover published dates, include and exclude domains, a `category` such as research papers or news, and text-must-include and text-must-exclude constraints, plus `userLocation` and `moderation`. Through Mux the Exa options arrive as `published_after`, `published_before`, `include_domains`, `exclude_domains` and a small set of `provider_options`.

Exa's index is neural, which matters for the kind of query an agent writes. A long natural-language question such as "startups building solid-state battery electrolytes that raised in 2026" works well on Exa and is the use case it was designed for. Tavily handles natural-language queries too, but the distinctive features on its side are the vertical topics and the one-call answer, not semantic retrieval over a very large result set.

## Extract, crawl and research

This is where Tavily is the broader product. Alongside search it offers extract (page text for a list of URLs), map (discover the pages of a site), crawl (map plus extract) and a research endpoint that runs a multi-step investigation for 4 to 250 credits per request depending on the model. An agent that needs to walk a documentation site or pull clean text from a known list of URLs can do that from one vendor with one bill.

Exa sells a contents endpoint and other products directly, but through Mux you get search only. If crawl is part of the job, that pushes you toward Tavily, or toward Exa direct, rather than a router. The same caveat applies to every Mux article, including the broader [Tavily alternatives](https://getmux.io/compare/tavily-alternatives) roundup.

## Latency

Neither vendor publishes measured latency on its pricing page. Tavily describes `ultra-fast` as minimizing latency above all else, `fast` as prioritizing lower latency, and `advanced` as highest relevance with increased latency, and returns a `response_time` field on each call. Through Mux the typical figures seen for Exa are about 300 ms for `exa/instant`, 500 ms for `exa/fast`, 1 s for `exa/auto` and 5 s for `exa/deep`, and every response carries `usage.latency_ms`. Measure both on your own queries before you commit; the shape of the request, especially page text, moves latency more than the vendor does.

## When Tavily is the better choice

- You need extract, map or crawl as well as search and want one vendor for all of it.
- Your volume fits inside 1,000 free credits a month, or a monthly plan that prices below $7 per 1,000 for your tier.
- You want vertical topics (news, finance), a 300-domain allow-list, or a one-call `include_answer` summary.
- You already have Tavily wired into your framework and the switching cost is real.

## When Exa is the better choice

- You want semantic search over a large neural index, with natural-language queries as the norm.
- You need more than 20 results per request, up to 100.
- You want full page text inline for every result in a single call.
- You want to run Exa alongside other providers with fallback. Through Mux you can put [`exa/auto`](https://getmux.io/models/exa/auto) behind [`parallel/fast`](https://getmux.io/models/parallel/fast) in one `models` list and pay only for the model that answered; see [search fallbacks for AI agents](https://getmux.io/guides/search-fallbacks-for-ai-agents).

## Trying Exa with one request

Through Mux, an Exa search with full page text looks like this. Swap `model` for any other Mux model id and the response shape does not change.

```bash
curl -X POST https://api.getmux.io/v1/search \
  -H "Authorization: Bearer $MUX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "solid-state battery electrolyte startups 2026", "model": "exa/auto", "max_results": 10, "content": "full"}'
```

```ts
import { Mux } from "getmux";

const mux = new Mux();
const res = await mux.search({
  query: "solid-state battery electrolyte startups 2026",
  model: "exa/auto",
  maxResults: 10,
  content: "full",
});
console.log(res.usage.costUsd, res.results[0]?.content?.length);
```

```python
from getmux import Mux

mux = Mux()
res = mux.search("solid-state battery electrolyte startups 2026", model="exa/auto", max_results=10, content="full")
print(res.cost_usd, len(res.results[0].content or ""))
```

(Live price table: https://getmux.io/models.md or GET https://api.getmux.io/v1/models)

## FAQ

### Is Exa or Tavily cheaper per search?

At list prices as of October 2026, Exa's `auto` at $7 per 1,000 requests and `lite` at $4 are below Tavily's pay-as-you-go rate of $8 per 1,000 basic searches. Tavily's free tier of 1,000 credits a month and its monthly plans change that at low volume, so compare against the plan you would actually buy on [tavily.com/pricing](https://www.tavily.com/pricing).

### Which returns full page content?

Both. Exa returns it inline, and through Mux `content: "full"` on an Exa model costs nothing extra. Tavily returns it with `include_raw_content` on the search call or through its extract endpoint at 1 credit per 5 URLs for basic extraction.

### Can I use Tavily through Mux?

No. Mux routes to Exa, Parallel, Keenable and DeepSeek. If Tavily is the right fit, go to Tavily directly. The [buyer's guide to web search APIs for AI agents](https://getmux.io/compare/web-search-apis-for-ai-agents) covers how to evaluate the wider field.

### Does Exa or Tavily have a free tier?

Both. Exa gives new signups $10 in credit that resets monthly, enough for up to 2,500 `lite` searches. Tavily's Researcher plan includes 1,000 credits per month with no card. Mux has no free tier; credits are prepaid from $5.

To run an Exa search next to Parallel and Keenable with one key, start at the [quickstart](https://getmux.io/docs/quickstart).