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
Protocol integration

Twin Browser + MCP (Model Context Protocol)

MCP is an open protocol that lets an LLM application discover and call external tools over a standard interface. An MCP client (Cursor, Claude Desktop, Claude Code, Cline) connects to an MCP server, lists its tools, and invokes them on the model’s behalf — no bespoke glue per app.

Get an API keyRead the docs
Protocol3 MCP tools: run · compile_skill · run_skillBearer key auth

How Twin plugs into MCP (Model Context Protocol)

Twin ships a first-party MCP server that exposes three tools — `run` (turn a natural-language goal into deterministic browser action), `compile_skill` (freeze a successful run into a reusable skill), and `run_skill` (replay a compiled skill with zero LLM calls). Point any MCP client at the server with your Bearer key and the model can drive a real browser the same way it reads a file. Because the semantic dispatch cache lives server-side, a re-phrased goal matches an already-compiled skill automatically, so the marginal cost of each call trends toward zero.

Twin is the browser execution layer your stack calls. The first run cold-compiles a skill; every similar request after that is matched from the cache and replayed deterministically, so your marginal cost per run trends toward zero.

app.example.com
  1. Receive goal from MCP (Model Context Protocol)done
  2. Compile DOM → token-efficient indexed statedone
  3. Match the semantic dispatch cacherunning
  4. Replay compiled skill — 0 LLM callsqueued

What you get through MCP (Model Context Protocol)

Every integration is a thin wrapper over the same execution layer, so the cache, replay, and corpus benefits apply no matter how you call in.

Semantic dispatch cache

A re-phrased goal fuzzy-matches an already-compiled skill, so most calls never touch the LLM.

Deterministic replay

A compiled skill replays the exact action path with zero LLM calls — fast, repeatable, cheap.

Cross-tenant skill corpus

A skill compiled once can be safely reused across tenants, so the hit rate climbs as the network runs.

One Bearer key

Auth, usage-based billing, and an audit log run on every call — the same key works from every integration.

Wire it up

Drop Twin into MCP (Model Context Protocol)

Copy, paste, and swap in your Bearer key. The first run compiles a skill; repeats hit the semantic dispatch cache and replay deterministically.

mcp.json — register the Twin MCP serverjson
{
  "mcpServers": {
    "twin-browser": {
      "url": "https://twin-browser.com/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer tw_live_xxx"
      }
    }
  }
}

// The model can now call:
//   run(goal, url)        -> compiles + executes a goal
//   compile_skill(run_id) -> freezes a run into a reusable skill
//   run_skill(skill_id)   -> deterministic replay, zero LLM calls

Base URL https://twin-browser.com/api/v1 · auth Authorization: Bearer tw_live_… · MCP tools run, compile_skill, run_skill.

Read the MCP (Model Context Protocol) docsAPI reference
Get started

Connect MCP (Model Context Protocol) in 4 steps

Install → configure your key → make the first call. The cache takes over from there.

  1. 1
    Get an API key

    Create a key in the Twin dashboard under Keys. It authenticates every MCP call as your tenant.

  2. 2
    Register the server

    Add the Twin MCP server to your client config with the key in the Authorization header.

  3. 3
    List the tools

    Restart the client; it discovers run, compile_skill, and run_skill automatically.

  4. 4
    Run a goal

    Ask the agent to perform a web task — it calls run, and repeated tasks hit the cache.

Why this stays cheap at scale

Most browser infrastructure re-runs the LLM on every execution, so cost climbs with usage. Twin compiles a task once via skill compilation, matches re-phrased requests to it, and replays without the model — so repeated workflows stop scaling with your token bill.

FAQ

MCP (Model Context Protocol) on Twin — common questions

Which MCP clients work with Twin?
Any MCP-compatible client — Cursor, Claude Desktop, Claude Code, and Cline are tested. You register the Twin MCP server once and the run, compile_skill, and run_skill tools appear automatically.
Do I pay the LLM cost on every MCP call?
No. The first time a goal is seen it cold-compiles; after that the semantic dispatch cache matches re-phrased goals to the compiled skill and replays deterministically, so most calls make zero LLM calls.

Go deeper

REST API referenceMCP serverDocsSemantic dispatch cacheDeterministic replayCredential vaultCompare browser tools
Related

More ways to connect Twin

Cursor

MCP client

Cursor is an AI-native code editor with a built-in agent that can call MCP tools. Once an MCP server is registered in Cursor’s settings, the agent can invoke its tools while you work — including driving a real browser.

Claude Code

MCP client

Claude Code is Anthropic’s agentic coding tool that runs in the terminal and supports MCP servers. Registered MCP tools become available to the agent so it can take real actions — including browser automation — as part of a coding task.

REST API

API

Twin’s REST API is the universal integration path: a small set of HTTPS endpoints under `/api/v1/*` authenticated with a Bearer key. Any language that can make an HTTP request can drive the browser execution layer — no SDK required.

Wire up MCP (Model Context Protocol) in minutes

Free to start. Usage-based credits from $29/mo, with LLM cost metered and passed through at 1×.

Get an API keySee pricing