WebMCP Documentation

This guide shows you how to use the upstream chrome-devtools-mcp package to connect desktop AI agents to a live Chrome browser. The server gives your agent browser automation tools plus the ability to discover and call WebMCP tools registered on a page. Use chrome-devtools-mcp@latest directly; the WebMCP changes from the former fork have all landed upstream.

Install the MCP server

Add the server to your MCP client configuration and enable its experimental WebMCP category:

MCP client configuration

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--category-experimental-webmcp",
        "--chrome-arg=--enable-features=WebMCP"
      ]
    }
  }
}

The upstream WebMCP category currently requires Chrome 150 or newer with the WebMCP feature enabled. The configuration above passes the required browser flag. The server launches Chrome when the agent first uses a browser tool; connecting to the MCP server alone does not start it.

Test the connection

Enter this prompt in your MCP client:

Prompt

Navigate to https://webmcp.sh and take a screenshot

Your agent should open Chrome, navigate to the page, and return a screenshot. This confirms the browser connection works before you start discovering tools.

Discover WebMCP tools on a page

The server detects Chrome’s native WebMCP registry through the Chrome DevTools Protocol. MCP-B tools appear when @mcp-b/global adopts and mirrors that native context; a standalone JavaScript polyfill is not a DevTools discovery source. The upstream server exposes two WebMCP tools:

list_webmcp_tools lists the tools exposed by the current page.
execute_webmcp_tool executes one listed tool with JSON-stringified input.

Ask your agent:

Prompt

Navigate to https://webmcp.sh, call list_webmcp_tools, and show me the available tools.

webmcp.sh landing page showing registered WebMCP tools organized by category — webmcp.sh registers tools for navigation, data management, SQL queries, and more

Then ask it to execute a listed tool:

Prompt

Use execute_webmcp_tool to call sql_query with this query:
SELECT name, category, importance_score
FROM memory_entities
ORDER BY importance_score DESC
LIMIT 5

The agent passes the selected tool name and JSON-stringified input to execute_webmcp_tool, then returns the result from the page.

SQL REPL showing query results returned by the agent via the sql_query WebMCP tool — The agent executed the sql_query WebMCP tool against the in-browser PostgreSQL database

Call list_webmcp_tools again after a navigation or hot reload. The upstream tool returns the current page’s list and takes no parameters.

Use the AI-driven development workflow

The most powerful use case is building WebMCP tools with your AI agent in a tight feedback loop. Clone the Chrome DevTools Quickstart for a minimal project with @mcp-b/global pre-installed, or use your own app.

Ask your agent to create a tool

Prompt

Wrap our existing product-search function in a WebMCP tool named "search_products"

Let the dev server reload the change

Wait for the app’s normal hot reload to finish.

The agent discovers the new tool

Prompt

Navigate to http://localhost:3000 and call list_webmcp_tools

The agent tests the tool

Prompt

Call execute_webmcp_tool with toolName=search_products and input={"query":"headphones"}

The agent iterates if something fails

The agent sees the actual response, fixes bugs, and repeats until the tool works.

Connect to an existing Chrome instance

By default, the server launches its own Chrome with a dedicated profile. This is the simplest way to use the experimental WebMCP category because the server supplies the required feature flags. If you attach to an existing Chrome session, launch that browser with --enable-features=WebMCP first.

Auto-connect (Chrome 144+)

Enable remote debugging in Chrome

Navigate to chrome://inspect/#remote-debugging and follow the dialog to allow debugging connections.

Use the autoConnect flag

MCP client configuration

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--category-experimental-webmcp",
        "--autoConnect"
      ]
    }
  }
}

Manual connection via remote debugging port

Configure the MCP server with a browser URL

MCP client configuration

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--category-experimental-webmcp",
        "--browser-url=http://127.0.0.1:9222"
      ]
    }
  }
}

Start Chrome with remote debugging enabled

/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
  --remote-debugging-port=9222 \
  --enable-features=WebMCP \
  --user-data-dir=/tmp/chrome-profile-stable

google-chrome --remote-debugging-port=9222 \
  --enable-features=WebMCP \
  --user-data-dir=/tmp/chrome-profile-stable

"C:\Program Files\Google\Chrome\Application\chrome.exe" ^
  --remote-debugging-port=9222 ^
  --enable-features=WebMCP ^
  --user-data-dir="%TEMP%\chrome-profile-stable"

The remote debugging port is accessible to any process on your machine. Do not browse sensitive websites while it is open.

Common configuration options

Pass options through the args array in your MCP client config:

MCP client configuration

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--category-experimental-webmcp",
        "--chrome-arg=--enable-features=WebMCP",
        "--channel=canary",
        "--headless=true",
        "--isolated=true"
      ]
    }
  }
}

Option	What it does
`--category-experimental-webmcp`	Enable upstream WebMCP discovery and execution
`--chrome-arg`	Pass a feature or launch argument to a browser started by the server
`--channel`	Chrome channel: `stable`, `canary`, `beta`, `dev`
`--headless`	Run without a visible browser window
`--isolated`	Use a temporary profile, cleaned up on close
`--viewport`	Initial viewport size (e.g. `1280x720`)
`--executablePath`	Path to a custom Chrome binary

For the full list of options, see the upstream Chrome DevTools MCP repository.

Troubleshoot common issues

Problem	Fix
WebMCP tools are unavailable	Add the WebMCP category and `--chrome-arg=--enable-features=WebMCP`, or enable `WebMCP` when attaching to an existing Chrome 150+ browser
”WebMCP not detected”	Confirm the page exposes `document.modelContext` and has registered at least one tool
Tool call fails	Check the schema from `list_webmcp_tools`; pass JSON-stringified input to `execute_webmcp_tool`
Tools missing after navigation	Call `list_webmcp_tools` again for the current page
Browser does not start in sandbox	Some MCP clients sandbox the server process. Disable sandboxing for this server, or use `--browser-url` to connect to an external Chrome

ChromeDevTools/chrome-devtools-mcp for the full upstream tool list and CLI options
Connect desktop agents with the local relay for an explicit page-to-desktop bridge
Debug and Troubleshoot for general debugging strategies

How-To Guides

Adoption

Frameworks

Connectivity

Use Chrome DevTools MCP

Install the MCP server

Test the connection

Discover WebMCP tools on a page

Use the AI-driven development workflow

Connect to an existing Chrome instance

Auto-connect (Chrome 144+)

Manual connection via remote debugging port

Common configuration options

Troubleshoot common issues

​Install the MCP server

​Test the connection

​Discover WebMCP tools on a page

​Use the AI-driven development workflow

​Connect to an existing Chrome instance

​Auto-connect (Chrome 144+)

​Manual connection via remote debugging port

​Common configuration options

​Troubleshoot common issues

​Related pages

Install the MCP server

Test the connection

Discover WebMCP tools on a page

Use the AI-driven development workflow

Connect to an existing Chrome instance

Auto-connect (Chrome 144+)

Manual connection via remote debugging port

Common configuration options

Troubleshoot common issues

Related pages