What can browser-devtools-mcp do?

browser-devtools-protocol-bridging, page-navigation-and-context-management, mcp-resource-streaming-for-page-state, dom-query-and-element-inspection, user-interaction-simulation, javascript-execution-and-evaluation, network-activity-monitoring-and-interception, console-and-error-logging, screenshot-and-visual-capture, performance-metrics-and-timing-analysis, cookie-and-storage-management

browser-devtools-mcp

MCP ServerFree

MCP Server for Browser Dev Tools

Open Source

/ 100

11 capabilities

Capabilities11 decomposed

browser-devtools-protocol-bridging

Medium confidence

Exposes Chrome DevTools Protocol (CDP) as MCP resources and tools, allowing LLM agents to interact with browser automation and inspection through a standardized message-passing interface. Implements bidirectional communication between MCP clients and CDP endpoints, translating MCP tool calls into CDP commands and streaming CDP events back as resource updates.

Solves for

I need my AI agent to control a browser and inspect page state without writing Puppeteer/Playwright codeI want to expose browser debugging capabilities to Claude or other LLM clients via MCPI need to automate browser interactions (navigation, clicking, form filling) through an LLM interface

Best for

AI agent developers building browser automation workflows

Teams integrating LLMs with web testing and debugging pipelines

Developers prototyping AI-driven web scraping and interaction systems

Requires

Node.js 16+

Chrome/Chromium/Edge browser with --remote-debugging-port=9222 (or custom port)

MCP client implementation (Claude Desktop, custom agent framework, etc.)

Limitations

Requires active Chrome/Chromium instance with DevTools Protocol enabled (--remote-debugging-port flag)

No built-in session persistence — each MCP connection maps to a single CDP session

Limited to Chrome/Edge/Chromium browsers; Safari and Firefox require separate protocol implementations

What makes it unique

Directly maps MCP tool schema to Chrome DevTools Protocol methods, eliminating the need for intermediate abstraction layers like Puppeteer; enables LLM agents to access low-level browser inspection and control primitives (DOM queries, network interception, JavaScript evaluation) without wrapper libraries

vs alternatives

More direct and lower-latency than Puppeteer/Playwright MCP wrappers because it translates MCP calls directly to CDP without additional process overhead or abstraction layers

page-navigation-and-context-management

Medium confidence

Manages browser page lifecycle (navigation, reload, back/forward) and maintains context about the current page state (URL, title, DOM structure). Implements CDP Page domain methods wrapped as MCP tools, allowing agents to navigate to URLs, wait for page load events, and retrieve structured snapshots of page content for decision-making.

Solves for

I need my agent to navigate to different URLs and wait for pages to fully load before taking actionI want to capture the current page structure and content so the agent can decide what to do nextI need to implement browser back/forward/reload actions as part of an agent workflow

Best for

Web scraping agents that need to traverse multi-page workflows

Testing automation where page state verification is critical

Research agents that need to navigate and analyze multiple web pages

Requires

Active Chrome DevTools Protocol connection

Target page must be accessible from the MCP server's network context

Limitations

No built-in handling of JavaScript-heavy SPAs — may require explicit wait conditions for dynamic content

Page load detection relies on CDP Page.frameStoppedLoading event, which may fire before all async resources load

DOM snapshots are point-in-time and don't reflect subsequent JavaScript mutations without re-querying

What makes it unique

Exposes CDP Page domain as MCP tools with built-in wait-for-load semantics, allowing agents to express navigation intent declaratively ('navigate to URL and wait for load') rather than managing event listeners and timeouts manually

vs alternatives

Simpler than Playwright's page object model for MCP because it maps directly to CDP primitives without introducing additional state management or retry logic

mcp-resource-streaming-for-page-state

Medium confidence

Exposes current page state (DOM, metadata, network activity, console logs) as MCP resources that agents can subscribe to and monitor in real-time. Implements resource URIs for different page aspects (e.g., 'browser://page/dom', 'browser://page/console'), with automatic updates as page state changes, enabling agents to maintain contextual awareness without polling.

Solves for

I need to subscribe to page state changes and react to them in my agent workflowI want to maintain a current snapshot of the page DOM and metadata for decision-makingI need to monitor console output and network activity in real-time during automation

Best for

Long-running agents that need to react to page state changes

Multi-step workflows where page state is critical context for decisions

Monitoring agents tracking page health and activity over time

Requires

MCP client that supports resource subscriptions

Active Chrome DevTools Protocol connection

Limitations

Resource updates are asynchronous — agents must handle eventual consistency

Large page DOMs can generate high-volume resource updates, impacting performance

No built-in filtering or sampling — all state changes are streamed

What makes it unique

Implements MCP resource protocol for page state, allowing agents to subscribe to real-time updates rather than polling or managing CDP event listeners manually, providing a declarative interface to browser state

vs alternatives

More efficient than polling-based state checks because it streams updates as they occur, reducing latency and network overhead for long-running automation workflows

dom-query-and-element-inspection

Medium confidence

Provides MCP tools for querying the DOM using CSS selectors or XPath, retrieving element properties (text content, attributes, computed styles, bounding box), and inspecting element hierarchy. Implements CDP DOM domain methods with selector-based lookup, enabling agents to locate and analyze page elements without JavaScript execution.

Solves for

I need to find elements on a page by CSS selector or XPath and extract their text/attributesI want to check if a specific element exists and get its computed styles or positionI need to inspect the DOM tree structure to understand page layout before interacting with it

Best for

Web scraping agents extracting structured data from HTML

Testing agents that need to verify element presence and properties

Accessibility auditing agents analyzing page structure and ARIA attributes

Requires

Active Chrome DevTools Protocol connection

Page must be loaded and DOM accessible via CDP

Limitations

Selector queries are synchronous snapshots — don't wait for elements to appear in the DOM

Computed styles reflect only CSS, not JavaScript-applied styles (e.g., inline style mutations)

XPath queries may be slower than CSS selectors on large DOMs (no built-in optimization)

What makes it unique

Wraps CDP DOM.querySelector and DOM.getAttributes as MCP tools with structured output, allowing agents to query and inspect elements without writing JavaScript or managing CDP node IDs directly

vs alternatives

More efficient than Puppeteer's page.evaluate() for simple DOM queries because it uses CDP's native DOM domain instead of spinning up a JavaScript context

user-interaction-simulation

Medium confidence

Simulates user interactions (click, type, scroll, hover, key press) by translating MCP tool calls into CDP Input domain commands. Implements element targeting via CSS selector or coordinates, with automatic scroll-into-view and focus management, enabling agents to interact with page elements without JavaScript injection.

Solves for

I need my agent to click buttons, fill forms, and submit pages as if a human were using the browserI want to type text into input fields and trigger keyboard events (Enter, Tab, etc.)I need to scroll the page and hover over elements to reveal hidden content or tooltips

Best for

Web automation agents performing end-to-end workflows (login, form submission, navigation)

Testing agents simulating user interactions for functional testing

Accessibility testing agents verifying keyboard navigation and focus management

Requires

Active Chrome DevTools Protocol connection

Page must be visible and interactive (not minimized or backgrounded)

Target element must be in the DOM and have a valid bounding box

Limitations

Click coordinates must be calculated from element bounding box — may fail if element is off-screen or obscured

No built-in retry logic for stale element references — requires explicit re-query if DOM changes between lookup and interaction

Typing speed is instantaneous (no human-like delays) — may trigger different validation behavior than real user input

What makes it unique

Combines CDP Input domain (for low-level event injection) with element targeting via selectors, providing agents with high-level interaction primitives (click element by selector) without requiring coordinate calculation or JavaScript event handling

vs alternatives

More reliable than JavaScript-based click simulation because it uses CDP's native input injection, which properly triggers browser event handlers and respects z-index/visibility rules

javascript-execution-and-evaluation

Medium confidence

Executes arbitrary JavaScript in the page context via CDP Runtime domain, allowing agents to evaluate expressions, call page functions, and access JavaScript objects. Implements serialization of return values to JSON, with support for primitive types, objects, and arrays, enabling agents to extract computed data or trigger page-specific logic.

Solves for

I need to execute custom JavaScript to extract data that's not accessible via DOM queriesI want to call page functions or access window object properties from my agentI need to evaluate complex expressions (e.g., computed properties, React state) to make decisions

Best for

Agents scraping data from JavaScript-heavy SPAs (React, Vue, Angular)

Testing agents that need to verify application state or trigger internal functions

Debugging agents that need to inspect runtime state and object properties

Requires

Active Chrome DevTools Protocol connection

Page must be loaded and JavaScript execution must be enabled

Return value must be JSON-serializable (primitives, objects, arrays only)

Limitations

Return values must be JSON-serializable — complex objects (DOM nodes, functions, circular references) cause serialization errors

Execution context is isolated per call — no persistent variables across multiple evaluations (unless stored on window object)

Long-running scripts may timeout (CDP default ~30s) — no built-in support for async operations or promises

What makes it unique

Exposes CDP Runtime.evaluate as an MCP tool with automatic JSON serialization, allowing agents to execute arbitrary JavaScript without managing CDP protocol details or handling serialization errors manually

vs alternatives

More flexible than DOM-only queries for complex data extraction because it can access JavaScript state and call page functions, but requires careful error handling for non-serializable return values

network-activity-monitoring-and-interception

Medium confidence

Monitors network requests and responses via CDP Network domain, providing agents with visibility into HTTP traffic, response bodies, and request headers. Implements request/response logging with optional filtering by URL pattern or resource type, enabling agents to verify API calls, extract data from network responses, or detect failed requests.

Solves for

I need to see what API calls the page is making and extract data from the responsesI want to verify that specific network requests were made with correct parametersI need to detect failed network requests and decide how to handle them in my workflow

Best for

Agents scraping data from API-driven applications (need to intercept API responses)

Testing agents verifying network behavior and API contract compliance

Debugging agents analyzing network traffic to understand application behavior

Requires

Active Chrome DevTools Protocol connection

Network domain must be enabled via CDP (automatic in most cases)

Limitations

Response body capture requires explicit enablement and may increase memory usage for large responses

Network events are streamed in real-time — no built-in buffering or replay mechanism

Request/response filtering is pattern-based — no support for complex conditional logic

What makes it unique

Exposes CDP Network domain as MCP tools with structured request/response logging, allowing agents to monitor and analyze network traffic without writing custom CDP event listeners or managing request buffering

vs alternatives

More comprehensive than Puppeteer's request interception because it captures full response bodies and provides detailed timing metrics, but requires explicit enablement to avoid memory overhead

console-and-error-logging

Medium confidence

Captures console output (log, warn, error, info) and JavaScript errors via CDP Runtime domain, streaming them as MCP resources or tool responses. Implements log level filtering and error stack trace capture, enabling agents to monitor page health and detect runtime errors during automation.

Solves for

I need to see console errors and warnings to detect if something went wrong on the pageI want to capture console.log output from the page to extract debugging informationI need to verify that no JavaScript errors occurred during my automation workflow

Best for

Testing agents verifying application stability and error handling

Debugging agents diagnosing page failures and runtime issues

Monitoring agents detecting anomalies or unexpected behavior during automation

Requires

Active Chrome DevTools Protocol connection

Runtime domain must be enabled via CDP

Limitations

Console capture is asynchronous — early logs may be missed if capture is enabled after page load

Error stack traces may be minified or source-mapped depending on page configuration

No filtering for third-party library errors — all console output is captured indiscriminately

What makes it unique

Streams console and error events from CDP Runtime domain as MCP resources, allowing agents to monitor page health in real-time without polling or manual log extraction

vs alternatives

More immediate than checking page state after interactions because it captures errors as they occur, enabling agents to detect and respond to failures during automation

screenshot-and-visual-capture

Medium confidence

Captures page screenshots and visual state via CDP Page.captureScreenshot, returning base64-encoded PNG images. Implements viewport-aware capture with optional clipping to specific elements or regions, enabling agents to verify visual state, detect layout changes, or provide visual context for decision-making.

Solves for

I need to take a screenshot of the current page state to verify it looks correctI want to capture a specific element or region of the page for visual analysisI need to compare screenshots before and after an interaction to detect visual changes

Best for

Visual testing agents verifying UI appearance and layout

Accessibility agents analyzing visual hierarchy and contrast

Debugging agents capturing page state for troubleshooting

Requires

Active Chrome DevTools Protocol connection

Page must be visible and rendered (headless or headed mode)

Limitations

Screenshots are static snapshots — don't capture animations or transitions

Base64 encoding adds ~33% overhead to image size

Clipping to elements requires element lookup and coordinate calculation — adds latency

What makes it unique

Exposes CDP Page.captureScreenshot as an MCP tool with optional element-based clipping, allowing agents to capture visual state without managing viewport calculations or image encoding

vs alternatives

More efficient than Puppeteer's screenshot method for MCP because it returns base64-encoded data directly without intermediate file I/O

performance-metrics-and-timing-analysis

Medium confidence

Retrieves page performance metrics (navigation timing, resource timing, Core Web Vitals) via CDP Performance domain, providing agents with quantitative data about page load performance and responsiveness. Implements metric aggregation and filtering, enabling agents to detect performance regressions or optimize slow pages.

Solves for

I need to measure page load time and identify performance bottlenecksI want to verify that Core Web Vitals (LCP, FID, CLS) meet performance targetsI need to compare performance metrics before and after changes to detect regressions

Best for

Performance testing agents monitoring page load times and responsiveness

Optimization agents identifying slow resources or rendering bottlenecks

Monitoring agents tracking performance trends over time

Requires

Active Chrome DevTools Protocol connection

Page must be fully loaded

Performance domain must be enabled via CDP

Limitations

Metrics are only available after page load — no real-time performance monitoring during load

Core Web Vitals require user interaction (FID) or specific page behavior (CLS) — may not be measurable in automated scenarios

Resource timing data is limited by CORS — cross-origin resources may not have detailed timing

What makes it unique

Exposes CDP Performance domain as MCP tools with aggregated metric output, allowing agents to analyze page performance without parsing raw timing data or managing CDP protocol details

vs alternatives

More comprehensive than Lighthouse for MCP because it provides real-time metrics during automation rather than requiring a separate audit run

cookie-and-storage-management

Medium confidence

Manages browser cookies and storage (localStorage, sessionStorage, IndexedDB) via CDP Storage domain, enabling agents to set/get/delete cookies, inspect storage contents, and maintain session state across page navigations. Implements storage type detection and serialization, allowing agents to persist and retrieve data without JavaScript execution.

Solves for

I need to set cookies to maintain authentication state across page navigationsI want to inspect localStorage or sessionStorage to verify application stateI need to clear cookies and storage to reset the browser state between test runs

Best for

Testing agents managing authentication and session state

Automation agents persisting state across multi-page workflows

Debugging agents inspecting application storage for troubleshooting

Requires

Active Chrome DevTools Protocol connection

Page must be loaded for domain-specific storage operations

Limitations

Cookie operations are domain-specific — cannot set cookies for other domains

IndexedDB access is limited to inspection — no direct read/write of database contents

Storage quota limits apply — large data storage may fail silently

What makes it unique

Exposes CDP Storage domain as MCP tools for cookie and storage management, allowing agents to maintain session state and inspect application storage without JavaScript or manual cookie handling

vs alternatives

More reliable than JavaScript-based storage access because it uses CDP's native storage domain, which respects browser security policies and handles domain-specific restrictions automatically

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Related Artifactssharing capabilities

Artifacts that share capabilities with browser-devtools-mcp, ranked by overlap. Discovered automatically through the match graph.

MCP Server46

chrome-devtools-mcp

MCP server for Chrome DevTools

remote-browser-automation-via-devtools-protocolpage-navigation-and-load-state-trackingmcp-protocol-bridging-and-tool-registration

3 shared capabilities

MCP Server40

playwright-mcp

Playwright MCP server

dual-mode browser control (standalone and extension bridge)multi-page and multi-context workflow orchestrationbrowser extension integration with cdp relay

3 shared capabilities

MCP Server40

playwright-mcp

Playwright MCP server

browser context and session managementdual-mode browser control (standalone and extension bridge)cdp relay and extension bridge protocol

3 shared capabilities

MCP Server40

@executeautomation/playwright-mcp-server

Model Context Protocol servers for Playwright

page-navigation-and-context-managementbrowser-context-and-session-management

2 shared capabilities

MCP Server47

Playwright MCP Server

Automate browsers and run web tests via Playwright MCP.

dual-mode browser control: standalone server and extension bridgecontext and session management with persistent state

2 shared capabilities

MCP Server21

Puppeteer

** - Browser automation and web scraping.

browser-context-and-session-management

1 shared capability

Best For

✓AI agent developers building browser automation workflows
✓Teams integrating LLMs with web testing and debugging pipelines
✓Developers prototyping AI-driven web scraping and interaction systems
✓Web scraping agents that need to traverse multi-page workflows
✓Testing automation where page state verification is critical
✓Research agents that need to navigate and analyze multiple web pages
✓Long-running agents that need to react to page state changes
✓Multi-step workflows where page state is critical context for decisions

Known Limitations

⚠Requires active Chrome/Chromium instance with DevTools Protocol enabled (--remote-debugging-port flag)
⚠No built-in session persistence — each MCP connection maps to a single CDP session
⚠Limited to Chrome/Edge/Chromium browsers; Safari and Firefox require separate protocol implementations
⚠Network latency between MCP server and CDP endpoint can add 50-200ms per command
⚠No built-in handling of JavaScript-heavy SPAs — may require explicit wait conditions for dynamic content
⚠Page load detection relies on CDP Page.frameStoppedLoading event, which may fire before all async resources load

Requirements

Node.js 16+Chrome/Chromium/Edge browser with --remote-debugging-port=9222 (or custom port)MCP client implementation (Claude Desktop, custom agent framework, etc.)Network connectivity between MCP server and browser DevTools endpointActive Chrome DevTools Protocol connectionTarget page must be accessible from the MCP server's network contextMCP client that supports resource subscriptionsPage must be loaded and DOM accessible via CDP

Input / Output

Accepts: MCP tool call with CDP command parameters (JSON), CDP method names and arguments (e.g., 'Page.navigate', 'DOM.getDocument'), URL string (for navigation), Wait condition parameters (timeout in milliseconds), Reload options (hard reload, ignore cache), Resource URI (e.g., 'browser://page/dom', 'browser://page/console'), Optional filter criteria (log level, network type, etc.), CSS selector string (e.g., '.button-primary'), XPath expression (e.g., '//button[contains(text(), "Submit")]'), Element node ID (from previous query results), CSS selector or element coordinates (x, y), Text string to type, Key name (e.g., 'Enter', 'Tab', 'Escape'), Scroll direction and amount (pixels or viewport height), JavaScript code string (expression or statement), Function name and arguments (for calling page functions), Object path string (e.g., 'window.myApp.state'), URL pattern string (for filtering requests), Resource type filter (e.g., 'xhr', 'fetch', 'document', 'image'), Request ID (from previous network event), Log level filter (e.g., 'error', 'warning', 'all'), Optional pattern matching for log messages, Optional viewport dimensions (width, height), Optional element selector for clipping, Optional region coordinates (x, y, width, height), Optional metric filter (e.g., 'navigationTiming', 'resourceTiming'), Cookie name, value, domain, path, expiration, Storage type (localStorage, sessionStorage, IndexedDB), Storage key (for key-value stores)

Produces: CDP command responses (JSON), Page state snapshots (DOM tree, computed styles, network logs), Event streams (navigation, console messages, network activity), Page metadata (URL, title, document ready state), DOM tree representation (JSON or HTML string), Page load timing metrics (domContentLoaded, loadEventFired), Structured page state (DOM tree, metadata, network events, console logs), Incremental updates (delta from previous state), Timestamp and change type (added, modified, removed), Element metadata (tag name, text content, attributes), Computed style properties (color, display, position, etc.), Bounding box (x, y, width, height in viewport coordinates), Element hierarchy (parent, children, siblings), Confirmation of interaction (success/failure), Updated page state after interaction (if page changes), Error details if interaction fails (element not found, out of bounds, etc.), Serialized return value (JSON), Error message if execution fails, Execution timing (duration in milliseconds), Network request metadata (URL, method, headers, status code), Response body (text, JSON, or binary), Timing information (duration, latency), Error details if request failed, Console message (text, log level, timestamp), JavaScript error details (message, stack trace, source location), Structured error object (if available), Base64-encoded PNG image, Image dimensions (width, height), Capture timestamp, Navigation timing metrics (domContentLoaded, loadEventFired, etc.), Resource timing (per-resource duration, size, type), Core Web Vitals (LCP, FID, CLS if available), Aggregated metrics (total load time, resource count), Cookie list (name, value, domain, expiration, flags), Storage contents (key-value pairs or IndexedDB object stores), Confirmation of storage operation (success/failure)

UnfragileRank

Adoption15%(30% weight)

Quality22%(25% weight)

Ecosystem58%(25% weight)

Match Graph10%(15% weight)

Freshness75%(5% weight)

UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.

Type: MCP Server

11 capabilities

Visit browser-devtools-mcp→

Package Details

npm

Registry

0.6.9

Version

Weekly Downloads

About

MCP Server for Browser Dev Tools

Alternatives to browser-devtools-mcp

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

Are you the builder of browser-devtools-mcp?

Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.

Claim this artifact →Verification via email

Get the weekly brief

New tools, rising stars, and what's actually worth your time. No spam.

Data Sources

mcp registry

Looking for something else?

Search →

Capabilities11 decomposed

browser-devtools-protocol-bridging

Medium confidence

Solves for

Best for

AI agent developers building browser automation workflows

Teams integrating LLMs with web testing and debugging pipelines

Developers prototyping AI-driven web scraping and interaction systems

Requires

Node.js 16+

Chrome/Chromium/Edge browser with --remote-debugging-port=9222 (or custom port)

MCP client implementation (Claude Desktop, custom agent framework, etc.)

Limitations

Requires active Chrome/Chromium instance with DevTools Protocol enabled (--remote-debugging-port flag)

No built-in session persistence — each MCP connection maps to a single CDP session

Limited to Chrome/Edge/Chromium browsers; Safari and Firefox require separate protocol implementations

What makes it unique

vs alternatives

More direct and lower-latency than Puppeteer/Playwright MCP wrappers because it translates MCP calls directly to CDP without additional process overhead or abstraction layers

page-navigation-and-context-management

Medium confidence

Solves for

Best for

Web scraping agents that need to traverse multi-page workflows

Testing automation where page state verification is critical

Research agents that need to navigate and analyze multiple web pages

Requires

Active Chrome DevTools Protocol connection

Target page must be accessible from the MCP server's network context

Limitations

No built-in handling of JavaScript-heavy SPAs — may require explicit wait conditions for dynamic content

Page load detection relies on CDP Page.frameStoppedLoading event, which may fire before all async resources load

DOM snapshots are point-in-time and don't reflect subsequent JavaScript mutations without re-querying

What makes it unique

vs alternatives

Simpler than Playwright's page object model for MCP because it maps directly to CDP primitives without introducing additional state management or retry logic

mcp-resource-streaming-for-page-state

Medium confidence

Solves for

Best for

Long-running agents that need to react to page state changes

Multi-step workflows where page state is critical context for decisions

Monitoring agents tracking page health and activity over time

Requires

MCP client that supports resource subscriptions

Active Chrome DevTools Protocol connection

Limitations

Resource updates are asynchronous — agents must handle eventual consistency

Large page DOMs can generate high-volume resource updates, impacting performance

No built-in filtering or sampling — all state changes are streamed

What makes it unique

vs alternatives

More efficient than polling-based state checks because it streams updates as they occur, reducing latency and network overhead for long-running automation workflows

dom-query-and-element-inspection

Medium confidence

Solves for

Best for

Web scraping agents extracting structured data from HTML

Testing agents that need to verify element presence and properties

Accessibility auditing agents analyzing page structure and ARIA attributes

Requires

Active Chrome DevTools Protocol connection

Page must be loaded and DOM accessible via CDP

Limitations

Selector queries are synchronous snapshots — don't wait for elements to appear in the DOM

Computed styles reflect only CSS, not JavaScript-applied styles (e.g., inline style mutations)

XPath queries may be slower than CSS selectors on large DOMs (no built-in optimization)

What makes it unique

Wraps CDP DOM.querySelector and DOM.getAttributes as MCP tools with structured output, allowing agents to query and inspect elements without writing JavaScript or managing CDP node IDs directly

vs alternatives

More efficient than Puppeteer's page.evaluate() for simple DOM queries because it uses CDP's native DOM domain instead of spinning up a JavaScript context

user-interaction-simulation

Medium confidence

Solves for

Best for

Web automation agents performing end-to-end workflows (login, form submission, navigation)

Testing agents simulating user interactions for functional testing

Accessibility testing agents verifying keyboard navigation and focus management

Requires

Active Chrome DevTools Protocol connection

Page must be visible and interactive (not minimized or backgrounded)

Target element must be in the DOM and have a valid bounding box

Limitations

Click coordinates must be calculated from element bounding box — may fail if element is off-screen or obscured

No built-in retry logic for stale element references — requires explicit re-query if DOM changes between lookup and interaction

Typing speed is instantaneous (no human-like delays) — may trigger different validation behavior than real user input

What makes it unique

vs alternatives

More reliable than JavaScript-based click simulation because it uses CDP's native input injection, which properly triggers browser event handlers and respects z-index/visibility rules

javascript-execution-and-evaluation

Medium confidence

Solves for

Best for

Agents scraping data from JavaScript-heavy SPAs (React, Vue, Angular)

Testing agents that need to verify application state or trigger internal functions

Debugging agents that need to inspect runtime state and object properties

Requires

Active Chrome DevTools Protocol connection

Page must be loaded and JavaScript execution must be enabled

Return value must be JSON-serializable (primitives, objects, arrays only)

Limitations

Return values must be JSON-serializable — complex objects (DOM nodes, functions, circular references) cause serialization errors

Execution context is isolated per call — no persistent variables across multiple evaluations (unless stored on window object)

Long-running scripts may timeout (CDP default ~30s) — no built-in support for async operations or promises

What makes it unique

vs alternatives

More flexible than DOM-only queries for complex data extraction because it can access JavaScript state and call page functions, but requires careful error handling for non-serializable return values

network-activity-monitoring-and-interception

Medium confidence

Solves for

Best for

Agents scraping data from API-driven applications (need to intercept API responses)

Testing agents verifying network behavior and API contract compliance

Debugging agents analyzing network traffic to understand application behavior

Requires

Active Chrome DevTools Protocol connection

Network domain must be enabled via CDP (automatic in most cases)

Limitations

Response body capture requires explicit enablement and may increase memory usage for large responses

Network events are streamed in real-time — no built-in buffering or replay mechanism

Request/response filtering is pattern-based — no support for complex conditional logic

What makes it unique

vs alternatives

More comprehensive than Puppeteer's request interception because it captures full response bodies and provides detailed timing metrics, but requires explicit enablement to avoid memory overhead

console-and-error-logging

Medium confidence

Solves for

Best for

Testing agents verifying application stability and error handling

Debugging agents diagnosing page failures and runtime issues

Monitoring agents detecting anomalies or unexpected behavior during automation

Requires

Active Chrome DevTools Protocol connection

Runtime domain must be enabled via CDP

Limitations

Console capture is asynchronous — early logs may be missed if capture is enabled after page load

Error stack traces may be minified or source-mapped depending on page configuration

No filtering for third-party library errors — all console output is captured indiscriminately

What makes it unique

Streams console and error events from CDP Runtime domain as MCP resources, allowing agents to monitor page health in real-time without polling or manual log extraction

vs alternatives

More immediate than checking page state after interactions because it captures errors as they occur, enabling agents to detect and respond to failures during automation

screenshot-and-visual-capture

Medium confidence

Solves for

Best for

Visual testing agents verifying UI appearance and layout

Accessibility agents analyzing visual hierarchy and contrast

Debugging agents capturing page state for troubleshooting

Requires

Active Chrome DevTools Protocol connection

Page must be visible and rendered (headless or headed mode)

Limitations

Screenshots are static snapshots — don't capture animations or transitions

Base64 encoding adds ~33% overhead to image size

Clipping to elements requires element lookup and coordinate calculation — adds latency

What makes it unique

Exposes CDP Page.captureScreenshot as an MCP tool with optional element-based clipping, allowing agents to capture visual state without managing viewport calculations or image encoding

vs alternatives

More efficient than Puppeteer's screenshot method for MCP because it returns base64-encoded data directly without intermediate file I/O

performance-metrics-and-timing-analysis

Medium confidence

Solves for

Best for

Performance testing agents monitoring page load times and responsiveness

Optimization agents identifying slow resources or rendering bottlenecks

Monitoring agents tracking performance trends over time

Requires

Active Chrome DevTools Protocol connection

Page must be fully loaded

Performance domain must be enabled via CDP

Limitations

Metrics are only available after page load — no real-time performance monitoring during load

Core Web Vitals require user interaction (FID) or specific page behavior (CLS) — may not be measurable in automated scenarios

Resource timing data is limited by CORS — cross-origin resources may not have detailed timing

What makes it unique

Exposes CDP Performance domain as MCP tools with aggregated metric output, allowing agents to analyze page performance without parsing raw timing data or managing CDP protocol details

vs alternatives

More comprehensive than Lighthouse for MCP because it provides real-time metrics during automation rather than requiring a separate audit run

cookie-and-storage-management

Medium confidence

Solves for

Best for

Testing agents managing authentication and session state

Automation agents persisting state across multi-page workflows

Debugging agents inspecting application storage for troubleshooting

Requires

Active Chrome DevTools Protocol connection

Page must be loaded for domain-specific storage operations

Limitations

Cookie operations are domain-specific — cannot set cookies for other domains

IndexedDB access is limited to inspection — no direct read/write of database contents

Storage quota limits apply — large data storage may fail silently

What makes it unique

Exposes CDP Storage domain as MCP tools for cookie and storage management, allowing agents to maintain session state and inspect application storage without JavaScript or manual cookie handling

vs alternatives

More reliable than JavaScript-based storage access because it uses CDP's native storage domain, which respects browser security policies and handles domain-specific restrictions automatically

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Alternatives to browser-devtools-mcp

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

browser-devtools-mcp

Capabilities11 decomposed

browser-devtools-protocol-bridging

page-navigation-and-context-management

mcp-resource-streaming-for-page-state

dom-query-and-element-inspection

user-interaction-simulation

javascript-execution-and-evaluation

network-activity-monitoring-and-interception

console-and-error-logging

screenshot-and-visual-capture

performance-metrics-and-timing-analysis

cookie-and-storage-management

Related Artifactssharing capabilities

chrome-devtools-mcp

playwright-mcp

playwright-mcp

@executeautomation/playwright-mcp-server

Playwright MCP Server

Puppeteer

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Package Details

About

Categories

Alternatives to browser-devtools-mcp

Are you the builder of browser-devtools-mcp?

Get the weekly brief

Data Sources

browser-devtools-mcp

Capabilities11 decomposed

browser-devtools-protocol-bridging

page-navigation-and-context-management

mcp-resource-streaming-for-page-state

dom-query-and-element-inspection

user-interaction-simulation

javascript-execution-and-evaluation

network-activity-monitoring-and-interception

console-and-error-logging

screenshot-and-visual-capture

performance-metrics-and-timing-analysis

cookie-and-storage-management

Related Artifactssharing capabilities

chrome-devtools-mcp

playwright-mcp

playwright-mcp

@executeautomation/playwright-mcp-server

Playwright MCP Server

Puppeteer

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Package Details

About

Categories

Alternatives to browser-devtools-mcp

Are you the builder of browser-devtools-mcp?

Get the weekly brief

Data Sources