Yes—Chrome DevTools MCP can control Microsoft Edge. Edge implements the Chrome DevTools Protocol (CDP), so the chrome-devtools-mcp server can inspect pages, navigate, capture screenshots and work with an embedded WebView2 app. You can have the server launch a clean Edge profile, attach to an already-running Edge session, or attach to a WebView2 host.
This guide covers the prerequisites, each connection method, client configuration, verification, security boundaries, and the errors that most often prevent a connection.
What Chrome DevTools MCP is doing with Edge
Chrome DevTools MCP is an MCP server that exposes browser inspection and automation tools to an MCP-capable coding agent. Microsoft documents Edge as a supported Chromium target because its DevTools Protocol APIs match the Chrome DevTools Protocol APIs. The server communicates with Edge through the DevTools WebSocket endpoint rather than through ordinary page-level browser automation.
You can use the connection to ask an agent to open a URL, inspect the DOM and console, investigate network or performance information, and take a screenshot. The exact tool names and prompts depend on the MCP client, but the browser connection choices are the same.
#1 Best Overall
Prerequisites
- Node.js: install the latest LTS release, including npm.
- Microsoft Edge: Stable, Beta, Dev or Canary. Use the channel whose executable or profile you intend to control.
- An MCP-capable client: for example, a coding agent that supports local MCP servers.
- A configuration file: Microsoft’s examples use VS Code’s
mcp.json. Other clients use different filenames, property names and wrappers.
The documented server invocation is npx -y chrome-devtools-mcp@latest. Because npx downloads the package when needed, the machine running the client must be able to reach npm and the package registry.
Choose the right connection method
| Method | Use it when | What you configure | Browser state |
|---|---|---|---|
| Server-launched Edge | You want a fresh, agent-controlled browser | --executablePath pointing to Edge |
New instance/profile unless you supply other profile settings |
| Auto-connect to Edge | You need an existing window, login or cookies | Remote debugging, --autoConnect and the Edge user-data directory |
Existing session, including accounts and cookies |
| Auto-connect to WebView2 | The target is an embedded Windows application | Host debugging, --autoConnect and the WebView2 user-data directory |
The application’s WebView2 profile |
Method 1: let the MCP server launch Edge
This is the simplest setup when the agent does not need your currently open tabs or signed-in account. The MCP server starts Edge itself, so your client configuration must identify the executable for the installed operating system and Edge channel.
Configure the server
In a VS Code MCP configuration, the server entry uses a standard input/output transport and passes the executable path as an argument. Keep the package invocation and argument separate:
{
"servers": {
"edge-devtools": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"chrome-devtools-mcp@latest",
"--executablePath",
"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
]
}
}
}Replace the Windows path with the actual executable path on your machine. Microsoft provides platform-specific paths for Windows, macOS and Linux; the correct value also changes between Stable, Beta, Dev and Canary. Do not copy a Stable path when you installed another channel.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Start and verify
- Save the MCP configuration and restart or reload the client so it starts the server.
- Ask the agent to navigate to a simple page and take a screenshot.
- Confirm that a new Edge window appears and that the screenshot corresponds to the requested page.
If the agent reports that it cannot find the executable, fix the path first. A browser installed per-user may be in a different directory from the system-wide installation.
Method 2: connect to a running Edge browser
Use auto-connect when the browser already contains a login, cookies, extensions or a page you want the agent to inspect. This is more convenient for debugging an authenticated site, but it gives the agent access to the active session.
Enable remote debugging
You can start Edge with a remote debugging port:
msedge.exe --remote-debugging-port=9222Alternatively, open edge://inspect, choose Remote debugging, and enable it for the browser instance. The debugging endpoint exposes targets through a local address such as http://localhost:9222/json/list; each target includes a webSocketDebuggerUrl that a DevTools client can use.
Configure auto-connect
Add the auto-connect switch and the user-data directory belonging to that Edge instance:
{
"servers": {
"edge-devtools": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"chrome-devtools-mcp@latest",
"--autoConnect",
"--user-data-dir",
"C:\Users\YOUR_NAME\AppData\Local\Microsoft\Edge\User Data"
]
}
}
}Use the profile directory for the browser you actually started with remote debugging. Microsoft documents different user-data locations for Windows, macOS and Linux. A path for the wrong operating system, channel or profile can make auto-connect fail even when Edge is open.
Understand the security consequence
An attached session can expose signed-in accounts, cookies and information available through page JavaScript. Microsoft recommends using this mode only with a trusted agent and treating its prompts as you would any other request to operate your logged-in browser. Prefer a separate test profile for sensitive work.
Method 3: connect to a WebView2 application
WebView2 is an embedded Edge-powered browser surface inside a Windows application, not a normal Edge window. The host application must enable remote debugging before the MCP server can attach.
- Enable WebView2 debugging in the host by using Microsoft’s WebView2Utilities approach or the documented Windows registry setting.
- Find the WebView2 user-data folder used by that application. A common profile path ends in
EBWebView. - Configure
--autoConnectand set--user-data-dirto that host-specific folder. - Start the host application before the MCP client attempts to connect.
{
"servers": {
"webview2-devtools": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"chrome-devtools-mcp@latest",
"--autoConnect",
"--user-data-dir",
"C:\Path\To\YourApp\EBWebView"
]
}
}
}Do not substitute your ordinary Edge profile for the application’s WebView2 directory. The embedded host has its own browser data and target lifecycle.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteClient configuration differences
The server arguments above are independent of the client wrapper. Microsoft’s VS Code examples use servers with type: "stdio". Copilot CLI uses mcpServers and type: "local". Many other MCP clients use mcpServers without a type field. Check the selected client’s configuration requirements before copying a VS Code example verbatim.
The command must ultimately launch npx -y chrome-devtools-mcp@latest; only the surrounding JSON, transport label and file location vary.
Verify the connection methodically
- Start the intended Edge channel or WebView2 host.
- Check that remote debugging is enabled when using auto-connect.
- Confirm the user-data directory exactly matches that running instance.
- Reload the MCP client and wait for the server to start.
- Ask the agent to navigate to a harmless page and take a screenshot.
- If that succeeds, test the real page or application and then inspect console, network or performance data.
For a running browser, the DevTools endpoint can also be inspected locally at http://localhost:9222/json/list. If it does not list a target, the debugging flag or host configuration is not active.
Troubleshooting
“Cannot connect” or no browser target
- For auto-connect, start Edge or the WebView2 host before the MCP client.
- Enable remote debugging and verify that the local target list is available.
- Check that another process has not claimed the debugging port.
- Use the exact user-data directory for the active browser or host.
Executable path errors
When the server launches Edge, --executablePath must point to the installed channel’s executable. Check whether Edge is installed system-wide or per-user, and whether you selected Stable, Beta, Dev or Canary.
Recommended Free Tools
WebView2 connection failures
Confirm that the host application has debugging enabled and that its profile directory—not a normal Edge profile—is supplied. The folder commonly ends in EBWebView, but the application determines the actual location.
The agent opens the wrong account or page
This usually means the wrong profile was attached. Stop the browser, identify the profile used with remote debugging, and update --user-data-dir. For sensitive debugging, create a dedicated test account and profile.
The client rejects the configuration
Translate the server entry into the client’s required wrapper. In particular, check whether it expects servers or mcpServers, whether a transport type is mandatory, and whether local servers are permitted by policy.
Performance, reliability and operational limits
Server-launched Edge is predictable because it starts a controlled instance, but it does not automatically contain your existing login state. Auto-connect avoids a login step and can inspect a live tab, while introducing dependencies on the running process, debugging port and profile path. WebView2 adds the host application and its debugging configuration to that dependency chain.
Free tools Windows power users keep installed
One-click scans. No signup required.
Best Value
For repeatable investigations, use a dedicated profile, keep the Edge channel and executable path fixed, and start the browser before the agent. For one-off authenticated debugging, auto-connect is practical; for unattended or shareable workflows, a fresh server-launched profile limits accidental access to personal data.
Or skip the browser setup
If you only need a clean image or PDF of a URL—not an interactive DevTools session—ScreenshotNeo is a simpler website screenshot API. It removes cookie-consent banners, newsletter popups and chat widgets before capture; bot checks, blank pages, timeouts, failed loads and cache hits are not billed. Its MCP server provides take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients.
One request is enough:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for all options and MCP setup. The Free plan includes 1,000 screenshots each month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Frequently Asked Questions
Does this work with Edge Beta, Dev and Canary?
Yes. Microsoft lists Stable, Beta, Dev and Canary; use the executable and profile paths for the channel you actually installed.
Can the MCP server attach to an ordinary Edge tab without remote debugging?
No. Auto-connect requires Edge or the WebView2 host to expose remote debugging so the server can discover a DevTools target.
Is WebView2 the same as Microsoft Edge?
No. WebView2 is an embedded browser host. It uses its own application profile and must be configured for debugging separately.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
