Zendriver is a Python framework for undetectable, asynchronous web scraping and browser automation that drives a real Chrome instance over the Chrome DevTools Protocol instead of Selenium or WebDriver.

What it is

Zendriver is an async-first web automation and scraping library published on PyPI as zendriver and documented at zendriver.dev. It is a fork of ultrafunkamsterdam/nodriver, created to add new features, compile unmerged bugfixes, and increase community engagement, and it keeps its predecessor's batteries-included approach. Everything runs through the Chrome DevTools Protocol with an async Python API, so a script can visit pages, scrape content, and execute JavaScript using a real browser in just a few lines of code.

The concrete problem it addresses is bot detection: traditional Selenium and WebDriver automation is comparatively slow and comparatively easy for anti-bot solutions to spot. Because Zendriver speaks the Chrome DevTools Protocol directly rather than going through WebDriver, the README describes it as almost impossible to detect, which matters for targets protected by services such as Cloudflare. It also solves a packaging problem — browser automation has been difficult to containerise, especially with a real GPU-accelerated, non-headless Chrome — through an officially supported Docker project template.

Key capabilities

• Drives a real Chrome browser over the Chrome DevTools Protocol with no Selenium or WebDriver in the stack, covering page visits, content scraping, and JavaScript execution.
• Ships first-class Docker support via the cdpdriver/zendriver-docker project template, which runs a real, GPU-accelerated (not headless) browser in a container on Linux.
• Handles cookie and profile management automatically: a fresh profile is used by default and cleaned up on exit, or cookies can be saved to and loaded from a file to skip repeated logins.
• Provides smart element lookup by selector or text, including inside iframes, retrying until timeout elapses so a lookup can double as a wait condition.
• Supports single-element lookup by text through tab.find() with a best_match flag, which ranks candidates by closest matching text length instead of returning the first match.
• Offers easy debugging through descriptive repr output for elements that renders the element as HTML.
• Provides page-level utilities such as page.save_screenshot("browserscan.png") alongside zd.start() and browser.stop() lifecycle calls.

Who uses it and how

• Python developers who need to scrape sites behind anti-bot protection such as Cloudflare without running a WebDriver stack.
• Teams that want browser automation packaged as a container, using the zendriver-docker template on Linux to run GPU-accelerated Chrome rather than headless Chrome.
• Operators running repeated automated sessions against sites requiring login, persisting cookies to a file so each run does not repeat the login steps.
• Contributors and users migrating from nodriver who want open pull requests addressed, including previously unmerged bugfixes for critical bugs.
• Anyone testing bot detection directly, as in the README example that visits https://www.browserscan.net/bot-detection and saves the results as a screenshot.

Getting started

Install the package from PyPI with pip install zendriver (or the equivalent uv, poetry, or other package-manager command), then run scripts through asyncio.run() with zd.start(); for containerised deployments, use the cdpdriver/zendriver-docker template.

How it compares

Zendriver sits alongside its predecessor nodriver, from which it forks to add features and unmerged bugfixes, and alongside Selenium and WebDriver-based tools, which it replaces at the protocol layer by speaking the Chrome DevTools Protocol directly. Among the tools named in its own documentation, it positions itself as the faster and harder-to-detect alternative to those Selenium/WebDriver solutions while preserving a batteries-included Python API.

When to use it — and when not

Users must operate a real Chrome installation, and the officially supported GPU-accelerated Docker path is Linux-only, so a self-hoster is managing a browser runtime rather than a turnkey service. The project is licensed AGPL-3.0, which may rule it out for teams unwilling to meet copyleft obligations, and the repository currently carries 57 open issues; the README also notes that its parent project restricted contributions for months, so anyone depending on it should evaluate issue responsiveness before committing.

pip install zendriver
# or uv add zendriver, poetry add zendriver, etc.

import asyncio

import zendriver as zd


async def main():
    browser = await zd.start()
    page = await browser.get("https://www.browserscan.net/bot-detection")
    await page.save_screenshot("browserscan.png")
    await browser.stop()


if __name__ == "__main__":
    asyncio.run(main())