# Browserbase

> Hosted, isolated Chromium runtime for AI agents that need a fresh browser per task.

[Canonical HTML page](https://top-mcps.com/mcp/browserbase) · [server.json](https://top-mcps.com/mcp/browserbase.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "-y",
        "@browserbasehq/mcp"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
# export BROWSERBASE_API_KEY=YOUR_API_KEY
# export BROWSERBASE_PROJECT_ID=YOUR_PROJECT_ID
claude mcp add browserbase -- npx -y @browserbasehq/mcp
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "-y",
        "@browserbasehq/mcp"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "-y",
        "@browserbasehq/mcp"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "-y",
        "@browserbasehq/mcp"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "browserbase": {
      "command": "npx",
      "args": [
        "-y",
        "@browserbasehq/mcp"
      ],
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": [
            "-y",
            "@browserbasehq/mcp"
          ],
          "env": {
            "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
            "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
          }
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.browserbase]
command = "npx"
args = [
  "-y",
  "@browserbasehq/mcp",
]
env = { BROWSERBASE_API_KEY = "${BROWSERBASE_API_KEY}", BROWSERBASE_PROJECT_ID = "${BROWSERBASE_PROJECT_ID}" }
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "browserbase": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@browserbasehq/mcp"
        ]
      },
      "env": {
        "BROWSERBASE_API_KEY": "${BROWSERBASE_API_KEY}",
        "BROWSERBASE_PROJECT_ID": "${BROWSERBASE_PROJECT_ID}"
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Browserbase doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Browserbase
- **Transport:** stdio
- **Auth model:** API key
- **Required secrets:** BROWSERBASE_API_KEY, BROWSERBASE_PROJECT_ID
- **Supported clients:** Claude, Cursor, Any MCP-compatible client
- **License:** MIT
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-05-26
- **GitHub stars:** 3,356 (fetched 2026-05-26T10:50:22.679Z)
- **Score:** 89/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/browserbase/mcp-server-browserbase

## Security & scope

- **Access scope:** exec
- **Sandbox:** Each session runs in an isolated cloud container under your Browserbase account. The browser has internet access but no access to your local filesystem.
- **Gotchas:**
  - Captured screenshots and downloads live on Browserbase's side until you fetch them.
  - API key grants project-wide access; rotate if leaked.
  - Sessions left open accrue per-minute charges — always close.

## Quick answer

**What it does.** Provisions cloud Chromium sessions on demand. Exposes navigate, click, type, screenshot, and cookie-persistence tools, with optional Stagehand AI primitives on top.

**Best for:**
- Hosted browser sessions
- Concurrent automation at scale
- Anti-bot resilience
- Persistent sessions across runs
- Geo-located IPs

**Not for:**
- Offline workflows
- Hobbyist budgets
- Heavy data-out scenarios (egress cost)

## Description

Browserbase runs Chromium in the cloud and exposes it as an MCP server. Each session gets a fresh browser with residential IPs, anti-bot mitigations, and session persistence, so an agent can log into a site, complete a multi-step flow, and hand back results without spawning Chromium on your laptop.

## Why it matters

Local browser automation is fine for personal scripts but breaks under parallelism, anti-bot detection, and reliability requirements. Hosted browsers solve those at the cost of a per-minute meter.

## Key features

- Cloud Chromium per session
- Residential IPs
- Session replay
- Stagehand AI primitives
- Concurrent sessions
- API + MCP

## FAQ

### Does it cost more than running Chromium locally?

Yes — Browserbase charges per browser-minute. The trade is reliability, parallelism, and IP diversity. For a few sessions a day, local Puppeteer is cheaper. For dozens of concurrent agents, hosted is usually less hassle.

### Can sessions persist across runs?

Yes. The MCP exposes session IDs that survive between tool calls and across MCP restarts. Useful for "log in once, run multiple workflows" patterns where you do not want to re-auth every time.

### How does it compare to Stagehand?

Stagehand is a higher-level layer that adds AI primitives (`act`, `observe`, `extract`) on top of Browserbase. If you want natural-language browser commands, install the Stagehand MCP; if you want raw Playwright-style control, the Browserbase MCP is enough.

## Changelog

- **2026-05-26** — Refreshed install snippets and fact sheet; verified for 2026.
- **2024-11-30** — Initial directory listing.
