KEEP IT HANDS-ON functional ~ tested 2026-10-03
// sandboxed in macOS 26 Β· aarch64 (host fallback, no sbx) Β·install log Β· why not fully functional: The stealth-browsing claim requires the patched Firefox engine, which publishes Windows and Linux binaries only (no Mac binaries since the firefox-21 engine; the current engine is firefox-35). On the macOS review host browser_open fails closed with the named error "macOS is no longer a supported platform: no Mac binaries have been published since firefox-21". Verified instead: MCP handshake, all 17 tools with schemas and annotations, read-only tool answers, structured unknown-tool rejection, the ui key refusal, and 889 of the repo's own tests passing locally. Β·functional log

invisible_playwright_mcp

by feder-cr · https://github.com/feder-cr/invisible_playwright_mcp · MIT (AGPL-3.0 for distributions before 2026-09-02) · v0.70.9 · updated 2026-10-03
Don't install your next skill blind. One email a week: what's worth installing.

The anti-detect browser agent sat untracked for 14 months. It is the best-engineered MCP server in its lane, and it does not run on macOS at all.

⚙ ⚙ ⚙ ⚙ ⚙ 4 / 5
quality 5/5
documentation 4/5
setup 4/5
value 4/5
ecosystem fit 4/5
// bottom line

This is the rare 31K-star repo whose code quality exceeds its hype: measured dependency floors, a self-downloading engine that never blocks a tool call, and 889 of its own tests passing on a platform it does not even support. The cost is that the patched-Firefox engine ships Windows and Linux binaries only, and the README never says so. Install it on those two platforms if you need agents to browse sites that block plain automation; skip it on a Mac, where the first browser call fails closed.

Get the skill digest The best and the broken from 100+ hands-on tests. One email a week.
Claude Code plugin
$claude plugin marketplace add feder-cr/invisible_playwright_mcp && claude plugin install invisible-playwright-mcp@feder-cr
any MCP client via uvx
$uvx invisible-playwright-mcp
skills rail (Hermes)
$npx skills add feder-cr/invisible_playwright_mcp --skill setup --agent hermes-agent

lands byte-identical SKILL.md in .hermes/skills

install if

  • Agent builders on Windows or Linux who need browsing on hostile sites. Login flows, booking sites, and storefronts that block plain Playwright are this project's stated home turf, and the tool surface (click_at with hold_seconds, watch, read_html with a form mode) is built for exactly that work.
  • Anyone who values fail-closed tool design. Even setting stealth aside, the progress-aware engine download, structured refusals, and annotated tools make this a reference implementation for how an MCP server should degrade.
  • Hermes and multi-host users. The skills rail lands the setup skill cleanly for hermes-agent, and seven packaging surfaces mean most hosts are one command away.

What It Does

invisible_playwright_mcp is a Python MCP server that gives an AI agent a real browser to drive: navigate, click, type, read, screenshot, and evaluate JavaScript, 17 tools in total. The difference from every ordinary Playwright server is the engine: a patched, "sealed" Firefox build (the current one is called firefox-35, roughly a quarter of a gigabyte) that the server downloads by itself from a GitHub release, designed to browse without triggering anti-bot systems and captchas. It targets developers and agent builders who need automation on sites that block plain headless browsers, and it ships in two forms: an MCP server for assistants (Claude Code, Codex, Gemini CLI, or any MCP client), and a standalone web UI where you bring an OpenRouter key. At review time the repo sat at 31,763 stars and 4,686 forks, and the discovery pipeline had never tracked it across 313 prior scans: it pushed rarely, and push-sorted search never surfaced it.

The Good

Fail-closed behavior at every layer, including the platform we tested on. The review host is macOS, which the engine does not support. Every failure we could provoke produced a named, structured answer instead of a hang or a crash: browser_open answered "the engine download failed: macOS is no longer a supported platform: no Mac binaries have been published since firefox-21" (isError false, a sentence, not a stack trace); browser_status with no browser open answered "the main browser is not open. Call browser_open to open one"; an unknown tool name came back as a structured error; and the ui subcommand without an OpenRouter key refused with exit 1 instead of starting a half-working interface.

Dependency management written like post-mortems, with measurements. The pyproject dependency floors each carry the defect they prevent. The floor invisible-playwright>=0.22.1 exists because below it "a click is not delivered once": a control that stops being hittable by its own effect was pressed again, and the comment records a measured case of a self-hiding button taking 1,068 clicks across 30 calls. Later floors document a Windows MSIX install path where the engine landed in redirected AppData and could not start (fixed in 0.25.6), and a 45-second freeze navigating YouTube and Reddit (0.25.7). This is the most honest dependency reasoning GearScope has read in a pyproject.

The test suite is exceptional, and half of it tests the suite itself. 64 test files at 18,555 lines. On this unsupported macOS host: 889 passed, 17 skipped, 3 xfailed in 58.77 seconds. One guard test that failed is itself evidence of the culture: it asserts the suite's own environment is "sealed" so no test can silently download the 250MB engine, because a prior un-marked e2e test once took CI from two minutes to the six-hour job ceiling without ever going red. The comment in that test documents the whole incident. The 3 errors we hit are host skew: the plugin-install tests drive a real claude binary and this host's version rejects the --yes flag the tests pass.

Packaging across seven surfaces, all valid, plus a working Hermes rail. The repo ships .claude-plugin/plugin.json and marketplace.json, .codex-plugin/plugin.json (with the skills pointer), .agents/plugins/marketplace.json, .mcp.json, a root plugin.json on the agent-plugins.org schema, and gemini-extension.json. All seven parse as JSON. One real skill rides along, skills/setup/SKILL.md (26 lines), which tells the agent what to do when browser_open reports an engine download. npx skills add feder-cr/invisible_playwright_mcp --skill setup --agent hermes-agent in an isolated HOME landed a byte-identical copy at .hermes/skills/setup/SKILL.md.

An unusually honest privacy policy. It discloses a telemetry fact most projects would bury: every browser launch fetches a one-line counter file from a GitHub release (launch counting, no identifiers). It also states where sessions, profiles, and screenshots live on disk, warns that --openrouter-key on the command line lands in shell history and the process list, and documents that the web UI's host and port flags expose an interface with no authentication.

The Bad

macOS support was dropped, and the README never says so. The engine publishes Windows and Linux binaries only; no Mac binaries have shipped since the firefox-21 engine, while the repo moved on to firefox-35. The pyproject classifiers exist precisely, in the author's words, so "a mac reader finds out at the first browser call unless the index says so first". The index says it. The README, which lists Windows and Linux install blocks side by side, never states the exclusion in words, and a substantial share of agent users sit on Macs. The failure is clean and named, but discovering your platform is unsupported by tripping the error is a documentation gap on a repo with 31K stars.

The documentation's center of gravity is off-repo. Tool reference, client config blocks, and settings live on a GitHub wiki rather than in the tree, and there is no in-repo CHANGELOG: the 30 GitHub releases carry the notes. Meanwhile the repo carries 138 SEO-oriented articles under docs/ ("browser-use alternatives", "best mcp servers for claude code"). The content marketing is competent and the wiki is well written, but a reader cloning the repo gets marketing essays where they might expect the tool contract.

No --version flag on the CLI. invisible-playwright-mcp --version answers "Error: No such option '--version'". The version surfaces correctly in the MCP handshake (serverInfo 0.70.9, verified), and the package's _version.py derives it carefully (it even distinguishes editable installs with a +editable PEP 440 segment), so the omission is small, but version checks are the first thing support conversations ask for.

The core claim is unverifiable from this repo alone. The anti-detection behavior lives in the binary: a patched Firefox downloaded from a release and pinned by a cryptographic seal. The seal machinery is in the sibling invisible_core package and the launch refuses binaries the seal does not name, which is a real integrity mechanism, but the stealth property itself cannot be rebuilt or audited from this source tree, and we could not test it on macOS at all. The registry rail is also thin: the skills.sh registry carries no entries for this repo (the GitHub-source install path works, the registry index does not list it).

The instructions card is heavy. The MCP instructions field runs 3,910 bytes, roughly twice the ~2KB context-weight discipline several well-regarded servers follow. It is well-written guidance, but it is loaded into every client session.

Smoke Test Results

Hands-on on the review host (macOS 26, aarch64, Python 3.13.12, uv). The repo targets Windows and Linux for the engine, so the browser-level probes assert the documented fail-closed paths rather than a live browser. Scripts and logs live at sandbox/skills/invisible-playwright-mcp/.

Run A: Fresh install, no deps preinstalled

$ git clone --depth 1 https://github.com/feder-cr/invisible_playwright_mcp
βœ… clone HEAD is the 0.70.9 release commit (4139237, pushed the morning of review)

$ uv venv /tmp/ipm-fresh && uv pip install --python /tmp/ipm-fresh/bin/python /tmp/ipm-314
βœ… install in 5s cold (1s warm), 66M venv, 51 distributions, uv pip check clean

$ /tmp/ipm-fresh/bin/invisible-playwright-mcp --help
βœ… exit 0, lists the ui subcommand and the stdio-server default

$ /tmp/ipm-fresh/bin/python -m compileall -q src
βœ… whole tree byte-compiles clean

$ curl -s https://pypi.org/pypi/invisible-playwright-mcp/json # version check
βœ… PyPI latest is 0.70.9, in lockstep with git HEAD

$ /tmp/ipm-fresh/bin/invisible-playwright-mcp --version
❌ "Error: No such option '--version'" (no CLI version flag; handshake carries it)

$ python3 -c 'json.loads(...)' over the 7 packaging manifests
βœ… all 7 parse as JSON (claude, codex, agents, mcp.json, gemini, root plugin.json)

Pass rate: 10 of 11. The one failure is the missing --version flag, recorded above as a finding. (The script's internal SUMMARY counter reads 9 because the manifest probe prints from Python; the log shows 10 βœ… of 11 prompts.)

Full fresh log β†’

Run B. The server starts

$ python3 mcp-stdio-client.py /tmp/ipm-fresh/bin/invisible-playwright-mcp
βœ… initialize handshake over stdio: serverInfo {"name": "stealth", "version": "0.70.9"}

$ (same run, protocol line)
βœ… protocolVersion 2024-11-05 echoed (the stock client offers 2024-11-05, so this proves the answer, not the supported set)

$ (same run, capabilities line)
βœ… capabilities: tools, prompts, resources, experimental

$ python3 -c 'len(INSTRUCTIONS)'
βœ… instructions card present, 3910 bytes (NOTE: ~2x the 2KB discipline; observation, not a defect)

Pass rate: 4 of 4.

Full server-starts log β†’

Tools respond

Probes below run through a purpose-built client on the venv's own mcp library (full assertion list in the log: 10 of 10 passed).

$ python3 functional-probe.py # handshake + tools/list + calls + negatives
βœ… 17 tools, every one with an inputSchema; 8 declare readOnlyHint true (read_text, read_html, snapshot, list, status, evaluate, screenshot, watch); core actuation set present (navigate, click, click_at, type, select_option, upload_files, press_key, evaluate)

$ /tmp/ipm-fresh/bin/invisible-playwright-mcp ui # no key
βœ… refuses honestly, exit 1

$ cmp <landed SKILL.md> <repo skills/setup/SKILL.md> # npx skills add, isolated HOME
βœ… byte-identical landing at .hermes/skills/setup/SKILL.md for hermes-agent

Pass rate: 3 of 3. Inside the probe: browser_list answers with structured JSON and a note ("the main browser is not open. Call browser_open to..."), browser_status refuses honestly, unknown tool browser_nonsense is a structured error, and browser_open on macOS fails closed naming the engine, quoting the firefox-21 cutoff verbatim.

Full tools-respond log β†’

Run C: The repo's own suite

$ /tmp/ipm-fresh/bin/python -m pytest -q # 64 files, 18,555 lines
βœ… 889 passed, 17 skipped, 3 xfailed in 58.77s on an UNSUPPORTED platform

$ pytest tests/test_the_plugin_really_installs.py
❌ 3 errors: host claude CLI rejects 'plugin install --yes' (flag drift on this host's Claude Code; environment skew, not a repo defect)

$ pytest tests/test_the_suite_reads_no_real_session.py
❌ 1 failed: the self-guard that seals the suite against engine downloads found no local seal in force on macOS (harness environment; the repo's CI runs this green on its supported platforms)

Pass rate: 1 of 3 prompt-level, 889 of 893 test-level. The suite-level number is the meaningful one: the only failures are host-environment skew, and each one is a test of the repo's own tooling discipline rather than of the server's behavior.

What the runs tell you

Install, handshake, tool listing, and every negative path work exactly as documented, on a platform the engine does not even ship for. What could not be verified is the headline: driving a real site through the patched Firefox and observing that anti-bot systems do not fire. That requires Windows or Linux, a ~250MB engine download, and a target site, and it is the one claim resting on the binary rather than the source.

Setup Walkthrough

  1. Install uv (the README's one prerequisite): curl -LsSf https://astral.sh/uv/install.sh | sh on Linux, or the PowerShell line on Windows.
  2. Claude Code: claude plugin marketplace add feder-cr/invisible_playwright_mcp, then claude plugin install invisible-playwright-mcp@feder-cr. Codex and Gemini CLI have equivalent commands in the README.
  3. Any other MCP client: point it at uvx invisible-playwright-mcp over stdio (the repo's own .mcp.json block).
  4. First browser call starts the engine download in the background; browser_open answers with download progress and asks to be called again, so no tool call blocks. To pre-fetch by hand: uvx invisible-playwright fetch.
  5. No account or key is needed over MCP. The standalone UI mode needs an OpenRouter key.

Gotchas: on macOS, step 4 ends at the named unsupported-platform error (see The Bad). Over MCP the model is whatever your client uses; the OpenRouter key only matters for the UI mode.

Alternatives

  1. microsoft/playwright-mcp - the official Playwright MCP server (GearScope 5/5). Accessibility-snapshot model, no stealth. Prefer it when you do not need anti-detection and want the vendor-supported path.
  2. vercel-labs/agent-browser - the browser-actuation skill lane's other giant, riding regular automation rather than a patched engine. Prefer it inside the Vercel skills ecosystem.
  3. browserbase/skills - cloud browsers as an MCP service (GearScope 4/5). Prefer it when you cannot run a local Firefox or need scale and isolation more than stealth.
// review provenance
reviewed by
GearScope
tested
2026-10-03 · macOS (Apple Silicon)
last verified
2026-10-03
depth
HANDS-ON
sponsorship
none, ever
// share this review
// feedback
was this review helpful?

Don't install your next skill blind.

Every week: the shortlist of skills worth installing β€” and the ones to skip β€” from 100+ hands-on tests. No spam, no affiliate links.