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- 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
How to use chrome-devtools
- 1.Install the skill: npx skills add https://github.com/chromedevtools/chrome-devtools-mcp --skill chrome-devtools
- 2.Navigate to a page using navigate_page or create a new page with new_page
- 3.Wait for content to load using wait_for if needed
- 4.Take a snapshot with take_snapshot and the pageId to see page structure and element UIDs
- 5.Interact with elements using their UIDs via click, fill, or other interaction tools
- 6.Use take_screenshot for visual inspection or get_css_styles for styling details
- 7.For extensions: install with install_extension, trigger actions, and evaluate scripts in service workers
Use cases
- 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
- 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
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.
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.
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.
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.
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
--categoryExtensionsflag. - For memory tooling, use the
--memoryDebuggingflag.
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
- Navigate:
navigate_pageornew_page - Wait:
wait_forto ensure content is loaded if you know what you look for. - Snapshot:
take_snapshotwithpageIdto understand page structure - Interact: Use element
uids from snapshot forclick,fill, etc., passing the correspondingpageId.
Efficient data retrieval
- Use
filePathparameter for large outputs (screenshots, snapshots, traces) - Use pagination (
pageIdx,pageSize) and filtering (types) to minimize data - Set
includeSnapshot: falseon 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_stylesto inspect matched rules, cascade, and CSS variables. Treat the output as authoritative and complete. - Additional details: Use
evaluate_scriptfor runtime DOM/JS data not available viaget_css_stylesortake_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--categoryExtensionsflag. 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.
- Install: Use
install_extensionwith the path to the unpacked extension. - Identify: Get the extension ID from the response or by calling
list_extensions. - Trigger Action: Use
trigger_extension_actionto open the popup or side panel if applicable. - Verify Service Worker: Use
evaluate_scriptwithserviceWorkerId(omittingpageIdandargs) to check extension state or trigger background actions. When evaluating in a page, passpageId(omittingserviceWorkerId). - Verify Page Behavior: Navigate to a page where the extension operates and use
take_snapshotto 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.

chrome-devtools-cli
Automate browser tasks and inspect Chrome DevTools from the command line.

debug-optimize-lcp
Debug and optimize Largest Contentful Paint (LCP) performance using Chrome DevTools MCP.

memory-leak-debugging
Diagnose and fix memory leaks in JavaScript/Node.js apps using Chrome DevTools MCP heap snapshot tools.

troubleshooting
Diagnose and fix Chrome DevTools MCP connection and initialization failures.

ego-browser
Chromium browser for AI agents to automate websites, fill forms, extract data, and test web apps.

clickup
Interact with ClickUp tasks and documents via API—get details, manage tasks, post comments, and create/edit docs.