invisible-playwright-mcp
Automates a patched Firefox-based engine binary (optionally a user-supplied build pinned to the required version), sending realistic pointer and keyboard input so pages see it as an ordinary Firefox with a seed-derived fingerprint, proxy, locale and timezone.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@invisible-playwright-mcp Open example.com, search for wireless headphones, and read me the top result"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Other AI browser agents get captchas. This one is invisible to anti-bots.
Two ways to use this browser agent
1. From your assistant, over MCP
Windows, in PowerShell:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
$env:Path = "$env:USERPROFILE\.local\bin;$env:Path"Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/envThen install it in your assistant.
Claude Code:
claude plugin marketplace add feder-cr/invisible_playwright_mcp
claude plugin install invisible-playwright-mcp@feder-crCodex:
codex plugin marketplace add feder-cr/invisible_playwright_mcp
codex plugin add invisible-playwright-mcp@feder-crGemini CLI:
gemini extensions install https://github.com/feder-cr/invisible_playwright_mcp2. Standalone: the web UI
We bring the interface, you bring an OpenRouter key. Chat on the left, the live browser on the right.
Windows, in PowerShell:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
$env:Path = "$env:USERPROFILE\.local\bin;$env:Path"
uvx invisible-playwright-mcp ui --openrouter-key sk-or-...Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env
uvx invisible-playwright-mcp ui --openrouter-key sk-or-...Then open http://127.0.0.1:8765 and type the same thing.
Related MCP server: puppeteer-real-browser-mcp-server
What to ask a web browsing agent
Anything that needs real web automation: a browser rather than an API, and a person's judgement about what is on the page.
Go to
<paste the URL>. One way, Milan to Lisbon, economy, one checked bag, one adult. Check every date from the 12th to the 16th of next month, one at a time, and read the cheapest fare for each day. The date field is a calendar widget, so click the days rather than typing them. If a date has no availability, say so. Do not guess a number.
It drives the page the way a person would: the pointer moves, keys are pressed.
Options: proxy, profile, seed
--openrouter-keyYour key, or theOPENROUTER_API_KEYvariable.--modelAn OpenRouter model id, orINVISIBLE_MCP_MODEL. Defaults toz-ai/glm-5.3-flash.--proxyOptional.http://user:pass@proxy.example.com:8080orsocks5://proxy.example.com:1080. Host and port are both required. The timezone, locale and egress follow it.--binaryAn engine binary you already have. It must be the build the seal pins, or startup refuses: this skips the download, not the version check.--seedAn integer. Same seed, same browser identity, every run.--profile-dirA directory to keep the profile in, so logins and cookies survive restarts.--headedShow the browser window. The interface shows you the page anyway.--host,--port127.0.0.1and8765. Changing the host exposes an interface that has no authentication.
A .env beside the command
Rather than retyping the key and the binary path, put them in a .env in the
directory you run from:
OPENROUTER_API_KEY=sk-or-...
STEALTHFOX_BINARY=/path/to/firefoxIt is read at startup, and on the way in it never overrides something
already set, so the order is --flag > the environment > .env > the default.
Only the directory you are in is read - there is no search upwards, so running
from a subfolder cannot silently pick up a different key. The startup line names
the variables it applied and never prints their values.
Passing --openrouter-key puts the key in your shell history, and on Linux in
the process list. OPENROUTER_API_KEY in the environment or in a .env avoids
both.
The wiki: AI browser-agent guides
The reading room around the agent lives in the wiki: the AI browser-agent landscape: browser-use, Operator-style and computer-use agents compared, what to check when an agent gets blocked, and what happened to OpenAI Operator, among others. Worked examples, transcripts and their outputs live in articles/.
The rest of the family: engine, core
The MCP server from option 1 ships inside this package: invisible_playwright_mcp with no
subcommand is the server, invisible-playwright-mcp ui the interface. Its config blocks for
clients that take a file, its settings and its tools are on the wiki page
The MCP server.
invisible_playwright The engine, as a Python library, for writing code instead of prompts. The API is Playwright's.
invisible_core Seed to fingerprint to preferences, proxy and geolocation.
Using it responsibly
This automates a browser under your control. Read the terms of the sites you point it at, respect their rate limits, and do not submit anything a human has not read.
Privacy Policy
This browser agent runs on your machine and has no server of its own. What leaves your computer, and to whom:
The sites you visit see the browser, as they would any Firefox.
Your model provider. The web UI sends the conversation and what the agent reads on the page to OpenRouter under your key. Over MCP, the client you plugged it into does the same with whichever model it uses.
GitHub. The engine is downloaded from a GitHub release the first time the server or the interface starts, and a GeoIP database is when a proxy is set. Each browser launch also fetches a one-line counter file from a GitHub release, which is how launches are counted: the request carries no identifier and nothing of yours, and GitHub sees what any HTTPS request shows, your IP address.
Nothing else is collected and nothing is sent to the author. Sessions,
profiles and screenshots are stored locally, under INVISIBLE_MCP_HOME if set and
otherwise in the application-data directory of your system, and are yours to
delete; nothing is retained anywhere else. Questions go to the
issues.
License
MIT. Everything distributed before 2 September 2026 was released under AGPL-3.0 and stays under it.
Available Tools
16 toolsbrowser_clickADestructive
Click the first element matching a CSS selector.
Scrolls it into view and waits for it to be clickable. When no selector can describe the target, use browser_click_at with coordinates from browser_snapshot.
Inputs: selector (required), browser. Returns: result
browser_click_atADestructive
Click (or press-and-hold) a raw viewport coordinate instead of a selector - for targets a selector cannot reliably reach: a slider track, a canvas-drawn captcha, a precise point inside a wider element. Moves the pointer there first (no teleport), then down, then up, holding first if hold_seconds is set. Returns a screenshot taken right after release.
Coordinates are relative to the VIEWPORT, not to the page, so the ones in a
snapshot go stale the moment anything scrolls. Nothing raises when that
happens: the click lands on whatever is at that spot now. Take a fresh
snapshot after anything that could have moved the page, and prefer
browser_click with the element's selector whenever it has one.
Inputs: x (required), y (required), browser, hold_seconds.
browser_closeADestructive
Close one browser and free what it was holding.
The page it had is gone with it. The other browser is not touched.
Who it was is kept: browser_open with no arguments brings the same person back. To be somebody else, pass a seed, a proxy or a profile.
Inputs: browser. Returns: result
browser_evaluateARead-only
READ from the page with JavaScript and get the result as JSON.
For what the other tools cannot see: a computed style, a value held in a framework's state, the length of a list.
Acting on the page is refused, and the refusal names the tool to use.
Assigning to value, checked or selected, or calling click(),
dispatchEvent(), submit() or requestSubmit(), changes the page without
a real keystroke or pointer, and a page can tell. Use browser_click,
browser_type or browser_select_option instead; they do the same thing
through the pointer and the keyboard. Reading any of those properties is
fine.
The refusal catches the obvious spellings, not every possible one. A script that slips past it is still the wrong way to do the thing: report it in your answer rather than using it.
Inputs: expression (required), browser. Returns: result
browser_listARead-only
Which of the two browsers are open, where each one is, and which one you are working in.
Answers JSON: focus, the browser your last command acted in, or "" when
none is open; note, which says how many are open and that a command
naming no browser goes to main; and browsers - each row id, url
(the page it is on) and urls (every page it holds, which is more than
one only when a site opened one). Only open browsers are listed, so every
row is one you can act on.
Starts nothing: it reports what is open, so asking is free.
Inputs: no named parameters. Returns: result
browser_openADestructive
Open main or support, or reopen one as somebody else.
support is yours to manage: open it when the task needs a second
identity, and close it with browser_close as soon as the task no longer
needs it, before you answer. It is not saved.
Called on a browser that is already up, this REOPENS it with the settings given, and what it held is gone.
seed the identity; same seed, same fingerprint. Left out, one is drawn.
profile a directory keeping cookies, logins and the seed between opens;
"" means none. It keeps the SEED too, so a login does not come
back on different hardware every visit.
proxy the exit, http://user:pass@host:port or socks5://host:port;
"" means this machine's own address; left out for support, it
shares the exit main has. A profile does NOT pin its exit, and
a login arriving from a new country is as visible as one arriving
on new hardware.
Inputs: seed, proxy, browser, profile. Returns: result
browser_press_keyADestructive
Press a key on whatever has focus: "Enter", "Tab", "Escape", "ArrowDown", "Control+a", or a single character.
Inputs: key (required), browser. Returns: result
browser_read_htmlARead-only
The page's HTML, cleaned down to what is worth reading.
Use this when the STRUCTURE matters - a form and its labels, a table, what
a control is wired to. browser_snapshot gives a flat inventory of things
to click; this keeps the markup and the relationships inside it.
mode="form" keeps the interactive surface and the text explaining it, mode="text" returns the prose alone, mode="full" keeps the structure with the noise and the attribute soup removed.
Unlike browser_read_text this is NOT capped: it returns the whole reduced page, tens of thousands of characters on a large one. Cutting markup in the middle leaves tags that mean nothing, so it is not cut - but the answer can be long. Reach for browser_snapshot when you only need something to click.
Inputs: mode, browser. Returns: result
browser_read_textARead-only
The visible text of an element, with the markup gone.
The cheapest way to read a page. Narrow the selector when you know where the answer is; use browser_read_html instead when the structure matters, or browser_snapshot when you need something to click.
Long text is cut at max_chars (6000 by default) and the cut is marked in what comes back, so text that ends without that marker is the whole thing.
Inputs: browser, selector, max_chars. Returns: result
browser_select_optionADestructive
Choose an option in a dropdown (<select>), by its visible label or by
its value.
Use this rather than clicking the dropdown and pressing arrow keys: a click plus arrows cannot tell you which row it landed on, and setting the value through browser_evaluate changes it without the page seeing a real interaction.
Inputs: value (required), selector (required), browser. Returns: result
browser_snapshotARead-only
Title, url, and the interactive elements that are actually visible.
Each element carries a selector when one can reach it: pass that string to
browser_click or browser_type VERBATIM rather than writing your own. It is
built to match exactly ONE element, which the obvious selector often does
not, and the driver acts on the first match - so a caller aiming at the
third of five identical links would silently hit the first and be told it
succeeded.
Elements with no selector carry at, the centre coordinates, for
browser_click_at.
It lists what a caller can act on, and it is not the accessibility tree:
one country <select> would otherwise fill the answer with its options
before the form you were looking for appears.
Inputs: browser, max_chars. Returns: result
browser_statusARead-only
Who is browsing right now: the identity, the exit, the profile and the page.
Ask whenever you need to know which person the browser currently is, or
from where its traffic leaves. The seed is what you would pass to
browser_open to become this person again, so this is also how you
record an identity worth repeating.
It starts nothing: a browser that is not open, or gone, is answered with the sentence that says which.
Inputs: browser. Returns: result
browser_take_screenshotBRead-only
One screenshot of this browser's page, on demand.
Inputs: browser.
browser_typeADestructive
Fill a field, replacing whatever it holds.
This sets the value rather than typing key by key, so it will not fire the per-keystroke handlers an autocomplete needs. For those, click the field and use browser_press_key.
Inputs: text (required), selector (required), browser. Returns: result
browser_watchARead-only
The whole browser window as a person at the machine sees it: tab strip, address bar, the page and the pointer, from a live capture kept running on that page. For watching the work, not for acting on it: the picture is window pixels, so do not feed its coordinates to browser_click_at; use browser_take_screenshot for that.
Starts nothing. A browser that is not open has no window, so this answers the sentence that says so, and the live panes - which call this many times a second - read that sentence as the idle pane.
Inputs: browser.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 16 tools
Most tools target clearly different actions (navigate, click, type, select, press, evaluate), and the descriptions actively steer callers between the tricky pairs (read_text vs read_html vs snapshot; click vs click_at; watch vs take_screenshot). The only real softness is browser_list vs browser_status, which both report on open browsers/identity, and the three reading tools remain conceptually close even though the docs draw the lines well.
Every tool carries the `browser_` prefix and snake_case, so the set reads as one family. Within that, though, it mixes bare nouns (browser_list, browser_status, browser_snapshot, browser_evaluate) with verb_noun forms (browser_take_screenshot, browser_read_text, browser_select_option), so the verb position is not fully predictable.
Sixteen tools is at the upper edge but each one maps to a distinct browser capability (session lifecycle, observation, reading, and input), so nothing looks like filler. It is slightly over the ideal band, with the three read/snapshot tools and the two observation tools pushing the count up.
Core automation is covered — open/close/status, navigate, read text/html/snapshot, click, click_at, type, select, press key, evaluate, screenshots. But there are noticeable gaps: no scrolling tool, no back/forward history navigation, no hover, and no way to switch among the multiple pages a browser reports in `urls`, which leaves a genuine dead end when a site opens a second tab.
Related MCP Connectors
Browser agents and stealth cloud browsers for AI: run web tasks, fill forms, extract data.
Let your AI agent operate any website through a real, logged-in browser session.
Undetectable cloud browser sessions for AI agents and scrapers. Navigate, extract, click, captcha.
Control a real browser from AI agents: navigate, click, type, screenshot, read the page.
Related MCP Servers
- AlicenseAqualityBmaintenanceGives your AI agent a persistent browser identity with anti-detection, credential vault, and multi-persona support for automated web browsing, login, and signup.316 npm10MIT
- AlicenseNot gradedqualityDmaintenanceProvides AI assistants with powerful, detection-resistant browser automation capabilities, allowing them to control a real web browser to navigate, extract content, and perform tasks while avoiding bot detection.13 npmMIT
- AlicenseAqualityCmaintenanceEnables AI agents to fully control a browser for web automation, including navigation, clicking, typing, scrolling, screenshots, and DOM inspection, with session persistence and anti-bot bypass.4036 npmMIT
- AlicenseCqualityDmaintenanceEnables AI-powered browser automation with real profiles, supporting interaction, navigation, form filling, and advanced features like visual overlays and self-healing selectors.42Apache 2.0