{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github_mcp-chromedevtools-chrome-devtools-mcp","slug":"mcp-chromedevtools-chrome-devtools-mcp","name":"chrome-devtools-mcp","type":"mcp","url":"https://github.com/ChromeDevTools/chrome-devtools-mcp","page_url":"https://unfragile.ai/mcp-chromedevtools-chrome-devtools-mcp","categories":["mcp-servers"],"tags":["browser","chrome","chrome-devtools","debugging","devtools","mcp","mcp-server","puppeteer"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_0","uri":"capability://tool.use.integration.live.browser.control.via.mcp.protocol","name":"live-browser-control-via-mcp-protocol","description":"Exposes Chrome browser automation through the Model Context Protocol (MCP) using a STDIO transport layer, enabling AI agents to send structured tool requests that are serialized into Puppeteer commands and executed against a live Chrome instance managed by a single-threaded Mutex-protected execution pipeline. The system translates natural language agent intents into browser operations (navigation, interaction, inspection) and returns token-optimized structured responses designed for LLM consumption.","intents":["I want my AI agent to control a real Chrome browser and get live feedback on page state","I need to automate browser interactions (clicks, typing, navigation) through an LLM without writing custom Puppeteer code","I want to integrate Chrome DevTools capabilities into my AI coding assistant workflow"],"best_for":["AI agent developers building autonomous browser automation workflows","Teams integrating Claude, Gemini, or Cursor with live browser testing","Developers creating LLM-powered web scraping or testing agents"],"limitations":["Single-threaded Mutex-based execution model means only one tool action processes at a time per server instance, creating sequential bottlenecks for parallel browser operations","STDIO transport limits throughput compared to WebSocket or gRPC alternatives; no built-in connection pooling across multiple browser instances","Requires Chrome 144+ for auto-connect mode; older Chrome versions require explicit --browserUrl configuration"],"requires":["Node.js 18+","Chrome browser installed locally or accessible via HTTP debug protocol (Chrome 144+)","MCP client implementation (Claude, Gemini, Cursor, VS Code Copilot, or custom)","TypeScript/JavaScript runtime for server execution"],"input_types":["MCP tool request JSON with structured parameters","Natural language instructions from LLM agents (converted to tool calls by client)","Browser URLs, selectors, input text, keyboard/mouse events"],"output_types":["Structured JSON responses with page state, element properties, performance metrics","Accessibility snapshots (DOM tree with ARIA attributes)","Screenshot data (base64-encoded PNG)","Network request/response logs","Console output and error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_1","uri":"capability://data.processing.analysis.accessibility.snapshot.extraction.with.aria.semantics","name":"accessibility-snapshot-extraction-with-aria-semantics","description":"Captures a structured accessibility snapshot of the current page by traversing the DOM and extracting element properties (role, name, state, value, ARIA attributes) into a hierarchical JSON representation. This snapshot is optimized for LLM consumption by filtering out noise and preserving semantic relationships, enabling agents to understand page structure without visual rendering. The system uses Chrome DevTools Protocol (CDP) to query the accessibility tree directly rather than parsing raw HTML.","intents":["I want my agent to understand the semantic structure of a page (buttons, forms, landmarks) without needing visual screenshots","I need to extract ARIA labels and roles to verify accessibility compliance or interact with complex widgets","I want to debug accessibility issues by inspecting the computed accessibility tree"],"best_for":["Accessibility testing automation agents","LLM-powered web testing tools that need semantic page understanding","Developers building screen-reader simulation for automated testing"],"limitations":["Snapshot is point-in-time and does not capture dynamic ARIA updates triggered by JavaScript after initial load","Complex shadow DOM structures may not be fully traversed depending on Chrome version and CDP protocol version","ARIA attributes are extracted as-is without validation against WCAG standards; malformed ARIA is passed through unchanged"],"requires":["Chrome browser with DevTools Protocol support","Page must be fully loaded before snapshot (no automatic wait for dynamic content)","JavaScript execution must be enabled for CDP accessibility tree queries"],"input_types":["Page URL or loaded page context","Optional CSS selectors to filter snapshot scope"],"output_types":["Hierarchical JSON with element nodes containing: role, name, state, value, ARIA attributes, parent/child relationships","Flattened text representation of page structure for LLM parsing"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_10","uri":"capability://code.generation.editing.javascript.execution.and.evaluation.in.page.context","name":"javascript-execution-and-evaluation-in-page-context","description":"Executes arbitrary JavaScript code in the page context using Chrome DevTools Protocol Runtime domain. The system evaluates JavaScript expressions and returns the result as structured JSON (primitives, objects, arrays). Code execution is sandboxed within the page context, enabling access to page variables, DOM, and global objects. The system supports both synchronous evaluation and asynchronous function execution with promise handling. Return values are serialized for LLM consumption; functions and circular references are converted to string representations.","intents":["I want to extract data from the page using JavaScript (e.g., scrape table data, extract JSON from page state)","I need to call page functions or access page variables to verify application state","I want to execute custom logic in the page context to prepare data for extraction"],"best_for":["Data extraction agents that need to run custom JavaScript","Agents testing application state by accessing page variables","Developers debugging page behavior by executing diagnostic code"],"limitations":["Code execution is sandboxed in page context; cannot access Node.js modules or external APIs directly","Return values must be JSON-serializable; functions, DOM nodes, and circular references are converted to strings, losing type information","Execution timeout is fixed (default 30s); long-running scripts may timeout without partial results","Code injection is subject to Content Security Policy (CSP); some pages may block script execution"],"requires":["Chrome browser with DevTools Protocol Runtime domain support","JavaScript execution must be enabled","Page must be loaded before code execution"],"input_types":["JavaScript code string (expression or function)","Optional function arguments (serialized as JSON)","Optional timeout in milliseconds"],"output_types":["Execution result (JSON-serialized return value)","Error message if execution failed or timed out","Execution time in milliseconds"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_11","uri":"capability://tool.use.integration.mcp.tool.schema.definition.and.validation","name":"mcp-tool-schema-definition-and-validation","description":"Defines and validates MCP tool schemas that expose Chrome DevTools capabilities to LLM agents. Each tool is defined with a JSON schema specifying input parameters (type, required, description) and output format. The system validates agent requests against these schemas before execution, ensuring type safety and preventing invalid arguments. Tool schemas are introspectable by MCP clients, enabling agents to discover available capabilities and their parameters. The system provides detailed error messages when schema validation fails, helping agents correct malformed requests.","intents":["I want to define tools that my agent can call with validated parameters","I need to ensure agents only call tools with correct argument types and required fields","I want agents to discover available tools and their parameters automatically"],"best_for":["MCP server developers integrating Chrome DevTools with LLM agents","Teams building agent frameworks that need tool schema validation","Developers ensuring type safety in agent-to-tool communication"],"limitations":["Schema validation is JSON Schema v7 compatible; complex validation rules (conditional fields, cross-field validation) may require custom logic","Schema introspection is read-only; agents cannot modify tool schemas at runtime","Error messages are based on JSON Schema validation; may not be user-friendly for complex schema violations"],"requires":["MCP client implementation that supports tool schema introspection","JSON Schema v7 compatible validator (included in dependencies)"],"input_types":["Tool definition (name, description, input schema, output schema)","Agent request with parameters"],"output_types":["Tool schema JSON (for introspection)","Validation result (valid/invalid with error details)","Tool execution result"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_12","uri":"capability://automation.workflow.daemon.mode.server.with.persistent.browser.session","name":"daemon-mode-server-with-persistent-browser-session","description":"Runs the MCP server in daemon mode as a long-lived process with a persistent browser session, enabling multiple agent interactions across a single browser instance. The system manages server lifecycle (startup, shutdown, signal handling) and maintains browser connection state across tool invocations. Daemon mode is configured via CLI flags and supports systemd integration for automatic restart on failure. The system logs all activity to a file for debugging and monitoring.","intents":["I want to run a persistent MCP server that maintains browser state across multiple agent interactions","I need to integrate Chrome DevTools MCP with my application as a background service","I want to monitor server health and automatically restart on failure"],"best_for":["Production deployments requiring persistent browser automation","Applications integrating Chrome DevTools as a background service","Teams running MCP servers on servers or containers with systemd"],"limitations":["Daemon mode requires manual process management (systemd, supervisor, etc.); no built-in clustering or load balancing","Single browser instance per daemon; high-concurrency scenarios require multiple daemon processes","Log files can grow large; no automatic log rotation or cleanup","Signal handling may not gracefully close browser on SIGKILL; only SIGTERM is handled"],"requires":["Node.js 18+","Chrome browser installed locally or accessible via HTTP debug protocol","systemd (optional, for automatic restart)"],"input_types":["CLI flags for daemon configuration (--daemon, --logFile, etc.)"],"output_types":["Server startup confirmation","Log file path","Process ID (PID)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_13","uri":"capability://text.generation.language.token.optimized.response.formatting.for.llm.consumption","name":"token-optimized-response-formatting-for-llm-consumption","description":"Formats all tool responses as compact JSON optimized for LLM context windows, using abbreviated field names, removing unnecessary whitespace, and filtering out non-essential data. The system prioritizes information density and readability for LLMs over human readability. Response formatting is consistent across all tools, enabling agents to parse responses reliably. The system includes optional verbose mode for debugging, which expands response details at the cost of token usage.","intents":["I want tool responses to be compact and token-efficient for my LLM agent","I need consistent response format across all tools for reliable parsing","I want to debug tool responses with detailed information when needed"],"best_for":["Agents with limited context windows that need token-efficient responses","Teams optimizing LLM API costs by reducing token usage","Developers building reliable agent-to-tool communication"],"limitations":["Abbreviated field names may be less intuitive for human debugging; verbose mode required for detailed inspection","Token optimization may remove context that some agents need; no per-tool customization of response format","Filtering logic is hardcoded; cannot customize which fields are included/excluded"],"requires":["MCP client that can parse JSON responses"],"input_types":["Tool execution result","Optional verbose flag"],"output_types":["Compact JSON response (default)","Detailed JSON response (verbose mode)"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_2","uri":"capability://data.processing.analysis.performance.trace.analysis.with.devtools.frontend.integration","name":"performance-trace-analysis-with-devtools-frontend-integration","description":"Collects Chrome DevTools performance traces (CPU profiling, memory snapshots, network waterfall, Core Web Vitals) using the Chrome DevTools Protocol and analyzes them using chrome-devtools-frontend components for deep insights. The system records traces during page load or user interactions, parses the trace JSON, and extracts metrics like LCP (Largest Contentful Paint), FID (First Input Delay), CLS (Cumulative Layout Shift), and memory heap snapshots. Results are formatted as structured JSON with actionable bottleneck identification.","intents":["I want to measure Core Web Vitals (LCP, FID, CLS) for a page and identify performance bottlenecks","I need to detect memory leaks by comparing heap snapshots before and after user interactions","I want to analyze CPU profiling data to find slow JavaScript execution or rendering bottlenecks"],"best_for":["Performance testing automation agents","CI/CD pipelines that need automated performance regression detection","Developers debugging LCP and memory leak issues in production-like environments"],"limitations":["Trace collection adds 500ms-2s overhead per measurement depending on page complexity; not suitable for real-time performance monitoring","Memory heap snapshots are point-in-time and require manual comparison logic to detect leaks; no built-in leak detection algorithm","Core Web Vitals are measured in lab environment (not field data); results may differ from real-world user experiences due to different hardware/network conditions","Trace parsing depends on Chrome DevTools Frontend version; breaking changes in trace format may require updates"],"requires":["Chrome browser with DevTools Protocol support","Page must complete load cycle for accurate metrics","chrome-devtools-frontend package installed (included in dependencies)","Sufficient memory for heap snapshot capture (can be 100MB+ for large applications)"],"input_types":["Page URL","Optional trace duration (milliseconds)","Optional interaction sequence (clicks, typing) to profile during user actions"],"output_types":["Structured JSON with Core Web Vitals metrics (LCP, FID, CLS values in milliseconds)","CPU profile data with function call stacks and execution time","Memory heap snapshot with object counts and retained size","Network waterfall with request/response timings and resource sizes","Bottleneck summary with actionable recommendations"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_3","uri":"capability://data.processing.analysis.network.request.inspection.and.response.capture","name":"network-request-inspection-and-response-capture","description":"Intercepts and logs all network requests and responses during page load or user interactions using Chrome DevTools Protocol Network domain. The system captures request headers, response bodies (with automatic decompression for gzip/brotli), status codes, timing data, and resource types. Responses are stored in memory with configurable size limits and can be filtered by URL pattern, resource type, or status code. The captured data is formatted as structured JSON for LLM analysis of API calls, failed requests, and data flow.","intents":["I want to inspect API calls made by a page and verify request/response payloads","I need to detect failed network requests (4xx, 5xx) and understand why they occurred","I want to analyze network timing (DNS, TCP, TLS, request, response) to identify slow endpoints"],"best_for":["API testing automation agents","Debugging agents that need to understand data flow between frontend and backend","Security testing tools that need to inspect request/response payloads for vulnerabilities"],"limitations":["Response bodies are stored in memory; large responses (>10MB) may cause memory pressure; no automatic cleanup of old requests","Binary response bodies (images, videos, PDFs) are captured but not decoded; only text-based responses are human-readable","Request/response interception does not support modifying requests in-flight; read-only inspection only","CORS preflight requests are captured but may not reflect actual request payloads due to browser CORS handling"],"requires":["Chrome browser with DevTools Protocol Network domain support","Page must be navigated or interactions performed after network inspection is enabled","Sufficient memory for storing response bodies (configurable limit)"],"input_types":["Page URL","Optional URL pattern filter (regex or string match)","Optional resource type filter (xhr, fetch, document, stylesheet, image, etc.)","Optional status code filter (e.g., only 4xx/5xx errors)"],"output_types":["Structured JSON array of network requests with: URL, method, status code, headers, response body (text), timing breakdown","Filtered request logs based on specified criteria","Summary statistics (total requests, failed requests, average response time)"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_4","uri":"capability://data.processing.analysis.console.output.capture.and.error.logging","name":"console-output-capture-and-error-logging","description":"Captures all console output (log, warn, error, info) and JavaScript errors (uncaught exceptions, promise rejections) from the page using Chrome DevTools Protocol Runtime domain. The system logs messages with timestamps, severity levels, and stack traces. Errors are categorized by type (SyntaxError, TypeError, ReferenceError, etc.) and source location (file, line number). Output is formatted as structured JSON for LLM analysis of application behavior and debugging.","intents":["I want to capture JavaScript errors and warnings to detect application issues","I need to see console.log output from the page to understand application flow","I want to detect unhandled promise rejections and uncaught exceptions"],"best_for":["Debugging agents that need to understand application errors","QA automation tools that verify error handling","Developers troubleshooting production issues in automated testing"],"limitations":["Console output is captured after page load; early initialization errors may be missed if capture is not enabled before navigation","Stack traces are limited by browser's error reporting; minified/obfuscated code produces unhelpful stack traces without source maps","Large console output (>10MB) may cause memory issues; no automatic log rotation or cleanup","Promise rejections are only captured if not handled; caught rejections are not logged"],"requires":["Chrome browser with DevTools Protocol Runtime domain support","Page must be navigated after console capture is enabled","JavaScript execution must be enabled"],"input_types":["Page URL","Optional severity filter (error, warn, info, log)","Optional message pattern filter (regex)"],"output_types":["Structured JSON array of console messages with: timestamp, severity, message text, source file, line number, stack trace","Categorized error summary (count by error type)","Filtered logs based on severity or pattern"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_5","uri":"capability://automation.workflow.dom.element.interaction.with.selector.based.targeting","name":"dom-element-interaction-with-selector-based-targeting","description":"Enables agents to interact with page elements (click, type, focus, blur, scroll) using CSS selectors or XPath expressions. The system resolves selectors to DOM elements using Chrome DevTools Protocol DOM domain, validates element visibility and interactability, and executes the requested action (click, keyboard input, mouse movement). Actions are queued and executed sequentially through the Mutex-protected pipeline to ensure deterministic state. The system returns success/failure status with error details if interaction fails (element not found, not clickable, etc.).","intents":["I want to click a button or link identified by CSS selector","I need to type text into a form field and submit the form","I want to scroll to an element and verify it's visible before interacting with it"],"best_for":["Web automation agents performing user workflows (login, form submission, navigation)","Testing agents that need to simulate user interactions","Agents building web scraping workflows that require interaction before data extraction"],"limitations":["Selector must be valid CSS or XPath; invalid selectors fail silently or throw errors without helpful debugging","Element visibility check is based on computed styles; elements hidden by CSS (display: none, visibility: hidden) are detected, but elements obscured by other elements may not be","Keyboard input does not trigger all JavaScript events (e.g., custom input handlers may not fire); only standard DOM events are guaranteed","Scroll actions are not animated; instant scroll may trigger different behavior than user scroll (e.g., lazy loading may not trigger)"],"requires":["Chrome browser with DevTools Protocol DOM domain support","Page must be loaded and DOM must be stable before interaction","Element must exist in DOM and be interactable (not disabled, not hidden)"],"input_types":["CSS selector or XPath expression","Action type (click, type, focus, blur, scroll, hover)","Optional action parameters (text to type, scroll distance, key to press)"],"output_types":["Success/failure status","Error message if interaction failed (element not found, not clickable, etc.)","Updated page state after interaction (optional screenshot or accessibility snapshot)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_6","uri":"capability://automation.workflow.page.navigation.and.wait.strategies","name":"page-navigation-and-wait-strategies","description":"Navigates to URLs and implements configurable wait strategies (wait for navigation, wait for element, wait for network idle, wait for function) using Chrome DevTools Protocol Page domain. The system supports multiple wait conditions: networkidle0 (no network activity), networkidle2 (at most 2 network connections), domcontentloaded (DOM parsing complete), load (all resources loaded), or custom JavaScript function evaluation. Navigation timeout is configurable (default 30s). The system returns page metadata (title, URL, status code) and waits for the specified condition before returning control to the agent.","intents":["I want to navigate to a URL and wait for the page to fully load before proceeding","I need to wait for a specific element to appear on the page after navigation","I want to navigate and wait for network activity to settle before extracting data"],"best_for":["Web automation agents that need reliable page load detection","Data extraction agents that must wait for dynamic content to load","Testing agents that need to handle slow or unreliable network conditions"],"limitations":["networkidle0 wait strategy may timeout on pages with persistent background requests (analytics, polling); networkidle2 is more practical but less strict","Custom JavaScript function evaluation requires the function to be defined in the page context; external functions cannot be passed","Wait timeout is global; no per-condition timeout customization","Navigation may fail silently if page returns 404 or 5xx status; no automatic retry logic"],"requires":["Chrome browser with DevTools Protocol Page domain support","Valid URL (http/https)","Network connectivity to target URL"],"input_types":["URL to navigate to","Wait strategy (networkidle0, networkidle2, domcontentloaded, load, element, function)","Optional wait condition parameter (CSS selector for element, JavaScript function for custom condition)","Optional timeout in milliseconds"],"output_types":["Page metadata (title, URL, status code)","Success/failure status","Error message if navigation failed or wait timeout exceeded","Actual wait time in milliseconds"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_7","uri":"capability://automation.workflow.browser.instance.lifecycle.management.with.connection.strategies","name":"browser-instance-lifecycle-management-with-connection-strategies","description":"Manages browser instance lifecycle (launch, connect, disconnect, close) with support for multiple connection strategies: launch new instance, auto-connect to existing instance via user data directory, or connect via HTTP debug protocol URL. The system uses Puppeteer for browser automation and supports configuration flags (--headless, --isolated, --userDataDir) to customize launch behavior. Connection state is managed through a singleton pattern with automatic reconnection on failure. The system ensures proper cleanup on shutdown to prevent zombie processes.","intents":["I want to launch a fresh Chrome instance for isolated testing","I need to connect to an existing Chrome instance without launching a new one","I want to reuse the same browser instance across multiple agent interactions"],"best_for":["Agents that need long-lived browser sessions across multiple interactions","Testing environments that require isolated browser instances per test","Developers integrating with existing Chrome instances (e.g., user's running browser)"],"limitations":["Launch strategy requires Chrome binary to be installed locally; no support for remote Chrome instances via SSH","Auto-connect strategy only works with Chrome 144+; older versions require explicit --browserUrl","Singleton pattern means only one browser instance per server process; multiple instances require multiple server processes","No automatic cleanup of user data directory; --isolated flag creates temporary directory but does not clean up on crash"],"requires":["Chrome browser installed locally (for launch strategy) or accessible via HTTP debug protocol (for connect strategy)","Node.js 18+","Puppeteer package (included in dependencies)","For auto-connect: Chrome 144+ with user data directory accessible"],"input_types":["Connection strategy flag (--autoConnect, --browserUrl, or default launch)","Optional launch flags (--headless, --isolated, --userDataDir)","Optional browser URL for HTTP debug protocol connection"],"output_types":["Browser instance handle (internal to system)","Connection status (connected, disconnected, error)","Error message if connection fails"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_8","uri":"capability://automation.workflow.emulation.and.device.simulation","name":"emulation-and-device-simulation","description":"Simulates different device types, screen sizes, user agents, and network conditions using Chrome DevTools Protocol Emulation domain. The system supports predefined device profiles (iPhone, iPad, Android, desktop) or custom viewport dimensions, user agent strings, and device pixel ratios. Network throttling can be configured (4G, 3G, slow, offline) to simulate different connection speeds. Geolocation and timezone can be spoofed. The system applies emulation settings before page navigation, ensuring consistent behavior across test runs.","intents":["I want to test how a page renders on mobile devices without owning physical devices","I need to simulate slow network conditions (3G, 4G) to test performance on mobile","I want to test geolocation-dependent features by spoofing location"],"best_for":["Responsive design testing agents","Mobile performance testing automation","Agents testing geolocation or timezone-dependent features"],"limitations":["Device emulation simulates viewport and user agent but not actual hardware constraints (e.g., touch latency, GPU limitations); behavior may differ from real devices","Network throttling is applied at CDP level; actual network requests may not be throttled if using system proxy or VPN","Geolocation spoofing requires page permission; pages that check geolocation without user interaction may not work","Timezone spoofing is limited to TZ environment variable; JavaScript Date object may not reflect spoofed timezone on all systems"],"requires":["Chrome browser with DevTools Protocol Emulation domain support","Emulation settings must be applied before page navigation"],"input_types":["Device profile name (iPhone, iPad, Android, desktop) or custom viewport dimensions","Optional user agent string","Optional network throttling profile (4G, 3G, slow, offline) or custom bandwidth/latency","Optional geolocation (latitude, longitude, accuracy)","Optional timezone string"],"output_types":["Confirmation of emulation settings applied","Error message if emulation failed"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github_mcp-chromedevtools-chrome-devtools-mcp__cap_9","uri":"capability://image.visual.screenshot.and.visual.capture.with.format.options","name":"screenshot-and-visual-capture-with-format-options","description":"Captures screenshots of the current page or specific elements using Chrome DevTools Protocol Page domain. The system supports full-page screenshots (including off-screen content), viewport-only screenshots, and element-specific screenshots. Output formats include PNG (default) and JPEG with configurable quality. Screenshots are base64-encoded for embedding in JSON responses. The system can capture screenshots at different device scales (1x, 2x, 3x) for testing responsive design. Captured images are optimized for LLM vision models by default.","intents":["I want to capture a screenshot of the current page state for visual verification","I need to capture a full-page screenshot including off-screen content","I want to capture a specific element's screenshot for comparison or analysis"],"best_for":["Visual regression testing agents","Agents that need to verify page rendering before proceeding","Developers debugging visual layout issues"],"limitations":["Full-page screenshots can be very large (>10MB for complex pages); base64 encoding adds 33% overhead, increasing response size","Screenshots are static; dynamic content (animations, hover states) are not captured","Element-specific screenshots may not capture pseudo-elements or overlays positioned outside element bounds","JPEG compression may lose detail; PNG is lossless but larger"],"requires":["Chrome browser with DevTools Protocol Page domain support","Page must be rendered (not just loaded); layout must be stable"],"input_types":["Screenshot type (fullPage, viewport, element)","Optional CSS selector for element screenshots","Optional format (png, jpeg)","Optional quality (0-100 for JPEG)","Optional device scale (1x, 2x, 3x)"],"output_types":["Base64-encoded image data (PNG or JPEG)","Image dimensions (width, height)","File size in bytes"],"categories":["image-visual","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":52,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+","Chrome browser installed locally or accessible via HTTP debug protocol (Chrome 144+)","MCP client implementation (Claude, Gemini, Cursor, VS Code Copilot, or custom)","TypeScript/JavaScript runtime for server execution","Chrome browser with DevTools Protocol support","Page must be fully loaded before snapshot (no automatic wait for dynamic content)","JavaScript execution must be enabled for CDP accessibility tree queries","Chrome browser with DevTools Protocol Runtime domain support","JavaScript execution must be enabled","Page must be loaded before code execution"],"failure_modes":["Single-threaded Mutex-based execution model means only one tool action processes at a time per server instance, creating sequential bottlenecks for parallel browser operations","STDIO transport limits throughput compared to WebSocket or gRPC alternatives; no built-in connection pooling across multiple browser instances","Requires Chrome 144+ for auto-connect mode; older Chrome versions require explicit --browserUrl configuration","Snapshot is point-in-time and does not capture dynamic ARIA updates triggered by JavaScript after initial load","Complex shadow DOM structures may not be fully traversed depending on Chrome version and CDP protocol version","ARIA attributes are extracted as-is without validation against WCAG standards; malformed ARIA is passed through unchanged","Code execution is sandboxed in page context; cannot access Node.js modules or external APIs directly","Return values must be JSON-serializable; functions, DOM nodes, and circular references are converted to strings, losing type information","Execution timeout is fixed (default 30s); long-running scripts may timeout without partial results","Code injection is subject to Content Security Policy (CSP); some pages may block script execution","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.783135517268791,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T14:23:31.492Z","last_commit":"2026-05-03T00:04:50Z"},"community":{"stars":37986,"forks":2360,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=mcp-chromedevtools-chrome-devtools-mcp","compare_url":"https://unfragile.ai/compare?artifact=mcp-chromedevtools-chrome-devtools-mcp"}},"signature":"uE+kY7clTrDwpGFKOL5vQXqlPu9VgPA4UAkdIva4NBp0EOa12eToqhwPyjk6fATX/MTDDUM3KezA56uQ2X67Dw==","signedAt":"2026-06-21T01:10:40.941Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/mcp-chromedevtools-chrome-devtools-mcp","artifact":"https://unfragile.ai/mcp-chromedevtools-chrome-devtools-mcp","verify":"https://unfragile.ai/api/v1/verify?slug=mcp-chromedevtools-chrome-devtools-mcp","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}