# MathiasPaulenko/wavexis-mcp [Health: Active] **Category:** 📂 Browser Automation **Repository:** https://github.com/MathiasPaulenko/wavexis-mcp **GitHub Stars:** 3 **Views:** 6 **Installs:** 0 **Upvotes:** 1 **Directory Page:** https://allmcps.com/mcp/mathiaspaulenko-wavexis-mcp ## Description MCP server exposing 220 browser automation tools across 13 capability tiers. Chrome + Firefox via CDP + BiDi. No Node.js, no Chromium download — uses your existing browser. Stealth mode, Lighthouse audits, multi-action YAML batching, raw CDP/BiDi access, structured errors with LLM-actionable suggestions. ## Tools Capabilities this server exposes over MCP: - **wavexis_session_open** — Launch a persistent browser session for multi-step workflows. Call once at the start of a task and reuse the returned session_id for all subsequent calls; use wavexis_navigate with session_id omitted for one-off page fetches instead. Side effects: Launches a browser process (or connects to an existing one) and allocates server-side session state; may open network connections to remote/cloud browsers. Returns: JSON string with keys: 'status' ('ok'/'error'), 'session_id' (str), 'backend' (str). - **wavexis_session_close** — Close a browser session and release all associated resources. Call when the session is no longer needed to free memory and browser processes; use wavexis_close_tab to close individual tabs instead. Side effects: Terminates the browser process (or disconnects from a remote one) and frees session state. Destructive — all unsaved page state is lost. Returns: JSON string with keys: 'status' ('ok'/'error'), 'session_id' (str). - **wavexis_session_info** — Query metadata and current URL of an active browser session. Use to inspect session health or retrieve the current page URL; use wavexis_list_tabs for tab-level details instead. Side effects: None — read-only; queries in-memory session state and the browser's current URL. Returns: JSON string with keys: 'status' ('ok'/'error'), 'session_id' (str), 'backend' (str), 'created_at' (str), 'current_url' (str). - **wavexis_navigate** — Navigate the browser to a URL with a configurable wait strategy. Use for direct URL navigation; use wavexis_back/wavexis_forward for history navigation, or wavexis_act for natural-language interaction instead. Side effects: Issues a network request to the target URL and replaces the current page content; may auto-create a stateless session if session_id is omitted. Returns: JSON string with keys: 'status' ('ok'/'error'), 'url' (str). - **wavexis_back** — Navigate backward one step in the browser history. Use for history navigation instead of wavexis_navigate when the target is the previous page. Side effects: Changes the active page to the previous history entry; may trigger network requests if that page was not cached. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_forward** — Navigate forward one step in the browser history. Use after wavexis_back to restore a page; use wavexis_navigate for direct URL navigation instead. Side effects: Changes the active page to the next history entry; may trigger network requests if that page was not cached. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_reload** — Reload the current page, optionally bypassing the cache. Use to refresh stale content or retry a failed load; use wavexis_navigate to go to a different URL instead. Side effects: Re-issues network requests for the current page and its resources; discards in-memory page state. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_stop** — Stop all pending navigations and resource loads in the session. Use when a page load is hanging or no longer needed; use wavexis_wait to wait for a load to complete instead. Side effects: Aborts in-flight network requests and pending navigations; the page is left in its current partial state. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_wait** — Block until a page condition (load, selector, URL, network idle) is met. Use after wavexis_navigate when the wait strategy was 'none', or to wait for dynamic content; use wavexis_stop to cancel a load instead. Side effects: None — read-only polling with no page mutations; blocks the tool call up to the configured timeout. Returns: JSON string with keys: 'status' ('ok'/'error'), 'elapsed_ms' (int). - **wavexis_screenshot** — Capture a screenshot of a web page or matched element. Use ``wavexis_pdf`` when a print-ready document is needed, or ``wavexis_annotated_screenshot`` when labelled element markers are required. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, optionally evaluates ``js``; writes to ``output_path`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'format' (str), 'base64' (str) or 'path' (str), 'size_bytes' (int). - **wavexis_pdf** — Generate a PDF document from a web page. Use ``wavexis_screenshot`` for image capture, or ``wavexis_page_pdf`` when pixel-level control over paper size and margins is required. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, optionally evaluates ``js``; writes to ``output_path`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'base64' (str) or 'path' (str), 'size_bytes' (int). - **wavexis_scrape** — Scrape data from multiple URLs by evaluating a JS expression on each. Use ``wavexis_eval`` for single-page evaluation, or ``wavexis_scrape`` when the same expression must run across many pages with pagination. Side effects: launches/acquires a browser backend, navigates to each URL in ``urls`` sequentially, evaluates ``expression`` in every page context. Returns: JSON string with keys: 'status' ('ok'/'error'), 'results' (list[dict[str, Any]]), 'format' (str), 'count' (int), 'total' (int). - **wavexis_screencast** — Capture a frame-by-frame screenshot sequence over a duration. Use ``wavexis_screenshot`` for a single still image, or ``wavexis_screencast`` when animation or time-series capture is needed. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, captures frames for ``duration``; writes frame files to ``output_dir`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'frames' (list[str]) or 'dir' (str), 'count' (int). - **wavexis_annotated_screenshot** — Capture a screenshot with numbered labels overlaid on elements. Injects overlay divs with labels @e1, @e2, ... on each element matching the provided selectors, captures a screenshot, removes the overlays, and returns the image plus a label-to-selector map. Use ``wavexis_screenshot`` for plain captures, or this tool when visual element identification is needed for follow-up actions. Side effects: uses an existing session backend, injects and removes temporary overlay DOM nodes; writes to ``output_path`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'format' (str), 'base64' (str) or 'path' (str), 'size_bytes' (int), 'labels' (dict[str, str]). - **wavexis_page_pdf** — Generate a PDF via the low-level Page.printToPDF CDP method. Offers pixel-level control over paper size, margins, and print options beyond ``wavexis_pdf``. Use ``wavexis_pdf`` for simpler high-level PDF generation. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided; writes to ``output_path`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'type' ('pdf'), 'base64' (str) or 'path' (str), 'size_bytes' (int). - **wavexis_page_snapshot** — Capture the page as MHTML or a plain text document. Use ``wavexis_scrape`` for structured data extraction, or this tool when a full page archive (MHTML) or text dump is required. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided; writes to ``output_path`` when given. Returns: JSON string with keys: 'status' ('ok'/'error'), 'format' (str), 'content' (str) or 'path' (str), 'size_bytes' (int). - **wavexis_eval** — Evaluate a JavaScript expression in the browser context and return the result. Use ``wavexis_scrape`` when the same expression must run across many pages, or ``wavexis_act`` for natural-language interaction instead of raw JS. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, executes arbitrary JS in the page (may trigger network requests or DOM mutations). Returns: JSON string with keys: 'status' ('ok'/'error'), 'result' (Any), 'type' (str). - **wavexis_dom_get** — Retrieve the HTML of an element matching a CSS selector. Use wavexis_dom_query instead when you need element metadata rather than raw HTML. Side effects: None; read-only. May navigate to ``url`` if provided. Returns: JSON string with keys: 'status' ('ok'/'error'), 'html' (str), 'selector' (str). - **wavexis_dom_query** — Query elements by CSS selector and return paginated metadata. Use wavexis_dom_get instead when you only need the raw HTML of a single element. Side effects: None; read-only. May navigate to ``url`` if provided. Returns: JSON string with keys: 'status' ('ok'/'error'), 'elements' (list[dict]), 'count' (int), 'total' (int). - **wavexis_dom_set_attr** — Set an attribute on an element matching a CSS selector. Use wavexis_dom_get_attr to read the current value before setting. Side effects: Mutates the DOM by writing the attribute on the matched element. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_dom_get_attr** — Read an attribute value from an element matching a CSS selector. Use wavexis_dom_set_attr to write an attribute value. Side effects: None; read-only. Returns: JSON string with keys: 'status' ('ok'/'error'), 'value' (str|None), 'selector' (str), 'name' (str). - **wavexis_dom_remove_attr** — Remove an attribute from an element matching a CSS selector. Use wavexis_dom_set_attr to restore or change an attribute instead of removing it. Side effects: Mutates the DOM by deleting the attribute from the matched element. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_dom_remove** — Remove an element matching a CSS selector from the DOM. Use wavexis_dom_set_attr to hide an element (e.g. ``display:none``) instead of deleting it. Side effects: Destructive; permanently removes the matched element from the live DOM. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_dom_focus** — Focus an element matching a CSS selector. Use wavexis_dom_click instead when the intent is to activate a control rather than focus it. Side effects: Mutates DOM focus state; may trigger focus event handlers on the element. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_dom_scroll** — Scroll to an element or by a pixel offset. Use wavexis_dom_get to inspect an element's position before scrolling by offset. Side effects: Changes the page scroll position; may trigger scroll event listeners. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_dom_snapshot** — Capture a full DOM snapshot of the page including iframes and shadow roots. Use wavexis_dom_query for lightweight element metadata instead of a full snapshot. Side effects: None; read-only. Returns: JSON string with keys: 'status' ('ok'/'error'), 'snapshot' (dict), 'documents' (int). - **wavexis_iframe_eval** — Evaluate a JavaScript expression inside an iframe. Use wavexis_iframe_click or wavexis_iframe_fill for standard interactions instead of raw JS. Side effects: Arbitrary; executes user-supplied JavaScript within the iframe context. Returns: JSON string with keys: 'status' ('ok'/'error'), 'result' (any). - **wavexis_iframe_click** — Click an element inside an iframe. Use wavexis_iframe_eval only for custom JS that click/fill cannot express. Side effects: Triggers click handlers and may navigate or mutate the iframe DOM. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_iframe_fill** — Fill an input element inside an iframe with a value. Use wavexis_iframe_click to submit or activate the field after filling. Side effects: Mutates the input value within the iframe; may trigger input/change events. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_shadow_eval** — Evaluate a JavaScript expression inside a shadow DOM tree. Pierces shadow boundaries using the provided selector chain: ``selectors[0]`` is in the main document, ``selectors[1]`` in ``selectors[0].shadowRoot``, and so on. Use wavexis_shadow_click or wavexis_shadow_fill for standard interactions instead of raw JS. Side effects: Arbitrary; executes user-supplied JavaScript within the shadow DOM context. Returns: JSON string with keys: 'status' ('ok'/'error'), 'result' (any). - **wavexis_shadow_click** — Click an element inside a shadow DOM tree. Pierces shadow boundaries using the provided selector chain. Use wavexis_shadow_eval only for custom JS that click/fill cannot express. Side effects: Triggers click handlers and may navigate or mutate the shadow DOM. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_shadow_fill** — Fill an input element inside a shadow DOM tree with a value. Pierces shadow boundaries using the provided selector chain. Use wavexis_shadow_click to submit or activate the field after filling. Side effects: Mutates the input value within the shadow DOM; may trigger input/change events. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_click** — Click an element matching a CSS selector. Use wavexis_double_click for double clicks, wavexis_right_click for context menus, or wavexis_nl_click when you only have a text description. Side effects: Triggers a click event on the target element, which may submit forms, toggle controls, or navigate the page. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_double_click** — Double-click an element matching a CSS selector. Use wavexis_click for single clicks or wavexis_nl_click when you only have a natural language description of the element. Side effects: Fires two rapid click events on the element, which may open files, edit cells, or trigger application-specific actions. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_right_click** — Right-click an element matching a CSS selector. Use wavexis_click for standard left clicks or wavexis_double_click for double clicks. Side effects: Fires a contextmenu event on the element, typically opening a context menu in the browser. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_type** — Type text into an element character by character with optional delay. Use wavexis_fill instead when you want to set a field's value instantly without per-keystroke delays, or wavexis_fill_form for multiple fields. Side effects: Appends characters to the target input/textarea element, firing keydown/keypress/input/keyup events per character. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_fill** — Fill an input element with a value, replacing existing content. Use wavexis_type for character-by-character typing with key events, or wavexis_fill_form when filling multiple fields in one call. Side effects: Clears the target input/textarea and sets its value to the provided string, firing a single input event. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_fill_form** — Fill multiple form fields in one call (convenience composite tool). Use wavexis_fill for a single field or wavexis_type when per-keystroke events are required. Side effects: Clears and sets the value of each field in the provided list, firing input events on every targeted element. Returns: JSON string with keys: 'status' ('ok'/'error'), 'fields_filled' (int, number of fields successfully filled). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_select_option** — Select an option in a ```` elements. Side effects: Changes the selected option of the ````). Use wavexis_drop when you need to simulate drag-and-drop of files or MIME data onto a non-file-input element. Side effects: Sets the selected files on the target file input element, firing change events that typically trigger upload logic. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_drop** — Drop files or MIME-typed data onto an element via drag events. Use wavexis_set_files for standard ```` uploads or wavexis_drag for dragging an existing DOM element to another element. Side effects: Dispatches dragEnter, dragOver, and drop events with the supplied data and files onto the target element's coordinates. Returns: JSON string with keys: 'status' ('ok'/'error'), 'selector' (str), 'x' (float), 'y' (float), 'data_types' (list[str]), 'files' (list[str]). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_check** — Check a checkbox or radio button matching a CSS selector. Use wavexis_uncheck to uncheck a checkbox or wavexis_click for generic element activation. Side effects: Clicks the target checkbox/radio, toggling its checked state and firing change events. Returns: JSON string with keys: 'status' ('ok'/'error'), 'checked' (bool, the element's checked state after the action). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_uncheck** — Uncheck a checkbox matching a CSS selector by clicking it. Use wavexis_check to check a checkbox or wavexis_click for generic element activation. Side effects: Clicks the target checkbox to toggle it to unchecked, firing change events. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_find_by_text** — Find element selector(s) by visible text content without interacting. Use this to locate elements before calling wavexis_click or wavexis_fill when you know the visible text but not the CSS selector. Side effects: None — this is a read-only lookup that does not modify the page or interact with any element. Returns: JSON string with keys: 'selector' (str, first match) when all=False, or 'selectors' (list[str]) and 'count' (int) when all=True. On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_nl_click** — Click an element described in natural language. Use wavexis_click when you already know the CSS selector, or wavexis_nl_fill to fill a field described in natural language. Side effects: Locates the best-matching element via text/semantic matching and triggers a click event on it. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_nl_fill** — Fill an element described in natural language with a value. Use wavexis_fill when you already know the CSS selector, or wavexis_nl_click to click an element described in natural language. Side effects: Locates the best-matching element via text/semantic matching, clears it, and sets its value to the provided string. Returns: JSON string with keys: 'status' ('ok'/'error'). On error also 'error', 'tool', 'type', 'message', 'suggestion' (all str). - **wavexis_cookies_get** — Retrieve all cookies for the current page context. Use ``wavexis_cookies_set`` to add a cookie, or ``wavexis_cookies_clear`` to remove all cookies at once. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided; read-only with respect to browser state. Returns: JSON string with keys: 'status' ('ok'/'error'), 'cookies' (list[dict]), 'count' (int). - **wavexis_cookies_set** — Set a single cookie in the browser for the current page. Use ``wavexis_cookies_get`` to read cookies, or ``wavexis_cookies_delete`` to remove a specific cookie. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, mutates browser cookie state. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_cookies_delete** — Delete cookies matching a name and domain in the browser. Use ``wavexis_cookies_clear`` to remove all cookies, or ``wavexis_cookies_set`` to add a new cookie. Side effects: launches/acquires a browser backend, navigates to ``url`` if provided, destructively removes matching cookies from browser state. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_cookies_clear** — Clear all cookies from the browser session. Use ``wavexis_cookies_delete`` to remove a specific cookie, or ``wavexis_cookies_get`` to inspect cookies before clearing. Side effects: uses an existing session backend, destructively removes all cookies from the browser. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_list_tabs** — List all open browser tabs in the session. Use to discover tab IDs before calling wavexis_activate_tab or wavexis_close_tab; use wavexis_session_info for session-level metadata instead. Side effects: None — read-only query of the browser's tab list. Returns: JSON string with keys: 'status' ('ok'/'error'), 'tabs' (list[dict]), 'count' (int). - **wavexis_new_tab** — Create a new browser tab, optionally navigating to a URL. Use to open a parallel page without losing the current tab; use wavexis_navigate to change the current tab's URL instead. Side effects: Opens a new browser tab; if a URL is provided, issues a network request to it. Returns: JSON string with keys: 'status' ('ok'/'error'), 'tab_id' (str), 'url' (str). - **wavexis_close_tab** — Close a browser tab by its ID. Use to clean up tabs created with wavexis_new_tab; use wavexis_session_close to terminate the entire session instead. Side effects: Closes the specified tab and discards its page state. Destructive — unsaved data in that tab is lost. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_activate_tab** — Focus (bring to front) a browser tab by its ID. Use to switch the active tab before running navigation or interaction tools; use wavexis_list_tabs to obtain tab IDs first. Side effects: Changes the browser's active tab; subsequent tool calls operate on the newly focused tab. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_browser_version** — Query the active browser's version string via the selected backend. Use ``wavexis_backends`` instead when you need a list of all installed backends without launching a browser. Side effects: Acquires (and may launch) a browser backend, then releases it. Returns: JSON string with keys: 'status' ('ok'/'error'), 'version' (str), 'backend' (str). - **wavexis_backends** — List installed browser backends and their versions without launching a browser. Use ``wavexis_browser_version`` instead when you need the version of a specific running session's backend. Side effects: None; queries the local filesystem only. Returns: JSON string with keys: 'status' ('ok'/'error'), 'backends' (dict), 'available' (list[str]). - **wavexis_invoke** — Invoke any wavexis backend method by name, the ultimate escape hatch. Use a dedicated MCP tool (e.g. ``wavexis_act``, ``wavexis_navigate``) instead when one exists for the desired action; this tool exposes the full ``AbstractBackend`` API (e.g. ``page_print_to_pdf``, ``perf_trace``, ``runtime_evaluate``, ``pwa_install``) for methods without a wrapper. Side effects: May launch an ephemeral browser, navigate to a URL, and execute arbitrary backend methods; potentially destructive. Returns: JSON string with keys: 'status' ('ok'/'error'), 'type' (str), and either 'result' (any), 'base64' (str), or 'path' (str) depending on output. - **wavexis_key_down** — Dispatch a raw keyDown event to the active page via CDP. This tool mirrors Playwright's API for compatibility; use ``wavexis_press_keys`` for typing text and ``wavexis_act`` for natural-language interaction. Side effects: Sends a key-down input event to the browser page. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_key_up** — Dispatch a raw keyUp event to the active page via CDP. This tool mirrors Playwright's API for compatibility; pair with ``wavexis_key_down`` for low-level key control, or use ``wavexis_press_keys`` for simple text entry. Side effects: Sends a key-up input event to the browser page. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_press_keys** — Type a sequence of characters at the page level without targeting an element. Use ``wavexis_key_down``/``wavexis_key_up`` instead for individual modifier-key control, or ``wavexis_act`` for natural-language typing. Side effects: Dispatches keyDown/keyUp pairs to the browser page; no network requests. Returns: JSON string with keys: 'status' ('ok'/'error'), 'typed' (str). - **wavexis_mouse_drag_xy** — Drag the mouse from one screen coordinate to another via CDP mouse events. This tool mirrors Playwright's API for compatibility; use ``wavexis_act`` instead for natural-language drag interactions. Side effects: Dispatches mouseMoved, mousePressed, and mouseReleased events to the browser page; may trigger page interactions. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_console_clear** — Clear all buffered console messages for the session. This tool mirrors Playwright's API for compatibility; use it before capturing a fresh set of console logs to avoid stale entries. Side effects: Resets the session's in-memory console message buffer. Returns: JSON string with keys: 'status' ('ok'/'error'). - **wavexis_cookie_get** — Retrieve a single cookie by name (and optional domain/path) from the browser. Use ``wavexis_cookie_list`` instead when you need multiple cookies or broad filtering. Side effects: None; reads cookie state from the browser session. Returns: JSON string with keys: 'status' ('ok'/'error'), 'cookie' (dict|null). - **wavexis_cookie_list** — List browser cookies with optional name, domain, and path filters. Use ``wavexis_cookie_get`` instead when you need a single named cookie. Side effects: None; reads cookie state from the browser session. Returns: JSON string with keys: 'status' ('ok'/'error'), 'cookies' (list[dict]), 'count' (int). - **wavexis_close_page** — Close a browser page/tab by target id, or the current page if omitted. This tool mirrors Playwright's API for compatibility; use it to free resources. The session itself remains active for other tabs. Side effects: Closes the specified browser target; destructive and irreversible. Returns: JSON string with keys: 'status' ('ok'/'error'), 'closed' (str). - **wavexis_find** — Search the accessibility snapshot for nodes matching text or a regex pattern. Use ``wavexis_act`` instead for natural-language element interaction; this tool mirrors Playwright's snapshot search for compatibility. Side effects: None; fetches and searches the a11y tree read-only. Returns: JSON string with keys: 'status' ('ok'/'error'), 'matches' (list[dict]), 'count' (int). - **wavexis_get_config** — Return wavexis-mcp server configuration and available browser backends. Use ``wavexis_backends`` instead when you only need the backend list; this tool additionally exposes the server name for introspection. Side effects: None; queries the local filesystem only. Returns: JSON string with keys: 'status' ('ok'/'error'), 'name' (str), 'available_backends' (list[str]), 'backend_versions' (dict). - **wavexis_act** — Execute a natural language instruction on the current page (M1). Takes an a11y snapshot, matches the instruction to an element, and performs the detected action (click, type, fill, hover). Args: input: Act parameters (instruction, session_id, max_retries). Returns: JSON string with ``action``, ``element``, ``score``, ``status``. ## Claude Desktop Quick Installation Install path detected from listing signals. Uses `uvx` (confidence: high): ```json "mcpServers": { "wavexis-mcp": { "command": "uvx", "args": ["wavexis-mcp"] } } ``` ## Documentation ## What MathiasPaulenko/wavexis-mcp does MathiasPaulenko/wavexis-mcp connects MCP-compatible AI clients to the wavexis browser automation library. It exposes 220 tools across 13 capability tiers, covering browser sessions, navigation, DOM inspection and mutation, JavaScript execution, screenshots, PDFs, scraping, iframe and shadow DOM interaction, network controls, storage, emulation, testing, DevTools features, and other browser functions. The server works with Chrome and Edge through the Chrome DevTools Protocol (CDP), and with Firefox through WebDriver BiDi. It uses browsers already installed on the machine rather than downloading a separate Chromium build. The implementation is written in Python. ## How it works An MCP client supplies the model with tool definitions and receives JSON results from tool calls. WaveXisMCP passes those calls to wavexis, which performs the operation through the selected browser backend. Results can contain text, structured data, base64-encoded output, or file paths. Two operating patterns are available: - Stateless calls accept a URL, launch or acquire a browser, perform the operation, and close automatically. - Session-based workflows begin with `wavexis_session_open`, reuse the returned `session_id` across calls, and finish with `wavexis_session_close`. Persistent sessions suit sequences such as opening a page, navigating, clicking, filling a form, and capturing a screenshot. The server also provides `wavexis_act` for heuristic natural-language actions such as clicking, typing, filling, or hovering. Multi-action YAML workflows can combine several operations into one tool call, while raw CDP and BiDi tools provide a lower-level escape hatch. ## Setup and configuration Install the Python package with `pip install wavexis-mcp`, run it without a local installation using `uvx wavexis-mcp`, or configure the MCP client to launch the `wavexis-mcp` command. The documented Python versions are 3.11, 3.12, and 3.13. The default capability set is `core`, which provides 72 tools. Pass `--caps=all` to expose all 220 tools, or select groups such as `network`, `storage`, and `emulation`. The CDP backend is included by default. Firefox and the BiDi backend require the optional `bidi` installation and the relevant browser driver; ChromeDriver or EdgeDriver is used for Chromium BiDi, while Firefox uses geckodriver. A minimal `uvx` configuration uses the `wavexis-mcp` command with `--caps all`. The project documents configuration examples for Claude Desktop, Cursor, Windsurf, and VS Code. ## Tools and capabilities Core tools include session lifecycle management, direct and history navigation, waiting, reload and stop controls, screenshots, PDF generation, page snapshots, multi-URL scraping, JavaScript evaluation, CSS-selector DOM queries, attribute changes, scrolling, iframe operations, and shadow DOM evaluation. Additional capability tiers cover: - Network inspection and modification, including headers, throttling, interception, mocking, HAR handling, and request replay. - Browser storage, device and viewport emulation, geolocation, locale, timezone, dark mode, touch, and sensors. - Accessibility snapshots and audits, downloads, permissions, dialogs, performance, CSS, console, security, and tracing. - Coordinate-based mouse input, video capture, assertions, locator generation, YAML workflows, Lighthouse audits, crawling, visual differences, and Core Web Vitals. - Experimental browser features such as service workers, WebAuthn, media, extensions, preferences, Bluetooth, and Cast. Errors include a `suggestion` field intended to help an LLM choose a corrective action. Stealth mode can hide `navigator.webdriver` and adjust browser-exposed values such as plugins, languages, and the Chrome runtime. ## Limitations and notes The server depends on a locally available supported browser and, for BiDi use, the appropriate driver. Closing a persistent session terminates its browser process or disconnects from the remote browser and discards unsaved page state. JavaScript evaluation, DOM mutation, navigation, downloads, and network controls can change page state or trigger external requests, so they should be used with appropriate care. Capability selection affects which tools are exposed to the MCP client. Starting with `core` and enabling additional tiers keeps the tool set smaller; `all` exposes the full catalog. _Full upstream README: https://allmcps.com/mcp/mathiaspaulenko-wavexis-mcp/readme_