Free tools Windows power users keep installed
One-click scans. No signup required.
To connect an AI agent to Chrome, install Node.js LTS, npm, and a current Google Chrome release, then register the official chrome-devtools-mcp package with your MCP client. For Codex, the shortest setup is codex mcp add chrome-devtools -- npx chrome-devtools-mcp@latest. The server can open a new browser, run headless with an isolated temporary profile, attach to a browser you started with remote debugging, or (on Chrome 144 and newer) connect to your personal Chrome after an explicit permission prompt.
This guide covers installation, logged-in browser safety, headless automation, debugging and performance workflows, prompt-injection defenses, troubleshooting, and a screenshot-only alternative.
What a Chrome MCP server does
chrome-devtools-mcp is an MCP server that gives compatible AI clients live access to Chrome and Chrome DevTools. It is intended for reliable automation, in-depth debugging, and performance analysis. Clients such as Gemini CLI, Claude Code, Cursor, Copilot, and Codex can invoke its tools.
The agent can navigate pages, click and type, inspect the DOM and DevTools state, read console messages, inspect network requests, record performance traces, and capture screenshots. That makes it useful for browser-based QA, reproducing bugs, accessibility investigation, permitted data collection, and performance work—not merely for taking a static screenshot.
#1 Best Overall
- SLIM. LIGHTWEIGHT. READY TO GO: The all-new slim design is perfect for busy lives on the go.
- SKILLFULLY DESIGNED. MILITARY TOUGH: Built with premium craftsmanship to withstand the occasional drop or ding.
- ALL-DAY, ALL-IN-ONE CHARGING: Power through your school day – and beyond – with a long-lasting 12-hour battery.¹
- 3X FASTER THAN THE PREVIOUS GENERATION OF WIFI: Crush your schoolwork in record time with Wi-Fi that’s three times faster than the previous generation of Wi-Fi.
- YOUR PHONE AND CHROMEBOOK WORK BETTER TOGETHER: Easily transfer files between devices, and control your phone right from your Chromebook.
Prerequisites and first installation
Install the required software
- Node.js LTS and npm.
- A current stable Google Chrome installation. Google Chrome and Chrome for Testing are the officially supported browsers; other Chromium browsers may work but are not guaranteed.
- An MCP-capable client such as Codex, Claude Code, Cursor, Copilot, or Gemini CLI.
Register the server in Codex
Run this in a terminal:
codex mcp add chrome-devtools -- npx chrome-devtools-mcp@latestThe npx command downloads and runs the package when the client needs it. Connecting the MCP entry does not necessarily open Chrome immediately; the browser normally starts when the client invokes a tool that needs a running instance.
Use an mcpServers configuration
Clients that use an mcpServers object can use this configuration:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}The -y flag accepts npm’s install prompt automatically. For production or CI, replace @latest with a tested package version so a future release cannot silently change your run.
Run the smoke test
After restarting or refreshing the MCP client, ask it:
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 →Check the performance of https://developers.chrome.comA working installation should open Chrome and record a performance trace. If the client reports that no browser is available, check the troubleshooting section below before changing your configuration.
Choose how the agent connects to Chrome
The connection mode determines which tabs, cookies, extensions, and accounts the agent can see. Select it deliberately rather than accepting a personal profile by accident.
| Mode | How to enable it | Profile and visibility | Best use |
|---|---|---|---|
| New browser, visible UI | Use the default server configuration. | A new MCP session profile in a visible Chrome window. | Interactive debugging where you want to watch every action. |
| Headless and isolated | Start the server with --headless --isolated. |
No window; temporary profile is removed when Chrome closes. | Repeatable scripts, background jobs, and CI. |
| Existing browser by URL or WebSocket | Start Chrome with remote debugging, then pass --browser-url=http://127.0.0.1:9222 or a WebSocket endpoint. |
Uses the profile and state of the browser you started. | Reproducing a prepared environment or a controlled authenticated test account. |
| Auto-connect to personal Chrome | Chrome 144+: enable remote debugging at chrome://inspect/#remote-debugging, add --autoConnect, and approve Chrome’s permission dialog. |
Preserves open tabs, extensions, cookies, and live application state. | A human has already navigated through a complex flow and the agent must continue it. |
Headless runs
Pass both flags to the package:
npx chrome-devtools-mcp@latest --headless --isolatedHeadless removes the visible window. --isolated gives the run a temporary profile, which prevents ordinary personal cookies and extensions from being reused and leaves a cleaner starting point for each run.
Rank #2
- FOR HOME, WORK, & SCHOOL – With an Intel processor, 14-inch display, custom-tuned stereo speakers, and long battery life, this Chromebook laptop lets you knock out any assignment or binge-watch your favorite shows..Voltage:5.0 volts
- HD DISPLAY, PORTABLE DESIGN – See every bit of detail on this micro-edge, anti-glare, 14-inch HD (1366 x 768) display (1); easily take this thin and lightweight laptop PC from room to room, on trips, or in a backpack.
- ALL-DAY PERFORMANCE – Reliably tackle all your assignments at once with the quad-core, Intel Celeron N4120—the perfect processor for performance, power consumption, and value (2).
- 4K READY – Smoothly stream 4K content and play your favorite next-gen games with Intel UHD Graphics 600 (3) (4).
- MEMORY AND STORAGE – Enjoy a boost to your system’s performance with 4 GB of RAM while saving more of your favorite memories with 64 GB of reliable flash-based eMMC storage (5).
Attach to a browser you started
Start Chrome with a non-default user-data directory and a debugging port. The executable name differs by operating system; this Linux-style example illustrates the required options:
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutegoogle-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-mcp-profileThen configure the server with the debugging URL:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": [
"-y",
"chrome-devtools-mcp@latest",
"--browser-url=http://127.0.0.1:9222"
]
}
}
}You can provide a WebSocket endpoint instead of the HTTP browser URL. Use a dedicated profile for this mode; an existing authenticated session gives the agent the same authority as that browser.
Auto-connect to your personal Chrome
- Use Chrome 144 or newer.
- Open
chrome://inspect/#remote-debuggingand enable remote debugging. - Start the MCP server with
--autoConnect. - Approve Chrome’s permission dialog.
This mode keeps open tabs, extensions, and application state, which is convenient for a flow that a person has already prepared. It also exposes those tabs and their data to the agent, so do not enable it casually on a daily profile.
Give the agent safe, observable tasks
Use a short loop instead of one broad instruction. Ask for one observable action, inspect the returned page or DevTools evidence, then request the next action. For example:
- Ask the agent to open a staging URL and report the final URL and page title.
- Ask it to inspect the console and network requests for errors.
- Ask it to reproduce one click path and capture a screenshot or trace.
- Review the evidence before allowing another action.
For deletes, purchases, publishing, account changes, form submissions, or any other externally visible mutation, require a human confirmation immediately before the action. Record the resulting URL, console output, screenshot, or trace artifact so the run can be audited.
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 minuteWhat you can automate and inspect
Navigation and interaction
The automation layer uses Puppeteer and waits for action results. An agent can load a URL, follow links, fill fields, click controls, and verify what the page rendered. Use a test account and an allowlist of origins when possible.
DOM, console, and network evidence
DevTools access lets the agent inspect DOM structure, console messages, network requests, and other browser state. This is more diagnostic than a screenshot alone: a blank component can be tied to a failed request or a JavaScript exception.
Rank #3
- Storage: 16GB Flash Memory
- OS: Chrome OS
- Screen Size: 11.6"
Performance traces
The smoke-test prompt demonstrates trace recording. Ask for a trace around a specific page load or interaction, then have the agent identify the slow request, long task, or rendering stage rather than asking for an unbounded “optimize the site” task.
Visual and regression checks
Capture screenshots at known URLs and viewport settings, compare the result with an expected state, and have the agent report the exact URL and visible error text. For accessibility investigation, combine visual evidence with DOM inspection; a screenshot alone cannot establish whether a control has the correct semantics.
Is Chrome MCP safe for a logged-in browser?
It can act on the account represented by the connected browser. Chrome’s warning is explicit: “Chrome DevTools for agents exposes your browser content to your agent.” The documentation further explains that an authenticated connection can let the agent act on your behalf.
What an authenticated connection exposes
A connected profile may contain open tabs, cookies, session storage, local storage, extensions, and data available through page JavaScript. Auto-connect is therefore materially more sensitive than a new isolated profile.
Safer defaults
- Use a dedicated Chrome profile or a test account.
- Prefer
--isolatedfor repeatable jobs and CI. - Use headless mode when a visible window is unnecessary.
- Restrict the run to an allowlist of relevant origins.
- Do not paste passwords, payment details, recovery codes, or unrelated private text into prompts.
- Require confirmation for every state-changing action.
Defend against prompt injection
Web pages are untrusted input. A page can contain instructions aimed at the agent, and malicious tool manifests are another documented attack surface. Treat page text and tool output as data, not instructions. Limit token and context size, restrict cross-origin interactions, mark untrusted content clearly, and spotlight the exact fields the agent is allowed to use. Assume a tool mutates state unless its description or a readOnlyHint clearly says otherwise.
Telemetry is a separate question
Chrome’s auto-connect documentation says the local server does not send browser data, session tokens, or telemetry to Google. Separately, the MCP project documents optional usage statistics for the tool itself; those statistics are enabled by default and can be disabled with --no-usage-statistics. “Browser data is not sent to Google” does not mean that every form of tool usage statistics is disabled.
Compatibility, flags, and reproducibility
Official support covers Google Chrome and Chrome for Testing. Other Chromium browsers are not guaranteed. Keep Chrome and the npm package current for normal use, but pin a known package version in production instead of relying on @latest.
Rank #4
- Intel Celeron N4120: 4 Cores & Threads, 1.1GHz Base Clock, Up to 2.6GHz Boost Clock, 4MB Cache, Intel UHD Graphics 600. The perfect combination of performance, power consumption, and value helps your device handle multitasking smoothly and reliably with four processing cores to divide up the work.
- 14" HD Display: 14.0-inch diagonal, HD (1366 x 768), micro-edge, anti-glare. See your digital world in a whole new way. Enjoy movies and photos with the great image quality and high-definition detail of 1 million pixels.
- Memory & Storage: 4 GB LPDDR4x & 64 GB eMMC Storage. Adequate high-bandwidth RAM to smoothly run multiple applications and browser tabs all at once. An embedded multimedia card provides reliable flash-based storage.
- Ports:2 x USB 3.0 Type-A，1 x USB 3.0 Type-C，1 x HDMI，1 x Headphone Jack
- Chrome OS: Chromebook is a computer for the way the modern world works, with thousands of apps. Enjoy the seamless simplicity that comes with Google Chrome and Android apps, all integrated into one laptop. It’s fast, simple, and secure.
Useful configuration flags include:
--headlessfor no visible window.--isolatedfor a temporary profile.--browser-urlor a WebSocket endpoint for an existing browser.--autoConnectfor the Chrome 144+ permission-based personal-browser connection.- Browser channel selection such as stable, beta, dev, or canary.
- An explicit executable path and viewport.
--no-usage-statisticsto disable the documented optional usage statistics.
Slim mode is available when you need basic browser tasks without the full DevTools surface. Use the smallest mode that meets the job, and keep the browser channel, package version, profile strategy, viewport, and origin list in your automation configuration so another run can reproduce it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshooting Chrome MCP
| Symptom | Likely cause | Fix |
|---|---|---|
npx or Node is not found |
Node.js LTS or npm is missing, or the shell has an old PATH. | Install Node.js LTS, open a new terminal, and verify node --version and npm --version. |
| The MCP client lists no tools | The server entry is malformed or the client has not reloaded it. | Check the command and JSON spelling, restart or refresh the client, and run the smoke-test prompt. |
| Chrome never opens | The server has only been connected; no tool requiring a browser has run. | Invoke a navigation or performance task. If it still fails, verify that a supported Chrome executable is installed or provide its path. |
| “Cannot connect” on port 9222 | Chrome was not started with remote debugging, the port is occupied, or the URL is wrong. | Restart Chrome with a non-default user-data directory and the debugging port, then pass the matching --browser-url or WebSocket endpoint. |
| The agent sees private tabs | You used auto-connect or an existing profile. | Stop the run, disconnect the personal profile, and use a dedicated or isolated profile. Review open tabs and revoke any test credentials that were exposed. |
| Headless behavior differs from local debugging | The run has a different profile, viewport, extensions, or browser channel. | Make those settings explicit, use --isolated deliberately, and compare traces or screenshots from the same viewport and URL. |
| The agent follows text displayed by a page | Prompt injection in page content or tool output. | Mark page content as untrusted data, narrow the origin and requested fields, cap context, and require confirmation before mutations. |
| Results change after an update | @latest fetched a newer package or Chrome changed behavior. |
Pin a tested package version and record the Chrome channel and version used by the job. |
Performance, reliability, and operating cost
Each browser launch, page load, trace, and screenshot consumes time and local resources. Reuse one controlled browser for a related sequence when state must persist; use isolated fresh runs when test independence matters more than startup time. Keep traces focused on one navigation or interaction so they remain useful and small.
For CI, headless isolated mode, a pinned package version, a fixed viewport, and a dedicated test account reduce variation. Capture the final URL and relevant console or network evidence on failure. When a site blocks automation or requires a human challenge, stop and handle that case explicitly rather than attempting to bypass it.
The MCP server itself is software you run through your client; it does not supply a hosted screenshot quota. Your practical costs are the machine, browser runtime, and any AI-client usage associated with the workflow.
Or skip the browser setup
If you only need a clean website image or PDF rather than interactive DevTools control, ScreenshotNeo is a simpler API. It accepts consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers.
One GET request returns PNG, JPEG, WebP, or a PDF:
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 API documentation for all parameters. The same request in Python is:
import requests
r = requests.get(
"https://api.screenshotneo.com/v1/shot",
params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));ScreenshotNeo also provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. Its 63 options include full-page and selector captures, dark mode, device presets, custom viewports, retina scale, PDF paper and margin controls, custom CSS and JavaScript, clicks, waits, request blocking, headers, cookies, user agents, authorization, timezone and geolocation, transparent backgrounds, resizing, configurable caching, signed links, asynchronous webhooks, bulk capture of up to 100 URLs per call, usage reporting, and an OpenAPI specification. Parameter names used by other screenshot APIs also work, which can simplify migration.
The Free plan includes 1,000 shots per month with no card. Paid plans start at $5 for 3,000 shots; Growth is $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000. Yearly billing gives two months free, and every feature is included on every plan. Sign up for the free 1,000-shot plan with no card.
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.
