# MathiasPaulenko/wavexis-mcp [Health: Active] **Category:** 📂 Browser Automation **Repository:** https://github.com/MathiasPaulenko/wavexis-mcp **GitHub Stars:** 1 **Views:** 4 **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 MCP server does MathiasPaulenko/wavexis-mcp MCP server exposes the wavexis browser automation library through MCP. Its tool set covers browser sessions, navigation, page waiting, screenshots, PDF creation, JavaScript evaluation, DOM inspection and mutation, iframe operations, shadow DOM access, and multi-page scraping. The complete distribution provides 220 tools organized into 13 capability tiers; the default `core` tier provides 72 tools. The server supports Chrome and other Chromium-based browsers through CDP, plus Firefox through BiDi. It uses an existing browser installation rather than downloading Chromium. ChromeDriver, EdgeDriver, or geckodriver may be needed for the BiDi backend, depending on the browser being used. ## How it works An MCP client receives the server's tool definitions and sends structured calls. The server passes those calls to the wavexis library, which drives the selected browser and returns JSON results containing values such as text, metadata, base64 data, or file paths. Use session mode for a workflow with several related actions. `wavexis_session_open` creates persistent browser state and returns a `session_id`; subsequent calls reuse that identifier until `wavexis_session_close` releases the browser and its resources. Stateless calls can instead provide a URL, allowing the server to launch a browser, perform the operation, and close it automatically. MathiasPaulenko/wavexis-mcp MCP server also includes a natural-language action tool that uses accessibility snapshots and heuristic keyword matching to select actions such as clicking, typing, filling, or hovering. It does not make external LLM calls for that matching. Errors include a suggestion field intended to help the calling model decide what to try next. ## Setup and configuration The project requires Python 3.11, 3.12, or 3.13. A no-install launch uses: ```bash uvx wavexis-mcp --caps all ``` A standard installation is available with `pip install wavexis-mcp`; the optional `[cdp]` extra adds CDP backend dependencies. MCP configuration examples are provided for Claude Desktop, Cursor, Windsurf, and VS Code. The `--caps` option controls which tool groups are exposed: `core` is enabled by default, while `all` enables all 220 tools. Specific groups can be selected, such as `network`, `storage`, or `emulation`. ## Tools and capabilities MathiasPaulenko/wavexis-mcp MCP server includes capabilities for: - Opening, inspecting, and closing persistent sessions. - Navigating history, reloading pages, waiting for conditions, and stopping loads. - Querying or changing DOM elements, including attributes, focus, scrolling, iframes, and shadow trees. - Capturing screenshots, annotated screenshots, screencasts, PDFs, MHTML, and text snapshots. - Running JavaScript in page, iframe, and shadow DOM contexts. - Scraping multiple URLs with a shared JavaScript expression. - Network controls, storage access, browser emulation, accessibility inspection, testing, workflows, DevTools, and data features when their tiers are enabled. ## Limitations and notes The server drives real browsers, so page actions can issue network requests, change page state, trigger event handlers, or discard unsaved state when a session closes. JavaScript evaluation is arbitrary within the selected page context. Browser availability and driver setup determine which backend can run. The provided material does not document API-key or OAuth authentication requirements. _Full upstream README: https://allmcps.com/mcp/mathiaspaulenko-wavexis-mcp/readme_