undetected-chromedriver vs nodriver vs Patchright: Stealth Browser 2026

The article has been generated. Here’s the markdown body:

—

The real fight in undetected-chromedriver vs nodriver vs Patchright is not API style, it is whether your browser survives modern detection long enough to do useful work. in 2026, the easy benchmark pages still matter, but the real test is Cloudflare Turnstile, DataDome, and increasingly aggressive behavioral scoring layered on top of fingerprint checks. i have used all three in production-style scraping stacks, and the short version is simple: Patchright is the strongest option for current high-friction targets, nodriver is the cleanest lightweight Python CDP tool, and undetected-chromedriver is now mostly a legacy compatibility choice.

what each tool actually is

undetected-chromedriver started as the practical fix for Selenium users who wanted ChromeDriver patched well enough to avoid obvious automation fingerprints. it still matters because a lot of internal tools, QA harnesses, and scraper fleets are built on Selenium. the value proposition is continuity: keep your existing Selenium mental model, keep most of your code, and reduce detection compared with stock ChromeDriver.

nodriver is the same author’s more modern direction. it skips Selenium and ChromeDriver entirely, drives Chromium over CDP directly, and exposes an async Python interface. that matters because every extra automation layer adds surface area. in practice, nodriver usually feels lighter, faster to start, and less “driver shaped” from a detection perspective.

Patchright is a patched Playwright fork, available for both TypeScript and Python, built specifically around stealth gaps that standard Playwright leaves exposed. in 2026, that makes it the most relevant of the three for hard commercial targets. if you already read Patchright vs Rebrowser-Patches: Stealth Playwright Patches Compared 2026, the big takeaway here is that Patchright belongs in the “serious stealth browser” bucket, not the “nice wrapper with a couple of flags” bucket.

where detection is won or lost in 2026

people still waste time debating navigator.webdriver, but serious anti-bot vendors moved past that years ago. the modern stack is layered:

browser startup flags
CDP side effects
JS runtime leaks
canvas, WebGL, audio, font, and screen consistency
proxy and DNS mismatches
session behavior, timing, and interaction flow

that is why Turnstile and DataDome matter more than test pages. a tool that looks fine on Sannysoft but fails on a retail checkout, sneaker queue, or travel search flow is not stealthy in any useful sense.

here is the production ranking I would use today:

tool	detection resistance	maintenance status in 2026	API style	async support	speed	best fit
undetected-chromedriver	medium	aging, low momentum	Selenium	limited, Selenium-centric	moderate	legacy Selenium stacks
nodriver	medium-high	active enough, successor path is clear	Python CDP	native async	fast	lightweight Python scraping
Patchright	high	actively maintained in 2026	Playwright-compatible	strong in Python and TS	fast	modern protected targets

that table hides one important nuance. Patchright is not magic. if your IP reputation is bad, your DNS leaks, your cookies are inconsistent, or you hit a site with robotic pacing, you will still get blocked. the tool only removes some browser-level reasons to fail.

undetected-chromedriver, still usable, but no longer first choice

there are still legitimate reasons to keep undetected-chromedriver in rotation.

you already have a large Selenium codebase
your target is medium difficulty, not aggressively defended
your team is Python-heavy and does not want a Playwright migration yet

for those cases, UC can still work well enough. login flows, internal portals, public records sites, marketplaces with moderate bot pressure, and sites that mainly check obvious webdriver markers are still realistic use cases.

the problem is architectural age. UC still carries the cost of ChromeDriver and Selenium semantics. that means more moving parts, more strange breakage when Chrome changes, and a larger fingerprint surface than direct CDP or patched Playwright approaches. it is also simply slower to evolve against new bot defenses.

my rule is blunt: if you are opening a new project in 2026, do not start with UC unless you need Selenium compatibility. if you already have a stable UC scraper making money, keep it until the target hardens, then migrate deliberately.

nodriver, the best Python-only middle ground

nodriver is the most underrated option here. it removes ChromeDriver entirely, keeps you in Python, and gives you a more modern async control model. for analysts and engineers who want fewer abstractions between their code and Chromium, it hits a useful sweet spot.

in practice, nodriver works well when you need:

direct CDP control
lower startup overhead
async concurrency in Python
a smaller automation signature than Selenium-based stacks

a minimal example looks like this:

import nodriver as nd

async def main():
    browser = await nd.start(
        browser_args=[
            "--proxy-server=socks5://127.0.0.1:9050"
        ]
    )
    page = await browser.get("https://example.com")
    await page.wait(2)
    print(await page.get_content())

that simplicity is real, but nodriver has limits. it is stronger than UC on browser architecture, yet it does not have Patchright’s dedicated patching depth for modern detection-heavy environments. on tougher targets, you often end up compensating with better proxies, tighter session handling, and more careful interaction scripts.

this is also where operators make avoidable mistakes outside the browser itself. if your browser uses a SOCKS proxy but local DNS still resolves outside the tunnel, you create a clean correlation point for defenders. that is why network hygiene matters as much as the driver choice, and Proxifier SOCKS v5: How to Force Proxy DNS Resolution (2026) is worth reviewing before you blame the automation layer.

Patchright, the strongest choice for modern anti-bot stacks

Patchright is the only one of these three that I would call a default recommendation for new scraping work against modern protected targets. it inherits Playwright’s strong automation model, then patches the areas that anti-bot vendors actually inspect. that combination matters.

the practical advantages are straightforward:

better resistance to current browser-level detection
Playwright-quality selectors, contexts, and tooling
Python and TypeScript support
good fit for teams already using Playwright conventions

if your targets include Cloudflare-managed pages, DataDome-protected commerce sites, or PerimeterX-style defenses, Patchright gives you the best starting odds. not guaranteed success, just the best starting odds.

that said, teams often overfocus on the core browser and underinvest in the surrounding environment. a clean Patchright browser behind bad residential routing, weak cookie reuse, or noisy interaction scripts still loses. treat the browser as one layer in a system.

for debugging and validation, I strongly recommend building repeatable stealth checks instead of trusting anecdotal success. the right baseline is a verification harness that tests fingerprint surfaces, IP consistency, and real target outcomes over time. the best starting framework for that is Build an Anti-Detection Test Suite: Verify Browser Stealth.

choosing the right tool for your stack

if you are deciding fresh, use this filter.

choose undetected-chromedriver if

you have existing Selenium jobs, your targets are not top-tier defended, and migration cost matters more than squeezing every bit of stealth. it is the conservative option, not the strongest one.

choose nodriver if

you want Python, direct CDP, async workflows, and a leaner browser control path than Selenium. it is a good engineering choice for custom data collection systems where you want control without fully switching to the Playwright ecosystem.

choose Patchright if

you are targeting modern anti-bot infrastructure and care more about passing real-world detection than preserving old code patterns. for many 2026 scraping teams, this is the correct default.

a few adjacent tools matter too. if your operators rely on keyboard-driven workflows for manual review, triage, or semi-automated browsing during scraper development, Surfing Keys, Vimium, Tridactyl: Keyboard Browser Automation for Scraping pairs surprisingly well with stealth testing. if your workflow uses an anti-detect browser shell around collection sessions, AntBrowser Proxy Setup 2026: Anti-Detect Browser + Proxy Guide is relevant, especially for teams separating analyst sessions from headless scraping infrastructure.

Bottom line

for 2026, Patchright is the best pick for modern protected targets, nodriver is the best lightweight Python CDP option, and undetected-chromedriver still makes sense for legacy Selenium codebases. if you are starting from zero, use Patchright unless your constraints clearly point elsewhere. for more field-tested comparisons like this, dataresearchtools.com is the right place to keep your stack current.