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
PricingContact
Log in

The product

Hand your agent the whole web.

You decide what it may touch. Agents reason brilliantly but stall the moment they must act on a live site — Twin Browser is the engine they call to reach any page, pull any data, and sign into the accounts you connect, while you set the guardrails and approve what matters.

Put your agent to workRead the docs
billing.acme.com
  1. Open billing.acme.comdone
  2. Read DOM → indexed state (42 elements, ~3k tokens)done
  3. Plan: log in → open invoices → pick latestdone
  4. Act: fill #user · fill #pass · click “Sign in”running
  5. Compile run into a deterministic skillqueued

One run: open the page, read it as indexed state, plan, act, and compile the path into a skill the next run replays with no model call — 1 instead of 10.

The loop

Observe, plan, compile, replay.

Four stages turn one LLM-driven browse into a skill the next run executes with no model in the loop. Only the second stage needs a model at all.

COMPILEdiscovery runretries · dead ends · backtracksminimisecompiled skill1open(url)2fill[3] {{email}}3click[7]4extract([…])book-slot@v3 · replayableone discovery run · a program that replays the same way every time
  1. 01

    DOM → indexed state

    A compiler turns the live page into a compact, numerically-indexed map of interactive elements under a token budget — not raw HTML. The model spends tokens on the decision, not the markup.

  2. 02

    Plan → act

    The planner picks actions against the indexed state — click element 14, type into element 7, submit — and drives the browser until your structured success condition is met. This is the only stage that needs an LLM.

  3. 03

    Compile → skill

    A successful run is minimized into a reusable, deterministic skill: the essential steps, no exploration noise, keyed to the page’s structure and stored in your skill library.

  4. 04

    Dispatch → replay

    Re-runs hit the semantic dispatch cache and replay deterministically with zero LLM calls — or compile fresh and cache for next time. Blocked steps hand off to a human, then resume.

Want the full eight-stage mechanism, end to end? Read how it works.

The cost wedge

The second run is nearly free.

Most browser infra re-runs the LLM on every execution, so the bill climbs with usage. Twin compiles a task once, matches re-phrased requests with a semantic cache, and replays deterministically — three rungs down, not up.

COST OF THE SAME GOAL, N TIMES0306090120036912creditsrunsbreaks even at run 6re-reason every run · 10 cr eachcompile once · 50 cr, then 1 cr a replayrates from the published card — GET /api/v1/pricing

Cold compile

1×LLM cost

The first time a goal is seen, the planner discovers a path and minimizes it into a deterministic skill. You pay the model once.

Semantic cache hit

~0.2×LLM cost

A re-phrased request is vector-matched to a compiled skill for that host and adapted — far cheaper than recompiling.

Deterministic replay

~0×LLM cost

Call a skill by name and it blind-replays with no model in the loop. The most-repeated workflows trend toward zero marginal LLM cost.

In code

Two calls, one skill

The first call discovers a path and compiles a skill. The next similar call — even re-worded — replays it deterministically. Same key, same audit log, same vault; the only difference is the token count in the response.

A cross-tenant skill corpus compounds it further: a skill compiled once can be safely reused across tenants. See how the cache and corpus fit together on the why-Twin page and the skills page.

run-then-dispatch.shbash
# 1 — cold run: the planner compiles a reusable skill
curl -X POST https://twin-browser.com/api/v1/run \
  -H "Authorization: Bearer $TWIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "goal": "Log in and download this month'\''s invoice",
    "url": "https://billing.acme.com"
  }'
# -> { "result": {...}, "skill_id": "sk_9f2c", "llm_tokens": 3120 }

# 2 — dispatch a re-phrased request: semantic cache HIT -> replay
curl -X POST https://twin-browser.com/api/v1/dispatch \
  -H "Authorization: Bearer $TWIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "goal": "Grab the latest invoice PDF", "url": "https://billing.acme.com" }'
# -> { "result": {...}, "replayed": true, "llm_tokens": 0 }

One engine, three ways in

REST API

Bearer-authenticated endpoints under /api/v1/* — run a goal, dispatch to the cache, or replay a compiled skill.

API reference

MCP server

Tools run, compile_skill and run_skill for Cursor, Claude Desktop, Claude Code and Cline.

MCP server

LangChain & AutoGen

One-line tool adapters drop the same engine into your existing agent framework — no replay logic to reimplement.

Adapters in the docs

Capabilities

Everything an authenticated task needs

Not a screenshot tool — a full execution engine, with the security, control, and observability real workflows demand. Every capability below is shipped; open one for the deep dive.

At a glance

A plain headless browser, plus a skill layer

Same browser underneath. The layer above it is what makes the second run nearly free, observable, and safe to run at volume.

A plain headless browser compared with Twin Browser, row by row.
AspectPlain headless browserTwin Browser
Cost of the next identical runFull LLM cost again~0 LLM — deterministic replay
Page representationRaw HTML / pixelsIndexed-state map under a token budget
Re-phrased requestCold startSemantic cache hit, adapted
Reuse across teamsNoneCross-tenant skill corpus (sanitized)
2FA / blocked stepRun failsAuto-fill code, else HITL handoff
ObservabilityLogs, if anyLive view + durable session video + audit log
BillingOpaqueUsage credits; higher of the flat action price or metered run cost

Illustrative engine behavior, not a benchmark. See the line-by-line breakdown on the compare pages.

Authorization

You delegate the work. You keep the authority.

Twin runs first-party sites, operator-approved automation, internal RPA, accessibility, and authorized testing. The run’s target URL is the authorization signal — and auth, billing, and audit logging run on every call.

DELEGATE · ACT · APPROVEYougoal + target URLReal browser runobserve · plan · actControl gateneeds a person?Work donevideo · audit logauthorizeactclearYou decidecode · approval · stopresume in placepauseyou authorize · it does the work · you approve what matters

Per-tenant API keys

Every call is authenticated with your own key, and the key is stored only as a hash — never in plaintext, never shared across tenants.

Default-deny row-level security

Tenancy is enforced in Postgres, not only in the application: every row on the multi-tenant Supabase backend is isolated by tenant with RLS on by default.

Audit log and credential vault

Every run records its goal, its path and the target it acted on, and every secret it used is filled at run time from the vault and redacted from the log.

It is not a CAPTCHA-bypass-for-hire or anti-bot evasion service. Read the full disclosure on the security page.

FAQ

The product, answered

What is Twin Browser?
The browser layer for AI agents. You hand your agent a goal and a target; it drives a live browser to reach any site, pull any data, and sign into the accounts you connect — while you set per-host policy, approve blocked steps, and read the full audit log. Repeated workflows also compile into deterministic skills that replay at near-zero cost, so running the same work at volume gets cheaper over time.
How is this different from a headless-browser API?
A plain headless browser re-runs the LLM on every execution, so cost climbs with usage. Twin adds a skill layer: a DOM→indexed-state compiler, compiled skills, a semantic dispatch cache, and deterministic replay — plus a cross-tenant corpus that compounds the savings. Cost falls as usage grows instead of rising.
What does the indexed-DOM compiler actually do?
It serializes a live page into a compact, numerically-indexed map of interactive elements (roles, text, positions) under a token budget, instead of raw HTML. The planner reasons over that compact state, and the indices stay stable enough to replay deterministically later.
Where is Twin authorized to automate?
Twin automates the web where you are authorized — first-party sites, operator-approved automation, internal RPA, accessibility, and authorized testing. The run’s target URL is the authorization signal; auth, billing, and audit logging run on every call. It is not a CAPTCHA-bypass-for-hire or anti-bot evasion service.
How do I call it?
A REST API under /api/v1/* with Bearer-key auth, an MCP server (tools: run, compile_skill, run_skill) for Cursor, Claude Desktop, Claude Code and Cline, and one-line LangChain and AutoGen tool adapters.
What does it cost?
Free to start, then usage-based credits from $29/mo. A read is roughly 1 credit and a solved goal roughly 10; once you compile a skill, every later run drops back toward ~1. A model-heavy run is billed the higher of its flat price and its metered cost — see the live rate card at /api/v1/pricing.

Free to start

Delegate the busywork — keep the control.

Put your agent to work across the web while you set the guardrails and approve what matters. Free to start; usage-based credits from $29/mo.

Get an API keySee pricing