> ## Content Index > Fetch the complete content index at: https://roundproxies.com/blog/llms.txt > Use this file to discover other available public pages before exploring further. # The 6 best Patchright alternatives in 2026 - URL: https://roundproxies.com/blog/best-patchright-alternatives/ - Published: 2025-12-17T20:20:44.000Z - Updated: 2026-09-23T13:04:17.000Z - Description: The 6 best Patchright alternatives for web scraping: Camoufox for Firefox stealth, Nodriver for CDP-free automation, SeleniumBase UC Mode. - Author: Marius Bernard - Tags: Best Alternatives, #dated-6932d31826f439f88a95a1a3 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: ```python 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 | Tool | Best For | Browser Engine | Language Support | Pricing | | ----------------------- | ------------------------------- | -------------- | ---------------- | ---------------- | | Camoufox | Firefox-based stealth | Firefox | Python | Free/Open Source | | Nodriver | CDP-minimal automation | Chrome | Python | Free/Open Source | | SeleniumBase UC Mode | Selenium users | Chrome | Python | Free/Open Source | | Undetected ChromeDriver | Simple Selenium setups | Chrome | Python | Free/Open Source | | Puppeteer Stealth | Puppeteer users | Chrome | Node.js | Free/Open Source | | Playwright Stealth | Lightweight Playwright patching | Chromium | Python/Node.js | Free/Open Source | ## The Best Patchright Alternative for Firefox-Based Stealth ### [Camoufox](https://camoufox.com/) ![The Best Patchright Alternative for Firefox-Based Stealth](https://cdn.roundproxies.com/blog-images/2025/12/Camoufox.webp) [Camoufox](https://roundproxies.com/blog/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: ```python pip install camoufox camoufox fetch ``` After installation, you use it similarly to Playwright: ```python 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](https://github.com/ultrafunkamsterdam/nodriver) ![The Best Patchright Alternative for CDP-Minimal Automati](https://cdn.roundproxies.com/blog-images/2025/12/Nodriver.webp) 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](https://roundproxies.com/blog/how-to-use-nodriver-for-web-scraping-in-7-steps/) 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: ```python pip install nodriver ``` The async-first API looks like this: ```python 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](https://github.com/seleniumbase/SeleniumBase) ![The Best Patchright Alternative for Selenium Users](https://cdn.roundproxies.com/blog-images/2025/12/SeleniumBase-UC-Mode.webp) If you're already invested in Selenium and don't want to switch frameworks, [SeleniumBase UC Mode](https://roundproxies.com/blog/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: ```python pip install seleniumbase ``` Using UC Mode requires the `uc=True` flag: ```python 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](https://github.com/ultrafunkamsterdam/undetected-chromedriver) ![The Best Patchright Alternative for Simple Selenium Setups](https://cdn.roundproxies.com/blog-images/2025/12/Undetected-Chromedriver.webp) 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: ```python pip install undetected-chromedriver ``` Usage mirrors standard Selenium: ```python 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)](https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin-stealth) ![The Best Patchright Alternative for Puppeteer Users](https://cdn.roundproxies.com/blog-images/2025/12/Puppeteer-Stealth.webp) 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: ```bash npm install puppeteer puppeteer-extra puppeteer-extra-plugin-stealth ``` Implementation is straightforward: ```javascript 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: ```javascript 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)](https://pypi.org/project/playwright-stealth/) ![The Best Patchright Alternative for Lightweight Playwright Patching](https://cdn.roundproxies.com/blog-images/2025/12/Playwright-Stealth.webp) 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: ```bash pip install playwright-stealth ``` Integration requires adding one function call: ```python 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: | Tool | Headless Score | Stealth Score | Notes | | -------------------- | -------------- | ------------- | ---------------------------------- | | Camoufox | 0% | 0% | Best overall stealth | | Patchright | 67% | 0% | Good but not perfect | | Nodriver | 67% | 0% | Similar to undetected-chromedriver | | Puppeteer Stealth | 33% | 80% | Stealth plugin detected | | Playwright (vanilla) | 100% | 0% | Easily detected | | Selenium (vanilla) | 100% | 0% | Easily detected | 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 sidesteps the patch-and-detect cycle that other tools are stuck in. **Choose SeleniumBase UC Mode if** you have existing Selenium code and need stealth features without rewriting everything. The built-in CAPTCHA handling saves you from writing custom CAPTCHA-handling code. **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: ```python 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 stealth browser tooling has moved on. 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 reduces headless detection (from 100% to about 67% on CreepJS) 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.