# Web search cost for AI agents: a budgeting guide

> How to budget web search cost for AI agents on Mux: monthly cost per model at 1k to 1M searches, fallback billing, credit fees and per-key spend limits.

Canonical: https://getmux.io/guides/web-search-cost-per-agent-run


Web search cost for AI agents comes down to three numbers: price per search, searches per run, and runs per month. On Mux a 10-result search costs between $0.001 (`parallel/turbo`, `parallel/fast`) and $0.012 (`exa/deep`), so an agent that makes 20 searches per run costs between two cents and twenty-four cents in search per run. The hard part is not the arithmetic but keeping a looping agent from running the arithmetic a million times.

This guide covers monthly cost for every Mux model, what you pay when a request falls back, how the credit purchase fee changes the bill, the per-key limits that stop a runaway agent, and how to measure what you spent.

## Monthly cost by model

All prices are the providers' list prices with no per-request markup. The table assumes 10 results per search, which is what each request includes.

| Model | $/search | 1,000 | 10,000 | 100,000 | 1,000,000 |
|---|---|---|---|---|---|
| `parallel/turbo` | $0.001 | $1 | $10 | $100 | $1,000 |
| `parallel/fast` | $0.001 | $1 | $10 | $100 | $1,000 |
| `exa/instant` | $0.004 | $4 | $40 | $400 | $4,000 |
| `keenable/pro` | $0.004 | $4 | $40 | $400 | $4,000 |
| `keenable/realtime` | $0.004 | $4 | $40 | $400 | $4,000 |
| `parallel/basic` | $0.005 | $5 | $50 | $500 | $5,000 |
| `parallel/advanced` | $0.005 | $5 | $50 | $500 | $5,000 |
| `exa/fast` | $0.007 | $7 | $70 | $700 | $7,000 |
| `exa/auto` | $0.007 | $7 | $70 | $700 | $7,000 |
| `exa/deep` | $0.012 | $12 | $120 | $1,200 | $12,000 |

Extra results beyond 10 cost $0.001 each on Exa and Parallel models, billed on what the provider returns and capped at what you asked for. Keenable charges nothing for extra results. An agent pulling 25 results per `exa/auto` search pays $0.022 per search, so the 100,000 column becomes $2,200 rather than $700. After model choice, result count is the biggest lever on your bill.

The live price table below is loaded from `GET /v1/models` and wins if this page ever drifts.

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

Mux's `auto` model tries `parallel/fast`, then `exa/auto`, then `keenable/pro`, so an agent that never sets `model` mostly pays the `parallel/fast` rate and only pays more when Parallel fails.

## From per-search to per-run

Count the searches a typical run makes, including retries and sub-agents, and multiply. A research agent that plans, searches 15 times on `parallel/fast`, then verifies 3 claims on `exa/auto` costs:

```
15 × $0.001 + 3 × $0.007 = $0.036 per run
```

At 10,000 runs a month that is $360. The same agent on `exa/auto` throughout would be 18 × $0.007 = $0.126 per run, or $1,260 a month. A cheap model for breadth and a higher-quality model for final checks is usually the biggest saving that needs no change to the agent's logic.

## How fallbacks affect cost

When you pass a `models` list, Mux tries each in order and you pay only for the model that answered. A failed attempt is refunded before the next one starts. With `["parallel/fast", "exa/auto"]`, a run where Parallel errors and Exa answers costs $0.007, not $0.008.

The exception is a provider timeout. If a provider has not answered after 15 seconds, the attempt is marked as an error but keeps the model's base price, because the provider has usually completed and billed the search by then. Only the extra-results portion is refunded. In the same example, a Parallel timeout followed by an Exa success costs $0.001 + $0.007 = $0.008. The response's `attempts` array shows a `cost_usd` on any timed-out attempt so you can see it.

If every model fails you get `502 all_providers_failed` and pay nothing except for any timed-out attempts. Requests rejected for validation, authentication, rate limiting, insufficient credits or a key limit are never charged.

For budgeting, treat the most expensive model in your list as the worst case per request. The average stays close to the first model's price unless that provider is having a bad day.

## How the credit purchase fee works

Mux is prepaid. The only Mux fee is charged when you buy credits: 5.5% of the amount, with a minimum of $0.80, taken out of what you pay.

| You pay | Fee | Credits added |
|---|---|---|
| $5 | $0.80 | $4.20 |
| $10 | $0.80 | $9.20 |
| $50 | $2.75 | $47.25 |
| $100 | $5.50 | $94.50 |
| $1,000 | $55.00 | $945.00 |

The minimum means the fee is $0.80 on anything up to about $14.55 and 5.5% above that, so small frequent top-ups are the most expensive way to buy. To land a specific credit amount, divide by 0.945: $700 of `exa/auto` searches needs a purchase of about $741. Purchases run from $5 to $10,000 each, so a $12,000 month of `exa/deep` needs two. There is no subscription and credits do not expire. Details at [/docs/pricing](https://getmux.io/docs/pricing).

If you bring your own provider key, the first 1,000,000 BYOK requests per calendar month carry no Mux fee at all, and the provider bills you directly. See [/docs/byok](https://getmux.io/docs/byok).

## Per-key limits stop runaway loops

An agent stuck in a loop is the main way a search budget goes wrong. Mux's rate limit of 20 requests per second per key bounds the damage, but at that rate `parallel/fast` still burns $72 an hour and `exa/auto` burns $504 an hour. A credit limit on the key is what actually stops it.

Each API key can carry a USD `limit` from 0 to 1,000,000 and a `limit_reset` of `daily`, `weekly` or `monthly`. The check happens atomically with the debit, so concurrent requests cannot push past it. A request that would exceed the limit is rejected with `402 key_limit_exceeded` and nothing is charged. With a `models` list, a model that does not fit under the remaining limit is skipped and a cheaper one later in the list can still run. Refunded calls return their amount to the limit.

Create one key per agent, customer or environment with a management key.

```bash
curl https://api.getmux.io/v1/keys \
  -H "Authorization: Bearer $MUX_MGMT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "research-agent-prod", "limit": 25, "limit_reset": "daily"}'
```
```ts
import { Mux } from "getmux";

const admin = new Mux({ apiKey: process.env.MUX_MGMT_KEY });
const { key, data } = await admin.keys.create({
  name: "research-agent-prod",
  limit: 25,
  limitReset: "daily",
});
// store `key` now; it is only returned once
```
```python
from getmux import Mux

admin = Mux(api_key="mux-mgmt-...")
secret, key = admin.keys.create("research-agent-prod", limit=25, limit_reset="daily")
# store `secret` now; it is only returned once
```

A $25 daily cap on `parallel/fast` is 25,000 searches a day and a hard ceiling of $775 in a 31-day month. Reset windows are in UTC. The same management key can lower a limit, disable a key as a kill switch, or delete it; see [/docs/keys](https://getmux.io/docs/keys).

## Measuring what you spent

Every search response carries `usage.cost_usd`, the settled price of that request after extra results and refunds. Log it next to your run id and you have exact per-run cost.

```ts
const res = await mux.search({ query, models: ["parallel/fast", "exa/auto"] });
runCost += res.usage.costUsd;
```
```python
res = mux.search(query, models=["parallel/fast", "exa/auto"])
run_cost += res.cost_usd
```

For totals, `GET /v1/usage?days=30` returns spend and request counts per day, per model and per key. The [dashboard](https://getmux.io/dashboard) shows the same breakdowns, a per-request activity log, and a ledger of purchases, usage and refunds. An agent can check its remaining budget before expensive work with `GET /v1/key`, which returns `limit_remaining`. The endpoints are documented at [/docs/credits](https://getmux.io/docs/credits).

## FAQ

### What does one web search cost for an AI agent on Mux?

Between $0.001 and $0.012 for 10 results, depending on the model, plus $0.001 per result beyond 10 on Exa and Parallel. The providers' list prices are passed through unchanged; the only Mux fee is 5.5% when you buy credits.

### How do I stop an agent from spending too much?

Give it its own API key with a `limit` and a `limit_reset` of `daily`, `weekly` or `monthly`. Requests that would exceed the limit are rejected with `402 key_limit_exceeded` and cost nothing, and the limit is enforced atomically so concurrency cannot leak past it.

### Do I pay twice when a request falls back to another provider?

No. Failed attempts are refunded and you pay for the model that answered. The exception is a 15-second provider timeout, which keeps that model's base price because the provider usually completed the search.

### Is there a monthly subscription?

No. Mux is prepaid with a $5 minimum purchase, a 5.5% purchase fee with an $0.80 minimum, and credits that do not expire. There are no per-seat or platform charges.

Start with the [quickstart](https://getmux.io/docs/quickstart) to get a key and run your first search.