public-browser

# <img src="https://raw.githubusercontent.com/Silbercue/public-browser/master/.github/assets/logo-400.png" width="30" alt=""> Public Browser

[![GitHub Release](https://img.shields.io/github/v/release/Silbercue/public-browser)](https://github.com/Silbercue/public-browser/releases)
[![npm version](https://img.shields.io/npm/v/public-browser)](https://www.npmjs.com/package/public-browser)
[![Tool definitions < 5k tokens](https://img.shields.io/badge/tool_definitions-%3C5k_tokens-brightgreen)](#why-an-mcp-server-and-not-a-cli)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Node >= 18](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)

Lets Claude Code and Cursor drive Chrome — with your real, logged-in profile. On the same 30-test benchmark page it used **30% fewer tokens, 25% less money, 41% fewer tool calls and 40% less time** than Playwright MCP at the same pass rate — two runs each, 2026-09-03, driver Claude Opus 5, raw data in the repo ([Benchmarks](#benchmarks), including where it loses). Its own tool definitions are **34% smaller since v2.10.4** (7,607 → 4,990 tokens, reproduce with `node scripts/token-count.mjs`). Direct CDP, a11y-tree refs, multi-tab ready — 2,360 TypeScript tests, 237 Python tests.

Built for [Claude Code](https://claude.ai/claude-code), [Cursor](https://cursor.sh), and any MCP-compatible client.

> **Looking for an alternative to Playwright MCP, Browser MCP, or claude-in-chrome?** Public Browser talks to Chrome directly via the DevTools Protocol — no Playwright dependency, no Chrome extension bridge, no single-tab limit. One command to install, zero config. [See benchmark comparison below](#benchmarks).

## Why Public Browser?

Every Chrome MCP server has the same problem: **bulky responses, too few reliable refs.** Screenshots return 10-30x more context payload than text trees. Selector-based refs break the second the DOM rerenders. Extension bridges (Browser MCP) get stuck on the connected tab. Playwright wrappers spin up a new browser instance for every session.

Public Browser fixes this. It talks directly to Chrome via CDP (same protocol Playwright and Puppeteer use internally), returns an accessibility-tree-based reference map, and caches it across calls so `click(ref: 'e5')` and `type(ref: 'e7', ...)` survive scrolls and DOM updates.

Benchmark rows below are **April 2026, 35-test suite, Opus 4.6** unless a cell also gives a September value. Cells marked *Sep* come from the blind September 2026 re-run (35-test page, 30 scored, driver `claude-opus-5`, two runs per required server; one browser-use run) — run files `public-browser-run1/2.json`, `playwright-mcp-run5/6.json`, `chrome-devtools-mcp-run3/4.json`, `browser-use-run6.json` in [`test-hardest/results/`](test-hardest/results). Cross-suite comparison is not valid; see [Benchmarks](#benchmarks).

| What you get | Playwright MCP | Browser MCP | claude-in-chrome | browser-use | **Public Browser** |
|---|---|---|---|---|---|
| Benchmark pass rate (Apr 2026: 31 scored / *Sep 2026: 30 scored*) | 29/31 (563s)<br>*Sep: 30/30 (468s, 493s)* | **6/31, aborted**<br>*Sep: not re-run* | (24-test suite only) | 21/31 (1870s)<br>*Sep: 24/30, incomplete run (2023s)* | **30/31 (598s)**<br>*Sep: 30/30 (281s, 296s)* |
| Session tokens, whole run (*Sep 2026 only*) | *Sep: 8.8M, 9.6M* | — | — | *Sep: 56.2M, incomplete run* | ***Sep: 6.3M, 6.5M** (−30%)* |
| Cost per run, Opus 5 list price (*Sep 2026 only*) | *Sep: $4.28, $4.78* | — | — | *Sep: $25.25, incomplete run* | ***Sep: $3.41, $3.35** (−25%)* |
| Avg Tool-Response (Chars) | 1,448<br>*Sep: 740, 656* | — | — | — | 807<br>*Sep: 1,298, 1,214* |
| P95 Tool-Response (Chars) | 8,068<br>*Sep: 3,617, 1,587* | — | — | — | 2,328<br>*Sep: 6,077, 6,479* |
| `view_page` avg (Chars) | 6,084 (`browser_snapshot`)<br>*Sep: 1,911, 2,269* | — | — | — | 1,124<br>*Sep: 2,841, 3,398* |
| Multi-tab support | Yes | **No (single tab)** | Yes | Partial | **Yes** |
| Connection | New browser | Extension bridge | Extension | Subprocess | **Direct CDP (pipe or WebSocket)** |
| Ref system | Playwright refs | Playwright refs | CSS selectors | Screenshots | **A11y-tree refs (stable across DOM changes)** |
| Drag & drop | Yes | No | Partial | No | **Yes (native CDP mouse events)** |
| Shadow DOM + iframe | Yes | Yes | Partial | No | **Yes (with OOPIF session support)** |
| Multi-step plan execution | — | — | — | — | **`run_plan` — server-side plan executor with variables, conditions, suspend/resume** |

<sub>P95 is not computed the same way in both rows: the April values are the largest per-tool P95 (`by_tool[].p95_chars`, jq index `floor((n-1)·0.95)`), the September values are a nearest-rank P95 over all MCP calls of a run. Do not read the April and *Sep* P95 numbers as one series.</sub>

**What changed since April.** In April 2026 Public Browser's page views were 5.4x smaller than Playwright MCP's; Playwright MCP 0.0.80 has since made its snapshot format much more compact, so in the September runs its individual responses are smaller than ours (Ø 740 and 656 chars against 1,298 and 1,214) and the tool-response payload summed over a whole run is roughly a tie (109,075 / 104,432 chars against 101,478 / 99,147) — "smallest responses" is no longer a claim we can make. What the model actually consumed over the whole session is a different story: 6.3M and 6.5M tokens against 8.8M and 9.6M (~30% fewer), $3.41 and $3.35 against $4.28 and $4.78 at Opus 5 list price (~25% less). That gap comes from the second thing left standing: ~41% fewer tool calls (84 and 86 against 137 and 151) and ~40% less time to finish (281s and 296s against 468s and 493s, page timer; 34% on the full wall clock, 331s and 346s against 501s and 527s) at the same reliability, 30/30 in each of those four runs. Every call re-reads the whole conversation so far, so fewer calls means fewer re-reads — that is where the token and cost gap comes from, not from smaller responses. The advantage moved from "cheaper per look" to "cheaper per task", and the headline was changed accordingly.

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Silbercue/public-browser/master/.github/assets/benchmark-2026-09-dark.svg">
  <img alt="September 2026 benchmark, 35-test page, 30 scored, driver model claude-opus-5. Each bar is Public Browser as a share of Playwright MCP 0.0.80 on the same metric; the vertical line is Playwright at 100 percent and shorter is better. Session tokens over the whole run: 6.3 and 6.5 million against 8.8 and 9.6 million, 30 percent fewer. Cost per run at list price: 3.41 and 3.35 dollars against 4.28 and 4.78, 25 percent less. Tool calls: 84 and 86 against 137 and 151, 41 percent fewer. Time to finish: 281 and 296 seconds against 468 and 493, 40 percent less. Average response size: 1,298 and 1,214 chars against 740 and 656, 80 percent larger — Public Browser loses this one. Total response volume: 109k and 104k chars against 101k and 99k, 6 percent more. Pass rate is a tie at 30 of 30 in all four runs." src="https://raw.githubusercontent.com/Silbercue/public-browser/master/.github/assets/benchmark-2026-09-light.svg" width="880">
</picture>

September 2026 data, both runs per server, against Playwright MCP 0.0.80. Rows where the bar runs past the line are rows Public Browser loses. Method and the full table: [Benchmarks](#september-2026-current).

## Quick Start

### Install in Claude Code

One command — installs globally for all projects:

```bash
claude mcp add --scope user public-browser npx -y public-browser@latest
```

**Important:** after `claude mcp add` you must **fully quit and reopen Claude Code**. `/mcp reconnect` is not enough — Claude Code reads the `mcpServers` config only at session start and caches it. After the restart, the first tool call auto-launches Chrome **visible** (no headless, no port setup). Done.

> To enable parallel Python [Script API](#script-api-python) access, add `--script` to the args:
> `claude mcp add --scope user public-browser npx -y public-browser@latest -- --script`

### Install in Cursor

Add to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "public-browser": {
      "command": "npx",
      "args": ["-y", "public-browser@latest"]
    }
  }
}
```

> For parallel Python [Script API](#script-api-python) access, use `"args": ["-y", "public-browser@latest", "--", "--script"]`

### Install in Cline

Add to your `cline_mcp_settings.json`:

```json
{
  "mcpServers": {
    "public-browser": {
      "command": "npx",
      "args": ["-y", "public-browser@latest"]
    }
  }
}
```

### Install in other MCP clients

Any client that supports stdio MCP servers: `npx -y public-browser@latest` with no arguments.

### Try it — your first prompt

After installing, paste this into your AI coding assistant:

> Open mcp-test.second-truth.com, read the page, and fill the contact form with Name "Test User" and Email "test@example.com".

This exercises three core tools in sequence: `navigate` loads the page, `view_page` reads the accessibility tree with stable element refs, and `fill_form` fills multiple fields in one call. You should see Chrome open, the page load, and the form filled — all without writing a single line of code.

### Uninstall

```bash
claude mcp remove --scope user public-browser
```

## Chrome Profiles

By default, Public Browser starts Chrome with a fresh temp profile — no cookies, no logins, no extensions. For tasks like research on sites that block anonymous visitors, you can launch Chrome with your real profile instead.

### List available profiles

```bash
npx public-browser profiles
```

### Launch with a profile

Three ways — pick whichever fits your setup:

```bash
# CLI flag
npx public-browser --profile "Julian"

# Environment variable
PUBLIC_BROWSER_PROFILE="Julian" npx public-browser

# MCP tool (call BEFORE any browser interaction)
configure_session({ profile: "Julian" })
```

When using a rea