Model Context Protocol

Hand your agent a browser. Keep the guardrails.

Cursor, Claude Code, or any MCP client gets a browser that does the real work: reach any site, pull any data, sign into the accounts you connect — on exactly the URL you pass, scoped to your tenant, and written to the audit log.

Set up the MCP server Get an API key

Every MCP client over stdio — one config block and your agent has a browser.

Cursor
Claude Desktop
Claude Code
Cline

What you get

An execution engine, exposed as MCP tools.

Not a screenshot tool bolted onto a model. The same engine the REST API drives, reachable by name from your editor — and the expensive parts of a real task are tools in the same list.

Native MCP tools

run_goal, compile_skill and run_skill drop straight into Cursor, Claude Desktop, Claude Code or Cline over stdio — no bespoke glue per client.

Replay with no LLM

compile_skill freezes a path once; run_skill blind-replays it with no model in the loop, so a repeated workflow stops scaling with your token bill.

Shared skill library

search_library matches your intent against a sanitized cross-tenant corpus, so the agent can find 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.

The whole task, not the happy path

Credential vault, proxy egress, CAPTCHA solving, 2FA handoff and video recording are tools in the same list — not bolt-ons behind a different product.

Token-efficient state

observe_page serializes a page into compact indexed DOM state instead of raw HTML, so the model spends tokens on the decision, not the markup.

The toolbelt

31 tools, and you can read every name.

Not integrations on a logo wall — functions the agent calls, with arguments you can inspect before they run. This is the whole surface, exactly as the server registers it.

Every tool exposed by the twin-browser-mcp server, grouped by family.
Tool	What it does
Core — run, compile, replay, dispatch
run_goal	Execute a goal on a target URL you provide — observe, 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.
dispatch	Fuzzy-match a goal to a compiled skill: a hit replays, a miss compiles and caches it for next time.
list_skills	List the compiled skills available for replay.
list_catalog	Each compiled skill plus its run contract — params, the secrets it fills, and auth readiness on the host.
search_library	Semantically search the cross-tenant shared skill library by intent and host.
Async jobs
submit_run	Submit a goal as a background job; returns a job id immediately.
get_job	Poll an async job by id for status, success, steps and result.
cancel_job	Cancel a running async job by id — full credit refund.
Observation & data
observe_page	Serialize a page into token-efficient indexed DOM state without taking any action.
screenshot	Capture an authorized URL as PNG or JPEG — full page or one CSS selector. No action, no LLM cost.
extract	Read an authorized page and return structured JSON matching the fields or JSON schema you request.
search	Web search returning ranked results; set fetchContent to also fetch and clean the top results.
deep_search	Async deep search — search, then scrape the top results for cleaned content. Returns a job id.
map_site	Discover a site’s URLs from sitemap.xml, robots.txt and a shallow link scan. No page content.
submit_crawl	Crawl a whole site asynchronously, bounded by page/depth limits and path globs.
etl	Extract → transform → chunk → embed → load into the queryable content store.
etl_query	Semantic search over content ingested with etl; returns the top-k matching chunks.
Monitors
create_monitor	Watch a page on a schedule and push an HMAC-signed webhook when the watched value changes.
list_monitors	List this tenant’s monitors.
delete_monitor	Delete a monitor by id.
get_monitor_history	A monitor’s recent checks — changed, unchanged or error, plus value excerpts.
Sessions, credentials & human-in-the-loop
connect_account	Mint a one-time link a HUMAN opens to sign in by hand; the captured session is restored on later runs.
list_connections	Check whether the user finished a connect link — pending, active, connected, failed or expired.
list_accounts	List stored logins as masked { label, host, emailPreview } — never a credential.
control_run	Drive a paused run’s browser directly: click, type, press, scroll or navigate.
submit_verification	Resume a run waiting on a 2FA or approval wall with a code — or cancel it.
solve_captcha	Hand a live or paused session’s CAPTCHA to the solver and continue.
Recording
record_run	Run a goal and capture a video recording of the session.
record_job	Submit an async job that records its run to video.

Full argument schemas, credit costs and the resource/prompt surface are in the MCP setup guide.

Wire up any client

One config block, every MCP client.

Cursor, Claude Desktop and Cline take the JSON; Claude Code registers from the CLI. One variable — your key — and the tools appear by name.

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 is optional — it defaults to https://twin-browser.com.

claude-code.shbash

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

# Verify it connected:
claude mcp list
# → twin-browser: connected (31 tools)

tool-calls.jsoncjsonc

// run_goal — execute a named goal on a target you authorize
{ "tool": "run_goal", "arguments": {
    "target": "https://app.example.com",
    "goal": "login",
    "account": "work",
    "persistSession": true } }

// compile_skill — discover once, minimize into a deterministic skill
{ "tool": "compile_skill", "arguments": {
    "target": "https://app.example.com",
    "goal": "login",
    "name": "acme-login" } }

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

Read the setup guide REST API reference

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_goal 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. dispatch, list_skills, search_library and observe_page round out the core, out of 31 tools in total.

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

Wire it up in two minutes.

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

Read the setup guide All docs