# Exa vs Parallel vs Keenable: which search API to pick

> Exa vs Parallel vs Keenable compared on latency, price per 1,000 searches, result caps, full content and filters, with a decision table for agent builders.

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


Exa, Parallel and Keenable are all web search APIs built for programs rather than people, and they overlap more than they differ. Parallel is the cheapest and fastest at the low end, Exa has the deepest semantic search and the only true full-page content, and Keenable offers a flat price with a realtime index option. Through Mux you can call all three with one key and let the request fall back from one to the next, so the choice is often "in what order" rather than "which one".

This page compares the three as they appear through Mux, using the list prices Mux passes through. Each vendor also sells directly, and at very high volume with a negotiated contract a direct relationship can be the better deal.

## The short version

| | Exa | Parallel | Keenable |
|---|---|---|---|
| Cheapest tier (per 1k requests, 10 results) | $4.00 (`exa/instant`) | $1.00 (`parallel/turbo`, `parallel/fast`) | $4.00 (`keenable/pro`, `keenable/realtime`) |
| Default-quality tier | $7.00 (`exa/auto`, ~1 s) | $5.00 (`parallel/basic`, ~1 s) | $4.00 (`keenable/pro`, ~700 ms) |
| Top tier | $12.00 (`exa/deep`, ~5 s) | $5.00 (`parallel/advanced`, ~3 s) | same as above |
| Fastest tier latency | ~300 ms | ~200 ms | ~700 ms |
| Extra results beyond 10 | $1.00 per 1k results | $1.00 per 1k results | free |
| Max results per request | 100 | 50 | 50 |
| `content: "full"` | full page text | joined excerpts | not supported |
| `published_before` | yes | not applied | yes |
| `include_domains` | native | native | one native, rest filtered by Mux |
| Provider options via Mux | `category`, `userLocation`, `moderation`, `includeText`, `excludeText` | `max_chars_total`, `client_model`, `advanced_settings.*` | none |

Prices are per 1,000 requests. One `exa/auto` search is $0.007, one `parallel/fast` search is $0.001, one `keenable/pro` search is $0.004. See [/docs/pricing](https://getmux.io/docs/pricing) for the billing rules.

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

## Latency tiers

Each provider exposes several speeds, and Mux names them `provider/variant`.

- **Parallel** spans the widest range: `parallel/turbo` at roughly 200 ms, `parallel/fast` around 800 ms, `parallel/basic` around 1 s and `parallel/advanced` around 3 s for higher-quality excerpts.
- **Exa** goes from `exa/instant` at roughly 300 ms to `exa/deep`, a multi-query search that takes about 5 s. `exa/auto` at about 1 s is the general-purpose default.
- **Keenable** has two variants, `pro` and `realtime`, both around 700 ms. They differ by index, not speed.

These are typical figures, not guarantees. The `usage.latency_ms` field in every Mux response tells you what you actually got.

## Price per 1,000 requests

Parallel's two $1.00 tiers are the floor. Nothing else in the table comes within a factor of four. If your agent does many cheap lookups where a decent snippet is enough, `parallel/fast` or `parallel/turbo` is where to start.

Keenable's $4.00 is flat: no extra charge for results past 10, so a 50-result Keenable request still costs $0.004. On Exa and Parallel the same 50 results add $0.04 in extra-result charges, which is more than the base price.

Exa is the most expensive per request, and `exa/deep` at $12.00 is the most expensive model Mux offers. You pay for it when the query is hard and a single pass will not do.

## Result caps and full content

Exa is the only provider that returns up to 100 results per request. Parallel and Keenable stop at 50. Mux caps `max_results` to the model's limit rather than erroring.

`content: "full"` behaves differently on each:

- Exa returns the full page text in `results[].content`.
- Parallel returns its excerpts joined together, which is longer than a snippet but not the whole page.
- Keenable returns `content: null`. If your pipeline needs page text, do not put a Keenable model first.

## Date and domain filters

All three accept `published_after` and `include_domains` / `exclude_domains`. Two caveats: Parallel does not apply `published_before`, and Keenable natively supports one domain. Mux enforces domain filters on the response regardless of provider, so results will never violate your filter, but on Keenable a long `include_domains` list may leave you with fewer results than you asked for.

## Provider options

Mux passes through an allow-list of provider-specific options. Exa gets `category`, `userLocation`, `moderation`, `includeText` and `excludeText`. Parallel gets `max_chars_total`, `client_model` and `advanced_settings` for excerpts and location. Keenable has none. If a workflow depends on one of these, that decides the provider for you.

## Typical fit

| Workload | Start with | Why |
|---|---|---|
| High-volume, cheap lookups (entity checks, URL discovery) | `parallel/fast` | $1.00 per 1k, ~800 ms |
| Lowest latency in a chat loop | `parallel/turbo` or `exa/instant` | ~200 to 300 ms |
| Semantic or research queries | `exa/auto`, then `exa/deep` | neural search, 100 results, full text |
| Full page text for RAG | `exa/auto` with `content: "full"` | only provider returning whole pages |
| Many results per query at fixed cost | `keenable/pro` | no extra-result charge up to 50 |
| Very recent pages | `keenable/realtime` | realtime index |
| Highest-quality excerpts without full pages | `parallel/advanced` | $5.00, ~3 s |

## Use fallbacks instead of choosing

The `models` field takes an ordered list of up to five model ids. Mux tries them in order, refunds any failed attempt, and bills you only for the model that answered. This means you can lead with the cheap option and keep a stronger one behind it.

```bash
curl -X POST https://api.getmux.io/v1/search \
  -H "Authorization: Bearer $MUX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "postgres logical replication slot lag",
    "models": ["parallel/fast", "exa/auto", "keenable/pro"],
    "max_results": 10,
    "published_after": "2025-01-01"
  }'
```

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

const mux = new Mux(); // reads MUX_API_KEY
const res = await mux.search({
  query: "postgres logical replication slot lag",
  models: ["parallel/fast", "exa/auto", "keenable/pro"],
  maxResults: 10,
  publishedAfter: "2025-01-01",
});
console.log(res.model, res.usage.costUsd, res.results.length);
```

```python
from getmux import Mux

mux = Mux()
res = mux.search(
    "postgres logical replication slot lag",
    models=["parallel/fast", "exa/auto", "keenable/pro"],
    max_results=10,
    published_after="2025-01-01",
)
print(res.model, res.cost_usd, [r.url for r in res.results])
```

The response's `attempts` array shows what happened at each step, so you can see how often the fallback fires. The default `"auto"` model is itself a fallback chain: `parallel/fast`, then `exa/auto`, then `keenable/pro`.

One exception to the refund rule: if a provider times out at 15 s, you still pay that model's base price before the next one is tried.

## When to go direct

Pick a vendor directly if you need something Mux does not expose, such as a crawl or contents endpoint, an answer endpoint, or options outside the allow-list. At sustained high volume with a negotiated contract, a direct relationship may also beat list price. Mux charges no per-request markup, only a 5.5% fee when you buy credits, and with [BYOK](https://getmux.io/docs/byok) you can keep your own vendor keys and still use the fallback chain.

## FAQ

### Which of Exa, Parallel and Keenable is cheapest?

Parallel, at $1.00 per 1,000 requests for `parallel/turbo` and `parallel/fast`. Exa's cheapest tier is `exa/instant` at $4.00 and Keenable's two variants are $4.00. Keenable is cheapest when you regularly ask for 30 to 50 results, because it does not charge for extra results.

### Which one returns full page content?

Only Exa returns full page text with `content: "full"`. Parallel returns joined excerpts and Keenable returns no content field. If you need whole pages, put an Exa model first in `models`.

### Do date and domain filters work on all three?

Mostly. All three honor `published_after` and domain filters. Parallel ignores `published_before`, and Keenable supports one domain natively with Mux filtering the rest after the fact.

### Can I use my own Exa, Parallel or Keenable key through Mux?

Yes. Store it with `PUT /v1/provider-keys/{provider}` and requests to that provider are billed to you by the vendor. The Mux fee is waived for the first 1,000,000 BYOK requests per calendar month, then 5% of list price.

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