even-better-playwright-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@even-better-playwright-mcp Search Amazon for 'headphones' and show a screenshot with visual labels."
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.
even-better-playwright-mcp
The best of all worlds Playwright MCP server - combining intelligent DOM compression, code execution, visual labels, and advanced DevTools capabilities.
Features
๐ญ Full Playwright API - Execute any Playwright code via the
executetool๐๏ธ 90%+ DOM Compression - SimHash-based list folding and wrapper removal
๐ Ref-Based Elements - Stable
[ref=e1]identifiers with aria-ref selectors๐ Enhanced Search & Diff - Search snapshots with regex, track changes with diff mode
๐ฏ Visual Labels - Vimium-style overlays for screenshot-based interaction
๐ง Advanced DevTools - Debugger, live editor, styles inspection, React source finding
๐ Network Capture - Request/response interception with analytics filtering
โฑ๏ธ Smart Page Load - Intelligent wait that filters analytics and stuck requests
๐ Browser Console Logs - Persistent per-page logging with search and filtering
๐งน Clean HTML - Get LLM-friendly HTML with search and diff capabilities
๐ Sandboxed Execution - Safe VM with scoped file system and module allowlist
Related MCP server: MCP Playwright Server
Installation
npm install -g even-better-playwright-mcpOr use directly with npx:
npx even-better-playwright-mcpConfiguration
Add to your MCP client settings (e.g., Claude Desktop's claude_desktop_config.json):
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["even-better-playwright-mcp"]
}
}
}CLI Options
Usage: even-better-playwright-mcp [options]
Options:
--browser <browser> Browser to use: chromium, firefox, webkit (default: chromium)
--headless Run browser in headless mode (default: false)
--cdp-endpoint <url> Connect to existing browser via CDP endpoint
--user-data-dir <path> Use persistent browser profile directory
-h, --help Show help messageExamples
# Basic usage (launches Chromium in headed mode)
even-better-playwright-mcp
# Use Firefox in headless mode
even-better-playwright-mcp --browser firefox --headless
# Connect to existing Chrome instance
even-better-playwright-mcp --cdp-endpoint ws://localhost:9222
# Use persistent profile
even-better-playwright-mcp --user-data-dir ./browser-profileTools
1. snapshot - Get Page Structure
Get compressed accessibility snapshot with ref IDs for element targeting.
Returns: DOM tree with [ref=e1], [ref=e2] etc.
Use refs with execute tool: await $('e1').click()
Call again after navigation (refs become stale).Options:
compress(boolean, default: true) - Enable smart compression (~90% token reduction)search(string | RegExp) - Search pattern to filter results with 5 lines of contextshowDiff(boolean, default: false) - Show changes since last snapshot
Example output:
### Page Info
- URL: https://example.com
- Title: Example Domain
### Accessibility Snapshot
- document [ref=e1]
- heading "Example Domain" [level=1] [ref=e2]
- paragraph [ref=e3]: This domain is for use in illustrative examples...
- link "More information..." [ref=e4]2. browser_execute - Run Playwright Code
Execute any Playwright code with full API access. This is the main tool for browser automation.
Scope variables:
page- Current Playwright pagecontext- Browser contextstate- Persistent object across calls$('e5')- Shorthand forpage.locator('aria-ref=e5')accessibilitySnapshot()- Get current page snapshotwaitForPageLoad()- Smart page load detection (filters analytics/ads)getLatestLogs()- Get browser console logs with search/filteringclearAllLogs()- Clear all stored console logsgetCleanHTML()- Get cleaned HTML with search and diffgetLocatorStringForElement()- Generate selector string from element
Common patterns:
// Navigate
await page.goto('https://example.com')
// Click by ref (from snapshot)
await $('e5').click()
// Fill input
await $('e12').fill('search query')
// Get text
const text = await $('e3').textContent()
// Wait for network (smart detection, filters analytics/ads)
const result = await waitForPageLoad({ timeout: 30000 })
// => { success: true, waitTimeMs: 1234, pendingRequests: [] }
// Screenshot
await page.screenshot({ path: 'screenshot.png' })Advanced - DevTools access:
// Get CDP session for debugging
const cdp = await getCDPSession({ page })
const dbg = createDebugger({ cdp })
// Set breakpoint
await dbg.setBreakpoint({ file: 'app.js', line: 42 })
// Inspect styles
const styles = await getStylesForLocator({ locator: $('e5') })
// Find React component source
const source = await getReactSource({ locator: $('e5') })
// => { fileName: 'Button.tsx', lineNumber: 42 }Browser Console Logs:
// Get latest 50 console logs from current page
const logs = await getLatestLogs({ count: 50 })
// Search logs with regex
const errorLogs = await getLatestLogs({ search: /error|warning/i })
// Get logs from all pages
const allLogs = await getLatestLogs()
// Clear all stored logs
clearAllLogs()HTML Utilities:
// Get cleaned HTML from page or element
const html = await getCleanHTML({
locator: page, // or $('e5') for specific element
maxContentLen: 500
})
// Search within HTML
const forms = await getCleanHTML({
locator: page,
search: 'form'
})
// Track HTML changes
const diff = await getCleanHTML({
locator: page,
showDiffSinceLastCall: true
})
// Generate readable selector for element
const button = $('e5')
const selector = await getLocatorStringForElement(button)
// => "page.getByRole('button', { name: 'Submit' })"Safe modules via require():
path, url, crypto, buffer, util, assert, os, fs (sandboxed)
3. screenshot - Capture Page Image
Capture screenshots with optional visual ref labels.
Options:
ref(string) - Screenshot specific element by reffullPage(boolean) - Capture entire scrollable areawithLabels(boolean) - Show Vimium-style ref labels
Label colors by role:
Color | Role |
Yellow | links |
Orange | buttons |
Coral | text inputs |
Pink | checkboxes, radios |
Blue | images, videos |
4. browser_search_snapshot - Search Content
Search the last captured snapshot using regex patterns.
Options:
pattern(string) - Regex pattern to search forignoreCase(boolean, default: false) - Case-insensitive matchinglineLimit(number, default: 100) - Maximum lines to return
Example:
Pattern: "button|link"
Result:
- link "Contact Us" [ref=e15]
- button "Submit" [ref=e23]
- link "Privacy Policy" [ref=e31]5. browser_network_requests - Capture Network Traffic
Get captured network requests with automatic filtering of analytics and ads.
Options:
includeStatic(boolean, default: false) - Include images, CSS, fontslimit(number, default: 50) - Max requests to return (most recent)clear(boolean, default: false) - Clear captured requests after returning
Features:
Automatically starts capturing on first call
Filters analytics/tracking domains (Google Analytics, Facebook Pixel, etc.)
Captures request/response bodies (up to 50KB)
Shows status codes, timing, and response previews
Example:
Network Requests (127 total, showing last 50):
POST https://api.example.com/login [200] (245ms)
POST: {"email":"user@example.com","password":"***"}
RESPONSE: {"token":"eyJ...","user":{"id":123,"name":"John"}}
GET https://api.example.com/profile [200] (89ms)
RESPONSE: {"id":123,"name":"John","email":"user@example.com"}Workflow
Basic Automation
Get page structure
Use: snapshot tool โ See all interactive elements with refsInteract with elements
Use: execute tool Code: await $('e5').click()After navigation, refresh refs
Use: snapshot tool again โ Refs are stale after navigation
Visual Automation
Take labeled screenshot
Use: screenshot tool with withLabels: true โ See visual labels overlaid on elementsIdentify element from image
Label shows: "e5" on a buttonClick using ref
Use: execute tool Code: await $('e5').click()
Architecture
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ even-better-playwright-mcp โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ CORE โ
โ โโโ aria-ref selector system ([ref=e1], [ref=e2], etc.) โ
โ โโโ page._snapshotForAI() for accessibility snapshots โ
โ โโโ Standard Playwright browser automation โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ ENHANCED SNAPSHOT โ
โ โโโ SimHash-based list folding (compress 48 items โ 2 lines) โ
โ โโโ Useless wrapper removal โ
โ โโโ Regex-powered content search with context โ
โ โโโ Diff tracking (compare snapshots over time) โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ CODE EXECUTION โ
โ โโโ browser_execute tool (run Playwright code in VM sandbox) โ
โ โโโ Sandboxed require (safe module allowlist) โ
โ โโโ Scoped file system (cwd, /tmp only) โ
โ โโโ Console log capture and forwarding โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ PERSISTENT LOGGING โ
โ โโโ Per-page browser console capture (5000 log limit) โ
โ โโโ Logs persist across executions and reconnections โ
โ โโโ Search logs with regex and context โ
โ โโโ Auto-clear on navigation โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ NETWORK & PAGE UTILITIES โ
โ โโโ Network capture with analytics filtering โ
โ โโโ Smart page load (filters stuck/analytics requests) โ
โ โโโ Clean HTML extraction with search/diff โ
โ โโโ Selector string generation from elements โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ ADVANCED DEVTOOLS โ
โ โโโ Debugger class (breakpoints, step, inspect variables) โ
โ โโโ Editor class (live code editing without reload) โ
โ โโโ Styles inspection (CSS like DevTools panel) โ
โ โโโ React source finding (component file/line locations) โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ VISUAL OVERLAYS โ
โ โโโ Vimium-style labels on interactive elements โ
โ โโโ Color-coded by role (links=yellow, buttons=orange, etc.) โ
โ โโโ Screenshot with visible ref labels โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโRef System
All projects use the same ref system built into Playwright:
Snapshots generate refs like
[ref=e1]Selectors use
page.locator('aria-ref=e1')Shorthand
$('e1')in execute tool
Important: Refs become stale after navigation. Always call snapshot again after page.goto() or clicking links that navigate.
Compression Algorithm
The snapshot compression achieves ~90% token reduction:
Original DOM (5000+ lines)
โ removeUselessWrappers()
โ truncateText(50 chars)
โ detectSimilarPatterns(SimHash)
โ foldLists()
Compressed (<500 lines)Example:
Before:
- listitem [ref=e234]: Product 1 - Description...
- listitem [ref=e235]: Product 2 - Description...
- listitem [ref=e236]: Product 3 - Description...
... (48 items)
After:
- listitem [ref=e234]: Product 1 - Description...
- listitem (... and 47 more similar) [refs: e235, e236, ...]Error Handling
The execute tool provides contextual hints:
Stale ref: "Page may have navigated. Refs are stale after navigation. Call snapshot tool to get fresh refs."
Timeout: "Operation timed out. Try increasing timeout or check if element exists/is visible."
Hidden element: "Element may be hidden or covered by another element. Try scrolling or closing overlays."
Connection lost: "Browser connection lost. The browser may have been closed - try again to relaunch."
Programmatic Usage
The server can be used as a library with full programmatic control:
import { createServerInstance, BrowserManager } from 'even-better-playwright-mcp';
// Create server instance with custom config
const { server, browserManager, cleanup } = createServerInstance({
browser: 'chromium',
headless: true,
isolated: true, // Force ephemeral context
launchOptions: {
slowMo: 50,
args: ['--disable-blink-features=AutomationControlled']
},
contextOptions: {
viewport: { width: 1920, height: 1080 },
userAgent: 'Custom User Agent'
}
});
// Connect your transport
await server.connect(transport);
// Cleanup when done
await cleanup();BrowserConfig Options
browser- Browser type: 'chromium', 'firefox', 'webkit'headless- Run in headless modecdpEndpoint- Connect to existing browser via CDPuserDataDir- Persistent browser profile directoryisolated- Force ephemeral context (overrides userDataDir)launchOptions- Pass-through to Playwright's browser.launch()contextOptions- Pass-through to browser.newContext()
Multi-Session Support
Each BrowserManager instance has isolated state:
Independent browser/context/page
Separate network capture
Isolated console logs
Per-instance persistent state
// Create multiple isolated sessions
const session1 = createServerInstance({ browser: 'chromium' });
const session2 = createServerInstance({ browser: 'firefox' });
// Each has its own browser and state
await session1.browserManager.getPage();
await session2.browserManager.getPage();Development
Building from Source
git clone https://github.com/your-repo/even-better-playwright-mcp
cd even-better-playwright-mcp
npm install
npm run buildRunning Tests
The project includes comprehensive end-to-end tests:
# Build first
npm run build
# Run e2e tests
npm run test:e2e
# Run all tests
npm testTest Coverage: 15 tests covering all MCP tools against Hacker News
Tool discovery and validation
Browser automation (navigate, click, fill forms)
Accessibility snapshots with ref system
Screenshot capture
Network request monitoring
Persistent state management
Error and timeout handling
Full end-to-end workflows
See test/README.md for detailed test documentation.
Project Structure
even-better-playwright-mcp/
โโโ bin/
โ โโโ cli.ts # CLI entry point with arg parsing
โโโ src/
โ โโโ index.ts # MCP server factory (createServerInstance)
โ โโโ browser.ts # BrowserManager class (refactored!)
โ โโโ vm-context.ts # VM sandbox setup
โ โโโ tools/
โ โ โโโ snapshot.ts # Snapshot tool (compressed + search + diff)
โ โ โโโ execute.ts # Execute tool (main)
โ โ โโโ screenshot.ts # Screenshot tool (with labels)
โ โ โโโ search.ts # Search tool
โ โ โโโ network.ts # Network capture tool
โ โโโ utils/
โ โ โโโ smart-outline.ts # DOM compression
โ โ โโโ list-detector.ts # Pattern detection
โ โ โโโ dom-simhash.ts # SimHash implementation
โ โ โโโ scoped-fs.ts # Sandboxed file system
โ โ โโโ search.ts # Regex search
โ โ โโโ browser-logs.ts # Persistent console logging
โ โ โโโ clean-html.ts # HTML cleaning with search/diff
โ โ โโโ locator-string.ts # Selector generation
โ โ โโโ wait-for-page-load.ts # Smart page load detection
โ โ โโโ network-capture.ts # Network request capture
โ โ โโโ console-capture.ts # Console log capture
โ โโโ devtools/
โ โ โโโ cdp-session.ts # CDP connection
โ โ โโโ debugger.ts # Debugger class
โ โ โโโ editor.ts # Live editor
โ โ โโโ styles.ts # CSS inspection
โ โ โโโ react-source.ts # React locations
โ โโโ visual/
โ โโโ aria-labels.ts # Vimium-style overlays
โโโ test/
โ โโโ e2e.test.js # Comprehensive E2E test suite
โ โโโ README.md # Test documentation
โโโ package.json
โโโ tsconfig.json
โโโ README.mdRecent Refactoring (v0.1.0)
The codebase was refactored from global module-level state to a clean, testable architecture:
Before: Global functions and singletons
import { getPage, getContext } from './browser.js';
const page = await getPage(); // Global stateAfter: Dependency injection with BrowserManager
const browserManager = new BrowserManager(config);
const page = await browserManager.getPage(); // Instance stateBenefits:
โ Multi-session support (multiple isolated browsers)
โ Better testability (no global state)
โ Library-friendly API (clean exports)
โ Full Playwright configuration control
โ Flexible browser lifecycle management
All tool handlers now use factory functions with dependency injection:
const handleSnapshot = createSnapshotHandler(browserManager);
const handleExecute = createExecuteHandler(browserManager);Acknowledgments
This project combines the best ideas from:
better-playwright-mcp - Intelligent DOM compression
playwriter - Code execution and DevTools
playwright-mcp - Microsoft's official MCP
License
MIT
Available Tools
5 toolsbrowser_executeA
Execute Playwright code with these in scope:
page- Current Playwright pagecontext- Browser context, access all pages via context.pages()state- Persistent object across calls (e.g., state.myPage = await context.newPage())$('e5')- Shorthand for page.locator('aria-ref=e5')accessibilitySnapshot()- Get current page snapshotrequire- Load Node.js modules (path, url, crypto, buffer, util, assert, os, fs)Node.js globals: setTimeout, setInterval, fetch, URL, Buffer, crypto, etc.
Rules
Multiple calls: Use multiple execute calls for complex logic - helps understand intermediate state and isolate failures
Never close: Never call browser.close() or context.close(). Only close pages you created or if user asks
No bringToFront: Never call unless user asks - it's disruptive and unnecessary
Check state after actions: Always verify page state after clicking/submitting (see next section)
Clean up listeners: Call page.removeAllListeners() at end to prevent leaks
Wait for load: Use page.waitForLoadState('domcontentloaded') not page.waitForEvent('load') - waitForEvent times out if already loaded
Avoid timeouts: Prefer proper waits over page.waitForTimeout() - there are better ways
Checking Page State
After any action (click, submit, navigate), verify what happened:
console.log('url:', page.url()); console.log(await accessibilitySnapshot().then(x => x.split('\n').slice(0, 30).join('\n')));For visually complex pages (grids, galleries, dashboards), use screenshotWithAccessibilityLabels({ page }) instead.
Accessibility Snapshots
await accessibilitySnapshot() // Full snapshot
await accessibilitySnapshot({ search: /button|submit/i }) // Filter results
await accessibilitySnapshot({ showDiffSinceLastCall: true }) // Show changesExample output:
- banner [ref=e3]:
- link "Home" [ref=e5] [cursor=pointer]:
- /url: /
- navigation [ref=e12]:
- link "Docs" [ref=e13] [cursor=pointer]Use aria-ref to interact - NO quotes around the ref value:
await page.locator('aria-ref=e13').click() // or: await $('e13').click()For pagination: (await accessibilitySnapshot()).split('\n').slice(0, 50).join('\n')
Choosing snapshot method:
Use
accessibilitySnapshotfor simple pages, text search, token efficiencyUse
screenshotWithAccessibilityLabelsfor complex visual layouts, spatial position matters
Selector Best Practices
For unknown sites: use accessibilitySnapshot() with aria-ref For development (with source access), prefer:
[data-testid="submit"]- explicit test attributesgetByRole('button', { name: 'Save' })- semanticgetByText('Sign in'),getByLabel('Email')- user-facinginput[name="email"]- semantic HTMLAvoid: classes/IDs that change frequently
If locator matches multiple elements (strict mode violation), use .first(), .last(), or .nth(n):
await page.locator('button').first().click()
await page.locator('li').nth(3).click() // 4th item (0-indexed)Working with Pages
const pages = context.pages().filter(x => x.url().includes('localhost'));
state.newPage = await context.newPage(); await state.newPage.goto('https://example.com');Navigation
await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
await waitForPageLoad({ page, timeout: 5000 });Common Patterns
Popups: const [popup] = await Promise.all([page.waitForEvent('popup'), page.click('a[target=_blank]')]); await popup.waitForLoadState();
Downloads: const [download] = await Promise.all([page.waitForEvent('download'), page.click('button.download')]); await download.saveAs('/tmp/' + download.suggestedFilename());
iFrames: const frame = page.frameLocator('#my-iframe'); await frame.locator('button').click();
Dialogs: page.on('dialog', async d => { await d.accept(); }); await page.click('button');
Load files: const fs = require('fs'); const content = fs.readFileSync('./data.txt', 'utf-8'); await page.locator('textarea').fill(content);
page.evaluate
Code inside page.evaluate() runs in the browser - use plain JavaScript only. console.log inside evaluate runs in browser, not visible here:
const title = await page.evaluate(() => document.title);
console.log('Title:', title); // Log outside evaluateUtility Functions
getLatestLogs({ page?, count?, search? })- Get browser console logsgetCleanHTML({ locator, search?, showDiffSinceLastCall?, includeStyles? })- Get cleaned HTMLwaitForPageLoad({ page, timeout? })- Smart load detection (ignores analytics/ads)getCDPSession()- Get CDP session for raw Chrome DevTools Protocol commandsgetLocatorStringForElement(locator)- Get stable selector from ephemeral aria-refgetReactSource({ locator })- Get React component source location (dev mode only)getStylesForLocator({ locator, cdp })- Inspect CSS styles (read styles-api resource first)createDebugger({ cdp })- Set breakpoints, step through code (read debugger-api resource first)createEditor({ cdp })- View/edit page scripts and CSS (read editor-api resource first)screenshotWithAccessibilityLabels({ page })- Screenshot with Vimium-style visual labels (yellow=links, orange=buttons, coral=inputs)
Network Interception
For scraping/reverse-engineering APIs, intercept network instead of scrolling DOM:
state.requests = []; state.responses = [];
page.on('request', req => { if (req.url().includes('/api/')) state.requests.push({ url: req.url(), method: req.method(), headers: req.headers() }); });
page.on('response', async res => { if (res.url().includes('/api/')) { try { state.responses.push({ url: res.url(), status: res.status(), body: await res.json() }); } catch {} } });Then trigger actions and analyze: console.log('Captured', state.responses.length, 'API calls');
Clean up when done: page.removeAllListeners('request'); page.removeAllListeners('response');
IMPORTANT: After navigation, refs are stale - call snapshot tool again.
Inputs: code (required), timeout.
browser_network_requestsA
Get captured network requests from the browser. Automatically starts capturing when first called. Use includeStatic:true to include images/CSS/fonts. Returns recent requests with status, timing, and response previews.
Inputs: includeStatic, limit, clear.
browser_search_snapshotA
Search current snapshot with regex.
Requires: Call snapshot first. Returns: Matching lines with refs.
Options:
pattern: Regex pattern to search for
ignoreCase: Case-insensitive matching (default: false)
lineLimit: Max lines to return (default: 100)
Use this to find specific elements in large pages without re-reading the entire snapshot.
Inputs: pattern (required), ignoreCase, lineLimit.
screenshotA
Capture page screenshot.
Options:
ref: Screenshot specific element by ref (e.g., 'e5')
fullPage: Capture entire scrollable area
withLabels: Show Vimium-style ref labels on interactive elements
When withLabels is used, labels are color-coded by role:
Yellow: links
Orange: buttons
Coral: text inputs
Pink: checkboxes/radios
Blue: images/videos
Inputs: ref, fullPage, withLabels.
snapshotA
Get compressed accessibility snapshot with ref IDs.
Returns: DOM tree with [ref=e1], [ref=e2] etc. Use refs with execute tool: await $('e1').click() Call again after navigation (refs become stale).
Options:
compress: Enable smart compression (default: true) Reduces token usage by ~90% via list folding and wrapper removal.
search: Search pattern (string or regex) to filter results with context
showDiff: Show changes since last snapshot (useful for tracking page updates)
Inputs: compress, search, showDiff.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogโฆ
TDQS
Scored across 5 tools
Each tool has a distinct and non-overlapping purpose: browser_execute runs code, browser_network_requests captures network data, browser_search_snapshot searches snapshots, screenshot captures images, and snapshot retrieves accessibility data. There is no ambiguity in their functions.
All tool names follow a consistent snake_case pattern with a 'browser_' prefix for three tools and simple nouns for the others, creating a clear and predictable naming scheme. The structure is uniform and easy to understand.
With 5 tools, the server is well-scoped for browser automation, covering execution, network monitoring, snapshot searching, screenshot capture, and accessibility snapshot retrieval. Each tool serves a unique and essential function without redundancy.
The tool set provides comprehensive coverage for browser automation tasks, including interaction, monitoring, and inspection. A minor gap exists in lacking a dedicated tool for browser context/page management (e.g., opening/closing pages), but this is mitigated by instructions within browser_execute.
Maintenance
Related MCP Connectors
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
Real Chrome for coding agents over MCP: browse, replay playbooks, human takeover, HIPAA & BAA.
Browser automation MCP for whole web tasks in a cloud browser: saved logins, bot checks, replays.
Related MCP Servers
- AlicenseBqualityDmaintenanceA browser automation server providing Playwright capabilities for controlling web browsers, capturing screenshots, extracting content, and performing complex interactions through an MCP interface.6Apache 2.0
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI-powered browser automation, web scraping, and testing using Playwright across Chromium, Firefox, and WebKit. It allows users to perform actions like navigation, clicking, typing, and taking screenshots through natural language interfaces.MIT
- AlicenseAqualityDmaintenanceA high-performance browser automation MCP server that provides AI agents with a fast, persistent Chromium instance via Playwright. It features reference-based element interaction, snapshot diffing, and manual handoff capabilities to handle complex tasks like CAPTCHAs.6116 npm32MIT
- AlicenseCqualityCmaintenanceAn MCP server that enables AI agents to autonomously test, debug, and analyze web interfaces visually using Playwright, with 30 tools for screenshots, workflows, performance, and visual comparison.3029 npm84ISC