Stealth Chrome DevTools MCP

Invoke an already-defined JavaScript function by its dotted path — does not run arbitrary source.

Use execute_script / inject_and_execute_script to run source; use this when the function already exists on the page (e.g. 'document.querySelector'); use execute_function_sequence to chain several such calls in one round trip.

Args: instance_id (str): Browser instance ID. function_path (str): Full path to the function (e.g., 'document.getElementById'). args (List[Any], optional): List of arguments to pass to the function.

Returns: Dict[str, Any]: Function call result.

Clean up old clone files to save disk space.

Args: max_age_hours (int): Maximum age in hours for files to keep.

Returns: Dict[str, int]: Number of files deleted.

Clear all stored elements.

Returns: Dict[str, Any]: Success message.

Clear cookies.

Args: instance_id (str): Browser instance ID. url (Optional[str]): Optional URL to clear cookies for (clears all if not specified).

Returns: bool: True if cleared successfully.

Clear all debug logs and statistics with timeout protection.

Returns: bool: True if cleared successfully.

Clear a specific stored element.

Args: element_id (str): Element ID to clear.

Returns: Dict[str, Any]: Success/error message.

Click an element.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath. text_match (Optional[str]): Click element with matching text. timeout (int): Timeout in ms (default 10000, max 60000). Clicks rarely need more than 5s — only increase for dynamically loaded elements. Values above 60000 are capped.

Returns: bool: True if clicked successfully.

Extract ALL element data inline as one canonical flat clone (the authoritative "complete" extractor).

Composes the six aspects on the canonical engine — styles via direct CDP, and structure/events/animations/assets/related_files via JS-eval — into a flat, aspect-keyed dict with `selector forwarded to every sub-extractor. Prefer this for complete fidelity when the payload can be returned inline. The three siblings differ only in delivery/transport: clone_element_to_file and extract_complete_element_to_file write this same clone to disk (path + summary) instead of returning it; extract_complete_element_cdp returns the pure-CDP *nested* variant (element` block) for CDP-native fidelity.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. extraction_options (Optional[str]): Dict specifying what to extract and options for each. Example: { 'styles': {'include_computed': True, 'include_pseudo': True}, 'structure': {'include_children': True, 'max_depth': 2}, 'events': {'include_framework': True, 'analyze_handlers': False}, 'animations': {'analyze_keyframes': True}, 'assets': {'fetch_external': False}, 'related_files': {'follow_imports': True, 'max_depth': 1} }

Returns: Dict[str, Any]: Complete element clone with styles, structure, events, animations, assets, related files.

Clone element progressively - returns lightweight base structure with element_id.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_children (bool): Whether to extract child elements.

Returns: Dict[str, Any]: Base structure with element_id for progressive expansion.

Save the complete canonical clone to a file — the to-file twin of `clone_element_complete (same engine, same per-aspect transport, accepts the same extraction_options`).

Returns `{file_path, extraction_type, summary} instead of the full data, so a large clone never overwhelms the response. Use extract_complete_element_to_file for the lighter variant that takes only an include_children` toggle (no per-aspect options).

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. extraction_options (Optional[str]): JSON string with extraction options.

Returns: Dict[str, Any]: File path and summary information about the cloned element.

Close a browser instance.

Args: instance_id (str): Browser instance ID.

Returns: bool: True if closed successfully.

Close a specific tab.

Args: instance_id (str): Browser instance ID. tab_id (str): Tab ID to close.

Returns: bool: True if closed successfully.

Create a new dynamic hook with AI-generated Python function.

This is the new powerful hook system that allows AI to write custom Python functions that process network requests in real-time with no pending state.

Args: name (str): Human-readable hook name requirements (Dict[str, Any]): Matching criteria (url_pattern, method, resource_type, custom_condition) function_code (str): Python function code that processes requests (must define process_request(request)) instance_ids (Optional[List[str]]): Browser instances to apply hook to (all if None) priority (int): Hook priority (lower = higher priority)

Returns: Dict[str, Any]: Hook creation result with hook_id

Example function_code:

def process_request(request):
    if "example.com" in request["url"]:
        return HookAction(action="redirect", url="https://httpbin.org/get")
    return HookAction(action="continue")

Create a persistent JavaScript function that survives page reloads.

Args: instance_id (str): Browser instance ID. function_name (str): Name for the function. function_code (str): JavaScript function code.

Returns: Dict[str, Any]: Function creation result.

Create a binding that allows JavaScript to call Python functions.

Args: instance_id (str): Browser instance ID. binding_name (str): Name for the binding. python_code (str): Python function code (as string).

Returns: Dict[str, Any]: Binding creation result.

Create a simple dynamic hook using predefined templates (easier for AI).

Args: name (str): Hook name url_pattern (str): URL pattern to match action (str): Action type - 'block', 'redirect', 'add_headers', or 'log' target_url (Optional[str]): Target URL for redirect action custom_headers (Optional[Dict[str, str]]): Headers to add for add_headers action instance_ids (Optional[List[str]]): Browser instances to apply hook to

Returns: Dict[str, Any]: Hook creation result

Discover all global JavaScript functions available in the page.

Args: instance_id (str): Browser instance ID. context_id (str, optional): Optional execution context ID.

Returns: List[Dict[str, Any]]: List of discovered functions with their details.

Discover methods of a specific JavaScript object.

Args: instance_id (str): Browser instance ID. object_path (str): Path to the object (e.g., 'document', 'window.localStorage').

Returns: List[Dict[str, Any]]: List of discovered methods.

Execute a raw CDP Runtime command by name — the low-level escape hatch beneath the exec-family tools. Prefer execute_script for ordinary page JS; use this only for a specific CDP method (e.g. 'evaluate', 'callFunctionOn').

Args: instance_id (str): Browser instance ID. command (str): CDP command name (e.g., 'evaluate', 'callFunctionOn'). params (Dict[str, Any], optional): Command parameters as a dictionary. IMPORTANT: Use snake_case parameter names (e.g., 'return_by_value') NOT camelCase ('returnByValue'). The nodriver library expects Python-style parameter names.

Returns: Dict[str, Any]: Command execution result.

Example: # Correct - use snake_case params = {"expression": "document.title", "return_by_value": True}

params = {"expression": "document.title", "returnByValue": True}

Invoke several already-defined JavaScript functions in order, in a single round trip.

Each entry is one call_javascript_function-style call; use this to batch them instead of issuing repeated call_javascript_function calls.

Args: instance_id (str): Browser instance ID. function_calls (List[Dict[str, Any]]): List of function calls, each with 'function_path', 'args', and optional 'context_id'.

Returns: List[Dict[str, Any]]: List of function call results.

Author browser logic in Python — it is transpiled to JavaScript and then executed in the page.

Use execute_script to write JavaScript directly; use this when you would rather write Python.

Args: instance_id (str): Browser instance ID. python_code (str): Python code to translate and execute.

Returns: Dict[str, Any]: Execution result.

Execute JavaScript source in the active page and return its value.

The default exec-family tool; prefer a sibling when it fits — inject_and_execute_script (specific execution context), call_javascript_function/execute_function_sequence (invoke defined functions), execute_python_in_browser (Python), execute_cdp_command (raw CDP).

⚠️ Async, non-blocking code only. The script runs on the page's main thread, so anything that blocks it freezes the whole tab and makes every later call time out. Specifically:

• NEVER use synchronous XHR — xhr.open(url, false). Use await fetch(url).
• NEVER use infinite/blocking loops — while(true), for(;;), busy-waits.
• NEVER call alert() / confirm() / prompt() — they block automation.
• To UPLOAD FILES, use the upload_file tool — do NOT fetch blobs or build base64/DataTransfer here (mixed-content/CORS limits and can freeze the page).
• Keep scripts small (< ~100KB); don't inline large payloads.

Args: instance_id (str): Browser instance ID. script (str): JavaScript to execute. Must be non-blocking. args (Optional[List[Any]]): Arguments passed to the script body. timeout_ms (Optional[int]): Max run time in ms (default 10000, max 60000). A blocking script is killed at this limit instead of hanging the tab.

Returns: Dict[str, Any]: {"success": bool, "result": Any, "error": Optional[str]}.

Expand animations and fonts data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive().

Returns: Dict[str, Any]: Animations, transitions, and fonts data.

Expand children data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive(). depth_range (Optional[List]): [min_depth, max_depth] range to include. max_count (Optional[Any]): Maximum number of children to return.

Returns: Dict[str, Any]: Filtered children data.

Expand CSS rules data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive(). source_types (Optional[List[str]]): CSS rule sources to include (inline, external stylesheet URLs).

Returns: Dict[str, Any]: Filtered CSS rules data.

Expand event listeners data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive(). event_types (Optional[List[str]]): Event types or sources to include (click, react, inline, addEventListener).

Returns: Dict[str, Any]: Filtered event listeners data.

Expand pseudo-elements data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive().

Returns: Dict[str, Any]: Pseudo-elements data (::before, ::after, etc.).

Expand styles data for a stored element.

Args: element_id (str): Element ID from clone_element_progressive(). categories (Optional[List[str]]): Style categories to include (layout, typography, colors, spacing, borders, backgrounds, effects, animation). properties (Optional[List[str]]): Specific CSS property names to include.

Returns: Dict[str, Any]: Filtered styles data.

Export debug logs to a file using the fastest available method with timeout protection.

Args: filename (str): Name of the file to export to. max_errors (int): Maximum number of errors to export (default: 100). max_warnings (int): Maximum number of warnings to export (default: 100). max_info (int): Maximum number of info logs to export (default: 100). include_all (bool): Include all logs regardless of limits (default: False). format (str): Export format: 'json', 'pickle', 'gzip-pickle', 'auto' (default: 'auto'). 'auto' chooses fastest format based on data size:

• Small data (<100 items): JSON (human readable)
• Medium data (100-1000 items): Pickle (fast binary)
• Large data (>1000 items): Gzip-Pickle (fastest, compressed)

Returns: str: Path to the exported file.

Export network data to JSON file.

Args: instance_id (str): Browser instance ID. filepath (str): Path to save JSON file.

Returns: Dict[str, Any]: `{"success": bool}, plus a capture_note` when body capture is off (exported responses have no bodies until it is enabled).

Extract a complete element inline via native CDP for every aspect — the pure-CDP variant with a *nested* schema (data under an `element` block).

Unlike `clone_element_complete` (canonical flat schema; styles CDP + the rest JS-eval), this bypasses JavaScript entirely and uses CDP directly for all aspects:

• Computed styles via CSS.getComputedStyleForNode
• Matched CSS rules via CSS.getMatchedStylesForNode
• Event listeners via DOMDebugger.getEventListeners
• DOM structure and attributes via DOM.describeNode

Prefer this when you specifically need CDP-native fidelity (e.g. matched CSS rules, CDP event listeners) and can consume the nested shape; prefer `clone_element_complete` for the flat, per-aspect default.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_children (bool): Whether to include child elements.

Returns: Dict[str, Any]: Complete element data with 100% accuracy.

Save a complete canonical clone to a file — the lightweight to-file variant.

Same canonical engine as `clone_element_complete (styles via CDP, the rest via JS-eval) but exposes only an include_children toggle rather than per-aspect extraction_options. Returns {file_path, extraction_type, summary}. Use clone_element_to_file` when you need the full per-aspect option set.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_children (bool): Whether to include child elements.

Returns: Dict[str, Any]: File path and concise summary instead of massive data dump.

Extract CSS animations, transitions, and transforms.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_css_animations (bool): Include CSS @keyframes animations. include_transitions (bool): Include CSS transitions. include_transforms (bool): Include CSS transforms. analyze_keyframes (bool): Analyze keyframe rules.

Returns: Dict[str, Any]: Animation data, transition data, transform data, keyframe rules.

Extract element animations and save to file, returning file path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_css_animations (bool): Include CSS animations. include_transitions (bool): Include CSS transitions. include_transforms (bool): Include CSS transforms. analyze_keyframes (bool): Analyze keyframe rules.

Returns: Dict[str, Any]: File path and summary of extracted animations.

Extract all assets related to an element (images, fonts, etc.).

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_images (bool): Include img src and related images. include_backgrounds (bool): Include background images. include_fonts (bool): Include font information. fetch_external (bool): Whether to fetch external assets for analysis.

Returns: Dict[str, Any]: Images, background images, fonts, icons, videos, audio assets.

Extract element assets and save to file, returning file path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_images (bool): Include images. include_backgrounds (bool): Include background images. include_fonts (bool): Include font information. fetch_external (bool): Fetch external assets.

Returns: Dict[str, Any]: File path and summary of extracted assets.

Extract complete event listener and JavaScript handler information.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_inline (bool): Include inline event handlers (onclick, etc.). include_listeners (bool): Include addEventListener attached handlers. include_framework (bool): Include framework-specific handlers (React, Vue, etc.). analyze_handlers (bool): Analyze handler functions for full details (can be large).

Returns: Dict[str, Any]: Event listeners, inline handlers, framework handlers, detected frameworks.

Extract element events and save to file, returning file path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_inline (bool): Include inline event handlers. include_listeners (bool): Include addEventListener handlers. include_framework (bool): Include framework-specific handlers. analyze_handlers (bool): Analyze handler functions.

Returns: Dict[str, Any]: File path and summary of extracted events.

Extract complete HTML structure and DOM information.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_children (bool): Include child elements. include_attributes (bool): Include all attributes. include_data_attributes (bool): Include data-* attributes specifically. max_depth (int): Maximum depth for children extraction.

Returns: Dict[str, Any]: HTML structure, attributes, position, and children data.

Extract element structure and save to file, returning file path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_children (bool): Include child elements. include_attributes (bool): Include all attributes. include_data_attributes (bool): Include data-* attributes. max_depth (int): Maximum depth for children extraction.

Returns: Dict[str, Any]: File path and summary of extracted structure.

Extract complete styling information from an element.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_computed (bool): Include computed styles. include_css_rules (bool): Include matching CSS rules. include_pseudo (bool): Include pseudo-element styles (::before, ::after). include_inheritance (bool): Include style inheritance chain.

Returns: Dict[str, Any]: Complete styling data including computed styles, CSS rules, pseudo-elements.

Extract element styles using direct CDP calls (no JavaScript evaluation). This prevents hanging issues by using nodriver's native CDP methods.

Args: instance_id (str): Browser instance ID selector (str): CSS selector for the element include_computed (bool): Include computed styles include_css_rules (bool): Include matching CSS rules include_pseudo (bool): Include pseudo-element styles include_inheritance (bool): Include style inheritance chain

Returns: Dict[str, Any]: Styling data extracted using CDP

Extract element styles and save to file, returning file path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the element. include_computed (bool): Include computed styles. include_css_rules (bool): Include matching CSS rules. include_pseudo (bool): Include pseudo-element styles. include_inheritance (bool): Include style inheritance chain.

Returns: Dict[str, Any]: File path and summary of extracted styles.

Discover and analyze related CSS/JS files for context.

Args: instance_id (str): Browser instance ID. analyze_css (bool): Analyze linked CSS files. analyze_js (bool): Analyze linked JS files. follow_imports (bool): Follow @import and module imports (uses network). max_depth (int): Maximum depth for following imports.

Returns: Dict[str, Any]: Stylesheets, scripts, imports, modules, framework detection.

Get information about the currently active tab.

Args: instance_id (str): Browser instance ID.

Returns: Dict[str, Any]: Active tab information.

Get cookies for current page or specific URLs.

Args: instance_id (str): Browser instance ID. urls (Optional[List[str]]): Optional list of URLs to get cookies for.

Returns: List[Dict[str, Any]]: List of cookies.

Get current debug logger lock status for debugging hanging exports.

Returns: Dict[str, Any]: Lock status information.

Get comprehensive debug view with all logged errors and statistics.

Args: max_errors (int): Maximum number of errors to include (default: 50). max_warnings (int): Maximum number of warnings to include (default: 50). max_info (int): Maximum number of info logs to include (default: 50). include_all (bool): Include all logs regardless of limits (default: False).

Returns: Dict[str, Any]: Debug information including errors, warnings, and statistics.

Get detailed information about a specific dynamic hook.

Args: hook_id (str): Hook identifier

Returns: Dict[str, Any]: Detailed hook information including function code

Get complete state of an element.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath.

Returns: Dict[str, Any]: Element state including attributes, style, position, etc.

Get all available JavaScript execution contexts.

Args: instance_id (str): Browser instance ID.

Returns: List[Dict[str, Any]]: List of execution contexts with their details.

Get information about the CDP function executor state.

Args: instance_id (str, optional): Optional browser instance ID for specific info.

Returns: Dict[str, Any]: Function executor state and capabilities.

Get common hook patterns and use cases.

Returns: Dict[str, Any]: Common patterns like ad blocking, API proxying, etc.

Get comprehensive documentation for creating hook functions (AI learning).

Returns: Dict[str, Any]: Documentation of request object structure and HookAction types

Get example hook functions for AI learning.

Returns: Dict[str, Any]: Collection of example hook functions with explanations

Get documentation on hook requirements and matching criteria.

Returns: Dict[str, Any]: Requirements documentation and best practices

Get detailed state of a browser instance.

Args: instance_id (str): Browser instance ID.

Returns: Optional[Dict[str, Any]]: Full page state, or a partial record (`partial: True) with detail_error` if collection times out or fails.

Get current network capture filters plus resolved body-capture state.

Args: instance_id (str): Browser instance ID.

Returns: Dict[str, Any]: 'include'/'exclude' lists, the resolved 'capture_bodies' and 'capture_internal_urls' flags, and body-store usage ('body_store_bytes', 'body_store_max_bytes', 'body_max_bytes').

Get page HTML and text content.

Args: instance_id (str): Browser instance ID. include_frames (bool): Include iframe information.

Returns: Dict[str, Any]: Page content including HTML, text, and metadata.

Get detailed information about a network request.

Args: request_id (str): Network request ID.

Returns: Optional[Dict[str, Any]]: Request details including headers, cookies, and body.

Get response body content.

Live-refetches the body from CDP on demand, so it works even when response-body capture is off (the default) and independent of the stored-body cap. CDP evicts bodies from its own buffer quickly, so fetch soon after load.

Args: instance_id (str): Browser instance ID. request_id (str): Network request ID.

Returns: Optional[str]: Response body as text (base64 encoded for binary).

Get response details for a network request.

Response bodies are only stored when capture is enabled (off by default); status/headers/content-type metadata is always captured. When the body is absent because capture is off, a `capture_note` explains how to enable it.

Args: request_id (str): Network request ID.

Returns: Optional[Dict[str, Any]]: Response details including status, headers, and metadata.

Navigate back in history.

Args: instance_id (str): Browser instance ID.

Returns: bool: True if navigation was successful.

Navigate forward in history.

Args: instance_id (str): Browser instance ID.

Returns: bool: True if navigation was successful.

Import network data from JSON file.

Args: instance_id (str): Browser instance ID. filepath (str): Path to JSON file.

Returns: bool: True if successful.

Run custom JavaScript source, optionally inside a specific execution context (isolated world / iframe) via context_id.

Like execute_script, but lets you choose the execution context; prefer plain execute_script when the default page context is what you want.

Args: instance_id (str): Browser instance ID. script_code (str): JavaScript code to execute. context_id (str, optional): Optional execution context ID.

Returns: Dict[str, Any]: Script execution result.

Inspect a JavaScript function's signature and details.

Args: instance_id (str): Browser instance ID. function_path (str): Full path to the function.

Returns: Dict[str, Any]: Function signature and details.

List all available CDP Runtime commands for function execution.

Returns: List[str]: List of available CDP command names.

List all element clone files saved to disk.

Returns: List[Dict[str, Any]]: List of clone files with metadata and file information.

List all dynamic hooks.

Args: instance_id (Optional[str]): Optional filter by browser instance

Returns: Dict[str, Any]: List of hooks with details and statistics

List all active browser instances.

Returns: List[Dict[str, Any]]: List of browser instances with their current state.

List captured network requests.

Browser-internal traffic (chrome://, chrome-extension://, devtools://, about:) is excluded from capture by default — see set_network_capture_filters.

Args: instance_id (str): Browser instance ID. filter_type (Optional[str]): Filter by CDP resource type, matched case-insensitively (e.g., 'document', 'image', 'script', 'xhr').

Returns: Union[List[Dict[str, Any]], Dict[str, Any]]: List of network requests, or file metadata if response too large.

List all stored elements with their basic info.

Returns: Dict[str, Any]: List of stored elements with metadata.

List all tabs for a browser instance.

Args: instance_id (str): Browser instance ID.

Returns: List[Dict[str, str]]: List of tabs with their details.

Modify request headers for future requests.

Args: instance_id (str): Browser instance ID. headers (Dict[str, str]): Headers to add/modify.

Returns: bool: True if modified successfully.

Navigate to a URL.

Args: instance_id (str): Browser instance ID. url (str): URL to navigate to. wait_until (str): Wait condition - 'load', 'domcontentloaded', or 'networkidle'. timeout (int): Navigation timeout in ms (default 30000, max 60000). Most pages load in under 10s — only increase if you have evidence the page is slow. Values above 60000 are capped. referrer (Optional[str]): Referrer URL.

Returns: Dict[str, Any]: Navigation result with final URL and title.

Raises: ToolError: the navigation failed at the browser — Chrome committed an error page (unresolvable host, refused connection, TLS failure). An HTTP error status (404/500) is a loaded page, not a failure.

Open a new tab in the browser instance.

Args: instance_id (str): Browser instance ID. url (str): URL to open in the new tab.

Returns: Dict[str, Any]: New tab information.

Paste text instantly into an input field.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath. text (str): Text to paste. clear_first (bool): Clear field before pasting.

Returns: bool: True if pasted successfully.

Query DOM elements.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath (starts with '//'). text_filter (Optional[str]): Filter by text content. visible_only (bool): Only return visible elements. limit (Optional[Any]): Maximum number of elements to return.

Returns: List[Dict[str, Any]]: List of matching elements with their properties.

Reload the current page.

Args: instance_id (str): Browser instance ID. ignore_cache (bool): Whether to ignore cache when reloading.

Returns: bool: True if reload was successful.

Remove a dynamic hook.

Args: hook_id (str): Hook identifier to remove

Returns: Dict[str, Any]: Removal status

Scroll the page.

Args: instance_id (str): Browser instance ID. direction (str): 'down', 'up', 'left', 'right', 'top', or 'bottom'. amount (int): Pixels to scroll (ignored for 'top' and 'bottom'). smooth (bool): Use smooth scrolling.

Returns: bool: True if scrolled successfully.

Search network requests with advanced filters and pagination.

Args: instance_id (str): Browser instance ID. url_pattern (Optional[str]): Filter by URL pattern (substring match). method (Optional[str]): Filter by HTTP method. status_code (Optional[int]): Filter by response status code. response_contains (Optional[str]): Search in response body. payload_contains (Optional[str]): Search in request payload. resource_type (Optional[str]): Filter by resource type. limit (int): Max results per page. offset (int): Starting index for pagination.

Returns: Dict[str, Any]: Paginated results with metadata. Includes a `capture_note` when body capture is off (response_contains matching is unavailable then).

Select an option from a dropdown.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector for the select element. value (Optional[str]): Option value attribute. text (Optional[str]): Option text content. index (Optional[Any]): Option index (0-based). Can be string or int.

Returns: bool: True if selected successfully.

Set a cookie.

Args: instance_id (str): Browser instance ID. name (str): Cookie name. value (str): Cookie value. url (Optional[str]): The request-URI to associate with the cookie. domain (Optional[str]): Cookie domain. path (str): Cookie path. secure (bool): Secure flag. http_only (bool): HttpOnly flag. same_site (Optional[str]): SameSite attribute ('Strict', 'Lax', or 'None').

Returns: bool: True if set successfully.

Set resource type filters for network capture to reduce memory usage.

Args: instance_id (str): Browser instance ID. include_types (Optional[List[str]]): Only capture these types (e.g., ['XHR', 'Fetch', 'Document']). exclude_types (Optional[List[str]]): Exclude these types (e.g., ['Image', 'Stylesheet', 'Font', 'Script']). capture_bodies (Optional[bool]): Enable/disable response-body capture for this instance (default off; overrides STEALTH_MCP_NETWORK_CAPTURE_BODIES). Each argument is merged — passing only capture_bodies keeps include/exclude. capture_internal_urls (Optional[bool]): Capture Chrome's own traffic — chrome://, chrome-extension://, chrome-error://, devtools://, about: — which is EXCLUDED by default so the page's requests are not drowned out (overrides STEALTH_MCP_NETWORK_CAPTURE_INTERNAL_URLS).

Type matching is case-insensitive, so 'document' and 'Document' behave alike. Common resource types: Document, Stylesheet, Image, Media, Font, Script, XHR, Fetch, WebSocket, Manifest, Other

Returns: bool: True if successful.

Spawn a new browser instance.

Args: headless (bool): Run in headless mode. user_agent (Optional[str]): Custom user agent string. viewport_width (int): Requested browser WINDOW width in pixels (outer, not the CSS viewport). Best-effort: a headed window is clamped to the work area of the LAUNCHING context's desktop — the user's monitor only when the backend runs on it (F-808), not the caller's screen — so a request larger than that desktop lands smaller. viewport_height (int): Requested browser WINDOW height in pixels, same best-effort clamping as viewport_width. proxy (Optional[str]): Proxy server URL. browser_args (List[str]): Additional browser launch args. timezone_id (Optional[str]): IANA timezone ID applied via CDP timezone override. idle_timeout_seconds (Optional[int]): Idle timeout override in seconds for automatic instance cleanup. block_resources (List[str]): List of resource types to block (e.g., ['image', 'font', 'stylesheet']). extra_headers (Dict[str, str]): Additional HTTP headers. user_data_dir (Optional[str]): Leave UNSET for normal use. When unset, the server automatically clones a disposable session from the master profile and deletes it as soon as the browser closes — you never need to manage or clean up sessions. Only set this when the user has EXPLICITLY asked for a persistent/named profile: a named profile is NOT auto-cleaned and persists on disk indefinitely, so treat creating one as a deliberate, space-consuming action. Do not invent names. sandbox (Optional[Any]): Enable browser sandbox. Accepts bool, string ('true'/'false'), int (1/0), or None for auto-detect.

Network interception captures request/response metadata by default, but response *bodies* are NOT stored unless capture is enabled — via set_network_capture_filters(capture_bodies=True) or STEALTH_MCP_NETWORK_CAPTURE_BODIES=1 (F-605, off by default). When on, the body store is byte-bounded (STEALTH_MCP_NETWORK_BODY_MAX_BYTES per body, STEALTH_MCP_NETWORK_BODY_STORE_MAX_BYTES total). get_response_content live-refetches a body on demand regardless of this setting.

Returns: Dict[str, Any]: Instance information including instance_id. `viewport is the window size Chrome ACTUALLY produced (measured post-launch, F-804), not an echo of the request; spawn_diagnostics["window_size"] carries requested/actual/inner_viewport/clamped` so a size the OS overrode is visible rather than silent.

Switch to a specific tab by bringing it to front.

Args: instance_id (str): Browser instance ID. tab_id (str): Target tab ID to switch to.

Returns: bool: True if switched successfully.

Take a screenshot of the page.

Args: instance_id (str): Browser instance ID. full_page (bool): Capture full page (not just viewport). format (str): Image format ('png' or 'jpeg'). file_path (Optional[str]): Optional file path to save screenshot to.

Returns: Union[str, Dict]: File path if file_path provided, otherwise optimized base64 data or file info dict.

Type text into an input field.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath. text (str): Text to type. clear_first (bool): Clear field before typing. delay_ms (int): Delay between keystrokes in milliseconds. parse_newlines (bool): If True, parse as Enter key presses. shift_enter (bool): If True, use Shift+Enter instead of Enter (for chat apps).

Returns: bool: True if typed successfully.

Upload local file(s) to a file input. USE THIS for file uploads.

Sets the files directly on the <input type="file"> via CDP — reliable and non-blocking. Do NOT try to upload by fetching blobs / building base64 / DataTransfer inside execute_script: that hits mixed-content/CORS limits and can freeze the page. This tool is the supported path.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath for the <input type="file"> element. file_paths (Union[str, List[str]]): Absolute path, or list of paths, to attach. For multiple files the input must have the multiple attribute. timeout (int): Element lookup timeout in ms (default 10000, max 60000).

Returns: Dict[str, Any]: {"uploaded": [absolute paths], "count": int}.

Validate browser environment and diagnose potential issues.

Returns: Dict[str, Any]: Environment validation results with platform info and recommendations

Validate hook function code for common issues before creating.

Args: function_code (str): Python function code to validate

Returns: Dict[str, Any]: Validation results with issues and warnings

Wait for an element to appear.

Args: instance_id (str): Browser instance ID. selector (str): CSS selector or XPath. timeout (int): Timeout in ms (default 30000, max 60000). Most elements appear within 5-10s — only increase for very slow async content. Values above 60000 are capped. visible (bool): Wait for element to be visible. text_content (Optional[str]): Wait for specific text content.

Returns: bool: True if element found.