Does playwright-stealth still beat bot detection?

playwright-stealth does one job, and it does it entirely inside the page. Before your code navigates anywhere, it injects a bundle of JavaScript that rewrites the browser properties an automated Chromium leaks. It's the Python port of puppeteer-extra-plugin-stealth, the same evasion pack that's circulated the Node scraping world for years.

For a while that was enough. Flip navigator.webdriver to false, fake a couple of plugins, harmonize one permissions check, and most detection scripts waved you through. But the detectors moved, and injected JavaScript is exactly the approach they learned to catch. So the useful question in 2026 isn't whether playwright-stealth works. It's against what.

What playwright-stealth actually patches

Everything it does happens in page-script land, before your navigation fires. The evasions it ships are a subset of the puppeteer-extra pack, ported to Python. The ones that carry the weight:

• navigator.webdriver. The loudest tell of them all. Stock automated Chromium reports true; stealth flips it back to false.
• chrome.runtime. Headless Chrome is missing chunks of the window.chrome object a real tab carries. Stealth stubs the runtime and its friends back in.
• The permissions mismatch. A classic. In headless Chrome, Notification.permission reports denied while navigator.permissions.query({name:'notifications'}) reports prompt. Those two can't disagree in a real browser, so stealth patches the query to make them agree.
• navigator.plugins and mimeTypes. Real Chrome ships a specific set of PDF plugins. Headless ships an empty list, which is itself a giveaway, so stealth fakes a plausible one.
• WebGL vendor and renderer. It overrides getParameter so UNMASKED_VENDOR_WEBGL and UNMASKED_RENDERER_WEBGL return believable GPU strings instead of a SwiftShader default that screams headless.
• navigator.languages. Makes sure it's populated instead of empty.
• iframe.contentWindow. Patches how properties resolve through iframes, another seam where automated Chromium leaks.

Run all of that and your browser looks a lot more like a person's than a fresh Playwright launch does. On a page that only checks navigator.webdriver, you're invisible. The trouble starts when the page checks how you became invisible.

Installing and running it

One pip install, plus the browser binary if you don't have it yet:

pip install playwright-stealth
playwright install chromium

The current package exposes a Stealth class. The cleanest way to use it wraps Playwright's own context manager, so every page and context you open gets patched automatically and you can't forget to apply it:

from playwright.sync_api import sync_playwright
from playwright_stealth import Stealth

with Stealth().use_sync(sync_playwright()) as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://bot.sannysoft.com/")
    page.screenshot(path="check.png", full_page=True)
    browser.close()

Async is the same shape with use_async:

from playwright.async_api import async_playwright
from playwright_stealth import Stealth

async def main():
    async with Stealth().use_async(async_playwright()) as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto("https://bot.sannysoft.com/")
        await browser.close()

If you're following an older tutorial you'll see from playwright_stealth import stealth_sync and a bare stealth_sync(page) call right after you create the page. That's the pre-1.0 API. The stealth_sync and stealth_async helpers still exist, but the Stealth class is what the maintained package points you at now, and it's harder to misuse.

Point any of these at bot.sannysoft.com and you'll watch the red rows flip green. That test is the catch, though. It sits at the naive end of the spectrum, and passing it tells you almost nothing about how you'll fare against a target that's actually paying a vendor to keep you out.

Where it stops working

Here's the uncomfortable part. The thing that makes playwright-stealth convenient, that it patches from inside the page, is also its ceiling.

The patches are detectable as patches. Override a native browser function from JavaScript and you leave marks. The function's toString() can stop reading [native code]. Property descriptors look subtly off. Stealth tries to paper over those too, but now you're patching the patches, and fingerprinting scripts like CreepJS are built to hunt for exactly that recursion. Worse, the spoofed values are known constants. A detector that's seen playwright-stealth before can match its specific fake WebGL strings and flag them on sight. You're not invisible. You're wearing a costume the bouncer has seen a hundred times.

It can't touch anything below the page. An init script runs in the page. That's the whole sandbox. It can't reshape your TLS ClientHello, it can't reorder your HTTP/2 frames, and it can't scrub the Chrome DevTools Protocol channel Playwright drives the browser over. There's good news buried in that: because Playwright launches real Chromium, your raw TLS and HTTP/2 fingerprints already look like Chrome, which is more than a plain requests script can say. The bad news is the CDP layer. Automating Chromium over DevTools leaves artifacts, like the Runtime.Enable call that fires on startup, and no page script can reach down and erase them. Cloudflare and DataDome probe that layer directly.

It does nothing about your IP. Nothing at all. Run from a cloud box and the target sees a datacenter IP and can be done with you before a single line of your stealth JavaScript executes. This is the layer people skip, then blame the browser.

It does nothing about behavior. No cursor movement, instant page-to-page jumps, requests spaced to the millisecond. A flawless fingerprint that acts like a machine still reads as one.

Stack those up and you get the honest 2026 answer on hard targets. Against Cloudflare's managed challenge or DataDome, playwright-stealth on its own mostly loops or eats a 403. Not because the patches are bad, but because the detector is reading a whole stack of signals and your script only reaches one floor of the building.

When it's still the right call

None of that makes playwright-stealth useless. It makes it situational. Reach for it when:

• The target has no serious anti-bot. A plain site, a homegrown navigator.webdriver check, an internal dashboard, a staging box. Stealth clears these without breaking a sweat.
• You already live in Playwright and you just want the obvious tells knocked off a light target. It's one import and one wrapper. The cost of adding it is close to zero.
• It's a quick, low-stakes job. A one-off pull from a site you know isn't fighting back. Don't bring a heavier tool than the target earns.

The rule I'd give anyone: match the tool to the defense. playwright-stealth is a fine first move on soft targets and a wasted afternoon against Cloudflare. If you can't tell which you're facing, read the block first before you escalate.

The stronger play: spoof at the source

If injected patches are the weakness, the fix is obvious in hindsight. Don't inject. Fake the values so deep in the browser that they read as native, because at that point they are.

That's Camoufox. It's a custom build of Firefox where the fingerprint spoofing is compiled into the browser's C++ internals instead of bolted on as JavaScript. When a detector reads navigator, WebGL, canvas, or fonts, there's no evasion script sitting in the page to catch, because the value was faked down in the engine. Nothing to toString(), no descriptor to inspect, no known-constant costume to match. The lie is native all the way down.

It talks to your code through Playwright, sync or async, so the example you just wrote for playwright-stealth mostly carries over. A few constructor options do the heavy lifting: os picks the fingerprint's operating system, humanize gives you curved, human-shaped cursor paths, and geoip=True lines timezone and locale up with your proxy's exit IP.

It's not magic, and I won't pretend otherwise. Camoufox is pre-1.0, it's Firefox (so a handful of Chromium-only sites act weird), and a real browser is heavier on RAM than a bare request. But on a target that actually fights back, engine-level spoofing holds up where injected patches fall over. That's the entire reason to switch.

The Chrome-side sibling

If you're wedded to Chrome instead of Firefox, playwright-stealth's closest cousin is undetected-chromedriver. Same core instinct, opposite engine. It patches a real Chrome to strip the automation tells rather than injecting them away inside the page, and it rides Selenium instead of Playwright, so it's the drop-in when your codebase is already Selenium.

It carries the same structural problem, plus a maintenance one. It's still Chrome over CDP, so the patch-and-detect arms race applies, and its last stable release is old enough that serious targets catch it more often than they used to. I put the two side by side in Camoufox vs undetected-chromedriver if you're choosing between engines.

The pattern across all three is the same. playwright-stealth, undetected-chromedriver, and the rest of the injected-JS crowd patch a browser the detectors already know by heart. Camoufox rebuilds the browser so there's nothing to patch. On easy targets the difference is invisible. On hard ones it's the whole game.

FAQ

Is playwright-stealth detectable?

Yes, and more so every year. The patches it injects leave their own marks: altered toString() output, off-looking property descriptors, and known-constant spoof values that fingerprinting scripts recognize on sight. It'll pass a naive check and fail a fingerprinting-grade one like CreepJS or a tuned Cloudflare rule.

Does playwright-stealth work against Cloudflare?

On its own, usually not in 2026, at least not against Cloudflare's managed challenge. It patches page-level tells, but Cloudflare also weighs IP reputation and the CDP automation layer, neither of which an injected script can reach. Add residential proxies and you improve your odds on lighter Cloudflare setups. Against a hardened one you're better off with a browser that spoofs at the engine level. More in the Cloudflare bypass guide.

playwright-stealth vs undetected-chromedriver?

Same philosophy, different engine. playwright-stealth injects evasions into Playwright-driven Chromium; undetected-chromedriver patches a Selenium-driven Chrome. Both dress up a browser the detectors already know, and both get caught on serious targets. Pick by your existing stack, then read the full comparison for the details.

Is there a better alternative in 2026?

For hard targets, yes. Camoufox spoofs at the browser's C++ level, so the faked values read as native and there's no injected patch to detect. It's the anti-detect browser most scrapers graduate to once playwright-stealth stops clearing their target. Whatever browser you run, a protected site still needs residential proxies for the IP layer, and the nastiest ones may want the DataDome playbook on top.