# Parallel vs Exa: price, latency and content compared

> Parallel vs Exa for agent builders, comparing the four tiers of each on price per 1,000 searches, latency, result caps, excerpts vs full page text, filters and when to use both.

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


Parallel and Exa are the two search APIs most often shortlisted by teams building agents, and they split cleanly on price and depth. Parallel's `turbo` and `fast` tiers cost $1 per 1,000 requests and return LLM-ready excerpts up to 50 results, with higher-quality `basic` and `advanced` tiers at $5. Exa runs from $4 to $12 per 1,000, returns up to 100 results, and is the only one of the two that hands back whole pages inline. Start with Parallel for high-volume, low-cost lookups and move to Exa when a query needs semantic depth, a large result set or full page text. Through Mux both are available on one key with the same request shape, so the usual answer is an ordered list rather than a single pick.

Prices below are the vendors' list prices as of October 2026, from [parallel.ai/pricing](https://parallel.ai/pricing) and [exa.ai/pricing](https://exa.ai/pricing), which are the same prices Mux passes through with no per-request markup.

## The short version

| | Parallel | Exa |
|---|---|---|
| Cheapest tier | $1 per 1k ([`parallel/turbo`](https://getmux.io/models/parallel/turbo), [`parallel/fast`](https://getmux.io/models/parallel/fast)) | $4 per 1k ([`exa/instant`](https://getmux.io/models/exa/instant)) |
| Default-quality tier | $5 per 1k ([`parallel/basic`](https://getmux.io/models/parallel/basic)) | $7 per 1k ([`exa/auto`](https://getmux.io/models/exa/auto)) |
| Top tier | $5 per 1k ([`parallel/advanced`](https://getmux.io/models/parallel/advanced)) | $12 per 1k ([`exa/deep`](https://getmux.io/models/exa/deep)) |
| Extra results beyond 10 | $1 per 1k results | $1 per 1k results |
| Max results per request | 50 | 100 |
| Typical fastest latency via Mux | ~200 ms (`turbo`) | ~300 ms (`instant`) |
| Typical top-tier latency via Mux | ~3 s (`advanced`) | ~5 s (`deep`) |
| `content: "full"` via Mux | joined excerpts | full page text |
| `published_before` | not applied | applied |
| Free credit direct | up to $80 on signup plus $5 a month | $10 a month |
| Direct rate limit | 600 requests per minute | not published on pricing page |

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

## Price

The price gap at the bottom is four to one. A 10-result `parallel/fast` search is $0.001; the cheapest Exa tier is $0.004. At the top the gap is less than it looks: `parallel/advanced` at $0.005 against `exa/auto` at $0.007 is 40 percent, and `exa/deep` at $0.012 is a different kind of product, running several queries upstream for one request.

Both charge $1 per 1,000 for results past the tenth, billed on what the provider returns and capped at what you asked for. That extra-result charge dominates once you ask for many results. A 50-result search costs $0.041 on `parallel/fast` and $0.047 on `exa/auto`, so at wide result counts the tier you picked matters less than the count. The per-tier tables are in [Parallel search API pricing](https://getmux.io/guides/parallel-search-api-pricing) and [Exa pricing explained](https://getmux.io/guides/exa-pricing-explained).

Free credit is where Parallel is unusually generous for evaluation: its pricing page lists up to $80 on signup plus $5 every month, which it describes as up to 5,000 requests a month free. Exa gives $10 a month, enough for up to 2,500 of its `lite` searches. Neither of those applies through Mux, which bills prepaid credits at list price.

## Latency

Each vendor sells a spread of speeds. Through Mux the typical figures are:

- **Parallel**: `turbo` about 200 ms, `fast` about 800 ms, `basic` about 1 s, `advanced` about 3 s.
- **Exa**: `instant` about 300 ms, `fast` about 500 ms, `auto` about 1 s, `deep` about 5 s.

For an interactive agent, `parallel/turbo` and `exa/instant` are the two sub-half-second options, and the difference between them is small enough that quality on your queries should decide. For a background research job the slow tiers are fine and the question becomes depth, which is where Exa pulls ahead. These numbers are typical rather than guaranteed; `usage.latency_ms` on each Mux response is the real figure.

## What comes back

This is the clearest difference. Parallel returns excerpts selected for relevance to the query, which is what an LLM context window wants. Set `content: "full"` through Mux and you get those excerpts joined together, longer than a snippet but never a whole page. Parallel also accepts a `client_model` hint and a `max_chars_total` budget so you can size the excerpts to the model that will read them.

Exa returns search results and, with `content: "full"`, the complete page text in `results[].content`, with no extra charge through Mux. For RAG, summarization or anything that needs to quote from a page, this saves a second fetch. For a tool call inside a chat loop it is often too much, and you will want to trim or request snippets only.

Exa also goes to 100 results per request where Parallel stops at 50. Mux caps `max_results` to the model's limit rather than erroring, so a request for 80 on a Parallel model returns at most 50 and is billed for at most 50.

## Filters

Both apply `published_after` and include and exclude domain lists natively. Parallel does not apply `published_before`, so a request with an upper date bound can return newer pages and is billed for them; if you need both bounds, route to Exa. Domain filters are also re-checked by Mux on the response regardless of provider, so results never violate your list.

Exa accepts a `category` (research papers, news, companies and so on), `includeText` and `excludeText` phrase constraints, `userLocation` and `moderation` through `provider_options`. Parallel accepts `max_chars_total`, `client_model` and `advanced_settings` for excerpt tuning and location. If a workflow depends on one of these, that chooses the provider.

## Index and query style

Exa's index is neural and built for semantic queries. Long, descriptive, natural-language questions do well, and the `deep` tier decomposes a hard question into several searches. Parallel positions its search around returning excerpts an agent can act on at low cost and latency, with the `advanced` processor for higher-quality excerpts. In practice, most teams find `parallel/fast` good enough for entity lookups, URL discovery and fact checks, and reach for `exa/auto` or `exa/deep` when the question is open-ended or the agent needs to read rather than skim.

## Fit by workload

| Workload | Start with | Why |
|---|---|---|
| High-volume cheap lookups | `parallel/fast` | $0.001 per search, ~800 ms |
| Lowest latency in a chat loop | `parallel/turbo` | ~200 ms at $0.001 |
| Research-style or semantic queries | `exa/auto` | neural index, 100 results |
| Full page text for RAG | `exa/auto` with `content: "full"` | whole pages inline, no extra charge via Mux |
| Best excerpts without whole pages | `parallel/advanced` | $0.005, tuned for LLM consumption |
| Hard multi-hop questions | `exa/deep` | multi-query search at $0.012 |
| Upper date bound required | any Exa model | Parallel ignores `published_before` |

## Use both

Because the two differ in price and depth rather than overlapping, they pair well. The default Mux `auto` chain is `parallel/fast`, then `exa/auto`, then `keenable/pro`: cheap first, deeper second, a third independent index last. A failed attempt is refunded and you pay for the model that answered. An agent that wants breadth and then depth can also split the work explicitly, discovering with Parallel and reading with Exa; the worked cost of that pattern is in [web search cost per agent run](https://getmux.io/guides/web-search-cost-per-agent-run).

```bash
curl -X POST https://api.getmux.io/v1/search \
  -H "Authorization: Bearer $MUX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "wasm component model adoption 2026", "models": ["parallel/fast", "exa/auto"], "max_results": 10}'
```

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

const mux = new Mux();
const res = await mux.search({
  query: "wasm component model adoption 2026",
  models: ["parallel/fast", "exa/auto"],
  maxResults: 10,
});
console.log(res.model, res.usage.costUsd, res.attempts.length);
```

```python
from getmux import Mux

mux = Mux()
res = mux.search("wasm component model adoption 2026", models=["parallel/fast", "exa/auto"], max_results=10)
print(res.model, res.cost_usd, len(res.attempts))
```

The order matters for content. If a request needs page text, put the Exa model first, because a successful Parallel answer ends the chain with excerpts rather than pages. How to read the `attempts` array and build each order is covered in [search fallbacks for AI agents](https://getmux.io/guides/search-fallbacks-for-ai-agents).

## When to go direct

Parallel's free credit and 600 requests per minute direct limit make it the easier one to evaluate without an intermediary, and Parallel also sells an extract API and a task API that Mux does not proxy. Exa sells a contents endpoint and other products beyond search. If you need any of those, or you have a negotiated contract at volume, go to the vendor. With [BYOK](https://getmux.io/docs/byok) you can store either key in Mux and keep the fallback chain while the vendor bills you.

## FAQ

### Is Parallel or Exa cheaper?

Parallel. Its `turbo` and `fast` tiers are $1 per 1,000 requests against Exa's cheapest at $4, and its top tier at $5 is below Exa's default `auto` at $7. Both add $1 per 1,000 results beyond 10, which narrows the gap on wide result sets.

### Which one returns full page text?

Only Exa. Through Mux, `content: "full"` on an Exa model returns the whole page in `results[].content`. On Parallel the same flag returns the provider's excerpts joined together.

### Which is faster?

Their fastest tiers are close: `parallel/turbo` is typically about 200 ms and `exa/instant` about 300 ms through Mux. At the top end `parallel/advanced` is around 3 s and `exa/deep` around 5 s, because `deep` runs multiple queries for one request.

### Can I run both from one integration?

Yes. Mux exposes both behind one endpoint with the same request and response shape, and the `models` field takes an ordered fallback list. The third provider in the default chain, Keenable, is compared alongside these two in [Exa vs Parallel vs Keenable](https://getmux.io/compare/exa-vs-parallel-vs-keenable).

To try both with one key, start at the [quickstart](https://getmux.io/docs/quickstart).