# Parallel search API pricing: turbo, fast, basic, advanced

> Parallel search API pricing through Mux: per-request and extra-result math for all four tiers, the 50-result cap, full-content behavior and allowed options.

Canonical: https://getmux.io/guides/parallel-search-api-pricing


Parallel search API pricing on Mux is per request, with 10 results included and $1.00 per 1,000 results past the tenth. `parallel/turbo` and `parallel/fast` cost $1.00 per 1,000 requests, and `parallel/basic` and `parallel/advanced` cost $5.00. These are Parallel's list prices passed through with no markup, and Mux's only fee is 5.5% when you buy credits.

This guide walks through the four tiers, the per-request math with worked examples, monthly cost at volume, the 50-result cap, what `content: "full"` returns on Parallel, the date-filter caveat, and which Parallel options you can pass through. For Parallel's own plans and pricing, see [parallel.ai](https://parallel.ai).

## The four Parallel tiers on Mux

Parallel positions its search API around returning excerpts that are ready to feed to a language model rather than a list of links. On Mux its processors are exposed as four model ids.

| Model | What it is | $/1k requests | $/1k extra results | Max results | Typical latency |
|---|---|---|---|---|---|
| `parallel/turbo` | Fastest tier | 1.00 | 1.00 | 50 | ~200 ms |
| `parallel/fast` | Fast, the first stop for Mux `auto` | 1.00 | 1.00 | 50 | ~800 ms |
| `parallel/basic` | Standard quality | 5.00 | 1.00 | 50 | ~1 s |
| `parallel/advanced` | Highest-quality excerpts | 5.00 | 1.00 | 50 | ~3 s |

The tiers pair up on price. `turbo` and `fast` are the same price and differ in speed, and `basic` and `advanced` are the same price and differ in excerpt quality and latency. Because `parallel/fast` is the first model in Mux's `auto` order, a plain request with no `model` set lands here first.

The live table is loaded from `GET /v1/models` and reflects current prices.

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

## The per-request math

Each request includes 10 results. Every result past the tenth costs $0.001 on all four tiers:

```
cost = base_price + max(0, results_returned - 10) × 0.001
```

You pay for the results Parallel returns, capped at what you asked for. Ask for 30, receive 18, pay for 8 extra results.

| Model | 10 results | 25 results | 50 results |
|---|---|---|---|
| `parallel/turbo` | $0.001 | $0.016 | $0.041 |
| `parallel/fast` | $0.001 | $0.016 | $0.041 |
| `parallel/basic` | $0.005 | $0.020 | $0.045 |
| `parallel/advanced` | $0.005 | $0.020 | $0.045 |

On the $1.00 tiers, extra results are the whole story. A 50-result `parallel/turbo` search costs 41 times a 10-result one, and the price difference between `turbo` and `advanced` at 50 results is under 10%. If you need many results per query, pick the tier by quality; if you need few, the cheap tiers are very cheap.

## The 50-result cap

Parallel models return at most 50 results. `max_results` accepts up to 100, but Mux caps it to the model's maximum before calling the provider, so a request for 80 results on `parallel/advanced` returns at most 50 and is billed for at most 50. If you need up to 100 results from one call, use an Exa model instead. See [/docs/search](https://getmux.io/docs/search).

## Monthly cost at volume

At the default of 10 results per search:

| Model | 1,000 searches | 100,000 searches | 1,000,000 searches |
|---|---|---|---|
| `parallel/turbo` | $1 | $100 | $1,000 |
| `parallel/fast` | $1 | $100 | $1,000 |
| `parallel/basic` | $5 | $500 | $5,000 |
| `parallel/advanced` | $5 | $500 | $5,000 |

At 25 results per search, multiply by the 25-result column: a million `parallel/fast` searches at 25 results is $16,000, sixteen times the 10-result figure.

Then add the credit purchase fee, 5.5% with a $0.80 minimum. $100 buys $94.50 of credits, $1,000 buys $945. A $500 month of `parallel/basic` costs about $529 at checkout. Purchases are prepaid, between $5 and $10,000 each, and credits do not expire. Full terms are at [/docs/pricing](https://getmux.io/docs/pricing).

## What `content: "full"` returns on Parallel

On Parallel, `content: "full"` does not fetch whole pages. Parallel returns excerpts, and Mux joins them together into the `content` field. This is often what you want for an LLM context window, since the excerpts are already selected for relevance, but it is not a page scrape. If you need full page text, use an Exa model, where `content: "full"` returns the complete page. There is no extra Mux charge for `content: "full"` on any provider.

## `published_before` is not applied

Parallel's search supports a lower date bound but not an upper one. Mux passes `published_after` through natively, and does not apply `published_before` on Parallel models at all. Results outside your upper bound can therefore appear, and because Parallel already returned them, they are billed. If you need both bounds, route the request to an Exa or Keenable model. Domain filters, by contrast, are passed natively and also re-checked by Mux after the response.

## A worked request

Twenty-five results from `parallel/advanced`, with joined excerpts, restricted to a domain and a lower date bound, with `parallel/fast` as the fallback:

```bash
curl https://api.getmux.io/v1/search \
  -H "Authorization: Bearer $MUX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "lithium iron phosphate battery recycling methods",
    "models": ["parallel/advanced", "parallel/fast"],
    "max_results": 25,
    "content": "full",
    "include_domains": ["nature.com"],
    "published_after": "2025-01-01"
  }'
```
```ts
import { Mux } from "getmux";

const mux = new Mux();
const res = await mux.search({
  query: "lithium iron phosphate battery recycling methods",
  models: ["parallel/advanced", "parallel/fast"],
  maxResults: 25,
  content: "full",
  includeDomains: ["nature.com"],
  publishedAfter: "2025-01-01",
});
console.log(res.model, res.usage.costUsd); // "parallel/advanced", up to 0.02
```
```python
from getmux import Mux

mux = Mux()
res = mux.search(
    "lithium iron phosphate battery recycling methods",
    models=["parallel/advanced", "parallel/fast"],
    max_results=25,
    content="full",
    include_domains=["nature.com"],
    published_after="2025-01-01",
)
print(res.model, res.cost_usd)  # "parallel/advanced", up to 0.02
```

If Parallel returns fewer than 25 results for the narrow domain filter, `usage.cost_usd` will be lower than $0.020, because extra results are billed on the returned count.

## Parallel options you can pass through

Through `provider_options`, Mux allows these Parallel-specific fields:

- `max_chars_total`, to bound the total excerpt text across results
- `client_model`, to tell Parallel which model will consume the excerpts
- `advanced_settings.excerpt_settings`, to tune how excerpts are selected
- `advanced_settings.location`, to localize results

Fields that would change the bill (processor, result count) or that Mux uses for filtering (domains, dates) are rejected with `400 invalid_request`. The options are forwarded as given; see the [Parallel search reference](https://docs.parallel.ai/api-reference/search-api/search) for accepted values and [/docs/models](https://getmux.io/docs/models) for the allow-list.

## When to go direct to Parallel

Mux bills Parallel's list price. If you have a negotiated contract or existing Parallel credits, store your Parallel key with `PUT /v1/provider-keys/parallel` and Parallel bills you directly. The first 1,000,000 BYOK requests per calendar month carry no Mux fee; after that the fee is 5% of list price, or $0.00005 per 10-result `parallel/fast` search. See [/docs/byok](https://getmux.io/docs/byok).

If Parallel is your only provider, you don't need fallbacks or per-key spend caps, and your volume is large enough to negotiate, a direct relationship is the simpler choice. Mux is worth it when one key should fail over to Exa or Keenable, when you want `published_before` and 100-result queries available from the same client, or when each agent needs its own budget.

## FAQ

### Is there a markup on Parallel searches through Mux?

No. Each Parallel model is billed at Parallel's list price per request. Mux's only charge is 5.5% of each credit purchase, minimum $0.80, deducted from the amount you pay. With your own Parallel key, the first million requests a month carry no Mux fee.

### Why is `parallel/fast` the default for `auto`?

Mux's `auto` order is `parallel/fast`, then `exa/auto`, then `keenable/pro`. `parallel/fast` is first because at $0.001 per 10-result search it is the cheapest general-purpose option, with fallbacks covering the cases where it fails.

### What do I pay if a Parallel call fails and Mux falls back?

Only the model that answered. The failed attempt is refunded, and the response's `attempts` array shows each one. The exception is a 15-second timeout, which keeps the model's base price because the provider has usually completed the search.

### Can I get 100 results from Parallel?

No. Parallel models return at most 50 results, and Mux caps `max_results` to 50 before calling them. Exa models go to 100.

To run your first Parallel search through Mux, start with the [quickstart](https://getmux.io/docs/quickstart).