The 6 best Patchright alternatives in 2026

If you've been scraping with Playwright and keep getting blocked by Cloudflare or DataDome, you've probably discovered Patchright. It patches Playwright's CDP leaks and makes your scraper less detectable. But maybe Patchright isn't working for your specific use case, or you want something based on a different framework entirely.

I've spent years testing stealth browser automation tools against the toughest anti-bot systems. What I've learned is that the "best" tool depends entirely on your tech stack, your target websites, and whether you prefer Chromium or Firefox under the hood.

By the end of this guide, you'll understand what makes Patchright tick, where it falls short, and which Patchright alternative might work better for your scraping projects.

The Best Patchright Alternatives

• Camoufox for Firefox-based stealth
• Nodriver for CDP-minimal automation
• SeleniumBase UC Mode for Selenium users
• Undetected ChromeDriver for simple Selenium setups
• Puppeteer Stealth for Puppeteer users
• Playwright Stealth for lightweight Playwright patching

What is Patchright?

Patchright is a patched version of Microsoft's Playwright library designed to bypass modern bot detection systems. The core problem it solves is CDP (Chrome DevTools Protocol) detection.

When standard Playwright controls a browser, it sends commands through CDP that leave detectable traces. Anti-bot systems like Cloudflare and DataDome can spot these artifacts instantly. They check for things like the Runtime.enable command, WebSocket serialization patterns, and JavaScript injection signatures.

Patchright fixes these issues by executing JavaScript in isolated contexts rather than the main browser context. It also patches browser fingerprinting leaks that would otherwise expose your scraper as automated.

The library works as a drop-in replacement for Playwright. You change one import line and your existing code works with added stealth capabilities.

Here's the typical way you'd use Patchright:

from patchright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch_persistent_context(
        user_data_dir="/tmp/patchright_profile",
        channel="chrome",
        headless=False,
        no_viewport=True
    )
    page = browser.new_page()
    page.goto("https://example.com")

The key configuration points are using a persistent context, launching real Chrome (not Chromium), and running in headed mode for challenging targets.

Why Look for Patchright Alternatives?

Patchright is solid, but it's not perfect for every situation. Here's why you might need something else.

Detection on advanced anti-bots: While Patchright reduces headless detection scores significantly, some sophisticated systems still catch it. In CreepJS tests, Patchright brings headless detection down from 100% to about 67%, but that's not zero.

Chromium-only: Patchright is built on Playwright's Chromium implementation. If you need Firefox or WebKit support, you're out of luck.

Maintenance concerns: As a community project, Patchright depends on volunteers keeping up with Playwright updates and new detection methods. Updates can lag behind.

JavaScript ecosystem: Patchright works in Python and Node.js, but if you're using other languages or frameworks, you'll need a different approach.

Learning curve for persistent contexts: Getting Patchright to work reliably requires understanding persistent browser contexts and proper configuration. Misconfigure something and you're instantly detected.

The Best Patchright Alternatives at a Glance

The Best Patchright Alternative for Firefox-Based Stealth

Camoufox

Camoufox is a custom Firefox build specifically designed for web scraping and anti-bot evasion. Unlike Chromium-based tools that try to patch detection leaks after the fact, Camoufox modifies Firefox at the C++ level before any JavaScript can inspect it.

Camoufox Pros:

• Achieves 0% headless detection on CreepJS
• Fingerprint spoofing happens at the engine level
• Built-in virtual display mode for headless servers
• Compatible with Playwright's API

Camoufox Cons:

• Firefox-only (can't spoof Chrome fingerprints perfectly)
• Some features kept closed-source to prevent reverse engineering
• Requires separate Firefox download

The fundamental approach differs from Patchright. Most anti-bot tools focus on Chromium because that's what most scrapers use. Camoufox exploits this by using Firefox, which has less sophisticated detection mechanisms targeting it.

Installation is straightforward:

pip install camoufox
camoufox fetch

After installation, you use it similarly to Playwright:

from camoufox.sync_api import Camoufox

with Camoufox(headless=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")
    # Your scraping code here

Camoufox automatically handles fingerprint rotation using BrowserForge data. It spoofs navigator properties, screen dimensions, WebGL parameters, and audio context at the C++ level rather than through JavaScript injection.

In my testing against DataDome-protected sites, Camoufox succeeded where Patchright failed. The Firefox fingerprint appears completely legitimate because it is a legitimate Firefox installation with modified internals.

The trade-off is that you're locked into Firefox. Some websites serve different content to Firefox users, and you might encounter sites that require Chrome-specific features.

Camoufox pricing: Free and open source

The Best Patchright Alternative for CDP-Minimal Automation

Nodriver

Nodriver represents a fundamental shift in how stealth browser automation works. Instead of patching Selenium or Playwright to hide their traces, Nodriver communicates with Chrome directly while avoiding the detection vectors that traditional tools create.

Nodriver Pros:

• No WebDriver or Selenium dependencies
• Direct Chrome communication reduces detection vectors
• Fully asynchronous architecture
• Active development from undetected-chromedriver creator

Nodriver Cons:

• Newer tool with smaller community
• Python-only
• Requires Chrome installed on your system

The creator of undetected-chromedriver built Nodriver after recognizing that patching WebDriver-based tools was becoming a losing battle. Anti-bot systems learned to detect the patches themselves.

Nodriver takes a different path. It doesn't use CDP in ways that trigger detection. There's no WebDriver binary, no Selenium, and no familiar automation signatures.

Here's how to get started:

pip install nodriver

The async-first API looks like this:

import nodriver as uc

async def main():
    browser = await uc.start()
    page = await browser.get("https://example.com")
    await page.save_screenshot("screenshot.png")

if __name__ == "__main__":
    uc.loop().run_until_complete(main())

What makes Nodriver special is what it doesn't do. It avoids enabling high-risk CDP domains like Runtime or Console that create detectable artifacts. It reimplements automation primitives without relying on instrumentation that anti-bot systems watch for.

In benchmarks against Cloudflare, Nodriver consistently passes challenges that block Patchright. The lack of traditional automation signatures means detection systems have fewer patterns to match against.

The downside is the async-only architecture. If your existing code is synchronous, you'll need to refactor. And because it's newer, you'll find fewer tutorials and Stack Overflow answers when you hit problems.

Nodriver pricing: Free and open source

The Best Patchright Alternative for Selenium Users

SeleniumBase UC Mode

If you're already invested in Selenium and don't want to switch frameworks, SeleniumBase UC Mode offers stealth capabilities without abandoning your existing code.

SeleniumBase UC Mode Pros:

• Built on improved undetected-chromedriver
• Includes special uc_*() methods for CAPTCHA handling
• Works with pytest for test automation
• Extensive documentation and examples

SeleniumBase UC Mode Cons:

• Selenium's overhead compared to lighter tools
• Requires GUI mode for best results
• More complex configuration than Patchright

SeleniumBase is a Python framework built on top of Selenium that adds web scraping and automation testing features. Its UC Mode (Undetected-Chromedriver Mode) specifically addresses bot detection by making browsers appear human.

Installation adds SeleniumBase to your Python environment:

pip install seleniumbase

Using UC Mode requires the uc=True flag:

from seleniumbase import SB

with SB(uc=True, test=True) as sb:
    url = "https://example.com"
    sb.uc_open_with_reconnect(url, reconnect_time=2)
    sb.uc_gui_handle_captcha()
    # Continue scraping

The uc_open_with_reconnect() method is clever. It opens the page, disconnects the chromedriver service (which is what anti-bots detect), waits for any challenges to resolve, then reconnects. This pattern works because most detection happens on initial page load.

SeleniumBase also includes CDP Mode, which combines UC Mode with Chrome DevTools Protocol access for even more control. You can solve Cloudflare Turnstile and Google reCAPTCHA challenges programmatically with the built-in CAPTCHA handling methods.

The main advantage over Patchright is ecosystem familiarity. If your team knows Selenium, SeleniumBase feels natural. The uc_*() methods handle common anti-bot patterns that would require custom code in other tools.

SeleniumBase pricing: Free and open source

The Best Patchright Alternative for Simple Selenium Setups

Undetected ChromeDriver

Undetected ChromeDriver is the original stealth ChromeDriver that inspired many of the tools on this list. It modifies browser properties to evade anti-bot detection without requiring framework changes.

Undetected ChromeDriver Pros:

• Large community (9,300+ GitHub stars)
• Drop-in replacement for standard ChromeDriver
• Well-documented with many tutorials
• Works with existing Selenium code

Undetected ChromeDriver Cons:

• Can still be detected by advanced systems
• Requires Chrome version matching
• Less actively maintained than newer alternatives

The library patches ChromeDriver to change Selenium's variable names, modify browser fingerprints, and mask automation indicators. It's been around since 2020 and has proven reliable for many use cases.

Installation is simple:

pip install undetected-chromedriver

Usage mirrors standard Selenium:

import undetected_chromedriver as uc

driver = uc.Chrome()
driver.get("https://example.com")
# Your existing Selenium code
driver.quit()

Undetected ChromeDriver handles version matching automatically. It downloads the appropriate ChromeDriver binary for your installed Chrome version and applies the necessary patches.

The limitation is that anti-bot vendors have studied this library extensively. Cloudflare, in particular, has developed countermeasures that can detect undetected-chromedriver in some configurations. For basic scraping, it works great. For heavily protected sites, you may need something more advanced.

Undetected ChromeDriver pricing: Free and open source

The Best Patchright Alternative for Puppeteer Users

Puppeteer Stealth (puppeteer-extra-plugin-stealth)

For JavaScript developers using Puppeteer, puppeteer-extra-plugin-stealth provides evasion techniques similar to what Patchright offers for Playwright.

Puppeteer Stealth Pros:

• Modular evasion system
• 450k+ weekly npm downloads
• Passes all sannysoft.com tests
• Can be used with Playwright via playwright-extra

Puppeteer Stealth Cons:

• Node.js only
• Struggles against advanced anti-bots like Cloudflare
• Requires puppeteer-extra wrapper

The plugin extends Puppeteer through puppeteer-extra, a lightweight wrapper that enables plugin support. Each evasion technique is implemented as a separate module that you can enable or disable based on your needs.

Installation requires three packages:

npm install puppeteer puppeteer-extra puppeteer-extra-plugin-stealth

Implementation is straightforward:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

(async () => {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await browser.close();
})();

The stealth plugin handles common detection vectors automatically. It overrides the navigator.webdriver property, sets realistic User-Agent headers, and adjusts browser dimensions to appear natural.

What's interesting is that puppeteer-extra-plugin-stealth also works with Playwright through playwright-extra. If you have existing Puppeteer code and want to try Playwright, you can use the same stealth plugin:

const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

The main limitation is performance against sophisticated anti-bot systems. In my tests, the stealth plugin passes basic detection tests but fails against production Cloudflare implementations more often than Patchright.

Puppeteer Stealth pricing: Free and open source

The Best Patchright Alternative for Lightweight Playwright Patching

Playwright Stealth (playwright-stealth)

playwright-stealth is a Python package that ports the puppeteer-extra-plugin-stealth evasions to Playwright. It's lighter-weight than Patchright and easier to integrate with existing code.

Playwright Stealth Pros:

• Simple drop-in integration
• Passes sannysoft.com tests
• Minimal code changes required
• Available for Python

Playwright Stealth Cons:

• Less comprehensive than Patchright
• Detection methods evolving faster than patches
• Not as actively maintained

The package applies stealth patches by overriding specific browser configurations. Unlike Patchright, which patches Playwright at a deeper level, playwright-stealth works more like a configuration wrapper.

Installation is one command:

pip install playwright-stealth

Integration requires adding one function call:

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    stealth_sync(page)
    page.goto("https://example.com")

The stealth_sync() function (or stealth_async() for async code) applies evasions like removing the navigator.webdriver property and changing the "HeadlessChrome" User-Agent to standard Chrome.

This approach works well for sites with basic bot detection. The sannysoft.com test passes completely. But against advanced systems, playwright-stealth falls short of what Patchright achieves.

The advantage is simplicity. If you just need to scrape sites with minimal protection, playwright-stealth requires less configuration and has a gentler learning curve than Patchright's persistent context requirements.

Playwright Stealth pricing: Free and open source

Comparing Patchright Alternatives by Detection Performance

Not all stealth tools perform equally against anti-bot systems. Here's how they stack up based on CreepJS testing:

Lower scores are better. A 0% headless score means the tool successfully appears as a regular browser to detection systems.

Camoufox's perfect scores come from its fundamental architecture. By modifying Firefox at the C++ level rather than applying JavaScript patches, it avoids the detection vectors that trip up other tools.

Which Patchright Alternative Should You Choose?

The right choice depends on your specific situation.

Choose Camoufox if you need maximum stealth and can work with Firefox. It's the only tool that consistently achieves 0% detection scores across major test suites.

Choose Nodriver if you want to avoid traditional automation signatures entirely. Its CDP-minimal approach represents the future direction of stealth automation.

Choose SeleniumBase UC Mode if you have existing Selenium code and need stealth features without rewriting everything. The built-in CAPTCHA handling is a significant time-saver.

Choose Undetected ChromeDriver if you want the simplest possible Selenium integration and your target sites don't have advanced protection.

Choose Puppeteer Stealth if you're working in Node.js and need evasion capabilities for your Puppeteer scripts.

Choose Playwright Stealth if you want lightweight patching without Patchright's complexity and your targets have basic detection.

Using Proxies with Stealth Tools

No matter which Patchright alternative you choose, combining it with quality proxies dramatically improves success rates. Anti-bot systems track IP addresses, and making thousands of requests from a single IP will get you blocked regardless of how good your stealth is.

Residential proxies work best because they appear as genuine home internet connections. Services like Roundproxies offer residential and ISP proxies that pair well with stealth browsers.

Here's an example of adding proxy support to Camoufox:

from camoufox.sync_api import Camoufox

proxy_config = {
    "server": "http://proxy.example.com:8080",
    "username": "user",
    "password": "pass"
}

with Camoufox(headless=True, proxy=proxy_config) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

Rotate proxies between requests and consider using different proxy types for different targets. Datacenter proxies work fine for sites without fingerprinting, while residential proxies are necessary for heavily protected targets.

Final Thoughts

Patchright solved a real problem by fixing Playwright's CDP leaks, but the stealth browser landscape has evolved. Tools like Camoufox achieve better detection scores through fundamentally different approaches, while Nodriver avoids detection vectors entirely rather than patching them.

The best Patchright alternative for you depends on your existing code, your target websites, and how much time you want to spend fighting detection systems. For maximum stealth, Camoufox is currently the leader. For simplicity with existing Selenium code, SeleniumBase UC Mode strikes a good balance.

Whatever you choose, remember that stealth is only part of the equation. Combine your tool with quality proxies, realistic request patterns, and proper error handling for reliable scraping at scale.

FAQ

What is the main difference between Patchright and Camoufox?

The main difference between Patchright and Camoufox is the underlying browser engine and patching approach. Patchright patches Playwright's Chromium implementation by fixing CDP leaks through JavaScript isolation, achieving about 67% headless detection reduction. Camoufox uses a custom Firefox build with fingerprint spoofing at the C++ level, achieving 0% headless detection because changes happen before JavaScript can inspect them.

Does Patchright work with all anti-bot systems?

Patchright significantly improves detection evasion but doesn't bypass all anti-bot systems. It works well against basic fingerprinting and CDP detection. However, advanced systems like Cloudflare's higher security levels and DataDome can still detect Patchright in certain configurations, especially when running headless without proper setup.

Which Patchright alternative is best for beginners?

For beginners, playwright-stealth offers the gentlest learning curve. It requires minimal code changes and works with standard Playwright installations. Simply install the package, add one function call, and your existing Playwright code gains basic stealth capabilities. For Selenium users, undetected-chromedriver provides similar simplicity.

Can I use multiple stealth tools together?

Yes, you can layer stealth techniques. For example, you might use Camoufox or Patchright for browser stealth while adding residential proxies for IP rotation and custom headers for additional obfuscation. However, combining multiple browser patching tools (like using Patchright with Playwright Stealth) typically causes conflicts and isn't recommended.

How often do stealth tools need updates?

Stealth tools require regular updates as anti-bot systems evolve. Major anti-bot vendors like Cloudflare and DataDome update their detection methods continuously. Open-source tools like Patchright and Camoufox typically release updates monthly or when new detection methods emerge.