proxy is set, otherwise the host's own public IP)

July 28, 2026 · View on GitHub

tests License: MIT Python 3.11+ Firefox 151.0 GitHub stars browser launches

invisible_playwright

Undetected Playwright automation on a stealth-patched Firefox.
Python, MIT, and it passes every bot detection test.

invisible_playwright - 5/5 detection suites passed

How it works

Anti-bots ask two questions. invisible_playwright answers yes to both.

1. Is this a real browser? Yes. It is Firefox, patched at the C++ source level.

  • Fingerprint set inside the engine, not injected into the page: Navigator, screen, GPU/WebGL, Canvas, fonts, audio, WebRTC, timezone, network.
  • No JS shim, no override, no seam to read.

2. Is a real person using it? Yes. The actions are humanized in the driver.

  • Every click, hover and drag follows a natural mouse path with human timing, no teleporting cursor.
  • Each input is byte-identical to a real mouse: real input source, pressure, trusted events.

Driven by the standard Playwright API. Full breakdown: feder-cr/firefox_antidetect_patch.

Still seeing captchas or anti-bot? It's the proxy.

Once the browser is handled it stops being the variable. If you are still getting challenged, the tell is no longer the browser, it is the IP you come from. Around 90% of proxies are public: anyone can rent the same address, so it is already known and sits on the blocked-IP lists sites check. A perfect browser on a known IP still loses.

The fix is the clean 10%, residential IPs that aren't already known. For those we recommend sx.org, who filter for and serve only IPs that aren't already on those lists.

Install

pip install invisible-playwright
python -m invisible_playwright fetch      # one-time ~238 MB download (~544 MB unpacked), sha256-verified

Supported platforms: Windows x86_64, Linux x86_64 / arm64, macOS arm64 / x86_64. On macOS the app is ad-hoc signed (not notarized): if Gatekeeper complains, clear the quarantine flag once with xattr -dr com.apple.quarantine on the cached Firefox.app.

Usage

Random fingerprint per session

100% Playwright-compatible - sync and async, all methods, zero API changes. If you already use Playwright, switching is two lines:

- from playwright.sync_api import sync_playwright
- with sync_playwright() as p:
-     browser = p.firefox.launch()
+ from invisible_playwright import InvisiblePlaywright
+ with InvisiblePlaywright() as browser:

Every session gets a distinct fingerprint (GPU, audio, fonts, screen, ~400 fields) and Bezier-curve mouse motion.

Sync

from invisible_playwright import InvisiblePlaywright

with InvisiblePlaywright(proxy={"server": "socks5://...", "username": "u", "password": "p"}) as browser:
    page = browser.new_page()
    page.goto("https://example.com")
    page.click("#submit")   # mouse arcs to the button on a Bezier curve

Async

from invisible_playwright.async_api import InvisiblePlaywright

async with InvisiblePlaywright(proxy={"server": "socks5://...", "username": "u", "password": "p"}) as browser:
    page = await browser.new_page()
    await page.goto("https://example.com")
    await page.click("#submit")

The browser object is a playwright.sync_api.Browser / playwright.async_api.Browser - every Playwright method works as-is.

Log the seed to replay a run:

sf = InvisiblePlaywright()
with sf as browser:
    print("seed =", sf.seed)
    # ...

Reproducible fingerprint

with InvisiblePlaywright(seed=42) as browser:
    ...   # same GPU, same canvas hash, same audio context, every run

Proxies

proxy = {
    "server": "socks5://gate.example.com:1080",
    "username": "user",
    "password": "pass",
}
with InvisiblePlaywright(proxy=proxy) as browser:
    ...

Schemes supported: socks5, socks4, http, https. DNS is routed through the proxy by default, no local leak.

Around 90% of proxies are public, so their IPs are already known and blocked. For the clean 10%, residential IPs that aren't already known, we recommend sx.org, who filter for and serve only IPs that aren't already on those lists.

Timezone

The browser timezone follows timezone=:

# default: timezone is auto-derived from the egress IP (proxy egress if a
# proxy is set, otherwise the host's own public IP)
with InvisiblePlaywright(proxy=proxy) as browser:
    ...

# explicit IANA zone always wins, the only way to force a specific zone
with InvisiblePlaywright(proxy=proxy, timezone="America/New_York") as browser:
    ...

Pinning specific fingerprint fields

By default everything comes from seed. To force specific values while the rest stays seed-derived:

with InvisiblePlaywright(
    seed=42,
    pin={
        "gpu.renderer": "ANGLE (NVIDIA, NVIDIA GeForce RTX 4090 Direct3D11)",
        "gpu.vendor":   "Google Inc. (NVIDIA)",
        "screen.width":  2560,
        "screen.height": 1440,
        "hardware.concurrency": 16,
    },
) as browser:
    ...

Full list of pinnable keys, how pinning interacts with the Bayesian sampler, and common patterns are in docs/pinning.md.

CLI

The installed command is invisible-playwright, with a hyphen. python -m invisible_playwright works identically and needs nothing on PATH.

invisible-playwright fetch          # download the engine if missing
invisible-playwright fetch --force  # re-download even if cached
invisible-playwright path           # absolute path to the cached engine (downloads it if absent)
invisible-playwright version        # wrapper, core and engine versions
invisible-playwright clear-cache    # remove cached engine trees
invisible-playwright doctor         # check every cached engine against the seal

Where the engine lives, and how big it is

The first launch downloads one archive for your platform - 238 MB on Windows, 217-232 MB elsewhere - and unpacks it to about 544 MB on disk. It is verified against a sha256 shipped inside invisible-core, so a truncated or substituted download is refused rather than used.

It is cached, so this happens once per engine version. Set INVISIBLE_PLAYWRIGHT_CACHE_DIR to put it somewhere else - a different drive, a shared location, a path your CI already caches:

export INVISIBLE_PLAYWRIGHT_CACHE_DIR=/mnt/big/engines

Other environment variables you may want:

variablewhat it does
INVISIBLE_PLAYWRIGHT_CACHE_DIRwhere engines are cached
INVPW_BINARY_PATHuse a specific binary and skip the download entirely
STEALTHFOX_GITHUB_TOKENauthenticate the download, for rate-limited or corporate networks
INVISIBLE_PLAYWRIGHT_SKEW=allowrun a Playwright outside the tested range anyway
INVPW_CURSOR_ENGINEpython (default), binary, or off

Guides and explainers

All of it reads better, and is searchable, at feder-cr.github.io/invisible_playwright. Same pages, same repo, with a search box.

Running it inside something else:

How any of this works, whether or not you use this project. Full index:

The open-source neighbours, and what each one is for.

On the Firefox side

  • Camoufox - an anti-detect Firefox that also patches at the C++ level. It covers a wider surface and ships its own fingerprint database; this project derives a fingerprint from a seed with a Bayesian sampler, so one number reproduces one machine. Full comparison.
  • LibreWolf - a Firefox fork with privacy defaults. It ships a configured binary for people to browse with; this ships source patches plus an automation wrapper.
  • arkenfox/user.js - Firefox hardening through preferences. Where a preference is enough, use it; this project patches C++ where one is not.

On the Chromium side

  • Patchright - a patched Playwright fork, so the stealth work lands in the driver rather than in the browser binary. Full comparison.
  • nodriver - the successor to undetected-chromedriver, driving Chrome over CDP directly and removing the WebDriver-flavoured tells. Full comparison.
  • playwright-stealth - an init-script patch applied before the page loads. Its own maintainer calls it a proof-of-concept; full comparison.

Which of these fits depends on the layer your problem is at, and on whether you need Firefox or Chromium. Three ways to make Playwright undetected works through what each layer can and cannot reach, including what this one costs.

If you are picking between engines rather than tools, note that a large share of AI agent frameworks drive Chromium over CDP, which decides the question for you: AI browser agents and stealth.

License

MIT - see LICENSE. The patched Firefox binary is distributed under the MPL-2.0 (Firefox upstream license). The C++ patches against mozilla-central that produce that binary are at feder-cr/firefox_antidetect_patch.

Disclaimer

This project is for educational purposes only. It is provided as-is, with no warranties. I take no responsibility for how it is used. Use it at your own risk and in compliance with the laws of your jurisdiction.

Built by Federico Elia  LinkedIn