Which integrations are available for this server?

Provides browser automation capabilities for Google Chrome, enabling control of tabs, navigation, clicks, form filling, and checkpoint captures through a shared Chrome instance with multi-agent tab isolation.

How do I use ultimate-playwright-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ultimate-playwright-mcp open a new tab and navigate to example.com" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

ultimate-playwright-mcp

by pm990320

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

Ultimate Playwright MCP

Multi-agent Playwright MCP server with tab isolation via targetId. Allows multiple Claude instances (or other MCP clients) to share a single Chrome browser while maintaining isolated tab groups.

Why Ultimate Playwright?

The official @playwright/mcp gives you browser control for a single agent. But what if you have multiple agents sharing one browser?

Ultimate Playwright MCP solves this with tab group isolation:

🔀 Multi-agent tab groups — Each agent creates a groupId and only sees its own tabs
🍪 Shared cookies & sessions — All agents share the same BrowserContext (log in once, everyone's authenticated)
🎨 Visual Chrome tab groups — Companion extension organizes tabs into color-coded Chrome tab groups
💾 Persistent registry — Tab groups survive MCP server restarts (~/.ultimate-playwright-mcp/tab-groups.json)
🔌 Connect to existing Chrome — Uses CDP to attach to your running Chrome (keeps your profile, extensions, bookmarks)

Comparison

Feature	ultimate-playwright-mcp	@playwright/mcp	browser-use-mcp
Multi-agent tab isolation	✅ Tab groups with `groupId`	❌ Single session	❌ Single session
Shared cookies across agents	✅ Same BrowserContext	N/A	N/A
Connect to existing Chrome	✅ CDP	❌ Launches new browser	❌ Launches new browser
Visual tab groups in Chrome	✅ Extension	❌	❌
Persistent tab registry	✅ Survives restarts	❌	❌
Accessibility tree snapshots	✅ Element refs (e1, e2…)	✅	❌ Screenshot-based
Open source	✅ MIT	✅ Apache-2.0	✅ MIT

Related MCP server: playwright-mcp-orchestrator

Features

✅ Tab Isolation - Each agent gets its own tabs via unique targetId
✅ Shared Cookies - All agents share the same BrowserContext (cookies, sessions, localStorage)
✅ Parallel Execution - Multiple agents can operate simultaneously without interference
✅ CDP Connection - Connects to existing Chrome via Chrome DevTools Protocol
✅ Native Page Checkpoints - Capture structured artifacts and generate reports per targetId
✅ Battle-Tested - Extracted from OpenClaw (MIT licensed)

Installation

npm install -g ultimate-playwright-mcp

Or run directly with npx:

npx ultimate-playwright-mcp --cdp-endpoint http://localhost:9222

Quick Start

1. Launch Chrome with Remote Debugging

# macOS
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
  --remote-debugging-port=9222 \
  --user-data-dir=/tmp/chrome-debug

# Linux
google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug

# Windows
"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" ^
  --remote-debugging-port=9222 ^
  --user-data-dir=C:\\temp\\chrome-debug

2. Configure Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "ultimate-playwright": {
      "command": "npx",
      "args": [
        "ultimate-playwright-mcp",
        "--cdp-endpoint",
        "http://localhost:9222"
      ]
    }
  }
}

3. Restart Claude Desktop

Claude will now have access to browser control tools with tab isolation.

Usage Example

User: Open two tabs and navigate them independently

Claude: I'll create two tabs with separate targetIds:

1. browser_tabs({ action: "new" })
   → **targetId: ABC123...**

2. browser_tabs({ action: "new" })
   → **targetId: XYZ789...**

3. browser_navigate({ targetId: "ABC123...", url: "https://github.com" })
4. browser_navigate({ targetId: "XYZ789...", url: "https://google.com" })

Both tabs are now navigated independently!

Available Tools

Tool	Description	Key Parameters
`browser_tab_group`	Create/list/delete tab groups for isolation	`action`, `name`, `color`, `groupId`
`browser_tabs`	List, create, close, or select tabs	`action`, `groupId`, `targetId`, `index`
`browser_navigate`	Navigate to a URL	`url`, `targetId`
`browser_snapshot`	Capture accessibility tree with refs	`targetId`
`browser_click`	Click an element	`ref`, `targetId`
`browser_type`	Type text into an element	`ref`, `text`, `targetId`
`browser_hover`	Hover over an element	`ref`, `targetId`
`browser_press_key`	Press a keyboard key	`key`, `targetId`
`browser_fill_form`	Fill multiple form fields	`fields`, `targetId`
`browser_wait_for`	Wait for conditions	`text`, `selector`, `url`, `loadState`, `targetId`
`browser_checkpoint`	Capture a structured checkpoint for a tab	`name`, `targetId`, `collectors`
`browser_checkpoint_report`	Generate reports from stored checkpoints	`format`, `resultsDir`

Checkpoints

Use browser_checkpoint when you want a persisted capture of the current page for later review or report generation.

Checkpoints are scoped to the resolved targetId, so they work with this server's tab isolation model.
Artifacts and manifests are written under ~/.ultimate-playwright-mcp/checkpoints by default.
Generated reports are written under ~/.ultimate-playwright-mcp/checkpoints/report.

Example:

1. browser_checkpoint({ targetId: "ABC123", name: "after-login" })
2. browser_checkpoint_report({ format: "html" })

Tab Groups (Multi-User Isolation)

When multiple users or agents share one browser instance, tab groups keep everyone's tabs isolated. Each session creates its own group, and all tab operations are scoped to that group.

User: Research product pricing

Claude: I'll create a tab group first, then open tabs within it.

1. browser_tab_group({ action: "create", name: "pricing-research", color: "blue" })
   → **groupId: g_a1b2c3d4e5f6**

2. browser_tabs({ action: "new", groupId: "g_a1b2c3d4e5f6", url: "https://example.com/pricing" })
   → **targetId: ABC123...**

3. browser_tabs({ action: "list", groupId: "g_a1b2c3d4e5f6" })
   → Only shows tabs in this group (not other users' tabs)

Meanwhile, another user on the same server:

1. browser_tab_group({ action: "create", name: "docs-review", color: "green" })
   → **groupId: g_x9y8z7w6v5u4**

2. browser_tabs({ action: "new", groupId: "g_x9y8z7w6v5u4", url: "https://docs.example.com" })
   → **targetId: XYZ789...**

Both users share the same cookies/sessions but only see their own tabs!

Tab Group Lifecycle

Create a group at the start of your session
Open tabs within the group using groupId
Work with tabs using targetId as before
Delete the group when done (optionally closes all tabs)

Group state is persisted to ~/.ultimate-playwright-mcp/tab-groups.json so it survives MCP server restarts.

Architecture

┌─────────────────────────────────────────────┐
│        Single Chrome Process                │
│    (--remote-debugging-port=9222)           │
│  ┌─────────────────────────────────────┐   │
│  │     Single BrowserContext            │   │
│  │  (shared cookies, storage)           │   │
│  │                                      │   │
│  │  Group: alice (blue)                 │   │
│  │  ┌─────┐ ┌─────┐                    │   │
│  │  │ Tab │ │ Tab │                    │   │
│  │  │  A  │ │  B  │                    │   │
│  │  └─────┘ └─────┘                    │   │
│  │                                      │   │
│  │  Group: bob (green)                  │   │
│  │  ┌─────┐ ┌─────┐ ┌─────┐            │   │
│  │  │ Tab │ │ Tab │ │ Tab │            │   │
│  │  │  C  │ │  D  │ │  E  │            │   │
│  │  └─────┘ └─────┘ └─────┘            │   │
│  └─────────────────────────────────────┘   │
└─────────────────────────────────────────────┘
                   ↑
           CDP Connection
                   ↓
┌─────────────────────────────────────────────┐
│    ultimate-playwright-mcp (MCP Server)     │
│    - Tab routing via targetId               │
│    - Tab groups via groupId                 │
│    - Shared ownership registry (JSON file)  │
│    - Stdio transport                        │
└─────────────────────────────────────────────┘
         ↓           ↓           ↓
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ Alice   │ │  Bob    │ │ Charlie │
   │ (Claude)│ │ (Claude)│ │ (Cursor)│
   └─────────┘ └─────────┘ └─────────┘

MCP Configuration

Cursor / Windsurf / Generic MCP Client

{
  "mcpServers": {
    "ultimate-playwright": {
      "command": "npx",
      "args": ["ultimate-playwright-mcp", "--cdp-endpoint", "http://localhost:9222"]
    }
  }
}

With Environment Variable

{
  "mcpServers": {
    "ultimate-playwright": {
      "command": "npx",
      "args": ["ultimate-playwright-mcp"],
      "env": {
        "CDP_ENDPOINT": "http://localhost:9222"
      }
    }
  }
}

CLI Options

ultimate-playwright-mcp [options]

Options:
  --cdp-endpoint <url>  CDP endpoint URL (e.g., http://localhost:9222)
                        Can also use CDP_ENDPOINT env var.
                        If omitted, daemon-managed Chrome is started lazily on first tool call.
  --agent-id <id>       Optional agent ID for logging/debugging
                        Can also use AGENT_ID env var
  --keep-alive          Auto-restart daemon-managed Chrome if it exits
                        Use --no-keep-alive for testing workflows where you want Chrome to stay down after kill
                        Default: disabled (no auto-restart)
                        Can also use KEEP_ALIVE env var (set to "false" to disable)
  --checkpoint-output-dir <path>
                        Root directory for checkpoint manifests, artifacts, and reports
                        Can also use CHECKPOINT_OUTPUT_DIR env var
  -V, --version         Output version number
  -h, --help            Display help

Multi-Agent Setup

Running Multiple Claude Code Instances

Each instance connects to the same MCP server and gets isolated tabs:

Terminal 1:

claude-code --mcp-config ./mcp-config.json
# Agent A creates tabs with targetIds starting from ABC...

Terminal 2:

claude-code --mcp-config ./mcp-config.json
# Agent B creates tabs with targetIds starting from XYZ...

Both agents share cookies and sessions but operate on different tabs!

Persistent Chrome Setup (macOS)

For a Chrome instance that auto-starts with debug port:

Create ~/Library/LaunchAgents/com.user.chrome-debug.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.chrome-debug</string>
    <key>ProgramArguments</key>
    <array>
        <string>/Applications/Google Chrome.app/Contents/MacOS/Google Chrome</string>
        <string>--remote-debugging-port=9222</string>
        <string>--user-data-dir=/Users/YOUR_USERNAME/chrome-debug-profile</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>

Load with:

launchctl load ~/Library/LaunchAgents/com.user.chrome-debug.plist

Development

# Install dependencies
npm install

# Build
npm run build

# Type check
npm run type-check

# Lint
npm run lint

# Watch mode
npm run watch

License

MIT

Attribution

This project extracts browser control code from OpenClaw (MIT licensed), which provides battle-tested tab isolation and Playwright integration.

Key extracted components:

CDP session management (pw-session.ts)
Browser operations (pw-tools-*.ts)
Role-based element refs (pw-role-snapshot.ts)

Available Tools

14 tools

browser_checkpointC

Capture a structured checkpoint for the current page or a specific tab. Stores checkpoint artifacts and a manifest under the server-managed checkpoint directory.

Inputs: name (required), targetId, description, highlightSelector, +2 more.

browser_checkpoint_reportA

Generate an HTML, Markdown, or MDX report from stored MCP checkpoint manifests.

Inputs: format, resultsDir.

browser_clickB

Click an element by its ref (e1, e2, etc. from snapshot)

Inputs: ref (required), targetId, button, doubleClick.

browser_evaluateA

Execute JavaScript in the page context via Playwright's page.evaluate(). Use for interacting with elements not in the accessibility snapshot (portal divs, framework overlays, shadow DOM). Can run arbitrary JS — click hidden elements, extract data, manipulate the DOM. Optionally scope to a specific element via ref.

Inputs: expression (required), ref, targetId.

browser_fill_formA

Fill multiple form fields at once

Inputs: fields (required), targetId.

browser_hoverC

Hover over an element

Inputs: ref (required), targetId.

browser_navigateA

Navigate to a URL in a specific tab. Use targetId from browser_tabs to specify which tab.

Inputs: url (required), targetId.

browser_press_keyC

Press a keyboard key

Inputs: key (required), targetId.

browser_screenshotA

Take a screenshot of the current page or a specific element. By default saves to file and returns the path (saves context window tokens). Use ref to screenshot a specific element (from snapshot refs like e1, e2), or element for a CSS selector. Omit both for a full page screenshot.

Inputs: targetId, ref, element, fullPage, +5 more.

browser_snapshotA

Capture accessibility tree snapshot of the current page. Returns element references (e1, e2, etc.) that can be used with other browser tools like click, type, etc.

Inputs: targetId, maxChars, compact, interactive, +1 more.

browser_tab_groupA

Manage tab groups for session isolation. Multiple users/agents sharing one browser MUST create a tab group first, then pass the groupId to browser_tabs and other tools. This ensures each session only sees and controls its own tabs.

Actions:

'create': Create a new tab group. Returns a groupId to use with all other browser tools.
'list': List all tab groups with tab counts.
'delete': Delete a tab group and optionally close its tabs.

⚡ IMPORTANT: Always create a tab group before opening tabs with browser_tabs.

Inputs: action (required), name, color, groupId, +1 more.

browser_tabsA

Manage browser tabs. When using tab groups (recommended for multi-user), pass groupId to scope operations to your group's tabs only.

Actions:

'list': Show tabs. With groupId → only your group's tabs. Without → all tabs.
'new': Create a tab. If groupId is provided, the tab is added to that group.
'close': Close a tab by index or targetId.
'select': Focus a tab by index or targetId.

⚡ IMPORTANT: Create a tab group first for multi-user isolation. Ungrouped tabs remain available as a fallback for local manual testing.

Inputs: action (required), groupId, url, index, +1 more.

browser_typeC

Type text into an element

Inputs: ref (required), text (required), targetId, submit.

browser_wait_forB

Wait for a condition (text, selector, load state, time, etc.)

Inputs: text, textGone, selector, url, +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.7/5.0

Scored 2026-05-28 02:45 across 14 tools

Disambiguation5/5

Each tool serves a distinct browser automation action (e.g., click, type, navigate, snapshot). Potential overlaps like browser_click vs. browser_hover are clearly differentiated by operation type, and browser_evaluate handles cases outside the snapshot tree.

Naming Consistency5/5

All tools follow a consistent 'browser_verb_noun' pattern using snake_case. For example, browser_click, browser_navigate, browser_tab_group. No mixing of conventions.

Tool Count5/5

With 14 tools, the server covers core browser automation tasks without being bloated. The count feels well-scoped for its purpose.

Completeness4/5

The tool set covers essential browser actions (navigation, interaction, snapshot, screenshots, tabs, checkpoints). Minor gaps exist, such as no explicit scroll or file upload, but these are advanced and not critical for most automation workflows.

Maintenance

ActivityInactive

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

Browserless
io.browserless
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Browser Automation Web Scraping Agent Orchestration
119
https://mcp.browserless.io/mcp
Web Crawler MCP by InsightfulPipeB
com.insightfulpipe
Hosted Web Crawler MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Browser Automation Web Scraping
71
https://crawler.insightfulmcp.com/
Irmu — Web Data MCP
io.github.polgoide
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
Browser Automation Web Scraping Agent Orchestration
1
https://app.irmu.com/mcp
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
https://api.anotherai.dev/mcp

Related MCP Servers

browser-devtools-mcp
Browser Automation Developer Tools Observability
serkan-ozal
A
license
Not graded
quality
Not graded
maintenance
A Playwright-based MCP server that exposes a live browser as a traceable, inspectable, debuggable and controllable execution environment for AI agents.
Updated 10 months ago (2026-01-27 17:50 UTC)
5,213 npm
57
-
playwright-mcp-orchestrator
Browser Automation Agent Orchestration Developer Tools
mediar-ai
A
license
Not graded
quality
D
maintenance
A multi-agent orchestrator that enables multiple AI agents to share a single Chrome browser instance with tab isolation and shared state. It preserves local browser data like cookies and logins while allowing concurrent agent sessions through the official Playwright MCP.
Updated 8 months ago (2026-03-14 23:29 UTC)
10
MIT
arc-devtools-mcp
Browser Automation Developer Tools
gabrielbryk
A
license
Not graded
quality
D
maintenance
MCP server enabling AI agents to control and inspect Chrome/Arc browsers via DevTools, with Arc-specific tab reuse.
Updated 3 months ago (2026-08-09 00:05 UTC)
12 npm
1
Apache 2.0
concurrent-playwright-mcp
Browser Automation Agent Orchestration
dgutierrez1
A
license
A
quality
C
maintenance
An MCP server that runs concurrent, session-isolated Playwright browser contexts, so many agents can each drive their own browser at the same time without colliding.
Updated 5 months ago (2026-06-28 18:27 UTC)
23
11 npm
5
MIT

Ultimate Playwright MCP

Why Ultimate Playwright?

Comparison

Features

Installation

Quick Start

1. Launch Chrome with Remote Debugging

2. Configure Claude Desktop

3. Restart Claude Desktop

Usage Example

Available Tools

Checkpoints

Tab Groups (Multi-User Isolation)

Tab Group Lifecycle

Architecture

MCP Configuration

Cursor / Windsurf / Generic MCP Client

With Environment Variable

CLI Options

Multi-Agent Setup

Running Multiple Claude Code Instances

Persistent Chrome Setup (macOS)

Development

License

Attribution

Links

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

browser-devtools-mcp

playwright-mcp-orchestrator

arc-devtools-mcp

concurrent-playwright-mcp