Model Context Protocol

The browser MCP server where cost falls with usage.

Give Cursor, Claude, or any MCP client an authenticated, audited browser. Compile a skill once, replay it with no LLM, and let a semantic cache match new requests to skills you — and the network — already built.

Set up the MCP server Get an API key

Works in every major MCP client over stdio — drop in one config block and your agent has a browser.

CursorClaude DesktopClaude CodeCline

What you get

A browser your agent drives natively

Not a screenshot tool bolted onto a model — a full execution engine exposed as MCP tools, authenticated and audited, and built to get cheaper the more it runs.

Native MCP tools

run, compile_skill, and run_skill (plus list_skills, search_library, observe and more) drop straight into Cursor, Claude Desktop, Claude Code, or Cline so your agent acts on the web.

Replay with no LLM

Compile a path once, then run_skill blind-replays it deterministically — no model in the loop. The most-repeated workflows trend toward zero marginal LLM cost.

Shared skill library

search_library matches your intent against a sanitized cross-tenant corpus, so your agent finds a skill the network already compiled for that host.

Authenticated by construction

Every target-bearing tool is authenticated with your key and acts on exactly the URL you pass — scoped to your tenant, metered, and written to the audit log.

Full task bundle

Credential vault, proxy egress, CAPTCHA solving, human-in-the-loop handoff, and video recording — exposed as tools, not bolt-ons.

Token-efficient state

Pages are serialized into compact indexed DOM state instead of raw HTML, so your model spends tokens on the decision, not the markup.

The core tools

Three tools, one authenticated engine

Lead with run, compile_skill, and run_skill — the loop that turns a goal into a cheap, replayable skill.

run

Execute a goal on a target URL you provide — observe the page as indexed state, plan, and act until a success condition is met.

compile_skill

Discover a goal once with the planner, then minimize it into a reusable, deterministic skill.

run_skill

Blind-replay a compiled skill with no LLM in the loop — the cheap, deterministic path.

mcp.jsonjson

// .cursor/mcp.json  (Cursor) — claude_desktop_config.json (Claude
// Desktop) and Cline use the identical "mcpServers" shape.
{
  "mcpServers": {
    "twin-browser": {
      "command": "npx",
      "args": ["-y", "@twin-browser/mcp"],
      "env": {
        "TWIN_API_KEY": "ab_live_…",
        "WEB_BASE_URL": "https://twin-browser.com"
      }
    }
  }
}

Claude Desktop, Claude Code and Cline use the same shape — the full how-to is in the MCP setup guide.

Wire up any client

Register once, call from anywhere

Cursor, Claude Desktop, and Cline take the JSON block; Claude Code registers from the CLI. Then your agent calls the tools by name — here are the three that matter.

claude-code.shbash

# Claude Code — register the server from the CLI:
claude mcp add twin-browser \
  --env TWIN_API_KEY=ab_live_… \
  --env WEB_BASE_URL=https://twin-browser.com \
  -- npx -y @twin-browser/mcp

# Verify it connected and list the exposed tools:
claude mcp list
# → twin-browser: run, compile_skill, run_skill, list_skills,
#   search_library, observe  (connected)

tool-calls.jsoncjsonc

// run — execute a goal on a target URL you provide
{ "tool": "run", "arguments": {
    "url": "https://app.acme.com/invoices",
    "prompt": "export last month as CSV",
    "success": { "kind": "urlIncludes", "value": "/exports" } } }

// compile_skill — discover once, minimize into a deterministic skill
{ "tool": "compile_skill", "arguments": {
    "url": "https://app.acme.com/invoices",
    "prompt": "export last month as CSV", "name": "acme-export" } }

// run_skill — blind-replay, no LLM in the loop
{ "tool": "run_skill", "arguments": {
    "name": "acme-export", "url": "https://app.acme.com/invoices" } }
// → { "success": true, "credits_charged": 1, "llm_calls": 0 }

FAQ

Browser MCP, answered

What is a browser MCP server?

An MCP (Model Context Protocol) server that exposes web-browser actions as tools an AI model can call directly. Twin Browser’s MCP server lets Cursor, Claude Desktop, Claude Code, Cline and other MCP clients compile, run, and replay browser automations on an authenticated, audited engine.

Which MCP clients are supported?

Any MCP client over stdio — including Cursor (via .cursor/mcp.json), Claude Desktop (claude_desktop_config.json), Claude Code (claude mcp add), and Cline. They all use the same mcpServers shape; see the setup guide for ready-to-paste configs.

What are the core tools?

run executes a goal on a target URL; compile_skill discovers a goal once and minimizes it into a deterministic skill; run_skill blind-replays a compiled skill with no LLM in the loop. list_skills, search_library, and observe round out the set.

How is Twin’s MCP server different from a plain headless-browser MCP?

A plain browser MCP re-runs the model on every action. Twin adds a skill layer: compile_skill compiles a path once, run_skill replays it deterministically with no LLM, and search_library semantically matches new requests to cached skills — so cost falls as usage grows.

How is access controlled?

Every target-bearing tool is authenticated with your per-tenant API key and acts on exactly the URL you provide. Each run is scoped to your tenant, metered in credits, and written to the audit log — nothing runs autonomously that you did not initiate.

Keep exploring

Where to go next

MCP setup guide REST API reference All integrations Cursor integration Claude Code integration Skill library

Wire it up in two minutes.

Paste one config block, point it at your engine, and your agent has an authenticated, audited browser.

Read the setup guide All docs