---
title: Modes, models & pricing
description: Choose fast or accurate mode, optionally run the agent on a model you pick, and see exactly how a run is reserved and charged.
---

A browser agent run is billed per step at its mode's price. Models are included. Time beyond one minute per step, mostly spent waiting for a person, is billed per minute. If you pick your own model, its tokens are billed on top. Prices on this page are current; the [browser agent page](/browser-agent) always shows the live step price.

| Item | Price |
| --- | --- |
| Step in `fast` mode (default) | $0.006 |
| Step in `accurate` mode | $0.012 |
| Run fee | None |
| Included time | 1 minute per step |
| Time beyond that | $0.005 per minute, prorated to the second |
| Your own `model` | Its tokens at the model's normal price, plus 20% |
| Structured output | Included |

## Choose a mode

Set `mode` when you start a run. Both modes use the same browser and the same API.

| | `fast` | `accurate` |
| --- | --- | --- |
| Price per step | $0.006 | $0.012 |
| How it reads pages | Page text and controls | Page text and controls, plus a screenshot of the page when it is unsure |
| Reading data | From the page text | Can also run read-only JavaScript on the page to pull out long tables, lists, counts and link targets |
| Good for | Lookups, searches, logins, most forms | Date pickers, maps, custom widgets, long tables, sites where fast mode fails |

Start with `fast`. It is quicker and handles most tasks. Switch a task to `accurate` when fast mode fails on it: on our 78-task benchmark of real websites, accurate mode completed more tasks.

```bash title="cURL"
curl https://lovelyrouter.com/v1/browser/runs \
  -H "Authorization: Bearer $LOVELY_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "goal": "Find the opening hours of the Louvre on Tuesdays in December 2026.",
    "start_url": "https://www.louvre.fr/en",
    "mode": "accurate"
  }'
```

```python title="Python"
run = requests.post(f"{API}/runs", headers=H, json={
    "goal": "Find the opening hours of the Louvre on Tuesdays in December 2026.",
    "start_url": "https://www.louvre.fr/en",
    "mode": "accurate",
}).json()
```

```js title="Node.js"
const run = await fetch(`${API}/runs`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    goal: 'Find the opening hours of the Louvre on Tuesdays in December 2026.',
    start_url: 'https://www.louvre.fr/en',
    mode: 'accurate',
  }),
}).then((r) => r.json());
```

The Python and Node.js samples on this page use the `API`, `H` and `headers` setup from [Run your first task](/docs/browser-agent#run-your-first-task). The run object reports the mode it ran in as `mode`. Any value other than `fast` or `accurate` returns `400`.

In accurate mode, the agent stops taking screenshots once it has typed a secret into the page, because a screenshot can't be scrubbed the way text can.

## Use your own model

By default the agent runs on models that are included in the step price. To use a model you prefer, pass its id from [`GET /v1/models`](/docs/api/models) as `model`:

```bash title="cURL"
curl https://lovelyrouter.com/v1/browser/runs \
  -H "Authorization: Bearer $LOVELY_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "goal": "Compare the three plans on the pricing page and tell me which one includes SSO and what it costs per month.",
    "start_url": "https://example.com/pricing",
    "model": "claude-sonnet-5.5",
    "max_model_usd": 0.60
  }'
```

Your model does the agent's thinking when it is unsure of the next step, writes the text it types into fields, writes the final answer and extracts `data`. The agent keeps its own fast model for choosing routine steps.

How it is billed:

- **Steps** cost the usual step price for the mode.
- **Model tokens** are billed as ordinary API requests at the model's normal price, from your balance. They appear in [Logs](/app/logs) under the run's API key.
- **A 20% surcharge** on those token charges is added to the run's `charge_usd`.

The hold covers the surcharge, not the tokens themselves, so keep enough balance for the model's requests while the run is live.

`model_usd` in the run object shows what the model has cost so far, tokens plus surcharge.

**`max_model_usd`** caps that amount (tokens plus surcharge, in USD). If you leave it out, a budget is estimated from `max_steps` and the model's prices. When the model's spend nears the budget, the run stops with status `failed` and the error `reached the model budget ($0.6000); raise max_model_usd`. Part of the budget is kept free for the final answer and data extraction.

With your own model, the agent does not use screenshots, even in accurate mode.

If the model can't be used for the browser agent, the request returns `400` with `Model "…" is not available. Use a model id from GET /v1/models.`

## Time and waiting

Every billed step includes one minute. A step takes a few seconds, so agent work alone almost never goes past it. Time is billed when the browser stays open longer:

- **Waiting for a person.** Each pause (a question, an approval, a handover, a takeover) also includes one minute. Beyond that, the wait costs $0.005 per minute until you reply or the run times out.
- **A slow step.** A step that takes longer than a minute, for example on a very slow page, is billed for the excess.

`billable_time_s` and `time_usd` in the run object show the billable time and its cost so far, including a wait in progress. To cap waiting costs, lower `human_timeout_minutes`: a run that waits longer ends as `timed_out`.

## How the hold works

When a run starts, it reserves (holds) the most it can cost. The hold is deducted from your balance right away. When the run ends, it is charged for what it used and the rest of the hold comes back.

The hold is the sum of:

1. **Steps:** `max_steps` × the mode's step price.
2. **One wait:** (`human_timeout_minutes` − 1) × $0.005, if the run can pause for a person. A run can pause unless you set both `"human": false` and `"approve": "none"`.
3. **Model surcharge:** one sixth of the model budget (the 20% surcharge part of it), only when you pass `model`.

| Run settings | Hold |
| --- | --- |
| Defaults: fast, 50 steps, can pause, 30-minute timeout | $0.30 + $0.145 = **$0.445** |
| `"mode": "accurate"`, other defaults | $0.60 + $0.145 = **$0.745** |
| `"max_steps": 20`, `"human_timeout_minutes": 5` | $0.12 + $0.02 = **$0.14** |
| `"max_steps": 20`, `"human": false`, `"approve": "none"` | **$0.12** |
| Defaults plus `"model": "claude-sonnet-5.5"`, `"max_model_usd": 0.60` | $0.445 + $0.10 = **$0.545** |

`reserved_usd` in the run object shows the hold while the run is live and `0` once it is settled. If your balance is below the hold, the start request returns `402`. Lower `max_steps` or `human_timeout_minutes`, or [top up](/app/billing). It also returns `402` if the hold would take the API key past its [spend limit](/docs/account/api-keys).

## What a run is charged

When a run ends, whatever its status, its charge is:

- **steps taken** × the mode's step price, not counting pauses for a person, and at most `max_steps`
- **plus billable time** × $0.005 per minute
- **plus the 20% surcharge** on your own model's tokens, if you passed `model`

The charge never exceeds the hold. A run that fails or that you stop pays for the steps it took. `charge_usd` shows the charge once the run is settled, a few seconds after it ends.

## Cost examples

| Task | Mode | Billed steps | Extra | Charge |
| --- | --- | --- | --- | --- |
| Read a value from a page | fast | 2 | none | $0.012 |
| Search a site and read a result | fast | 5 | none | $0.030 |
| Same search on a hard site | accurate | 6 | none | $0.072 |
| Log in, answer a 2FA question after 3 minutes, read account data | fast | 7 | 2 billable minutes, $0.010 | $0.052 |
| Fill and submit a long multi-step form | fast | 20 | none | $0.120 |
| Same form with `"model": "claude-sonnet-5.5"`, $0.20 of tokens | fast | 20 | $0.04 surcharge | $0.160, plus $0.20 in API requests |
| A question nobody answers, 30-minute timeout | fast | 4 | about 29 billable minutes, $0.145 | about $0.17, status `timed_out` |

## See what you spent

- `charge_usd`, `billable_time_s`, `time_usd` and `model_usd` on the [run object](/docs/api/browser#the-run-object).
- [Usage & logs](/docs/account/usage): browser agent runs appear with your other tool spend. Your own model's requests appear in Logs like any other API call.
- [Credits & billing](/docs/account/billing): balance, top-ups and holds.