MCP Servers for Chrome and Playwright Integration: 9 Essential Browser Automation Tools

Model Context Protocol (MCP) servers for Chrome and Playwright expose standardized JSON-RPC interfaces that let LLMs control browsers via Chrome DevTools Protocol (CDP) or Playwright APIs, eliminating the need for API keys or custom SDKs.

The punkpeye/awesome-mcp-servers repository curates production-ready MCP servers for Chrome and Playwright integration. These servers bridge the gap between LLM agents and browser engines, translating natural language requests into precise automation commands—from simple DOM clicks to full session replays.

Chrome DevTools Protocol (CDP) MCP Servers

Servers in this category communicate directly with Chrome's DevTools Protocol, offering low-level control over Chromium-based browsers without requiring the Playwright runtime.

opentabs-dev/opentabs

opentabs-dev/opentabs converts a user's authenticated Chrome session into an MCP server through a browser extension. According to the repository's README.md at line 208, this server exposes over 100 plugins via a simple HTTP endpoint, inheriting existing cookies, extensions, and login states from the user's real browser session.

andresolbach/nodriver-mcp-server

andresolbach/nodriver-mcp-server provides a pure-Python implementation that talks directly to Chrome's CDP without requiring a ChromeDriver binary. As documented in README.md at line 417, this server deliberately keeps navigator.webdriver undefined to support stealth-mode automation, while offering tools for network inspection, device emulation, and session persistence.

dashi96/chromium-bridge

dashi96/chromium-bridge functions as an MCP-to-Chrome extension bridge compatible with Chromium derivatives including Arc, Vivaldi, and Brave. The entry at line 436 in README.md notes that it exposes navigation, click simulation, JavaScript evaluation, and GIF capture tools through a unified MCP schema.

Cubenest/rrweb-stack

Cubenest/rrweb-stack offers a local-first recording solution that captures DOM mutations, console logs, and network traffic using rrweb. Per line 434 of README.md, agents can query or drive recorded sessions offline without cloud telemetry, making it ideal for debugging complex user flows.

Playwright MCP Servers

These servers wrap the Playwright library, supporting Chromium, Firefox, and WebKit through a unified API.

microsoft/playwright-mcp

microsoft/playwright-mcp is the official Microsoft implementation. Listed at line 465 in README.md, this server launches headless Playwright browsers, captures accessibility snapshots, and exposes the complete Playwright API as MCP-compatible tools.

automatalabs/mcp-server-playwright

automatalabs/mcp-server-playwright provides a Python-based wrapper around Playwright for web scraping and automation. The repository entry at line 421 describes tools including launch, navigate, click, and screenshot, accessible via HTTP JSON-RPC endpoints.

ViperJuice/mcp-gateway

ViperJuice/mcp-gateway operates as a meta-server that auto-provisions Playwright instances on demand. According to line 232 of README.md, this Docker-based solution dynamically spins up to 25+ MCP servers from a manifest, enabling plug-and-play browser automation without local Playwright installation.

executeautomation/mcp-playwright

executeautomation/mcp-playwright specializes in headless capture and full-page screenshot generation. Referenced at line 439, this server exposes standard Playwright primitives like page.goto and page.screenshot through the MCP interface.

aybelatchane/mcp-server-terminal

aybelatchane/mcp-server-terminal brings Playwright-style interaction patterns to terminal environments using Rust. As noted at line 654 of README.md, it exposes a structured "Terminal State Tree" that agents manipulate like a UI element hierarchy, treating terminal output as a browsable DOM.

Architecture and Implementation Details

Understanding how these MCP servers interface with browsers helps developers select the appropriate integration strategy.

MCP Transport Layer

Every server implements three canonical JSON-RPC methods defined in the MCP specification:

1. list – Enumerates available automation tools (e.g., chrome.click, playwright.screenshot)
2. get – Retrieves JSON schemas for specific tool parameters
3. call – Executes the requested tool with provided arguments

Browser Backend Differences

CDP-based servers (like nodriver-mcp-server) open local DevTools sessions via chrome://inspect and forward raw CDP commands such as Runtime.evaluate or DOM.enable. These servers excel at stealth automation because they bypass the navigator.webdriver flag detection.

Playwright-based servers (like microsoft/playwright-mcp) initialize Playwright processes using playwright.chromium.launch(), then translate MCP calls into high-level Playwright API invocations. These offer superior cross-browser support (Firefox, WebKit) and built-in waiting strategies.

Security and Session Context

Servers running inside the user's actual browser (e.g., opentabs, rrweb-stack) inherit existing authentication states, eliminating the need for credential management. Conversely, undetected CDP servers (e.g., nodriver-mcp-server) specifically mask automation fingerprints to evade anti-bot defenses while maintaining session persistence across requests.

Usage Examples

Calling Chrome Automation via curl

curl -X POST https://your-mcp-server.example.com/call \
  -H 'Content-Type: application/json' \
  -d '{
        "method": "call",
        "params": {
          "tool": "chrome.click",
          "args": { "selector": "#submit-button" }
        },
        "id": 1
      }'

Using the Official Playwright MCP Server

Install and query the Microsoft Playwright MCP server using npx:

# Install the server (once)

npx -y @playwright/mcp

# List available tools

curl http://localhost:8000/tools/list

# Launch a browser and navigate

curl -X POST http://localhost:8000/call \
  -d '{"method":"call","params":{"tool":"playwright.launch","args":{"headless":false}},"id":1}'

curl -X POST http://localhost:8000/call \
  -d '{"method":"call","params":{"tool":"playwright.goto","args":{"url":"https://example.com"}},"id":2}'

Python Client for nodriver-mcp-server

import json
import requests

url = "http://localhost:5000/call"
payload = {
    "method": "call",
    "params": {
        "tool": "chrome.evaluate",
        "args": {"expression": "document.title"}
    },
    "id": 1,
}
resp = requests.post(url, json=payload)
print(resp.json()["result"])   # => page title

Summary

• MCP servers for Chrome and Playwright provide standardized JSON-RPC interfaces that eliminate the need for custom browser automation SDKs or API keys.
• CDP-based servers (opentabs, nodriver-mcp-server, chromium-bridge) offer low-level Chrome control and stealth capabilities by interfacing directly with DevTools Protocol.
• Playwright-based servers (microsoft/playwright-mcp, automatalabs/mcp-server-playwright) provide cross-browser support and high-level abstractions for reliable automation.
• Installation patterns range from browser extensions (opentabs) to Docker containers (mcp-gateway) to Python packages (nodriver-mcp-server).
• Source references for all servers appear in README.md lines 208 through 470 of the punkpeye/awesome-mcp-servers repository.

Frequently Asked Questions

What is the difference between CDP-based and Playwright-based MCP servers?

CDP-based servers communicate directly with Chrome's DevTools Protocol, offering granular control over browser internals and the ability to mask automation detection by keeping navigator.webdriver undefined. Playwright-based servers utilize the Playwright library's high-level API, providing robust cross-browser support (Chromium, Firefox, WebKit) and automatic waiting strategies, but they typically run browsers in isolated contexts rather than attaching to existing user sessions.

How do MCP servers handle browser authentication and cookies?

Servers like opentabs-dev/opentabs and Cubenest/rrweb-stack operate as browser extensions within the user's actual Chrome profile, automatically inheriting cookies, localStorage, and authenticated sessions. Standalone servers (microsoft/playwright-mcp, nodriver-mcp-server) launch fresh browser instances and require explicit cookie injection or authentication steps unless configured to use persistent user data directories.

Can MCP servers bypass bot detection systems?

Certain implementations specifically target anti-bot evasion. The andresolbach/nodriver-mcp-server (line 417 in README.md) maintains stealth by avoiding ChromeDriver binaries and suppressing the navigator.webdriver flag. However, bypass capabilities depend on the specific server's implementation—standard Playwright servers may trigger detection without additional stealth configurations like proxy rotation or fingerprint randomization.

How do I choose between the official Microsoft Playwright MCP and third-party alternatives?

Select microsoft/playwright-mcp (line 465) for production stability, official support, and accessibility snapshot features when running headless automation. Choose automatalabs/mcp-server-playwright (line 421) for lightweight Python-based deployments, or ViperJuice/mcp-gateway (line 232) when you need containerized, on-demand browser provisioning without local Playwright installation. For authenticated session automation, prefer CDP-based alternatives like opentabs or chromium-bridge.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}