Skip to main content
Glama
BrowserGenie MCP Server

BrowserGenie MCP Server

by BrowserGenie

BrowserGenie MCP Server

An MCP (Model Context Protocol) server that gives AI models full control over a Chrome browser. It pairs with the BrowserGenie Extension to expose 50+ browser automation tools over stdio — navigation, clicking, typing, screenshots, touch gestures, macro recording, and complete DevTools access.

Two-repo setup: This is the server half. The Chrome extension lives in a separate repository. Both are required.

How It Works

AI Client (Claude, Cursor, etc.)
    │  stdio  (JSON-RPC / MCP)
    ▼
MCP Server  ◄── this repo
    │  WebSocket  ws://localhost:7890
    ▼
Chrome Extension
    ├── chrome.tabs         → Navigation, tab management
    ├── chrome.debugger     → DevTools Protocol (CDP)
    ├── chrome.scripting    → Content script injection
    ├── chrome.cookies      → Cookie management
    └── Content Scripts      → Real DOM event simulation

The MCP server bridges your AI client (over stdio) and the Chrome extension (over WebSocket). Every MCP tool call is forwarded to the extension, executed in the browser, and the result is returned to the AI client.

Related MCP server: BrowserMCP

Requirements

Installation

No installation required. Run directly from npm:

npx browser-genie-mcp-server

Or install globally:

npm install -g browser-genie-mcp-server
browser-genie-mcp-server

Option B — Run from source

For development or to use the latest unreleased changes:

git clone https://github.com/BrowserGenie/mcp.git
cd mcp
npm install
npm run build
node dist/index.js

Configuration

Add the server to your AI client's MCP configuration.

Claude Desktop

File: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
File: %APPDATA%\Claude\claude_desktop_config.json (Windows)

{
  "mcpServers": {
    "browser-genie": {
      "command": "npx",
      "args": ["browser-genie-mcp-server"]
    }
  }
}

Claude Code

File: ~/.claude/settings.json or project-level .mcp.json:

{
  "mcpServers": {
    "browser-genie": {
      "command": "npx",
      "args": ["browser-genie-mcp-server"]
    }
  }
}

Cursor / other MCP clients

{
  "mcpServers": {
    "browser-genie": {
      "command": "npx",
      "args": ["browser-genie-mcp-server"]
    }
  }
}

If you installed the package globally with npm install -g browser-genie-mcp-server, you can use "command": "browser-genie-mcp-server" with no args instead.

After saving the config, restart your AI client.

Environment Variables

Variable

Default

Description

WEBSOCKET_PORT

7890

Port the WebSocket server listens on. The extension must use the same port.

Pass via the MCP config env block:

{
  "mcpServers": {
    "browser-genie": {
      "command": "npx",
      "args": ["browser-genie-mcp-server"],
      "env": { "WEBSOCKET_PORT": "8080" }
    }
  }
}

If you change the port, also update WEBSOCKET_URL in constants.ts inside the extension repo.

Verifying the Connection

Once the server is running and the extension is loaded in Chrome, click the extension icon. The popup should show a green Connected indicator. If it shows Disconnected, ensure the MCP server process is running.

MCP Tools Reference

Every tool accepts an optional apiKey (string) when authentication is enabled in the extension popup, and an optional tabId (number) to target a specific tab (defaults to the active tab).

Tip: If you see "No active tab found" or "Cannot access a chrome:// URL", use list_tabs to find a valid tab ID, or navigate to a regular web page first.

Navigation

Tool

Description

Key Parameters

navigate_to_url

Navigate to a URL

url (required)

navigate_back

Go back in history

—

navigate_forward

Go forward in history

—

navigate_reload

Reload the page

ignoreCache (bool)

Tab Management

Tool

Description

Key Parameters

list_tabs

List all open tabs

—

select_tab

Focus a tab

tabId (required)

new_tab

Open a new tab

url (optional)

close_tab

Close a tab

tabId (required)

get_tab_state

Capture URL, title, and DOM hash for state comparison

—

assert_tabs_match

Verify two tabs have identical state

tabIdA, tabIdB

test_storage_sync

Test cross-tab localStorage sync

tabIdA, tabIdB, key, value

Keyboard

Tool

Description

Key Parameters

press_key

Press a key with optional modifiers

key, modifiers[]

type_text

Type text character by character

text, delay (ms)

Mouse & Interaction

Tool

Description

Key Parameters

click_element

Click via coordinates, CSS, or XPath with human-like Bézier curve movement and randomized delays

target.type, target.value, button, doubleClick

input_and_type

Click a field, optionally clear it, then type text with per-character jitter

selector, text, clearFirst, submit

drag_and_drop

Drag from one point to another

from, to

hover_element

Hover to trigger CSS states / tooltips with randomized dwell time

target

Click behavior: doubleClick: true fires two rapid clicks at the same position. The element's own handlers determine focus/select behavior — the tool does not automatically select text or set focus beyond what the browser does natively.

Touch Gestures

Tool

Description

Key Parameters

swipe

Touch swipe from point A to B with configurable duration

from, to, duration

long_press

Long-press on an element or coordinates

target, duration

pinch

Pinch zoom with two-finger convergence/divergence

center, startRadius, endRadius

double_tap

Double-tap for mobile interactions (zoom, edit)

target, interval

Ensure the viewport is set to mobile with touch: true via resize_viewport or emulate_device before using touch gestures.

Screenshots

Tool

Description

Key Parameters

screenshot_viewport

Capture visible viewport

format, quality

screenshot_full_page

Capture full scrollable page

format, quality

Both return an image content block.

DevTools — Sources

Tool

Description

Key Parameters

read_page_html

Full outerHTML of the page

—

read_stylesheets

CSS stylesheet sources

url (filter)

read_scripts

JavaScript sources

url (filter)

read_page_resources

List all resources with URLs & sizes

type filter

find_in_source

Search regex pattern across HTML and all loaded scripts

pattern, contextLines

DevTools — Modify

Tool

Description

Key Parameters

modify_html

Live DOM mutation

selector, action, value, attributeName

modify_css

Set inline styles

selector, styles (object)

DevTools — Network

Tool

Description

Key Parameters

get_network_logs

Get collected request/response logs

filter.urlPattern, filter.method, filter.statusCode

get_network_request_detail

Full details of one request

requestId, includeBody

clear_network_logs

Clear collected logs

—

get_network_errors

Get only failed/errored requests (4xx, 5xx, failed)

clear

Network logs are collected from when the debugger attaches. Call any DevTools tool first to trigger attachment before the traffic you want to capture.

DevTools — Storage

Tool

Description

get_cookies / set_cookie / delete_cookie

Cookie CRUD

get_local_storage / set_local_storage / remove_local_storage

localStorage

get_session_storage / set_session_storage / remove_session_storage

sessionStorage

DevTools — Console

Tool

Description

Key Parameters

get_console_logs

Retrieve console messages by level

level, clear

execute_javascript

Run JS in the page and return result

expression

Accessibility & Auditing

Tool

Description

Key Parameters

browser_snapshot

Text-based accessibility tree snapshot

—

get_accessibility_tree

Raw accessibility tree as JSON

selector (optional filter)

run_accessibility_audit

Run axe-core WCAG audit

selector, tags

check_color_contrast

Check text contrast ratios

selector

get_tab_order

Static list of focusable elements in tab order with unique selectors

—

record_focus_path

Interactive — simulate Tab presses and record where focus lands, flagging invisible targets

steps

get_performance_metrics

Single snapshot of navigation timing, LCP, CLS, FID, memory

—

record_performance_timeline

Start/stop/get timeline recording of memory, LCP, CLS over time

action, interval

check_font_loading

Verify web font loading status

—

audit_broken_resources

Find broken images, stylesheets, fonts

—

check_security_headers

Inspect CSP, HSTS, X-Frame-Options, etc.

url

detect_cookie_banners

Detect cookie consent banners and CMP patterns

—

When to use get_tab_order vs record_focus_path: Use get_tab_order for a one-time snapshot of all focusable elements and their order. Use record_focus_path when you want to verify the actual focus behavior during keyboard navigation — it presses Tab repeatedly and records where focus lands, catching invisible or hidden focus traps.

Element Inspection

Tool

Description

Key Parameters

find_element

Find by text, role, aria-label, CSS, or XPath

text, role, css, xpath, nth

get_element_state

Get exists, visible, enabled, focused, checked, etc.

selector, selectorType

query_shadow_dom

Query inside a single shadow root

hostSelector, innerSelector

deep_query_shadow_dom

Query through nested shadow roots by host path

hostPath[], innerSelector

get_shadow_dom_tree

Return full shadow DOM tree as JSON

hostSelector, maxDepth

get_computed_styles

Get computed CSS styles for an element

selector, properties, pseudoElement

QA & Assertions

Tool

Description

Key Parameters

assert_element

Assert conditions on an element (exists, visible, text, etc.)

assertion, selector

assert_no_console_errors

Assert zero console errors/warnings

level, clear

assert_no_network_errors

Assert zero failed network requests

clear

assert_css_property

Assert computed style value

selector, property, expected

assert_network_request_made

Assert a matching request was made

urlPattern, method, minCount

assert_page_load_time

Assert navigation timing is within threshold

threshold

check_form_validity

Check HTML5 form validation state

selector, checkAll

tab_to_next

Simulate Tab key and track focus movement

direction, shift

set_input_files

Set files on a file input

selector, files

emulate_network_conditions

Simulate slow/offline network

offline, latency, throughput

intercept_requests

Block, modify, or allow network requests

action, urlPattern

snapshot_page_state

Capture full page state (HTML, storage, cookies)

—

restore_page_state

Restore from a snapshot

snapshot

wait_for_condition

Poll a JS expression until true or timeout

expression, timeout, interval

stress_test_refresh

Refresh page N times and run assertion each time

iterations, assertionScript, bypassCache

get_all_issues

Unified diagnostic — console + network + resource errors in one call

includeConsole, includeNetwork, includeResources

Interaction Inspection

Tool

Description

Key Parameters

hover_and_inspect

Hover and capture DOM/style changes

target, captureChanges

force_pseudo_state

Force hover/focus/active and read computed styles

selector, pseudoState

get_tooltip_text

Extract tooltip text from title, aria-describedby, aria-labelledby, or CSS

target, waitForTooltip

Macro Recording

Tool

Description

Key Parameters

start_recording_macro

Start recording clicks, typing, and changes

—

stop_recording_macro

Stop recording and return events JSON

—

replay_macro

Replay recorded events with speed multiplier

events, speed

Visual Regression

Tool

Description

Key Parameters

compare_screenshots

Pixel-by-pixel diff of two base64 PNGs using pixelmatch

beforeImage, afterImage, threshold

Project Structure

browser-genie-mcp-server/
├── src/
│   ├── index.ts              # Entry point — stdio MCP transport
│   ├── server.ts             # McpServer setup & tool registration
│   ├── websocket-bridge.ts   # WebSocket server + request/response correlation
│   ├── auth.ts               # API key validation helper
│   ├── types.ts              # Shared types & constants (port, message shapes)
│   └── tools/                # One file per tool category
│       ├── navigation.ts
│       ├── tab-management.ts
│       ├── click.ts
│       ├── input.ts
│       ├── keyboard.ts
│       ├── hover.ts
│       ├── drag-drop.ts
│       ├── screenshot.ts
│       ├── gestures.ts
│       ├── macros.ts
│       ├── visual-regression.ts
│       ├── devtools-sources.ts
│       ├── devtools-modify.ts
│       ├── devtools-network.ts
│       ├── devtools-storage.ts
│       ├── devtools-console.ts
│       ├── accessibility.ts
│       ├── emulation.ts
│       ├── elements.ts
│       ├── audit.ts
│       ├── interaction.ts
│       ├── monitoring.ts
│       └── qa.ts
├── dist/                     # Compiled output (after npm run build)
├── package.json
├── tsconfig.json
├── .gitignore
└── LICENSE

Development

# Watch mode — recompiles on every file save
npm run dev

# One-shot build
npm run build

# Run the compiled server directly
npm start

Important Notes

Debugger Banner

When any DevTools feature is first used on a tab, Chrome shows an "Extension is debugging this browser" banner. This is a Chrome security requirement and cannot be suppressed. The debugger attaches lazily — only when a DevTools tool is first called for that tab.

Service Worker Lifecycle

Chrome MV3 service workers terminate after ~30 seconds of inactivity. The extension uses chrome.alarms to keep the WebSocket alive, with automatic exponential-backoff reconnection (1 s → 2 s → 4 s → … → 30 s max).

Human-Like Interactions

All mouse and keyboard interactions include randomized delays and natural movement patterns to avoid bot detection. Click uses Bézier curves, typing has per-character jitter, and hover has randomized dwell time.

Contributing

Contributions are welcome! Please open an issue first to discuss what you'd like to change, then submit a pull request.

  1. Fork the repository

  2. Create a feature branch: git checkout -b feat/my-feature

  3. Commit your changes: git commit -m 'feat: add my feature'

  4. Push and open a Pull Request

License

Apache License 2.0

Available Tools

99 tools
assert_css_propertyB

Assert that a computed CSS property value matches expected for an element.

Inputs: selector (required), property (required), expected (required), tabId, +1 more.

assert_elementC

Assert a condition on an element. Returns whether the assertion passed, the actual value, and a message. Essential for automated testing workflows.

Inputs: assertion (required), selector (required), expected, attributeName, +3 more.

assert_network_request_madeB

Assert that a network request matching a pattern was made. Useful for verifying analytics, API calls, or resource loading.

Inputs: urlPattern, method, minCount, tabId, +1 more.

assert_no_console_errorsA

Assert that there are no console errors (or specified level entries) for the tab. Returns error count, list of errors, and pass/fail.

Inputs: level, clear, tabId, apiKey.

assert_no_network_errorsA

Assert that there are no failed network requests (4xx, 5xx, or failed) for the tab. Returns failed count, list of failed requests, and pass/fail.

Inputs: clear, tabId, apiKey.

assert_page_load_timeB

Assert that the page load time (navigation timing loadEventEnd) is within a threshold.

Inputs: threshold, tabId, apiKey.

assert_tabs_matchA

Verify two tabs have the same state (URL, title, DOM hash). Useful for cross-tab state sync testing.

Inputs: tabIdA (required), tabIdB (required), apiKey.

audit_broken_resourcesB

Find broken images, failed stylesheets, font errors, and other resource loading problems on the page.

Inputs: tabId, apiKey.

browser_snapshotA

Get a text-based accessibility tree snapshot of the page. This shows the page structure with ARIA roles, names, and states — ideal for understanding page layout when you cannot see screenshots.

Inputs: tabId, apiKey.

check_color_contrastB

Check color contrast ratios for text elements against WCAG AA and AAA standards. Returns contrast ratios and pass/fail status.

Inputs: selector, tabId, apiKey.

check_font_loadingB

Verify that all web fonts have loaded correctly. Returns font family, status, weight, and style for each font.

Inputs: tabId, apiKey.

check_form_validityA

Check HTML5 form validation state for a form or all form elements within a selector. Returns validity details per element including valueMissing, typeMismatch, patternMismatch, etc.

Inputs: selector (required), checkAll, tabId, apiKey.

check_security_headersA

Inspect security-related HTTP response headers for the page: CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, and XSS-Protection.

Inputs: url, tabId, apiKey.

clear_network_logsA

Clear all collected network logs for a tab

Inputs: tabId, apiKey.

click_elementA

Click on any element on the page. Use this for buttons, links, checkboxes, dropdowns, or any interactive element. Simulates real human mouse behavior with Bézier curve movement, randomized delays, and natural press/release timing.

Inputs: target (required), button, doubleClick, tabId, +1 more.

close_tabA

Close a specific browser tab. Use this to clean up tabs you no longer need. Be careful - closed tabs cannot be recovered through this tool!

Inputs: tabId (required), apiKey.

compare_screenshotsB

Compare two screenshots pixel-by-pixel using pixelmatch. Returns match percentage, mismatched pixel count, and a diff image.

Inputs: beforeImage (required), afterImage (required), threshold, includeDiffImage.

compare_snapshotsA

Compare two page state snapshots (from browser_snapshot or read_page_html) and return the differences. Use this to verify state changes after an action.

Inputs: before (required), after (required), mode.

deep_query_shadow_domC

Query an element inside a deep shadow DOM tree by providing a path of host selectors.

Inputs: hostPath (required), innerSelector (required), tabId, apiKey.

detect_layout_issuesB

Detect layout problems like overflow, element overlap, viewport clipping, and z-index stacking issues.

Inputs: tabId, apiKey.

diff_page_sourceA

Compare two HTML strings structurally and return the differences (added nodes, removed nodes, attribute changes, text changes). Use this to detect DOM changes after an action.

Inputs: beforeHtml (required), afterHtml (required), tabId, apiKey.

double_tapA

Simulate double-tap at coordinates or on an element. Useful for testing double-tap-to-zoom, double-tap-to-edit, or other mobile interactions.

Inputs: target (required), interval, tabId, apiKey.

drag_and_dropA

Drag an element from one location to another. Use this for sliders, sortable lists, file upload drop zones, or any drag-interactive elements. Simulates realistic human drag speed.

Inputs: from (required), to (required), tabId, apiKey.

emulate_deviceA

Emulate a specific device preset (iPhone 14, Pixel 7, iPad Pro, desktop). Automatically sets viewport, DPR, user agent, and touch emulation.

Inputs: device (required), tabId, apiKey.

emulate_network_conditionsB

Simulate slow or offline network conditions. Use this to test how pages behave on poor connections. Set reset=true to restore normal conditions.

Inputs: offline, latency, downloadThroughput, uploadThroughput, +3 more.

execute_javascriptA

Run ANY JavaScript code directly in the page. This is your escape hatch for anything the other tools can't do: extract data, modify the page, trigger events, check values, etc. Full access to window, document, and all page APIs.

Inputs: expression (required), tabId, apiKey.

find_elementA

Find an element by visible text, ARIA role, ARIA label, CSS selector, or XPath. Returns a unique CSS selector and element details. Use this when you need to locate an element but don't know its exact selector. Role matching supports both explicit role="..." attributes AND semantic HTML (e.g., matches role "button", matches role "link"). When multiple filters are provided (e.g., role + text), they are combined with AND logic.

Inputs: text, role, ariaLabel, css, +4 more.

find_in_sourceA

Search for a regex pattern in page HTML and loaded scripts. Returns matches with file URL, line number, and surrounding context.

Inputs: pattern (required), contextLines, tabId, apiKey.

force_pseudo_stateA

Force a CSS pseudo-state (hover, focus, active, visited, focus-within, focus-visible) on an element and read the resulting computed styles. Useful for testing CSS state styles without actual interaction.

Inputs: selector (required), pseudoState (required), tabId, apiKey.

get_accessibility_treeB

Get the raw accessibility tree as structured JSON. Companion to browser_snapshot which returns formatted text. Optionally filter to a subtree with a selector.

Inputs: selector, tabId, apiKey.

get_active_media_queriesB

Check which CSS media queries are currently active and which breakpoints match the current viewport.

Inputs: breakpoints, tabId, apiKey.

get_all_issuesA

Unified diagnostic tool that returns console errors, network errors, and broken resources in a single call. Use this for a quick health check. For deeper inspection of a specific category, use get_console_logs, get_network_errors, or audit_broken_resources individually. Note: resource inspection requires the CDP debugger to be attached. If Chrome DevTools is open on the tab, resource inspection may be skipped but console/network data will still be returned.

Inputs: includeConsole, includeNetwork, includeResources, clearAfter, +2 more.

get_computed_stylesC

Get computed CSS styles for an element. Optionally filter to specific properties or query pseudo-elements like ::before and ::after.

Inputs: selector (required), properties, pseudoElement, tabId, +1 more.

get_console_logsA

Get all console messages from the page (console.log, console.error, warnings, etc.). Use this to debug JavaScript errors, see what the page is logging, or verify your code is running.

Inputs: level, clear, tabId, apiKey.

get_cookiesB

Get cookies for the current page or a specific URL

Inputs: url, name, apiKey.

get_element_layoutA

Get layout information for a specific element or all visible elements on the page. Returns bounding rectangles, overflow, z-index, position, display, visibility, and opacity.

Inputs: selector, includeAll, tabId, apiKey.

get_element_stateA

Get the state of an element: exists, visible, enabled, focused, checked, selected, readOnly, required, valid, and more. Essential for verifying element conditions during testing.

Inputs: selector (required), selectorType, tabId, apiKey.

get_local_storageC

Read localStorage entries for the current page

Inputs: key, tabId, apiKey.

get_network_errorsA

Get only failed/errored network requests for the tab. Useful for debugging resource loading issues.

Inputs: clear, tabId, apiKey.

get_network_logsA

Get network request/response logs collected since the debugger was attached. Optionally filter by URL pattern, method, status code, or resource type.

Inputs: filter, tabId, apiKey.

get_network_request_detailA

Get detailed information about a specific network request, including headers and optionally the response body

Inputs: requestId (required), includeBody, tabId, apiKey.

get_performance_metricsA

Get page load performance metrics: navigation timing, paint metrics (FCP), LCP, CLS, FID, and memory usage.

Inputs: tabId, apiKey.

get_session_storageA

Read sessionStorage entries for the current page

Inputs: key, tabId, apiKey.

get_shadow_dom_treeB

Return the full shadow DOM tree structure as JSON for a given host element.

Inputs: hostSelector (required), maxDepth, tabId, apiKey.

get_tab_orderA

Get a static list of all focusable elements on the page in tab order, with unique CSS selectors and visibility flags. Use this for a one-time snapshot of the tab order. For interactive focus path recording (simulating Tab presses and tracking where focus lands), use record_focus_path instead.

Inputs: tabId, apiKey.

get_tab_stateA

Capture URL, title, and a DOM hash for quick tab state comparison. Useful for verifying cross-tab state sync.

Inputs: tabId, apiKey.

get_tooltip_textA

Hover over an element and extract any tooltip text. Checks title attribute, aria-describedby, aria-labelledby, CSS tooltips, and custom tooltip components.

Inputs: target (required), waitForTooltip, tabId, apiKey.

get_viewport_infoB

Get current viewport dimensions, device pixel ratio, viewport meta tag, screen info, and user agent.

Inputs: tabId, apiKey.

hover_and_inspectA

Hover over an element and capture any resulting DOM or style changes. Useful for testing dropdown menus, tooltips, and hover effects.

Inputs: target (required), captureChanges, tabId, apiKey.

hover_elementA

Move mouse over an element without clicking. Use this to reveal dropdown menus, tooltips, hover-only buttons, or to trigger CSS :hover states.

Inputs: target (required), tabId, apiKey.

input_and_typeA

One-stop tool for filling form fields. Automatically clicks the input, clears existing text, types your text, and optionally submits with Enter. Use this for search boxes, login forms, registration fields, etc.

Inputs: selector (required), text (required), selectorType, clearFirst, +3 more.

intercept_requestsB

Intercept and modify or block network requests. Use block to abort requests, modify to return custom responses, or clear to remove all intercepts.

Inputs: action (required), urlPattern, method, statusCode, +4 more.

list_tabsA

Get a list of ALL open browser tabs. Use this to find tab IDs, see what pages are open, or locate a specific website you need to interact with. Returns tab ID, URL, title, and active status.

Inputs: apiKey.

long_pressB

Simulate long-press at coordinates or on an element. Useful for context menus or selection.

Inputs: target (required), duration, tabId, apiKey.

modify_cssB

Modify CSS styles of elements on the page

Inputs: selector (required), styles (required), tabId, apiKey.

modify_htmlB

Modify DOM elements on the page (set HTML, attributes, or remove elements)

Inputs: selector (required), action (required), value, attributeName, +2 more.

monitor_console_eventsB

Real-time console event monitoring. Start monitoring, get events since last read, or stop. Filter by log level.

Inputs: action (required), levels, tabId, apiKey.

monitor_storage_eventsA

Monitor localStorage and sessionStorage changes. IMPORTANT: Due to the Web Storage API spec, storage events only fire in OTHER tabs — same-tab changes are NOT captured. Start monitoring, get recorded events (from all tabs of same origin), or stop monitoring.

Inputs: action (required), storageType, tabId, apiKey.

new_tabA

Open a brand new browser tab. You can optionally provide a URL to navigate to immediately. Returns the new tab ID so you can interact with it.

Inputs: url, apiKey.

pinchA

Simulate pinch zoom with two touch points converging or diverging. Positive startRadius > endRadius = pinch in (zoom out). Negative = pinch out (zoom in).

Inputs: center (required), startRadius, endRadius, duration, +2 more.

press_keyA

Press a single keyboard key with optional modifiers. Use this for special keys: Enter, Tab, Escape, arrows, function keys, or keyboard shortcuts. Does NOT type text - use type_text for that.

Inputs: key (required), modifiers, selector, selectorType, +2 more.

query_shadow_domC

Query an element inside a shadow DOM root. Provide the host element selector and the inner selector within the shadow root.

Inputs: hostSelector (required), innerSelector (required), tabId, apiKey.

read_page_htmlA

Read the full HTML source of the current page

Inputs: tabId, apiKey.

read_page_resourcesA

List all resources loaded on the page (images, fonts, scripts, stylesheets) with their URLs and sizes

Inputs: type, tabId, apiKey.

read_scriptsB

Read JavaScript sources loaded on the page. Returns all scripts or a specific one by URL.

Inputs: url, tabId, apiKey.

read_stylesheetsA

Read CSS stylesheets loaded on the page. Returns all stylesheets or a specific one by URL.

Inputs: url, tabId, apiKey.

record_focus_pathA

Simulate Tab key presses N times and record where focus lands at each step, flagging invisible or hidden focus targets. This is an interactive alternative to get_tab_order — use record_focus_path when you want to verify the actual focus behavior during keyboard navigation, and get_tab_order when you just need a static list.

Inputs: steps, tabId, apiKey.

record_performance_timelineB

Start, stop, or get a performance timeline recording. Records memory, LCP, CLS at intervals during a user sequence.

Inputs: action (required), interval, duration, tabId, +1 more.

remove_local_storageB

Remove a localStorage entry from the current page

Inputs: key (required), tabId, apiKey.

remove_session_storageB

Remove a sessionStorage entry from the current page

Inputs: key (required), tabId, apiKey.

replay_macroB

Replay a recorded macro with optional speed multiplier. Events are replayed with original timing preserved.

Inputs: events (required), speed, tabId, apiKey.

reset_viewportB

Reset viewport emulation to the browser's default size and user agent.

Inputs: tabId, apiKey.

resize_viewportB

Resize the browser viewport to specific dimensions. Use this to test responsive layouts at different screen sizes.

Inputs: width (required), height (required), deviceScaleFactor, mobile, +4 more.

restore_page_stateA

Restore a page from a previously captured snapshot. Navigates to the URL, restores storage, cookies, HTML, and scroll position.

Inputs: snapshot (required), tabId, apiKey.

run_accessibility_auditA

Run an axe-core accessibility audit on the page. Returns violations, incomplete items (need manual review), and pass counts. Use this to find WCAG compliance issues.

Inputs: selector, tags, tabId, apiKey.

screenshot_elementA

Take a screenshot of a specific element only. Provide a CSS selector or XPath to capture just that element.

Inputs: selector (required), selectorType, format, quality, +2 more.

screenshot_full_pageA

Take a screenshot of the ENTIRE page, including content you need to scroll down to see. Automatically scrolls and stitches images together. Use this when you need to see everything on the page.

Inputs: format, quality, tabId, apiKey.

screenshot_viewportA

Take a screenshot of what's currently visible in the browser window. Use this to see the current state of the page, verify UI elements, or debug layout issues. Returns an image you can view.

Inputs: format, quality, tabId, apiKey.

select_tabA

Switch to a specific tab. Use this when you need to interact with a different open tab. Makes the tab active and brings its window to front.

Inputs: tabId (required), apiKey.

set_input_filesA

Set files on a file input element for testing file uploads. Uses CDP DOM.setFileInputFiles for virtual file creation.

Inputs: selector (required), files (required), tabId, apiKey.

set_local_storageB

Set a localStorage entry on the current page

Inputs: key (required), value (required), tabId, apiKey.

set_session_storageB

Set a sessionStorage entry on the current page

Inputs: key (required), value (required), tabId, apiKey.

snapshot_page_stateA

Capture a complete snapshot of the page state: HTML, localStorage, sessionStorage, cookies, scroll position, and form values. Use with restore_page_state to return to this exact state.

Inputs: tabId, apiKey.

start_recording_macroB

Start recording user actions (clicks, typing, navigation) in a tab. Inject the macro recorder content script.

Inputs: tabId, apiKey.

stop_recording_macroA

Stop recording and return the macro JSON with recorded events.

Inputs: tabId, apiKey.

stress_test_refreshA

Refresh page N times with cache bypass, running an assertion after each refresh. Returns pass/fail per iteration. Useful for catching intermittent font bugs, race conditions, and cache-dependent issues.

Inputs: iterations, assertionScript, waitAfterReload, bypassCache, +2 more.

swipeA

Simulate touch swipe from point A to point B with duration. Ensure viewport is set to mobile/touch enabled first via emulate_device or resize_viewport.

Inputs: from (required), to (required), duration, tabId, +1 more.

tab_to_nextB

Simulate Tab key navigation and track focus movement. Returns previous and current focused element info, and whether focus wrapped around.

Inputs: direction, shift, tabId, apiKey.

test_storage_syncA

Test cross-tab localStorage synchronization. Sets a value in tab A and checks if it appears in tab B.

Inputs: tabIdA (required), tabIdB (required), key (required), value (required), +1 more.

type_textA

Type regular text into the currently focused input field. Use this for typing usernames, passwords, search queries, form data, etc. Each character is typed individually like a real user.

Inputs: text (required), delay, tabId, apiKey.

wait_for_conditionA

Wait until a JavaScript condition evaluates to true. Polls the expression at the specified interval until the timeout. Returns whether the condition was met and how long it took.

Inputs: expression (required), timeout, interval, tabId, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 99 tools

    Disambiguation4/5

    Most tools have distinct purposes (e.g., navigation vs. assertions vs. storage), but the high number of assertion and logging tools (e.g., get_console_logs, get_network_logs, get_all_issues) may cause confusion about which to use for a specific task.

    Naming Consistency4/5

    Tools predominantly follow a verb_noun pattern with underscores, but there are outliers like 'input_and_type' and 'deep_query_shadow_dom' that break the pattern slightly. Overall, names are clear and predictable.

    Tool Count2/5

    With 99 tools, the surface is excessively large for an MCP server. Most servers have 5–20 tools; this many tools creates cognitive overhead and suggests the server may be trying to cover too much ground.

    Completeness4/5

    The toolset covers a wide range of browser automation tasks: navigation, element interaction, assertions, debugging, performance, accessibility, storage, cookies, screenshots, and network interception. Minor gaps like frame handling or alert dialogs are absent, but the coverage is still impressive.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that enables AI agents to control a real Google Chrome instance using specific user profiles, cookies, and extensions. It provides 18 tools for browser navigation, element interaction, and page inspection via the Chrome DevTools Protocol.
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that provides AI assistants with full control over a real browser session via a Chrome extension, supporting 36 tools for navigation, data extraction, and DOM manipulation. It bypasses bot detection by utilizing the user's active browser session, including cookies, authentication tokens, and installed extensions.
      4
      MIT
    • F
      license
      B
      quality
      D
      maintenance
      An MCP server that enables AI coding tools to control a browser for automated actions, UI extraction, network interception, and screenshots.
      23
      1
      -