Twin Browser
Platform
OverviewHow it worksREST APIMCP serverIntegrationsDocs
Capabilities
OverviewSemantic dispatch cacheDeterministic replayCross-tenant skill corpusToken-efficient DOMHuman-in-the-loopLive view & videoCredential vault
Solutions
All use casesAI agentsRPA replacementQA & test automationData extraction
Resources
GuidesGlossaryBlogCompareFAQStatus
Pricing
Log inGet an API key
Usage-based pricing

Pay for what your agent does.

Most browser infra re-runs the LLM on every execution, so cost climbs with usage. Twin compiles a task once and replays it deterministically — so a read costs one credit, a solved goal costs ten, and every later run drops back to one. Free to start, from $29/mo, with LLM cost metered and passed through at 1×.

Start freeSee the rate card

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

Scale

Usage

For high-volume workloads that grow with you.

Start scaling
  • Pure pay-as-you-go credits
  • Volume discounts
  • Priority replay throughput
  • Priority support

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 illustrative — see the live, edge-cached rate card at /api/v1/pricing for current numbers. No seats, no minimums, cancel anytime.

The model

Honest, transparent, usage-based

Three rules cover the whole pricing model.

Pay for what your agent does

No seats, no minimums, no per-browser-hour meter. Every action has a flat, predictable credit cost — a read is one credit, a solved goal is ten.

Repeats get cheaper

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

LLM cost passed through at 1×

When a call uses the model, the underlying token cost is metered per call and billed at cost — no markup. The transparent rate card lives at /api/v1/pricing.

What a credit buys

The whole cost model, one line each

Every action has a flat, predictable credit cost. Compiling a skill is the only premium — and it pays for itself the second time you run it.

ActionCostWhat it does
Read a page (indexed state)~1 creditPerceive a page without acting.
Solve a goal (model in the loop)~10 creditsPlan + execute a fresh goal end to end.
Compile a reusable skill~50 creditsDiscover & minimize once.
Replay a compiled skill~1 creditDeterministic, zero LLM calls.
Cache hit on a re-phrased goal~1 creditSemantic dispatch maps it to a skill.
Search the shared libraryfreeRead-only, 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
x-twin-cache: hit            # semantic dispatch matched a skill
x-twin-skill: book-slot@v3   # deterministic replay, pinned version
x-twin-llm-calls: 0          # zero model calls on this run
x-twin-steps: 4
x-twin-credits: 1            # flat action price — what you pay
x-twin-llm-cost-micro: 0     # metered model cost, passed through at 1x

Every call returns its own bill: x-twin-credits is what you pay and x-twin-llm-cost-micro is the metered model cost, passed through at 1×. No estimating — the receipt ships with the response.

Illustrative example: a goal you run 1,000 times costs ~10,000 credits if re-reasoned each time — or ~50 credits to compile once, then ~1,000 credits to replay. Compilation pays for itself around run six. See how the cache and corpus work on the skills page.

The cost wedge

Cost falls as you scale.

Rivals bill per browser-hour, per step, or per token and re-run the model on every execution — so the more you run, the more you pay. Twin front-loads reasoning into a one-time compile, then serves repeats from the semantic cache and deterministic replay. The curve bends down.

Credits per run, same workflow

One cold compile, then ~1 credit forever. The cross-tenant corpus means a workflow can start warm even on its first run.

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 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 LLM 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 upMetered + passed through at 1×, public rate card
Failed runsFrequently billed anywayRefunded — you only pay for solved work

Pay-as-you-go auto top-up

Long-running agents shouldn’t stall at 3 a.m. because a balance hit zero. Set a threshold and a recharge amount, and Twin buys more credits in the background the moment you dip below it — so production runs continue uninterrupted.

  • You set the trigger threshold and the recharge amount.
  • Background recharge — no run ever 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 — e.g. below 1,000 credits
Recharge
Auto-buys your set 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 is ~10, and a deterministic skill replay drops back to ~1. 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 LLM calls at roughly one credit.
Do you mark up LLM cost?
No. When a call uses the language model, the underlying token cost is metered per call and passed through to you at 1× — at cost, no markup. You are billed the higher of the flat action price and the actual metered LLM usage, and the full per-model rate card is public at /api/v1/pricing.
Why does cost fall as usage grows?
Most browser infra re-runs the LLM on every execution and bills per browser-hour, step, or token — so cost is flat or climbs with usage. Twin front-loads the LLM cost into a one-time compile, then serves repeats from the semantic cache or deterministic replay at ~1 credit. A cross-tenant skill corpus compounds the savings, so 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, Twin automatically 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.

Start free, scale when your agent earns its keep.

No card required to start. Compile a skill, watch the marginal cost per run trend toward zero, and let auto top-up keep production agents running.

Start freeRead the docs