PluginBench
Skill
Review
Audit score 70

chrome-devtools

chromedevtools/chrome-devtools-mcp

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

What is chrome-devtools?

Integrates Chrome DevTools through MCP for browser debugging, automation, and performance analysis. Use this skill when you need to debug web pages, automate browser interactions, analyze network requests, or inspect page elements. Note: not available in --slim mode.

  • Navigate pages and manage browser lifecycle with persistent Chrome profiles
  • Take snapshots of page structure with unique element identifiers for interaction
  • Capture screenshots for visual inspection of page state
  • Automate browser interactions like clicks and form fills using element UIDs
  • Evaluate custom JavaScript to retrieve data not in the accessibility tree
  • Install and test browser extensions with service worker verification

How to install chrome-devtools

npx skills add https://github.com/chromedevtools/chrome-devtools-mcp --skill chrome-devtools
Prerequisites
  • Chrome browser installed
  • MCP server configuration with chrome-devtools-mcp
  • For extension tools: MCP server started with --categoryExtensions flag
  • For memory tools: MCP server started with --memoryDebugging flag
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 new_page
  3. 3.Wait for content to load using wait_for if needed
  4. 4.Take a snapshot with take_snapshot to see page structure and element UIDs
  5. 5.Interact with elements using click, fill, or other tools with the element UIDs from snapshot
  6. 6.For extensions: install with install_extension, trigger actions with trigger_extension_action, and verify with evaluate_script

Use cases

Good for
  • Debugging web application issues by inspecting page structure and network requests
  • Automating repetitive browser tasks like form submission or data entry
  • Testing browser extensions by installing unpacked extensions and verifying behavior
  • Analyzing page performance and memory usage with optional memory debugging tools
  • Verifying content script injection and extension-modified page behavior
Who it's for
  • Web developers debugging applications
  • QA engineers automating browser testing
  • Extension developers testing unpacked extensions
  • Performance engineers analyzing page metrics
  • Automation engineers building browser-based workflows

chrome-devtools FAQ

What's the difference between take_snapshot and take_screenshot?

take_snapshot returns text-based page structure with element UIDs (faster, better for automation), while take_screenshot captures the visual rendering (useful when you need to show the user what the page looks like).

How do I use element UIDs to interact with the page?

After calling take_snapshot, each element has a unique uid. Use this uid in tools like click, fill, or other interaction tools to target that specific element.

Why aren't extension tools available?

Extension tools require the MCP server to be started with the --categoryExtensions flag. Update your MCP configuration and restart the server to enable them.

What should I do if an element isn't found?

Take a fresh snapshot—the element may have been removed or the page structure changed. The page may also need more time to load; use wait_for before taking a snapshot.

Can I run multiple tool calls at the same time?

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

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 selection: Tools operate on the currently selected page. Use list_pages to see available pages, then select_page to switch context. 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 to understand page structure
  4. Interact: Use element uids from snapshot for click, fill, etc.

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)
  • Additional details: evaluate_script for data not in accessibility tree

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 to check extension state or trigger background actions.
  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.

Related skills

More from chromedevtools/chrome-devtools-mcp and the wider catalog.