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.
- Open billing.acme.comdone
- Read DOM → indexed state (42 elements, ~3k tokens)done
- Plan: log in → open invoices → pick latestdone
- Act: fill #user · fill #pass · click “Sign in”running
- 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.
- 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.
- 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.
- 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.
- 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.
Cold compile
1×LLM costThe 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 costA re-phrased request is vector-matched to a compiled skill for that host and adapted — far cheaper than recompiling.
Deterministic replay
~0×LLM costCall 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.
# 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 }Native to your stack
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 referenceMCP server
Tools run, compile_skill and run_skill for Cursor, Claude Desktop, Claude Code and Cline.
MCP serverLangChain & 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.
Semantic dispatch cache
A re-phrased request is embedded, vector-matched against the skills you have already compiled, and replayed deterministically — so the second ask and every one after it skips the planner.
Deterministic replay
A successful run is minimized into a named, versioned skill — an ordered action path with its variable parts lifted out — and replaying it is a program, not a prompt.
Cross-tenant skill corpus
Compiled paths are sanitized down to their action structure and pooled, so a first run on a widely-automated surface can start from a shared scaffold instead of a cold compile.
Skill library & catalog
Every compiled skill is stored per tenant with a version and a run contract — the params it takes, the secrets it fills, and whether your stored auth is ready for its host.
Token-efficient DOM state
The live page is serialized into a numerically-indexed list of its interactive elements under a token budget, so the planner reasons over signal instead of markup.
Structured extraction
Ask for fields or a JSON schema and get typed data back — or match a per-host template, expand a row selector, or capture the page's own XHR, and pay no model cost at all.
Site mapping & crawl
Discover a site's URLs from its sitemap, robots and a shallow link scan for a flat fee — then run a bounded, resumable, robots-respecting crawl that can extract per page.
Web search & deep search
One search call blends web, discussion, news and FAQ clusters with Hacker News, deduped and source-tagged — then optionally fetches and cleans the top results, or scrapes them as a background job.
ETL & semantic query
Extract, clean, chunk, embed and load any source — URL, HTML or raw text — into a queryable store, then search it with a natural-language query for a flat credit.
Human-in-the-loop handoff
A 2FA prompt, an approval push or a CAPTCHA the agent cannot clear returns status "paused" with a live session — resolve it automatically from a connected inbox, hand back a code, or drive the page yourself.
Live view & session video
POST /api/v1/live streams the browser back as Server-Sent Events while the agent works, and an opted-in run keeps a durable video you can fetch long afterwards.
Async jobs & webhooks
Submit a run as a background job and get an id immediately — then poll it, stream its status, or receive an HMAC-signed webhook when it completes.
Change monitoring
A monitor reads a value on a cadence, hashes it, compares it to last time, and posts an HMAC-signed webhook only when it actually moved.
Credential vault
A write-only per-tenant vault: a stored secret is referenced in a goal as {{secret:NAME}}, resolved inside the browser at fill time, and redacted from every step, frame and log.
Connected accounts & handoff
Mint a single-use link, your end user completes the sign-in in a hosted browser, and the captured session makes every later run already logged in — with no password anywhere.
Egress, geo & locale
A single `country` field sets the residential exit AND the browser locale and timezone, so a site cannot serve a different language than the exit you asked for — or bring your own proxy and keep both.
Stealth tier
A full desktop browser profile — real Chrome, human-calibrated timing, residential egress — behind a plan gate and an explicit authorization attestation, billed per success.
Account cadence governor
A per-account, per-host governor caps how fast one identity may be re-poked and puts it on cooldown after a ban signal — answering 429 with Retry-After instead of burning the account.
Sub-tenants & reseller billing
One scoped call creates a sub-tenant under your account and returns its API key — billing either to its own balance or to your pool, with every charge attributed.
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.
| Aspect | Plain headless browser | Twin Browser |
|---|---|---|
| Cost of the next identical run | Full LLM cost again | ~0 LLM — deterministic replay |
| Page representation | Raw HTML / pixels | Indexed-state map under a token budget |
| Re-phrased request | Cold start | Semantic cache hit, adapted |
| Reuse across teams | None | Cross-tenant skill corpus (sanitized) |
| 2FA / blocked step | Run fails | Auto-fill code, else HITL handoff |
| Observability | Logs, if any | Live view + durable session video + audit log |
| Billing | Opaque | Usage 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.
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?
How is this different from a headless-browser API?
What does the indexed-DOM compiler actually do?
Where is Twin authorized to automate?
How do I call it?
What does it cost?
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.