Chrome Devtools MCP 6b167e25

MCP开发工具

提供方 benjaminr

开发工具 stdio · 本地进程 会话登录 社区 / 第三方 Claude DesktopClaude
查看接入方式

一个通过MCP协议集成Chrome开发者工具的服务,允许用户调试网页应用,监控网络请求、控制台错误和性能问题。

一句话选型结论

按资料字段整理

Chrome Devtools MCP 6b167e25 属于开发工具类 MCP 服务器,stdio · 本地进程,会话登录,可直接接入 Claude Desktop、Claude,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式stdio · 本地进程 鉴权会话登录 部署方式本地部署
GitHub 星标 297 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

网页调试Python本地部署开发者工具性能分析网络监控JavaScript调试

安装与配置

stdio · 本地进程 会话登录
客户端在本机拉起子进程,数据不出本机
pip install -r requirements.txt

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Chrome Devtools MCP 6b167e25当前 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方benjaminr上游标注的维护方 benjaminr
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

23.5 KB
来自项目仓库与上游目录的原文,未做删改

Chrome DevTools MCP

A Model Context Protocol (MCP) server that provides Chrome DevTools Protocol integration through MCP. This allows you to debug web applications by connecting to Chrome's developer tools.

Available as a Claude Desktop Extension (.dxt) for easy one-click installation!

What This Does

This MCP server acts as a bridge between Claude and Chrome's debugging capabilities. Once installed in Claude Desktop, you can:
- Connect Claude to any web application running in Chrome
- Debug network requests, console errors, and performance issues
- Inspect JavaScript objects and execute code in the browser context
- Monitor your application in real-time through natural conversation with Claude

Note: This is an MCP server that runs within Claude Desktop - you don't need to run any separate servers or processes.

Features

  • Network Monitoring: Capture and analyse HTTP requests/responses with filtering options
  • Console Integration: Read browser console logs, analyse errors, and execute JavaScript
  • Performance Metrics: Timing data, resource loading, and memory utilisation
  • Page Inspection: DOM information, page metrics, and multi-frame support
  • Storage Access: Read cookies, localStorage, and sessionStorage
  • Real-time Monitoring: Live console output tracking
  • Object Inspection: Inspect JavaScript objects and variables

Installation

Option 1: Claude Desktop Extension (Easiest)

Download the pre-built extension:
1. Download the latest .dxt file from Releases
2. Open Claude Desktop
3. Go to Extensions and install the downloaded .dxt file
4. Configure Chrome path if needed in extension settings

The extension includes all dependencies and is ready to use immediately!

Option 2: MCP CLI (Advanced)

Quick Install (most common):```bash
git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
mcp install server.py -n "Chrome DevTools MCP" --with-editable .


> **Note**: The `mcp` command is part of the Python MCP SDK. Install it with `pip install mcp` if not already available.

**All Installation Options:**```bash
# Clone the repository
git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp

# The --with-editable flag uses pyproject.toml to install dependencies

# Basic installation with local dependencies
mcp install server.py --with-editable .

# Install with custom name
mcp install server.py -n "Chrome DevTools MCP" --with-editable .

# Install with environment variables
mcp install server.py -n "Chrome DevTools MCP" --with-editable . -v CHROME_DEBUG_PORT=9222

# Install with additional packages if needed
mcp install server.py -n "Chrome DevTools MCP" --with-editable . --with websockets --with aiohttp

# Install with environment file (copy .env.example to .env first)
cp .env.example .env
# Edit .env with your settings
mcp install server.py -n "Chrome DevTools MCP" --with-editable . -f .env

Option 3: Claude Code Integration

For Claude Code CLI users:

  1. Clone this repository```bash
    git clone https://github.com/benjaminr/chrome-devtools-mcp.git
    cd chrome-devtools-mcp

2. **Install dependencies with UV (creates venv)**```bash
uv sync  # Creates .venv and installs dependencies
  1. Add MCP server using Claude CLI with absolute paths

IMPORTANT: Claude Code needs absolute paths to both the Python interpreter and the server script to work correctly.

Recommended setup using absolute paths:```bash

Get the absolute paths

SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"

Add the server with absolute paths

claude mcp add chrome-devtools "$PYTHON_PATH" "$SERVER_PATH" -e CHROME_DEBUG_PORT=9222


**Alternative: Using the system Python (if dependencies are installed globally):**```bash
# Only if you've installed dependencies globally
claude mcp add chrome-devtools python "$(pwd)/server.py" -e CHROME_DEBUG_PORT=9222

With custom scope:```bash

Add to user scope (available across all projects)

claude mcp add chrome-devtools "$(pwd)/.venv/bin/python" "$(pwd)/server.py" -s user -e CHROME_DEBUG_PORT=9222

Add to project scope (only for this project)

claude mcp add chrome-devtools "$(pwd)/.venv/bin/python" "$(pwd)/server.py" -s project -e CHROME_DEBUG_PORT=9222


4. **Verify installation**```bash
# List configured MCP servers
claude mcp list

# Get details about the server (check that paths are absolute)
claude mcp get chrome-devtools

# The output should show absolute paths like:
# Command: /Users/you/chrome-devtools-mcp/.venv/bin/python
# Args: ["/Users/you/chrome-devtools-mcp/server.py"]

Common Path Issues and Solutions:
- Problem: "python: command not found" or "server.py not found"
- Solution: Use absolute paths as shown above
- Problem: "ModuleNotFoundError" when server starts
- Solution: Use the venv Python interpreter that has dependencies installed
- Problem: Server doesn't start or shows as disconnected
- Solution: Test the command manually: /path/to/.venv/bin/python /path/to/server.py

Option 4: Manual Claude Desktop Setup

  1. Clone this repository```bash
    git clone https://github.com/benjaminr/chrome-devtools-mcp.git
    cd chrome-devtools-mcp

2. **Install dependencies**

**With uv (recommended):**```bash
uv sync

With pip:```bash
pip install -r requirements.txt


3. **Add to Claude Desktop configuration**

Edit your Claude Desktop config file:
- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows**: `%APPDATA%/Claude/claude_desktop_config.json````json
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "python",
      "args": ["/absolute/path/to/chrome-devtools-mcp/server.py"],
      "env": {
        "CHROME_DEBUG_PORT": "9222"
      }
    }
  }
}
  1. Restart Claude Desktop

Verify Installation

After installation (either method), verify the server is available:
1. Open Claude Desktop
2. Look for MCP tools in the conversation
3. Try a simple command: get_connection_status()

Alternative MCP Clients

For other MCP clients, run the server directly:```bash
python server.py


## Quick Start

Once installed in Claude Desktop, you can start debugging any web application:

### Debug Your Web Application

**One-step setup (recommended):**```
start_chrome_and_connect("localhost:3000")

Replace localhost:3000 with your application's URL

If Chrome isn't found automatically:```
start_chrome_and_connect("localhost:3000", chrome_path="/path/to/chrome")

*Use the `chrome_path` parameter to specify a custom Chrome location*

This command will:
- Start Chrome with debugging enabled
- Navigate to your application
- Connect the MCP server to Chrome

**Manual setup (if you prefer step-by-step):**```
start_chrome()
navigate_to_url("localhost:3000")
connect_to_browser()

Start Debugging

Once connected, use these commands:
- get_network_requests() - View HTTP traffic
- get_console_error_summary() - Analyse JavaScript errors
- inspect_console_object("window") - Inspect any JavaScript object

Available MCP Tools

Chrome Management

  • start_chrome(port?, url?, headless?, chrome_path?, auto_connect?) - Start Chrome with remote debugging and optional auto-connection
  • start_chrome_and_connect(url, port?, headless?, chrome_path?) - Start Chrome, connect, and navigate in one step
  • connect_to_browser(port?) - Connect to existing Chrome instance
  • navigate_to_url(url) - Navigate to a specific URL
  • disconnect_from_browser() - Disconnect from browser
  • get_connection_status() - Check connection status

Network Monitoring

  • get_network_requests(filter_domain?, filter_status?, limit?) - Get network requests with filtering
  • get_network_response(request_id) - Get detailed response data including body

Console Tools

  • get_console_logs(level?, limit?) - Get browser console logs
  • get_console_error_summary() - Get organized summary of errors and warnings
  • execute_javascript(code) - Execute JavaScript in browser context
  • clear_console() - Clear the browser console
  • inspect_console_object(expression) - Deep inspect any JavaScript object
  • monitor_console_live(duration_seconds) - Monitor console output in real-time

Page Analysis

  • get_page_info() - Get comprehensive page metrics and performance data
  • evaluate_in_all_frames(code) - Execute JavaScript in all frames/iframes
  • get_performance_metrics() - Get detailed performance metrics and resource timing

Storage & Data

  • get_storage_usage_and_quota(origin) - Get storage usage and quota information
  • clear_storage_for_origin(origin, storage_types?) - Clear storage by type and origin
  • get_all_cookies() - Get all browser cookies
  • clear_all_cookies() - Clear all browser cookies
  • set_cookie(name, value, domain, path?, expires?, http_only?, secure?, same_site?) - Set a cookie
  • get_cookies(domain?) - Get browser cookies with optional domain filtering
  • get_storage_key_for_frame(frame_id) - Get storage key for a specific frame
  • track_cache_storage(origin, enable?) - Enable/disable cache storage tracking
  • track_indexeddb(origin, enable?) - Enable/disable IndexedDB tracking
  • override_storage_quota(origin, quota_size_mb?) - Override storage quota

Use Cases

Debugging API Calls in Your Web Application

When your web application makes API calls that fail or return unexpected data:

Easy setup: Use the one-step command to start Chrome and navigate to your app:

Example workflow:```
You: "I need to debug my React app at localhost:3000"
Claude: I'll start Chrome with debugging enabled and navigate to your app.

start_chrome_and_connect("localhost:3000")

Perfect! Chrome is now running with debugging enabled and connected to your app. Let me check for any failed network requests:

get_network_requests(filter_status=500)

I can see there are 3 failed requests to your API. Let me get the details of the first one:

get_network_response("request-123")


**Manual setup (if you prefer):**
1. **Start Chrome**: Use `start_chrome()`
2. **Navigate to your app**: Use `navigate_to_url("localhost:3000")`
3. **Connect**: Use `connect_to_browser()`
4. **Monitor network traffic**: Use `get_network_requests()` to see all API calls

### Checking JavaScript Console Errors

When your web application has JavaScript errors or unexpected behaviour:

1. **Navigate to your application** in the connected Chrome instance
2. **Check for console errors**: Use `get_console_error_summary()` to see all errors
3. **Monitor live errors**: Use `monitor_console_live(10)` to watch for new errors as you interact
4. **Inspect variables**: Use `inspect_console_object("myVariable")` to examine application state

**Example workflow:**```
You: "My React component isn't updating properly"
Claude: Let me check the JavaScript console for any errors.

get_console_error_summary()

I can see there are 2 JavaScript errors. Let me also monitor the console while you interact with the component:

monitor_console_live(15)

Now try clicking the component that isn't working. I'll watch for any new errors or warnings.

Performance Debugging

When your web application loads slowly or uses too much memory:

  1. Load your application in the connected browser
  2. Check page metrics: Use get_page_info() to see load times and resource counts
  3. Analyse performance: Use get_performance_metrics() to see detailed timing data
  4. Monitor memory usage: Check the memory information in the performance metrics

Example workflow:```
You: "My application takes too long to load"
Claude: Let me analyse the performance of your application.

get_page_info()

I can see your page has 47 scripts and took 3.2 seconds to load. Let me get more detailed performance data:

get_performance_metrics()

The main bottleneck is the initial JavaScript bundle which is 2.1MB. The DOM processing also takes 800ms.


### Debugging Authentication Issues

When login or session management isn't working:

1. **Navigate to your login page**
2. **Check cookies**: Use `get_cookies()` to see authentication cookies
3. **Monitor network during login**: Use `monitor_console_live()` and `get_network_requests()` during the login process
4. **Examine stored data**: Use JavaScript execution to check localStorage/sessionStorage

**Example workflow:**```
You: "Users can't stay logged in"
Claude: Let me check the authentication setup.

get_cookies()

I can see the auth cookie is present. Let me check what happens during login by monitoring the network:

get_network_requests(filter_domain="your-api.com")

I notice the login request returns a 200 but no Set-Cookie header. Let me also check localStorage:

execute_javascript("Object.keys(localStorage)")

DOM Element Inspection

  • get_document(depth?, pierce?) - Retrieve DOM document structure
  • query_selector(node_id, selector) - Find single element by CSS selector
  • query_selector_all(node_id, selector) - Find multiple elements by CSS selector
  • get_element_attributes(node_id) - Get all attributes of an element
  • get_element_outer_html(node_id) - Get outer HTML of an element
  • get_element_box_model(node_id) - Get layout information
  • describe_element(node_id, depth?) - Get detailed element description
  • get_element_at_position(x, y) - Get element at screen position
  • search_elements(query) - Search DOM elements by text/attributes
  • focus_element(node_id) - Focus a DOM element

CSS Style Analysis

  • get_computed_styles(node_id) - Get computed CSS styles
  • get_inline_styles(node_id) - Get inline styles
  • get_matched_styles(node_id) - Get all CSS rules matching an element
  • get_stylesheet_text(stylesheet_id) - Get stylesheet content
  • get_background_colors(node_id) - Get background colors and fonts
  • get_platform_fonts(node_id) - Get platform font information
  • get_media_queries() - Get all media queries
  • collect_css_class_names(stylesheet_id) - Collect CSS class names
  • start_css_coverage_tracking() - Start CSS coverage tracking
  • stop_css_coverage_tracking() - Stop and get CSS coverage results

Common Commands

Task Command
Start Chrome and connect to app start_chrome_and_connect("localhost:3000")
Start Chrome (manual setup) start_chrome()
Navigate to page navigate_to_url("localhost:3000")
Connect to browser connect_to_browser()
See all network requests get_network_requests()
Find failed API calls get_network_requests(filter_status=404)
Check for JavaScript errors get_console_error_summary()
Watch console in real-time monitor_console_live(10)
Check page load performance get_page_info()
Examine a variable inspect_console_object("window.myApp")
View cookies get_cookies()
Run JavaScript execute_javascript("document.title")

Configuration

Environment Variables

  • CHROME_DEBUG_PORT - Chrome remote debugging port (default: 9222)

MCP Compatibility

  • MCP Protocol Version: 2024-11-05
  • Minimum Python Version: 3.10+
  • Supported MCP Clients: Claude Desktop, any MCP-compatible client
  • Package Manager: uv (recommended) or pip

Usage Workflow

Prerequisites (Your Development Environment)

  • Have your web application running (e.g., npm run dev, python -m http.server, etc.)
  • Note the URL where your application is accessible

Debugging Session

  1. Connect to your application via Claude Desktop:start_chrome_and_connect("localhost:3000")
    Replace with your application's URL

  2. Debug your application using the MCP tools:
    - Monitor network requests
    - Check console errors
    - Inspect JavaScript objects
    - Analyse performance

  3. Make changes to your code in your editor

  4. Refresh or interact with your application
  5. Continue debugging with real-time data

Manual Connection (Alternative)

If you prefer step-by-step control:
1. start_chrome() - Launch Chrome with debugging
2. navigate_to_url("your-app-url") - Navigate to your application
3. connect_to_browser() - Connect the MCP server
4. Use debugging tools as needed

Security Notes

  • Only use with development environments
  • Never connect to production Chrome instances
  • The server is designed for localhost debugging only
  • No data is stored permanently - all data is session-based

Troubleshooting

Server Shows as "Disabled" in Claude Desktop

If the server appears in Claude but shows as "disabled", try these steps:

  1. Check Claude Desktop logs:
    - macOS: ~/Library/Logs/Claude/mcp*.log
    - Windows: %APPDATA%/Claude/logs/mcp*.log

  2. Common fixes:```bash
    # Reinstall with verbose output
    mcp remove "Chrome DevTools MCP"
    mcp install server.py -n "Chrome DevTools MCP" --with-editable . -v CHROME_DEBUG_PORT=9222

# Check installation status
mcp list

# Test the server manually
python3 server.py
```

  1. Check dependencies:```bash
    # Ensure all dependencies are available
    pip install mcp websockets aiohttp

# Test imports
python3 -c "from server import mcp; print('OK')"
```

  1. Restart Claude Desktop completely (quit and reopen)

Installation Issues

  • MCP CLI not found: Install MCP CLI from the Python MCP SDK with pip install mcp
  • Server not appearing in Claude:
  • For MCP CLI: Run mcp list to verify the server is installed
  • For manual setup: Check Claude Desktop configuration file path and JSON syntax
  • Import errors:
  • For MCP CLI: Use --with-editable . to install local dependencies
  • For manual setup: Run pip install -r requirements.txt
  • Permission errors: Use absolute paths in configuration
  • Environment variables not working: Verify .env file format or -v flag syntax
  • Module not found: Ensure you're using --with-editable . flag for local package installation

Debugging Steps

Step 1: Check MCP CLI Status```bash

List all installed servers

mcp list

Check specific server status

mcp status "Chrome DevTools MCP"


**Step 2: Test Server Manually**```bash
# Test if server starts without errors
python3 server.py

# Test imports
python3 -c "from server import mcp; print(f'Server: {mcp.name}')"

Step 3: Check Configuration

For Claude Desktop:```bash

View current configuration (macOS)

cat "~/Library/Application Support/Claude/claude_desktop_config.json"

View current configuration (Windows)

type "%APPDATA%/Claude/claude_desktop_config.json"


**For Claude Code:**```bash
# List configured MCP servers
claude mcp list

# Get details about a specific server
claude mcp get chrome-devtools

# IMPORTANT: Verify paths are absolute, not relative
# Good example output:
#   Command: /Users/you/chrome-devtools-mcp/.venv/bin/python
#   Args: ["/Users/you/chrome-devtools-mcp/server.py"]
# Bad example output:
#   Command: python
#   Args: ["server.py"]

# Test the exact command Claude Code will use
/path/to/.venv/bin/python /path/to/server.py

# Check if server is working
claude mcp serve --help

Step 3.5: Fix Path Issues (Claude Code specific)```bash

If paths are relative, remove and re-add with absolute paths

claude mcp remove chrome-devtools

Re-add with absolute paths

SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"
claude mcp add chrome-devtools "$PYTHON_PATH" "$SERVER_PATH" -e CHROME_DEBUG_PORT=9222


**Step 4: Reinstall if Needed**

**For MCP CLI:**```bash
# Clean reinstall
mcp remove "Chrome DevTools MCP"
mcp install server.py -n "Chrome DevTools MCP" --with-editable .

# Restart Claude Desktop completely

For Claude Code:```bash

Remove and re-add the server

claude mcp remove chrome-devtools
claude mcp add chrome-devtools python server.py -e CHROME_DEBUG_PORT=9222

Or update with different scope

claude mcp add chrome-devtools python server.py -s user -e CHROME_DEBUG_PORT=9222


### Common Error Messages

| Error | Solution |
|-------|----------|
| "Module not found" | Use `--with-editable .` flag |
| "No server object found" | Server should export `mcp` object (already fixed) |
| "Import error" | Check `pip install mcp websockets aiohttp` |
| "Permission denied" | Use absolute paths in config |
| "Server disabled" | Check Claude Desktop logs, restart Claude |
| "python: command not found" (Claude Code) | Use absolute path to venv Python: `/path/to/.venv/bin/python` |
| "server.py: No such file" (Claude Code) | Use absolute path to server: `/path/to/server.py` |
| "ModuleNotFoundError" (Claude Code) | Use venv Python that has dependencies installed |

### Manual Configuration Fallback

**For Claude Desktop:**
If MCP CLI isn't working, add this to Claude Desktop config manually:```json
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "python3",
      "args": ["/absolute/path/to/chrome-devtools-mcp/server.py"],
      "env": {
        "CHROME_DEBUG_PORT": "9222"
      }
    }
  }
}

For Claude Code:
If the claude mcp add command isn't working, you can use the JSON format with absolute paths:```bash

Get absolute paths first

SERVER_PATH="$(pwd)/server.py"
PYTHON_PATH="$(pwd)/.venv/bin/python"

Add server using JSON configuration with absolute paths

claude mcp add-json chrome-devtools "{
\"command\": \"$PYTHON_PATH\",
\"args\": [\"$SERVER_PATH\"],
\"env\": {
\"CHROME_DEBUG_PORT\": \"9222\"
}
}"

Or if you have it working in Claude Desktop, import from there

claude mcp add-from-claude-desktop


**Example of correct Claude Code configuration (with absolute paths):**```json
{
  "command": "/Users/you/chrome-devtools-mcp/.venv/bin/python",
  "args": ["/Users/you/chrome-devtools-mcp/server.py"],
  "env": {
    "CHROME_DEBUG_PORT": "9222"
  }
}

Connection Issues

  • Chrome won't start: The MCP server will start Chrome automatically when you use start_chrome()
  • Can't connect: Try get_connection_status() to check the connection
  • Tools not working: Ensure you've called connect_to_browser() or used start_chrome_and_connect()

Common Misconceptions

  • This is not a web server: The MCP server runs inside Claude Desktop, not as a separate web service
  • No separate installation needed: Once configured in Claude Desktop, the server starts automatically
  • Your app runs separately: This tool connects to your existing web application, it doesn't run it

Development & Testing

This section is for developers who want to test or modify the MCP server itself.

Development Setup

With uv (recommended):```bash
git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
uv sync


**With pip:**```bash
git clone https://github.com/benjaminr/chrome-devtools-mcp.git
cd chrome-devtools-mcp
pip install -e ".[dev]"

Code Quality Tools```bash

Format code

uv run ruff format .

Lint code

uv run ruff check .

Type checking

uv run mypy src/


### Building the Extension

**Install DXT packaging tools:**```bash
npm install -g @anthropic-ai/dxt

Build the extension:```bash

Quick build

make package

Or manually

npx @anthropic-ai/dxt pack


**Using Makefile for development:**```bash
make help           # Show all commands
make install        # Install dependencies
make dev            # Setup development environment + pre-commit
make check          # Run all checks (lint + type + test)
make pre-commit     # Run pre-commit hooks manually
make package        # Build .dxt extension
make release        # Full release build

Pre-commit Hooks

This project uses pre-commit hooks to ensure code quality:

  • ruff: Linting and formatting
  • mypy: Type checking
  • pytest: Test validation
  • MCP validation: Server registration check

Pre-commit hooks run automatically on git commit and can be run manually with make pre-commit.

License

MIT License

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Chrome Devtools MCP 6b167e25 怎么安装?

在客户端按下面的安装命令接入:pip install -r requirements.txt。装完在客户端配置里引用同一个包或端点。

Chrome Devtools MCP 6b167e25 怎么在 Claude Desktop、Claude 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Chrome Devtools MCP 6b167e25 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Chrome Devtools MCP 6b167e25 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

Chrome Devtools MCP 6b167e25 支持哪些客户端?

资料标注支持 Claude Desktop、Claude;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Chrome Devtools MCP 6b167e25 能提供哪些能力?

资料显示能力标签包括 开发工具、Python、Claude、网络监控。具体工具清单以官方文档为准。

Chrome Devtools MCP 6b167e25 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Chrome Devtools MCP 6b167e25 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。