# Browsa pricing

Last updated: 2026-11-14

Browsa is a cloud browser API for AI agents. Everything is billed in credits drawn from one balance per workspace. There is no subscription. Human-readable version: https://browsa.io/pricing. Full product summary for LLMs: https://browsa.io/llms-full.txt

## Credit packs

| Pack | Price (USD) | Credits | Price per credit |
|---|---|---|---|
| Starter | $20 | 200 | $0.1000 |
| Growth | $100 | 1,200 | $0.0833 |
| Pro | $500 | 7,500 | $0.0667 |

- Credits never expire. Packs stack: buying a pack adds to your existing balance.
- Minimum purchase is one Starter pack ($20).
- Payment is by card, Apple Pay or Google Pay through Stripe. Invoicing is available on request.
- Buy packs in the dashboard: https://app.browsa.io/dashboard/credits

## Prices per unit

| What you run | Credits | Notes |
|---|---|---|
| Cloud browser (burner) | 1 per started 12 minutes of browser time | 5 credits for a full hour. See "How browser time is billed" below |
| Quick scrape, screenshot or extract (`POST /v1/quick/...`) | 1 per page | Runs on a short-lived browser |
| Batch of URLs | 1 per URL | Same as one quick scrape per URL |
| Agent task (`POST /v1/tasks`), your own LLM key | browser + 1 + 1 per 5 steps | See formula below |
| Agent task on a hosted tier (`"llm":"browsa"`, `"browsa-fast"` or `"browsa-smart"`) | browser + 1 + 1 per 5 steps + the tier's credits per task | 5 today for every tier, charged once per completed task. A server setting that can change per tier: `GET /v1/models` returns the live values |
| Persistent identity, per 30 days | 50 | Charged at creation, then every 30 days |
| Session opened on a persistent identity | 1 | Each session lasts up to 1 hour |
| Webhooks, job status, polling, result and file downloads | 0 | Free |

### How browser time is billed

Cloud browsers are billed for the time they actually run, in blocks of 12 minutes, with a 1-credit minimum:

| Time the browser ran | Credits |
|---|---|
| Up to 12 minutes | 1 |
| Up to 24 minutes | 2 |
| Up to 36 minutes | 3 |
| Up to 48 minutes | 4 |
| Up to 1 hour | 5 |

When the browser starts, Browsa holds the price of the TTL you asked for: 1 credit for a TTL up to 5 minutes, 5 credits for a longer one. That way a browser never runs without the credits behind it. When the browser ends, the blocks it never used go back to your balance as a `refund:browser_unused:<agent_id>` line in your ledger.

This covers every way a browser ends: you call `DELETE /v1/agents/{id}`, you stop a session, the TTL runs out, or the task that opened it finishes. So a browser that ran 2 minutes on a 1-hour TTL holds 5 credits while it is up and keeps 1 when it closes. A browser that runs the full hour keeps all 5.

A session on a persistent identity is 1 credit, which is already the minimum, so there is nothing to give back.

### Agent task formula

```
task_credits = browser + 1 + ceil(steps_taken / 5) + hosted_surcharge

browser          = 1 credit per started 12 minutes its browser ran, up to 5 for
                   a full hour (a task's browser has a 15-minute TTL, so a task
                   that finishes inside 12 minutes keeps 1 credit for it)
                 = 1 when the task runs on a persistent identity (agent_id set)
steps_taken      = steps the agent actually ran (default max_steps 20, cap 100)
hosted_surcharge = the tier's credits_per_task from GET /v1/models (5 today for
                   "browsa", "browsa-fast" and "browsa-smart") when llm is a hosted
                   tier and no key of your own is used, otherwise 0
```

Examples of the step part: 1 to 5 steps = 1, 6 to 10 steps = 2, 11 to 15 steps = 3, 16 to 20 steps = 4.

With your own LLM key (BYOK), Browsa adds no LLM markup. Your LLM provider bills you directly for tokens.

## Refunds

- A browser that fails to start is refunded automatically.
- When a browser ends, the browser time it reserved but never used is refunded (see "How browser time is billed").
- A task that fails (for example STALLED, TIMEOUT or an upstream error) gets its whole browser charge back, whatever the browser ran for, and is not charged the step or hosted-tier credits.
- A task you cancel keeps the charge for the time its browser ran. Step credits are not charged.

## What is free

- 100 free credits once you verify your email. No card required. Google sign-ups are verified at once.
- Webhooks, job status checks, polling, CSV / NDJSON / JSON downloads and job file downloads.
- Checking your balance, ledger and spending limit.

## Captcha solving

Captchas of the types marked solved at https://browsa.io/captcha are solved in the browser's own session, at no extra charge once a workspace has bought a pack (not on the free credits alone): in hosted agent tasks, with the page-view `solve_captcha` action, and in your own Playwright or Puppeteer code with the CDP command `Browsa.solveCaptcha`. Other kinds are not solved yet. Fair use: 300 solves an hour and 3,000 a day per workspace; ask support for more. Which captcha types are solved, with measured pass rates, recordings and logs: https://browsa.io/captcha

## Proxies

- Browsa's proxy network, metered per GB from credits: datacenter 5 credits per GB (Germany), residential 50 credits per GB (United States). Live prices: GET /v1/proxy-network.
- Your own HTTP, HTTPS or SOCKS5 proxy per browser costs nothing extra. Without a proxy, browsers use the IP address of Browsa's data center.

## What Browsa does not sell

- LLM tokens on your own key. With BYOK your provider bills you directly; Browsa adds no markup.

## Limits

| Limit | Value | What happens |
|---|---|---|
| Browser slots per workspace | 6 | A workspace has 6 browser slots. Each running browser takes one, and so does each saved (persistent) identity, for as long as it exists. A new browser, scrape or identity with every slot in use returns `429 TOO_MANY_REQUESTS` with `Retry-After: 30`, and nothing is charged. Email support@browsa.io if you need more |
| Maximum burner browser TTL | 1 hour | Longer values are capped at 1 hour |
| Maximum session on a persistent identity | 1 hour | |
| Agent task steps | default 20, max 100 | Set with `max_steps` |
| Balance at 0 | | `402 INSUFFICIENT_CREDIT` on the next paid request |
| Monthly spending limit (optional) | 1 to 1,000,000 credits, off by default | `402 BUDGET_REACHED` once this month's usage plus the request's cost would go over the limit. Resets on the 1st (UTC). Running work is not stopped |

Persistent identity renewal: renewal is attempted from one day before the 30 days end. If the balance cannot cover 50 credits by the end of the period, the identity is deleted and an `agent.renewal_failed` webhook is sent.

Spending limit API:

```
GET  https://browsa.io/v1/budget
PUT  https://browsa.io/v1/budget   {"monthly_budget_credits": 500}
PUT  https://browsa.io/v1/budget   {"monthly_budget_credits": null}   (removes the limit)
```

Usage counted against the limit is net spend this calendar month (UTC) minus refunds. Pack purchases and the signup bonus do not count. A task is checked at its minimum cost (1 credit, plus the tier's credits per task on a hosted tier: 6 today) because steps are billed after the run.

## Worked examples

Dollar figures use the price per credit of each pack: Starter $0.10, Growth $0.0833, Pro $0.0667.

### 1. 1,000 short scrapes

Each call is one browser that runs well under 12 minutes (or one `POST /v1/quick/scrape`).

```
1,000 x 1 credit = 1,000 credits
```

| Pack rate | Cost | Packs to buy |
|---|---|---|
| Starter | 1,000 x $0.10 = $100.00 | 5 Starter packs (1,000 credits) |
| Growth | 1,000 x $0.0833 = $83.33 | 1 Growth pack ($100, 200 credits left over) |
| Pro | 1,000 x $0.0667 = $66.67 | 1 Pro pack ($500, 6,500 credits left over) |

### 2. One agent task of 20 steps: a hosted tier vs your own key

The task's browser opens with a 15-minute TTL, which holds 5 credits while it runs. This task finishes inside 12 minutes, so its browser keeps 1 credit and 4 go back when it closes.

```
BYOK:          1 (browser) + 1 + ceil(20 / 5) = 1 + 1 + 4         = 6 credits
Hosted tier:   1 (browser) + 1 + ceil(20 / 5) + 5 = 1 + 1 + 4 + 5 = 11 credits
```

| Pack rate | BYOK (6 credits) | Hosted tier (11 credits) |
|---|---|---|
| Starter | $0.60 | $1.10 |
| Growth | $0.50 | $0.92 |
| Pro | $0.40 | $0.73 |

With BYOK you also pay your LLM provider for the tokens the agent used. On a hosted tier (`"llm":"browsa"`, `"browsa-fast"` or `"browsa-smart"`) there is no separate LLM bill. The example uses today's 5 credits per task; see https://browsa.io/guides/models for what each tier runs.

100 such tasks: 600 credits with BYOK, 1,100 credits on a hosted tier.

A task whose browser runs longer pays per block: between 12 and 24 minutes the browser part is 2 credits instead of 1, and so on up to 5 for a full hour.

### 3. A persistent identity used every day for a month

One identity, one session per day for 30 days:

```
50 (identity, 30 days) + 30 x 1 (sessions) = 80 credits
```

| Pack rate | Cost |
|---|---|
| Starter | 80 x $0.10 = $8.00 |
| Growth | 80 x $0.0833 = $6.67 |
| Pro | 80 x $0.0667 = $5.33 |

If instead each day runs a 10-step BYOK agent task on the identity (`agent_id` set), each task costs 1 (session) + 1 + ceil(10 / 5) = 4 credits:

```
50 + 30 x 4 = 170 credits  ->  $17.00 Starter, $14.17 Growth, $11.33 Pro
```

### 4. What the 100 free credits cover

| Usage | Credits |
|---|---|
| 100 browsers that each run under 12 minutes | 100 x 1 = 100 |
| 20 one-hour browsers | 20 x 5 = 100 |
| 25 ten-step BYOK tasks, each finishing inside 12 minutes | 25 x (1 + 1 + 2) = 100 |
| 11 ten-step tasks on a hosted tier, same browser time | 11 x (1 + 1 + 2 + 5) = 99 |
| 1 persistent identity for 2 months, no sessions | 50 + 50 = 100 |

Browsers hold the price of their TTL while they run, so you need that much on your balance to start them even when the unused part comes back at the end.

## Check your balance via API

```
curl https://browsa.io/v1/credits \
  -H "X-API-Key: agt_live_..."
```

`Authorization: Bearer agt_live_...` also works. Response:

```json
{
  "workspace_id": "...",
  "balance": 100,
  "packs": [
    {"sku": "starter_20", "label": "...", "amount_usd_cents": 2000, "credits": 200},
    {"sku": "growth_100", "label": "...", "amount_usd_cents": 10000, "credits": 1200},
    {"sku": "pro_500", "label": "...", "amount_usd_cents": 50000, "credits": 7500}
  ],
  "checkout_enabled": true
}
```

Every response for a paid action reports its cost: browsers return `cost_credits` (what the browser reserved, before the unused-time refund), jobs and tasks return `credits_charged`.

Where credits went: `GET https://browsa.io/v1/credits/ledger?limit=50` (newest first, default 50, max 500, each entry has `delta`, `reason` and a running `balance`).

## Contact

Billing questions, volume pricing or invoicing: support@browsa.io
