Twin Browser
Get an API key
PlatformOverviewHow it worksAll toolsREST APIMCP serverIntegrationsDocs
CapabilitiesSemantic dispatch cacheDeterministic replayCross-tenant skill corpusToken-efficient DOMHuman-in-the-loopLive view & videoCredential vaultOverviewSolutions
SolutionsAll use casesAI agentsRPA replacementQA & test automationData extraction
ResourcesGuidesGlossaryBlogCompareFAQStatus
Pricing
Log in

Usage-based pricing

Pay per action, not per browser-hour.

A page read is 1 credit, a freshly solved goal 10 credits, and every later run of the same goal drops to 1 credit — because Twin compiles a task once instead of re-reasoning it. Free to start, from $29/mo, with model cost metered per call.

Start freeSee the rate card

Plans

Start free, then pay by the credit.

No seats and no minimums. The plan sets your monthly credit allotment and your support level; underneath, every plan bills the same per-action prices.

Free

$0

Try the engine and run small personal agents — no card required.

Start free
  • Starter credit grant to explore
  • Indexed-DOM state + skill replay
  • REST API, MCP & LangChain
  • Community support
Most popular

Starter

$29/mo

For production agents with steady volume.

Get Starter
  • Monthly credit allotment included
  • Per-tenant API keys + audit log
  • Pay-as-you-go auto top-up
  • Human-in-the-loop handoff
  • Email support

Pro

Usage

For runs that have to get through, and volume worth recording.

Talk to us
  • Stealth tier — full anti-detection on an authorized run
  • POST /api/v1/agent, the one-shot premium call
  • 1080p session recording
  • 100 GB of recording storage

Enterprise

Custom

For teams with compliance, security, and procurement needs.

Contact sales
  • SSO + SCIM
  • Dedicated capacity
  • Custom data residency & retention
  • SLA + solutions engineering

Credit allotments are set per plan — the live, edge-cached rate card at /api/v1/pricing is always the current one. No seats, no minimums, cancel anytime.

The model

Three rules, and that is the whole bill.

What you pay is a flat price per action, a one-time premium for discovery, and the model cost the call actually incurred.

Pay for what your agent does

No seats, no minimums, no per-browser-hour meter. Every action has a flat, predictable credit price — a page read is 1 credit, a solved goal 10 credits.

Repeats get cheaper

Compile a goal into a skill once and every later run drops to 1 credit. You pay the discovery premium once, then replay it.

Model cost is metered per call

You are billed the higher of the flat action price and the metered cost of the run — model tokens, browser compute and egress. Most calls land on the flat price. The rate card is public at /api/v1/pricing.

What a credit buys

Every action, priced in credits.

Flat, predictable, one line each. Compiling a skill is the only premium on the card, and it pays for itself on run 6.

Flat credit price of each Twin Browser action
ActionCostWhat it does
Read a page (indexed state)1 creditPerceive a page without acting on it.
Solve a goal (model in the loop)10 creditsPlan and execute a fresh goal end to end.
Compile a reusable skill50 creditsDiscover and minimize the path once.
Replay a compiled skill1 creditDeterministic — zero model calls.
Cache hit on a re-phrased goal2 creditsSemantic dispatch maps it onto a skill.
Adapt a skill from the shared corpus5 creditsReuse a sanitized skeleton instead of compiling.
Search the shared libraryfreeRead-only — it drives no browser.
warm-run.shbash
# Warm run — the same goal, re-phrased, served from the cache
$ curl -sS https://api.twin-browser.com/api/v1/skills/book-slot/run \
    -H "Authorization: Bearer $TWIN_KEY" \
    -d '{"vars":{"date":"2026-07-02"}}' -i

HTTP/2 200
{
  "mode": "cache-hit",              // semantic dispatch matched a compiled skill
  "skill": "book-slot",             // the skill it replayed
  "version": 3,                     // pinned version — deterministic replay
  "success": true,
  "steps": 4,
  "credits_charged": 2,             // what this call cost you
  "runId": "run_2f9c…"              // the audit row for this call
}

Every call returns its own bill in the response body: credits_charged is what you paid, mode says whether the cache hit, and runId is the audit row you can look up later. No estimating — the receipt ships with the response.

Worked example: run one goal 1,000 times. Re-reason it every time and that is 10,000 credits; compile it once and replay and it is 1,050. The crossover is run 6. See how the cache and the corpus work on the skills page.

The cost wedge

Cost falls as you scale.

Per-hour and per-token infra re-runs the model on every execution, so the more you run the more you pay. Twin front-loads the reasoning into one compile, then serves the repeats. The curve bends down.

Credits per run, same workflow

One cold compile, then 1 credit a run. A workflow that matches the shared corpus skips the compile and starts at the adapt price of 5 credits.

api.twin-browser.com/v1/skills/book-slot/run
  1. Match re-phrased goal → skill (semantic cache)done
  2. Load compiled plan book-slot@v3done
  3. Replay 4 steps deterministicallydone
  4. Settle: 1 credit, 0 model costrunning
How per-hour, per-step and per-token billing behaves compared with Twin Browser
How billing behavesPer-hour / per-step / per-token infraTwin Browser
Unit of billingPer browser-hour, per step, or per tokenPer credit — one flat price per action
A repeated workflowRe-runs the model every time → cost is flat or risesReplays from cache at 1 credit → cost falls
Idle / waitingBrowser-hour clock keeps tickingYou pay for actions, not wall-clock time
Model markupBundled, opaque, often marked upHigher of the flat action price or metered run cost, public rate card
Failed runsFrequently billed anywayRefunded — you only pay for solved work

Auto top-up

Runs do not stop on an empty balance.

Set a threshold and a recharge amount, and Twin buys credits in the background the moment you dip below it — so a production agent at 3 a.m. keeps going instead of failing on a balance.

  • You set the trigger threshold and the recharge amount.
  • Background recharge — no run pauses mid-flight.
  • Turn it off anytime; read-only library search stays free.

How a balance behaves

Credit unit
1,000 credits = $1 ($5 = 5,000)
Trigger threshold
Your choice — the dashboard suggests 1,000 credits
Recharge
Buys your chosen pack in the background
Out of credits
Clear error on paid actions; search stays free
Failed runs
Refunded — pay only for solved work

Go deeper

Semantic dispatch cacheDeterministic replayGlossary: skill compilationLive rate card (/api/v1/pricing)How Twin compares

FAQ

Pricing, answered.

What is a credit?
A credit is Twin’s unit of usage. Every browser action has a flat credit price: a page read is 1 credit, a freshly solved goal 10 credits, and a deterministic skill replay 1 credit. Credits are priced at 1,000 per US dollar (a $5 pack = 5,000 credits), and the live rate card is published at /api/v1/pricing.
Is there a free tier?
Yes. It’s free to start with no card required — you get a starter credit grant to run the engine, compile a skill, and call the REST API, MCP server, or LangChain adapter. Upgrade to Starter ($29/mo) only when you need production volume and support.
What is a skill, and why does it make runs cheaper?
A skill is a compiled, replayable recording of a successfully solved goal. The first run reasons with the model (the discovery premium); compiling captures that solution so every later run — including re-phrased requests matched by the semantic dispatch cache — replays deterministically with zero model calls at 1 credit.
Do you mark up LLM cost?
You are billed the higher of two numbers: the flat price for the action, or the metered cost of that particular run — model tokens plus the browser compute and egress it used. Most calls land on the flat price, and a cache hit or a replay always does. The per-model rate card is public at /api/v1/pricing, and every response carries its own credits_charged.
Why does cost fall as usage grows?
Most browser infra re-runs the model on every execution and bills per browser-hour, step, or token — so cost is flat or climbs with usage. Twin front-loads the model cost into a one-time compile (50 credits), then serves repeats from the semantic cache or deterministic replay. A cross-tenant skill corpus compounds the saving, so the average cost per run falls the more a workflow runs.
What is auto top-up?
Pay-as-you-go auto top-up keeps long-running agents from stalling: when your credit balance drops below a threshold you set (the dashboard suggests 1,000 credits), Twin buys more in the background so runs continue uninterrupted. You stay in control of the threshold and the recharge amount, and can turn it off anytime.
What happens when I run out of credits?
If auto top-up is on, Twin recharges before you hit zero and runs never pause. If it’s off, in-flight runs settle and new paid actions return a clear out-of-credits error until you add a pack or upgrade — read-only library search stays free either way.
Are failed runs charged?
No. Failed, cancelled, or unsolved actions are fully refunded. For async jobs, credits are reserved on submit and settled on the first terminal read; you only pay for work that actually completes.

Pay for solved work, not browser-hours.

No card to start. Compile one skill, watch the per-run price fall to 1 credit, and let auto top-up keep production agents running.

Start freeRead the docs