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

> Discover 9 essential MCP servers for Chrome and Playwright integration. Control browsers with LLMs via JSON-RPC, no API keys needed. Automate tasks easily.

- Repository: [Frank Fiegel/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- Tags: getting-started
- Published: 2026-09-02

---

**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](https://github.com/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/microsoft/playwright-mcp)** is the official Microsoft implementation. Listed at line 465 in [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/Automata-Labs-team/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](https://github.com/ViperJuice/mcp-gateway)** operates as a meta-server that auto-provisions Playwright instances on demand. According to line 232 of [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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](https://github.com/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](https://github.com/aybelatchane/mcp-server-terminal)** brings Playwright-style interaction patterns to terminal environments using Rust. As noted at line 654 of [`README.md`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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

```bash
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`:

```bash

# 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

```python
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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/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`.