BrowserGenie MCP Server
BrowserGenie MCP Server gives AI models full control over a Chrome browser via 50+ tools covering automation, inspection, and auditing.
Navigation: Navigate to URLs, go back/forward, reload pages (with optional cache bypass).
Tab Management: List, open, close, and switch between tabs.
Keyboard Input: Press keys with modifier support (Ctrl, Shift, Alt, Meta); type text character by character with configurable delays.
Mouse & Interaction: Click by CSS selector, XPath, or coordinates (single/double); type into fields; drag and drop; hover to trigger states.
Touch Gestures: Simulate swipes, long presses, pinches, and double taps (requires mobile viewport).
Screenshots: Capture the visible viewport or full scrollable page in PNG or JPEG.
DevTools – Sources: Read full page HTML, CSS, JavaScript sources, and all loaded resources.
DevTools – Modify: Live DOM mutation (set HTML/attributes, remove elements) and inline CSS style changes.
DevTools – Network: Collect and filter request/response logs by URL, method, status, or type; inspect individual requests; clear logs.
DevTools – Storage: CRUD operations for cookies, localStorage, and sessionStorage.
DevTools – Console: Retrieve console messages filtered by level; execute arbitrary JavaScript in the page context.
Accessibility & Auditing: Generate accessibility trees, run WCAG/axe-core audits, check color contrast, tab order, focus paths, performance metrics, font loading, broken resources, security headers, and cookie banner detection.
Element Inspection: Find elements by text, role, CSS, or XPath; get element state (visible, enabled, focused); query Shadow DOM; retrieve computed styles.
QA & Assertions: Assert element conditions, no console/network errors, CSS properties, network requests made, page load times; check form validity; emulate network conditions; intercept requests; snapshot/restore page state; wait for conditions; stress test refreshes; get unified diagnostics.
Interaction Inspection: Hover and inspect DOM/style changes, force pseudo-states (hover, focus, active), extract tooltip text.
Macro Recording: Record and replay user interactions (clicks, typing, and other changes).
Visual Regression: Compare two screenshots pixel-by-pixel for differences.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@BrowserGenie MCP Server take a screenshot of the current page"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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 simulationThe 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
Node.js 18+
npm
The companion BrowserGenie extension installed in Chrome — Chrome Web Store | Source
Installation
Option A — npx (recommended)
No installation required. Run directly from npm:
npx browser-genie-mcp-serverOr install globally:
npm install -g browser-genie-mcp-server
browser-genie-mcp-serverOption 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.jsConfiguration
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 noargsinstead.
After saving the config, restart your AI client.
Environment Variables
Variable | Default | Description |
|
| 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_URLinconstants.tsinside 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_tabsto find a valid tab ID, or navigate to a regular web page first.
Navigation
Tool | Description | Key Parameters |
| Navigate to a URL |
|
| Go back in history | — |
| Go forward in history | — |
| Reload the page |
|
Tab Management
Tool | Description | Key Parameters |
| List all open tabs | — |
| Focus a tab |
|
| Open a new tab |
|
| Close a tab |
|
| Capture URL, title, and DOM hash for state comparison | — |
| Verify two tabs have identical state |
|
| Test cross-tab localStorage sync |
|
Keyboard
Tool | Description | Key Parameters |
| Press a key with optional modifiers |
|
| Type text character by character |
|
Mouse & Interaction
Tool | Description | Key Parameters |
| Click via coordinates, CSS, or XPath with human-like Bézier curve movement and randomized delays |
|
| Click a field, optionally clear it, then type text with per-character jitter |
|
| Drag from one point to another |
|
| Hover to trigger CSS states / tooltips with randomized dwell time |
|
Click behavior:
doubleClick: truefires 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 |
| Touch swipe from point A to B with configurable duration |
|
| Long-press on an element or coordinates |
|
| Pinch zoom with two-finger convergence/divergence |
|
| Double-tap for mobile interactions (zoom, edit) |
|
Ensure the viewport is set to mobile with
touch: trueviaresize_viewportoremulate_devicebefore using touch gestures.
Screenshots
Tool | Description | Key Parameters |
| Capture visible viewport |
|
| Capture full scrollable page |
|
Both return an image content block.
DevTools — Sources
Tool | Description | Key Parameters |
| Full outerHTML of the page | — |
| CSS stylesheet sources |
|
| JavaScript sources |
|
| List all resources with URLs & sizes |
|
| Search regex pattern across HTML and all loaded scripts |
|
DevTools — Modify
Tool | Description | Key Parameters |
| Live DOM mutation |
|
| Set inline styles |
|
DevTools — Network
Tool | Description | Key Parameters |
| Get collected request/response logs |
|
| Full details of one request |
|
| Clear collected logs | — |
| Get only failed/errored requests (4xx, 5xx, failed) |
|
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 |
| Cookie CRUD |
| localStorage |
| sessionStorage |
DevTools — Console
Tool | Description | Key Parameters |
| Retrieve console messages by level |
|
| Run JS in the page and return result |
|
Accessibility & Auditing
Tool | Description | Key Parameters |
| Text-based accessibility tree snapshot | — |
| Raw accessibility tree as JSON |
|
| Run axe-core WCAG audit |
|
| Check text contrast ratios |
|
| Static list of focusable elements in tab order with unique selectors | — |
| Interactive — simulate Tab presses and record where focus lands, flagging invisible targets |
|
| Single snapshot of navigation timing, LCP, CLS, FID, memory | — |
| Start/stop/get timeline recording of memory, LCP, CLS over time |
|
| Verify web font loading status | — |
| Find broken images, stylesheets, fonts | — |
| Inspect CSP, HSTS, X-Frame-Options, etc. |
|
| Detect cookie consent banners and CMP patterns | — |
When to use
get_tab_ordervsrecord_focus_path: Useget_tab_orderfor a one-time snapshot of all focusable elements and their order. Userecord_focus_pathwhen 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 by text, role, aria-label, CSS, or XPath |
|
| Get exists, visible, enabled, focused, checked, etc. |
|
| Query inside a single shadow root |
|
| Query through nested shadow roots by host path |
|
| Return full shadow DOM tree as JSON |
|
| Get computed CSS styles for an element |
|
QA & Assertions
Tool | Description | Key Parameters |
| Assert conditions on an element (exists, visible, text, etc.) |
|
| Assert zero console errors/warnings |
|
| Assert zero failed network requests |
|
| Assert computed style value |
|
| Assert a matching request was made |
|
| Assert navigation timing is within threshold |
|
| Check HTML5 form validation state |
|
| Simulate Tab key and track focus movement |
|
| Set files on a file input |
|
| Simulate slow/offline network |
|
| Block, modify, or allow network requests |
|
| Capture full page state (HTML, storage, cookies) | — |
| Restore from a snapshot |
|
| Poll a JS expression until true or timeout |
|
| Refresh page N times and run assertion each time |
|
| Unified diagnostic — console + network + resource errors in one call |
|
Interaction Inspection
Tool | Description | Key Parameters |
| Hover and capture DOM/style changes |
|
| Force hover/focus/active and read computed styles |
|
| Extract tooltip text from title, aria-describedby, aria-labelledby, or CSS |
|
Macro Recording
Tool | Description | Key Parameters |
| Start recording clicks, typing, and changes | — |
| Stop recording and return events JSON | — |
| Replay recorded events with speed multiplier |
|
Visual Regression
Tool | Description | Key Parameters |
| Pixel-by-pixel diff of two base64 PNGs using pixelmatch |
|
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
└── LICENSEDevelopment
# Watch mode — recompiles on every file save
npm run dev
# One-shot build
npm run build
# Run the compiled server directly
npm startImportant 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.
Fork the repository
Create a feature branch:
git checkout -b feat/my-featureCommit your changes:
git commit -m 'feat: add my feature'Push and open a Pull Request
Related
BrowserGenie Extension — the Chrome extension that pairs with this server
Model Context Protocol — the open protocol this server implements
License
Available Tools
99 toolsassert_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.
delete_cookieB
Delete a specific cookie
Inputs: name (required), url (required), apiKey.
detect_cookie_bannersA
Detect cookie consent banners and CMP (Consent Management Platform) UI patterns on the page. Returns detected banners with text and button labels.
Inputs: 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_cookie_changesA
Monitor cookie changes across all tabs. Start monitoring, get recorded changes, or stop. Optionally filter by domain.
Inputs: action (required), domain, 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_cookieC
Set a cookie
Inputs: name (required), value (required), url, domain, +6 more.
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
Scored across 99 tools
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.
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.
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.
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
Related MCP Connectors
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn 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
- AlicenseNot gradedqualityDmaintenanceAn 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.4MIT
- AlicenseAqualityDmaintenanceA MCP server that gives AI assistants full browser control, enabling navigation, clicking, form filling, and screenshots via any MCP client.8MIT
- FlicenseBqualityDmaintenanceAn MCP server that enables AI coding tools to control a browser for automated actions, UI extraction, network interception, and screenshots.231-