--- # Empty frontmatter opts this file into Jekyll Liquid processing without # applying a layout. Required so {% include %} and {{ site.data.cli.* }} work. ---
← Tap · Blog

# Install Tap MCP in Claude Code, Cursor, Cline, Windsurf, or VS Code

April 22, 2026 · Leon Ting · 4 min read

Tap is an MCP server for authenticated browser automation — it runs in your own Chrome on your real logged-in sessions. This guide shows how to connect Tap to every major MCP host, in about 60 seconds each.

If you already have Tap installed, skip to your host below. Otherwise, install first:

    {{ site.data.cli.install.curl }}

## The MCP server entrypoint

Tap exposes its MCP surface via the single `{{ site.data.cli.mcp.stdio }}` entrypoint. Every supported host points its `mcpServers` map at the same command — copy the config block below into the relevant file for your host, then restart the host.

    {{ site.data.cli.mcp.stdio }}      # default; pipe stdin↔stdout to your MCP host
    {{ site.data.cli.mcp.http }}       # streamable-HTTP transport on {{ site.data.cli.mcp.default_bind }}:{{ site.data.cli.mcp.default_port }} (bearer auth)

The host config tables below show exactly which file to edit per MCP host.

## What actually gets written

Each host has its own config file with its own schema. Tap's adapter layer handles each correctly — you don't have to think about it, but here's what's happening under the hood for transparency.

### Claude Code

~/.claude.json · top-level `mcpServers` map

    {
      "mcpServers": {
        "tap": {
          "command": "npx",
          "args": ["-y", "@taprun/cli", "mcp", "stdio"]
        }
      }
    }

Ref: code.claude.com/docs/en/mcp.md

### Cursor

~/.cursor/mcp.json · same schema as Claude Code

Cursor uses the identical `mcpServers` map format. After registration, open Cursor's settings → MCP Servers to verify Tap appears.

Ref: docs.cursor.com/context/model-context-protocol

### Cline

<vscode-user-dir>/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Cline is a VS Code extension, so its config lives inside VS Code's extension storage (not alongside user settings). Same `mcpServers` schema. After registration, open Cline's settings panel in VS Code — Tap will show up under "MCP Servers".

Note: if you run Cline inside Cursor instead of VS Code, the config path moves to Cursor's user dir. Current auto-detect targets the VS Code path; for Cursor-resident Cline, edit the config file manually or file an issue.

Ref: github.com/cline/cline

### Windsurf

~/.codeium/windsurf/mcp_config.json · same schema as Claude Code

Windsurf is Codeium's MCP host. Config lives under `~/.codeium/windsurf/`, not `~/.windsurf/` — that path doesn't exist in any real install.

Ref: docs.windsurf.com/windsurf/cascade/mcp

### VS Code

<vscode-user-dir>/mcp.json · top-level `servers` (NOT `mcpServers`)

VS Code is the odd one out. It uses a top-level `servers` key and each entry requires a `type: "stdio"` field. Tap's adapter handles this automatically:

    {
      "servers": {
        "tap": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "@taprun/cli", "mcp", "stdio"]
        }
      }
    }

The user-data dir varies by OS: macOS `~/Library/Application Support/Code/User/`, Linux `~/.config/Code/User/`, Windows `%APPDATA%/Code/User/`.

Ref: code.visualstudio.com/docs/copilot/customization/mcp-servers

## Verifying the registration worked

After editing the config and restarting the host, ask your agent to call the `capture` meta tool with a preview-only argument:

    capture { url: "https://news.ycombinator.com" }

If it returns a `ToolResult` with `inspection.source_class` populated, the host can talk to Tap end-to-end. Silent config-present-but-server-broken is one of the most confusing MCP failures; this single round-trip rules it out.

## Troubleshooting

### "Host doesn't load the config file"

Make sure the host's config directory actually exists. If you've installed Claude Code / Cursor / etc. but never opened it, the config dir may not exist yet. Open the host once, create the file, then restart.

### "Registered but host doesn't see Tap"

Most hosts need a restart to pick up MCP config changes. Quit the host fully (Cmd+Q on macOS, not just close-window) and relaunch. VS Code specifically: the `mcp.json` file is read on workspace open, so reload your window.

### "Cline's config path isn't what I expected"

Cline stores its MCP config inside VS Code's extension global storage. If you've installed Cline in a VS Code fork (Cursor, VSCodium, etc.), its config path differs. The current auto-detect targets vanilla VS Code. For other forks, pass the config explicitly or file a request for the fork you need.

### "tap: command not found" during install

The installer adds `~/.tap/bin` to your PATH via your shell's rc file. Open a new terminal after install, or source your rc manually: `source ~/.zshrc` (or `~/.bashrc`).

## What to do next

Once connected, ask your MCP host to do something behind authentication. A few that work out of the box with the community tap library:

- "Show me my last 5 GitHub notifications"
- "Summarize my Twitter home timeline from this morning"
- "List HackerNews front page stories scoring over 100"

These taps already exist in the community pack and will run without any forging. To build a new one against a site you care about — your Shopify admin, your HubSpot, your internal dashboard — ask your host to forge one:

> "Use tap to forge a program that pulls my Shopify unfulfilled orders and returns them as a table."

Your host will call the `capture` meta verb with `{ url, intent, site, name }`, walk through the structural layers, and compile a deterministic program you can run forever. The program lives at `~/.tap/plans/shopify/unfulfilled-orders.plan.json` — inspectable, diffable, yours.

### Start here

    curl -fsSL https://taprun.dev/install.sh | bash
    tap mcp stdio           # point your MCP host at this command

Related reading:

- The authenticated browser MCP: why cloud tools can't see your logged-in state
- Programs beat prompts
- MCP authoring, zero-token execution