PluginBench
Skill
Review
Audit score 70

chrome-devtools

chromedevtools/chrome-devtools-mcp

Debug, automate, and inspect web pages using Chrome DevTools via MCP.

What is chrome-devtools?

Integrates Chrome DevTools through the Model Context Protocol for efficient web debugging, browser automation, and performance analysis. Use when you need to debug web pages, automate browser interactions, analyze network requests, or inspect page elements and styling.

  • Navigate and create browser pages with persistent Chrome profiles
  • Take snapshots and screenshots to inspect page structure and visual state
  • Interact with page elements (click, fill, type) using unique element identifiers
  • Evaluate JavaScript in page context or extension service workers
  • Inspect CSS styles, matched rules, cascade, and CSS variables
  • Automate browser interactions and analyze network/performance data

How to install chrome-devtools

npx skills add https://github.com/chromedevtools/chrome-devtools-mcp --skill chrome-devtools
Prerequisites
  • Chrome browser installed
  • Node.js and npm for installing the skill
  • MCP server configuration in your AI client (Claude Code, Cursor, etc.)
  • Optional: --categoryExtensions flag for extension tooling, --memoryDebugging flag for memory tools
Claude Code
Cursor
Windsurf
Cline

How to use chrome-devtools

  1. 1.Install the skill: npx skills add https://github.com/chromedevtools/chrome-devtools-mcp --skill chrome-devtools
  2. 2.Navigate to a page using navigate_page or create a new page with new_page
  3. 3.Wait for content to load using wait_for if needed
  4. 4.Take a snapshot with take_snapshot and the pageId to see page structure and element UIDs
  5. 5.Interact with elements using their UIDs via click, fill, or other interaction tools
  6. 6.Use take_screenshot for visual inspection or get_css_styles for styling details
  7. 7.For extensions: install with install_extension, trigger actions, and evaluate scripts in service workers

Use cases

Good for
  • Debug a web application by inspecting elements, network requests, and console output
  • Automate form filling and multi-step user workflows in a browser
  • Analyze page performance metrics and CSS styling issues
  • Test Chrome extensions by installing, triggering actions, and verifying behavior
  • Scrape or extract data from dynamically-loaded web pages
Who it's for
  • Web developers debugging applications
  • QA engineers automating browser testing
  • Extension developers testing Chrome extensions
  • Performance engineers analyzing web performance
  • Automation engineers building browser-based workflows

chrome-devtools FAQ

What is pageId and how do I find it?

pageId is a unique identifier for each browser page. Use list_pages to see all open pages and their IDs, or use the ID returned when you create a page with new_page. Page-scoped tools require this parameter to target the correct page.

How do I interact with elements on a page?

First, call take_snapshot with your pageId to get the page structure and element UIDs. Each element has a unique uid. Then use interaction tools like click or fill, passing the uid and pageId.

When should I use take_snapshot vs take_screenshot?

Use take_snapshot for text-based automation and faster data retrieval; it returns page structure with element UIDs. Use take_screenshot when you need to see the visual state of the page.

How do I test a Chrome extension?

Install the extension with install_extension (requires --categoryExtensions flag), get its ID from list_extensions, trigger actions with trigger_extension_action, and verify behavior by evaluating scripts in the service worker or checking page modifications.

What should I do if extension tools are not available?

Extension tools require the MCP server to be started with the --categoryExtensions flag. Update your MCP configuration, restart your AI client, and the tools will become available.

Full instructions (SKILL.md)

Source of truth, from chromedevtools/chrome-devtools-mcp.


name: chrome-devtools description: Uses Chrome DevTools via MCP for efficient debugging, troubleshooting and browser automation. Use when debugging web pages, automating browser interactions, analyzing performance, or inspecting network requests. This skill does not apply to --slim mode (MCP configuration).

Core Concepts

Browser lifecycle: Browser starts automatically on first tool call using a persistent Chrome profile. Configure via CLI args in the MCP server configuration: npx chrome-devtools-mcp@latest --help. Addional tooling can be enabled by providing the following flags:

  • For extension tooling, use the --categoryExtensions flag.
  • For memory tooling, use the --memoryDebugging flag.

Page targeting: Page-scoped tools require a pageId parameter to target a specific page. Use list_pages to see available pages and their IDs (e.g. pageId: 1), or use the ID returned when creating a page with new_page. Note: For evaluate_script, pageId is required when targeting pages. However, when --categoryExtensions is enabled, pageId is optional so you can pass serviceWorkerId instead to evaluate inside an extension background service worker. Element interaction: Use take_snapshot to get page structure with element uids. Each element has a unique uid for interaction. If an element isn't found, take a fresh snapshot - the element may have been removed or the page changed.

Workflow Patterns

Before interacting with a page

  1. Navigate: navigate_page or new_page
  2. Wait: wait_for to ensure content is loaded if you know what you look for.
  3. Snapshot: take_snapshot with pageId to understand page structure
  4. Interact: Use element uids from snapshot for click, fill, etc., passing the corresponding pageId.

Efficient data retrieval

  • Use filePath parameter for large outputs (screenshots, snapshots, traces)
  • Use pagination (pageIdx, pageSize) and filtering (types) to minimize data
  • Set includeSnapshot: false on input actions unless you need updated page state

Tool selection

  • Automation/interaction: take_snapshot (text-based, faster, better for automation)
  • Visual inspection: take_screenshot (when user needs to see visual state)
  • CSS & Styling inspection: Use get_css_styles to inspect matched rules, cascade, and CSS variables. Treat the output as authoritative and complete.
  • Additional details: Use evaluate_script for runtime DOM/JS data not available via get_css_styles or take_snapshot.

Parallel execution

You can send multiple tool calls in parallel, but maintain correct order: navigate → wait → snapshot → interact.

Testing an extension

Before proceeding: Extension tools (install_extension, list_extensions, etc.) are only available when the MCP server is started with the --categoryExtensions flag. If these tools are not in your tool list, stop and ask the user to update their MCP server configuration:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest", "--categoryExtensions"]
    }
  }
}

After updating, the user must restart the MCP server (or their AI client) for the change to take effect.

  1. Install: Use install_extension with the path to the unpacked extension.
  2. Identify: Get the extension ID from the response or by calling list_extensions.
  3. Trigger Action: Use trigger_extension_action to open the popup or side panel if applicable.
  4. Verify Service Worker: Use evaluate_script with serviceWorkerId (omitting pageId and args) to check extension state or trigger background actions. When evaluating in a page, pass pageId (omitting serviceWorkerId).
  5. Verify Page Behavior: Navigate to a page where the extension operates and use take_snapshot to check if content scripts injected elements or modified the page correctly.

Troubleshooting

If chrome-devtools-mcp is insufficient, guide users to use Chrome DevTools UI:

If there are errors launching chrome-devtools-mcp or Chrome, refer to https://github.com/ChromeDevTools/chrome-devtools-mcp/blob/main/docs/troubleshooting.md.