CloakBrowser vs. Camoufox vs. Undetected-Chromedriver: A Stealth Browser Comparison for AI Agents

TL;DR

• CloakBrowser fits Playwright and Puppeteer agents best because it keeps Chromium and the Chrome DevTools Protocol (CDP), and Browser-use attached to it in our test.
• Camoufox has the most complete fingerprint control and runs on Firefox, so CDP-only frameworks such as Browser-use 0.13.11 can't attach to it.
• undetected-chromedriver still works for existing Selenium code, though its last release dates from 2024 and its author calls nodriver the official successor.
• No tool we tested held a full session on every protected site, and complete sessions also needed a clean residential IP. On a 3-page login task, code that sent public pages to a scraping endpoint cut our agent's time from 314 s to 41 s.

What agentic browsing requires that scraping doesn't

Agentic browsing is an LLM-driven loop that reads a page, decides on an action, performs it, and repeats until the goal is met. Frameworks such as Browser-use and most Model Context Protocol (MCP) servers drive Chromium over CDP.

A scraper and an agent fail in different ways:

• A scraper works from a known list of requests and retries a failed URL cheaply.
• An agent discovers its next action from the page it loaded, so a block at step 30 of 40 can waste steps 1 to 29.
• An agent holds state, such as cookies and a logged-in session, for minutes.

Failed runs cost browser time and tokens. To reduce both, agent workflows that call live web data can send some steps to a scraping API endpoint instead of the browser.

The 3 tools change the browser, not the agent loop, so it helps to know how headless browsers work. Each tool is measured on 4 axes:

• Session survival. Whether the session runs 30 or more actions without a block or challenge.
• Step latency. Milliseconds per action, multiplied by the steps in a task.
• Framework compatibility. Whether an agent framework that drives CDP can attach to the browser.
• Operational cost. Memory per session, update frequency, and licensing.

Our tests ran in an 8-core Linux arm64 Docker VM on an Apple host, mostly from one home broadband IP. Every test used CloakBrowser's free keyless build (Chromium 146, 58 patches, no license key), Camoufox 156.0.1-beta.36, and undetected-chromedriver on Google Chrome 155. Sessions ran 12 steps on an unprotected site and up to 30 pages on protected ones.

Live tests ran headless unless noted, which makes a browser easier to detect. Our sample was small, so confirm the survival results on your own targets.

The 4 signal layers, and which ones a stealth browser covers

Anti-bot systems commonly collect signals from 4 layers to profile a session:

• IP reputation. The IP's type, history, and location, scored before any JavaScript runs.
• Browser fingerprint. Canvas, WebGL, audio, fonts, hardware values, and CDP leaks such as navigator.webdriver.
• Transport fingerprint. The TCP/IP stack, the JA4 TLS fingerprint, and HTTP/2 frame settings, which should match the device the session claims to be.
• Behavioral signals. Cursor paths, scroll patterns, and keystroke timing across the session.

Detection systems check whether these layers agree. CloakBrowser, Camoufox, and undetected-chromedriver all work on the fingerprint layer, and CloakBrowser and Camoufox also handle the behavior layer. Input at exact, regular intervals across dozens of agent steps is a recognizable pattern for systems that score a session over time, such as DataDome. The IP layer comes from your proxy setup, because a clean fingerprint on a flagged IP can still fail.

The TCP/IP stack belongs to the machine that opens the connection, so a browser patch can't change it. The container's traffic used the macOS host's network stack. A TCP/IP classifier therefore identified CloakBrowser, Camoufox, and stock Playwright as the same Apple device, even when they claimed Windows.

Behind a proxy, the site sees the proxy exit's TCP/IP stack instead of your machine's. That stack is part of what Cloudflare checks before it serves a page.

CloakBrowser: Source-patched Chromium behind the Playwright API

CloakBrowser is a custom Chromium binary with fingerprint changes compiled into the browser source. MIT-licensed wrappers for Python, JavaScript, and .NET launch it through the standard Playwright and Puppeteer APIs. Wrapper 0.6.3 downloads a Chromium 154 build with a free or paid key, and its README keeps the current patch list. CloakBrowser's Windows fingerprint needs Windows fonts, so install them first on Linux.

Our test page runs 3 checks that detect an attached CDP client. CloakBrowser triggered none. Stock Playwright triggered 1 and reported navigator.webdriver as true:

The humanize=True flag covers the behavior layer. Per the README and changelog, it adds curved mouse paths, typing delays modeled on a 136M-keystroke study, and wheel scrolling. The flag costs time, because our median 12-step CloakBrowser task took 19.52 s with humanize and 6.31 s without it. Practitioners usually enable it on targets that score behavior, such as anti-fraud checks.

In wrapper 0.6.3, the flag also changes how clicks behave. A stock Playwright click waits until the next page starts to load. In a several-run check with humanize on, the click returned while the next page was still loading, and an immediate check found 0 quotes. An explicit navigation wait fixes it:

from cloakbrowser import launch

browser = launch(headless=True, humanize=True)
page = browser.new_page()
page.goto("https://quotes.toscrape.com/")

# A humanized click can return before the next page starts to load.
with page.expect_navigation(wait_until="domcontentloaded"):
    page.click("li.next > a")

print(page.url, page.locator(".quote").count())
browser.close()

With the wait, the script reached page 2 and counted its 10 quotes:

https://quotes.toscrape.com/page/2/ 10

CloakBrowser scores best on framework compatibility. We attached Browser-use through cdp_url, and the page still read navigator.webdriver as false. Humanize runs in the wrapper, so it doesn't apply when a framework drives raw CDP. The third-party stealth browser MCP server cloakbrowser-mcp wraps CloakBrowser as an agent tool.

The attach takes a debugging port and a matching cdp_url:

# Needs browser-use 0.13.11 and an OPENAI_API_KEY environment variable.
import asyncio

from browser_use import Agent, BrowserSession, ChatOpenAI
from cloakbrowser import launch_async


async def main():
    # Expose CDP on a local port, then point browser-use at that address.
    browser = await launch_async(headless=True, args=["--remote-debugging-port=9242"])
    session = BrowserSession(cdp_url="http://127.0.0.1:9242")
    agent = Agent(task="Open https://quotes.toscrape.com and return the first 3 author names.",
                  llm=ChatOpenAI(model="gpt-5-mini"), browser_session=session)
    try:
        history = await agent.run(max_steps=10)
        print(history.final_result())
    finally:
        await session.kill()
        await browser.close()  # close from the launching process, which frees the session seat


asyncio.run(main())

For logged-in agents, the wrapper's persistent context kept the same fingerprint in 4 of 4 restarts. CloakBrowser also has 5 trade-offs for agent work:

• The binary is proprietary. The binary license allows internal Docker and CI use, but embedding it for third parties needs an OEM or SaaS license.
• Pricing depends on concurrent sessions. A free GitHub sign-in unlocked the current build for 1 session when we tested. Paid plans add concurrent sessions, with current prices on the CloakBrowser site. The keyless build we tested reported Chrome 146, 9 versions behind stable.
• Crashed sessions keep their license seats. Per the wrapper source, a killed session frees its seat after 4 to 30 minutes. After connect_over_cdp(), browser.close() only disconnects, so close the browser from the process that launched it.
• Each fingerprint needs its own process. In 1 browser, 8 contexts shared 1 fingerprint, so separate fingerprints cost 170 MB each instead of 96 MB.
• You handle CAPTCHA solving and proxy rotation. Pair CloakBrowser with a proxy pool.

In wrapper 0.6.3, the Playwright request client ignores a proxy passed as a browser flag (issue #579). With the proxy passed as –proxy-server, page.goto() went through it, and page.request.get() bypassed it. A context-level proxy covers both kinds of requests:

import os
from cloakbrowser import launch

browser = launch(headless=True)
# A context-level proxy reaches page.goto() and page.request alike.
context = browser.new_context(proxy={
    "server": os.environ["PROXY_SERVER"],
    "username": os.environ["PROXY_USER"],
    "password": os.environ["PROXY_PASS"],
})
page = context.new_page()
print(page.request.get("https://ip.decodo.com/json").json()["proxy"]["ip"])
browser.close()

The script prints the proxy's exit IP, confirming that page.request uses the proxy. See how driver-level patching of Playwright and Puppeteer works and our guide to fingerprint defense with a patched browser build.

Camoufox: Engine-level fingerprint injection on Firefox

Camoufox is a modified Firefox build that injects navigator values, screen metrics, fonts, and WebGL data at the engine level. Playwright drives it through Juggler, the Firefox automation protocol that replaces CDP.

Camoufox is built for targets that check fingerprints closely. It doesn't add noise to canvas output. Stock Firefox draws the same pixels every time, so a browser whose canvas results change looks fake. On Linux, Camoufox's Windows fingerprint still had Segoe UI and Calibri, fonts that CloakBrowser leaves you to install.

The Firefox engine changes 3 things for agents:

• Browser-use 0.13.11 is CDP-only. It has no Firefox support, and Camoufox has no CDP endpoint.
• Playwright MCP accepts a Firefox target, so an agent loop built on Playwright is the practical option.
• Page variables need main_world_eval. Camoufox runs scripts apart from the page by default, so agent code needs it to read the page's own variables.

A CAPTCHA provider's script created a Worker from the Juggler package. Stock Firefox doesn't have that package, so the script could detect Camoufox. In beta.36, the release Camoufox ships as stable, the fix that hides Juggler from pages was only in prerelease builds. Check new stable releases for it.

The Camoufox input-dispatch notes record 4 input deadlocks, where one lost mouse event froze every tab with no error. The deadlock fix drops such events after 5 s.

Camoufox uses more memory. After the 12-step task, Camoufox used a median of 762 MB of memory against 348 MB for CloakBrowser across 5 runs. We measured proportional set size, which divides shared memory among the processes that use it.

For fleets, Camoufox's NewContext() helper creates a new fingerprint for each browser context, so many fingerprints can share 1 process. Only 6 of our 8 were distinct.

Pin a device preset to keep the same fingerprint. In beta.36, a restarted profile kept its cookies and localStorage but returned as a different device in 5 of 6 restarts. A logged-in agent on a new device can trigger a re-check. Camoufox ships recorded real-device presets, so pin one per profile:

import json
import random
from importlib.resources import files
from pathlib import Path

from camoufox.sync_api import Camoufox

profile = Path("profiles/agent-1")
pin = profile.parent / "agent-1.preset.json"  # outside the profile, so Firefox never touches it

# Pick a real-device preset once, then reuse it on every launch of this profile.
if not pin.exists():
    presets = json.loads((files("camoufox") / "fingerprint-presets.json").read_text())["presets"]
    pin.parent.mkdir(parents=True, exist_ok=True)
    pin.write_text(json.dumps(random.choice(presets["linux"])))  # host OS needs no canvas noise

with Camoufox(headless=True, persistent_context=True, user_data_dir=str(profile),
              fingerprint_preset=json.loads(pin.read_text())) as context:
    page = context.new_page()
    page.goto("https://quotes.toscrape.com/")
    print(page.evaluate("[navigator.platform, screen.width + 'x' + screen.height].join(' ')"))

Across 3 launches, the script printed the same fingerprint, a Linux preset, the same OS as the host:

Linux x86_64 3440x1440
Linux x86_64 3440x1440
Linux x86_64 3440x1440

Spoofing another OS needs canvas noise, which the project says no real machine produces.

Licensing is the simplest of the 3. The browser is MPL-2.0, a file-level copyleft, so you can ship it in a product if you make the source of its MPL files available.

If you need a Camoufox alternative that CDP agent frameworks can attach to, CloakBrowser and Patchright, a patched Playwright driver for Chromium, both qualify. For installation and launch code, follow our full Camoufox setup walkthrough.

undetected-chromedriver: Driver-level patching for Selenium

undetected-chromedriver is a patched Selenium ChromeDriver that removes the automation flags a stock driver exposes. Its patcher deletes the cdc_ block that ChromeDriver injects.

It still works for existing Selenium code on lightly protected sites. For agent work, 3 limits make other tools a better fit:

• The WebDriver layer remains, and it leaves traces that detection scripts can find.
• Updates have slowed. The last PyPI release, 3.5.5, dates from 2024.
• A successor exists. Its author describes nodriver as the official successor.

Headless mode can expose the automation. On the GPU-less test container, the headless session reported HeadlessChrome/155 in its user agent and used SwiftShader, a software renderer. It also reported an 800x600 screen with a larger 1920x993 window, which no real device has.

The tool had the lowest step latency in our benchmark, at 386 ms, and it works with Selenium tooling only. On 2 protected sites in our live tests, it stopped at page 1, so it fits lightly protected targets.

For an existing project, see our undetected ChromeDriver setup in Python. For new work, read how nodriver replaces the ChromeDriver layer entirely.

Side-by-side: Stealth browsers compared on agent workloads

Both tables cover the 3 tools plus 4 related projects. Latency comes from our benchmark, and the other cells from each project's docs, code, and license:

CloakBrowser vs. Camoufox vs. undetected-chromedriver, with 4 related projects, on the agent axes. Latency is the mean per step across 10 headless runs, with the keyless CloakBrowser 146 build.

The second table covers the stealth and its cost:

Both tables support a short decision path:

• If your Playwright or Puppeteer agent gets flagged and you can pay per concurrent session, start with CloakBrowser.
• If you run a purpose-built scraper on a target that checks fingerprints closely and want stealth code you can review, start with Camoufox.
• If you maintain legacy Selenium code on lightly protected sites, keep undetected-chromedriver and plan a move to nodriver.
• If you embed a browser in a product you distribute, compare licenses before performance.
• If your agent mostly reads public pages, fetch those pages through a scraping endpoint and keep the browser for logins.

Compare how Playwright and Selenium differ as automation layers, and see configuring stealth on stock Playwright for the baseline row.

How to benchmark stealth browsers against your own targets

Fingerprint test pages are a first check, not a full benchmark for agents:

• They cover one page load, which can't show a block that arrives later in a session.
• They don't test navigation, form input, or state that persists between steps.

A harness that measures each step

A multi-step harness runs 1 task through the 3 tools and measures each step:

1. Load quotes.toscrape.com, move to pages 2 and 3, and log in.
2. Read a view that only renders after login.
3. Repeat N times per browser, and record completion rate, wall-clock time, time per step, and the step index of each failure.

Install the tested versions. Python 3.12+ also needs setuptools, because undetected-chromedriver imports distutils:

python -m pip install "cloakbrowser==0.6.3" "camoufox==0.5.8" "undetected-chromedriver==3.5.5" "selenium==4.51.0" setuptools && python -m camoufox fetch

Save the script as stealth_bench.py. It reads an optional proxy from an environment variable and prints a summary table:

"""Multi-step session benchmark for stealth browsers.

Runs one 12-step task (paginate, log in, read an authenticated view) N times per
browser and prints completion rate, wall-clock time, time per step, and the step
index where each failed run stopped.

Usage:
    python stealth_bench.py --runs 10 --tools cloakbrowser camoufox uc
Optional proxy, read from the environment in the standard URL format:
    PROXY_URL=http://user:pass@host:port
"""
import argparse
import os
import shutil
import statistics
import time

BASE = os.environ.get("BENCH_TARGET", "https://quotes.toscrape.com")
PROXY_URL = os.environ.get("PROXY_URL")  # never hardcode credentials


# One task, written once. `b` is any object with goto/click/fill/count.
def task(b):
    return [
        ("open home", lambda: b.goto(BASE + "/")),
        ("read page 1", lambda: b.count(".quote") == 10),
        ("next page", lambda: b.click("li.next > a")),
        ("read page 2", lambda: b.count(".quote") == 10),
        ("next page", lambda: b.click("li.next > a")),
        ("read page 3", lambda: b.count(".quote") == 10),
        ("open login", lambda: b.click("a[href='/login']")),
        ("type username", lambda: b.fill("#username", "agent")),
        ("type password", lambda: b.fill("#password", "agent")),
        ("submit form", lambda: b.click("input[type='submit']")),
        ("check session", lambda: b.count("a[href='/logout']") == 1),
        ("read auth view", lambda: b.count("a[href*='goodreads.com']") > 0),
    ]


class PW:
    """Playwright page (CloakBrowser and Camoufox expose the Playwright API)."""

    def __init__(self, page, close):
        self.p, self.close = page, close

    def goto(self, url):
        self.p.goto(url, wait_until="domcontentloaded", timeout=30_000)

    def click(self, sel):
        # Every click in the task navigates. Wait for the navigation explicitly,
        # because a humanized click can return before the new page starts to load.
        with self.p.expect_navigation(wait_until="domcontentloaded", timeout=30_000):
            self.p.click(sel, timeout=15_000)

    def fill(self, sel, text):
        self.p.locator(sel).press_sequentially(text, timeout=15_000)  # keystrokes, not a paste

    def count(self, sel):
        return self.p.locator(sel).count()


class SE:
    """Selenium driver (undetected-chromedriver keeps the Selenium API)."""

    def __init__(self, driver):
        from selenium.webdriver.common.by import By
        self.d, self.by = driver, By.CSS_SELECTOR
        self.d.implicitly_wait(15)

    def goto(self, url):
        self.d.get(url)

    def click(self, sel):
        self.d.find_element(self.by, sel).click()

    def fill(self, sel, text):
        self.d.find_element(self.by, sel).send_keys(text)

    def count(self, sel):
        return len(self.d.find_elements(self.by, sel))

    def close(self):
        self.d.quit()


def pw_proxy():
    if not PROXY_URL:
        return None
    from urllib.parse import urlparse
    u = urlparse(PROXY_URL)
    return {"server": f"{u.scheme}://{u.hostname}:{u.port}",
            "username": u.username or "", "password": u.password or ""}


def launch_cloakbrowser(humanize=False):
    # A launch proxy covers page navigation, which is all this task does.
    # Pass a context proxy instead if you add page.request calls (issue #579).
    from cloakbrowser import launch
    browser = launch(headless=True, humanize=humanize, proxy=PROXY_URL)
    return PW(browser.new_page(), browser.close)


def launch_camoufox(humanize=False):
    from camoufox.sync_api import Camoufox
    cm = Camoufox(headless=True, humanize=humanize, proxy=pw_proxy())
    browser = cm.__enter__()
    return PW(browser.new_page(), lambda: cm.__exit__(None, None, None))


def launch_uc(humanize=False):
    import undetected_chromedriver as uc
    opts = uc.ChromeOptions()
    opts.page_load_strategy = "eager"  # return at DOMContentLoaded, like the Playwright adapter
    if PROXY_URL:  # Chrome ignores inline credentials here; use an IP-allowlisted proxy
        opts.add_argument(f"--proxy-server={PROXY_URL}")
    chrome = os.environ.get("CHROME_PATH") or shutil.which("chromium") or shutil.which("google-chrome")
    driver = uc.Chrome(options=opts, headless=True, browser_executable_path=chrome,
                       driver_executable_path=os.environ.get("CHROMEDRIVER_PATH"),
                       version_main=int(os.environ["CHROME_MAJOR"]) if "CHROME_MAJOR" in os.environ else None)
    return SE(driver)


LAUNCHERS = {"cloakbrowser": launch_cloakbrowser, "camoufox": launch_camoufox, "uc": launch_uc}


def run_once(launcher, humanize):
    t0 = time.perf_counter()
    b = launcher(humanize=humanize)
    launch_s = time.perf_counter() - t0
    step_times, failed_at = [], None
    try:
        for i, (name, step) in enumerate(task(b), start=1):
            s0 = time.perf_counter()
            try:
                ok = step()
            except Exception:
                ok = False
            step_times.append(time.perf_counter() - s0)
            if ok is False:
                failed_at = f"{i} ({name})"
                break
    finally:
        b.close()
    return launch_s, step_times, failed_at


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--runs", type=int, default=10)
    ap.add_argument("--tools", nargs="+", default=list(LAUNCHERS))
    ap.add_argument("--humanize", action="store_true")
    args = ap.parse_args()

    rows = []
    for tool in args.tools:
        done, walls, per_step, launches, failures = 0, [], [], [], []
        for _ in range(args.runs):
            launch_s, steps, failed_at = run_once(LAUNCHERS[tool], args.humanize)
            launches.append(launch_s)
            per_step.extend(steps)
            if failed_at:
                failures.append(failed_at)
            else:
                done += 1
                walls.append(sum(steps))
        rows.append((tool, f"{done}/{args.runs}",
                     f"{statistics.median(launches):.2f}",
                     f"{statistics.median(walls):.2f}" if walls else "-",
                     f"{statistics.mean(per_step) * 1000:.0f}",
                     ", ".join(sorted(set(failures))) or "-"))

    head = ("tool", "completed", "launch s", "task s (median)", "ms/step (mean)", "failed at step")
    widths = [max(len(str(r[i])) for r in rows + [head]) for i in range(len(head))]
    for r in [head] + rows:
        print("  ".join(str(c).ljust(w) for c, w in zip(r, widths)))


if __name__ == "__main__":
    main()

Without humanize, all 10 headless runs completed on all 3 tools:

Without humanize, all 10 headless runs completed on all 3 tools

With –humanize, the same 10 runs took 3.1x longer on CloakBrowser and 1.5x longer on Camoufox:

tool          completed  launch s  task s (median)  ms/step (mean)  failed at step
cloakbrowser  10/10      0.45      19.52            1658            -
camoufox      10/10      1.21      9.18             771             -

The step index caught the click bug early, because humanized CloakBrowser stopped at step 4 in all 5 runs without the navigation wait. A tool that fails at the same step every time has a specific, fixable problem. A tool that fails at random steps has a bot-detection problem that code changes rarely fix. The cause is often a challenge page that appears mid-run.

Session survival on protected sites

Protected sites show what the harness can't. On 4 sites behind different bot-protection products, 5-page sessions from our home IP loaded these pages before the first block:

Over 30 pages on sites A and B, with 5 to 9 s of reading per page, sessions ended like this:

An agent built on Playwright can keep both engines and choose per domain. Keep watching each domain's block rate, because results change over time.

Every block in these tests returned HTTP 403. Practitioners also report challenge pages served with HTTP 200, so check the page for the fields you need. That check also catches pages built to mislead automated readers.

Adding a clean IP changes the results. Each 8-page session ran on its own sticky residential IP from the site's country, kept for the whole session. Both stealth browsers' geoip option matched timezone and locale to that IP:

The table leaves out site C, which stopped every browser at page 1 in both tests. Site D needed both layers. The stealth browsers completed sessions on clean residential IPs, and stock Playwright on the same kind of IPs did not. Our home IP worked on site D only until it was flagged after a day of test traffic.

On site A, Camoufox completed sessions on the same kind of IPs, so CloakBrowser's block at page 2 points to the fingerprint layer. That layer included our keyless build's old Chrome version. Site B changed over time and later blocked CloakBrowser from our home IP too, so the 30-page result didn't repeat.

Survival depends on the site, the browser, and the IP together, so test each target with both layers in place

Splitting the work: Which agent steps need a browser and which need an endpoint

The split rests on 2 things: what a stealth browser costs and a rule for each step.

What a stealth browser costs

A stealth browser has costs that patching alone doesn't remove, starting with memory. Memory per profile depends on how the 8 profiles share processes:

There are 3 more costs:

• Constant rebuilds. Every source-patched build needs a rebuild after each Chromium or Firefox release. Paid CloakBrowser builds moved from Chromium 150 to 154 in under 3 months.
• The IP layer. A flagged IP can fail a session early, so rotate IPs between sessions and read why rotating IPs changes what a target sees. Keep 1 sticky IP within each agent session, because an IP change mid-login can look like a hijacked session. If an account logs in every day, give it a static IP, so its IP stays as stable as its device fingerprint.
• Slow steps cost hours. An extra 400 ms per action adds 16 s to a 40-step task. Humanize in CloakBrowser added 1.13 s per step, about 12.6 hours across 1,000 nightly 40-step tasks.

So reserve the stealth browser for the steps that need it.

The routing rule

Some sites offer agents an official way in. Cloudflare treats signed agents as verified bots if they use Web Bot Auth, an IETF draft, and behave without abuse. WebMCP is another way in, because it lets sites expose actions directly to agents.

In our 12-step task, 6 steps read public pages, and the other 6 logged in or used the session. Apply these rules in order:

• If the site offers official agent access, such as signed agents or WebMCP actions, use that access with the agent's signature.
• If the step needs authentication, holds state, or performs an action, use the stealth browser. Confirm you're authorized first, because logging in usually means accepting the site's terms.
• If the step reads a public page and returns content to the model, use a scraping endpoint. Add JavaScript rendering when the page builds its content in the browser.
• If the step discovers pages across a site before deciding what to read, use a crawling endpoint.

For the read-only path, the agent calls the Decodo Web Data API /scrape endpoint. One HTTP call from inside the loop returns the page as Markdown for the model, with JavaScript rendering available per request. Decodo manages the proxies server-side, so the agent sends a URL and reads the result.

For the quotes homepage, the response's Markdown starts like this:

# [Quotes to Scrape](/)

[Login](/login)

“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.” by Albert Einstein [(about)](/author/Albert-Einstein) Tags: [change](/tag/change/page/1/) [deep-thoughts](/tag/deep-thoughts/page/1/) [thinking](/tag/thinking/page/1/) [world](/tag/world/page/1/) “It is our choices, Harry, that show what we truly are, far more than our abilities.” by J.K. Rowling [(about)](/author/J-K-Rowling) …

For the discovery path, the agent calls the /crawl endpoint. The agent sets path filters, receives each matching page's content, and then decides which pages need a browser step. Crawling and scraping differ because discovery and extraction are separate jobs.

Each page fetch is one HTTP request, so fetches can run in parallel. What AI-driven scraping changes and an end-to-end LangChain workflow show the endpoint workflow.

For the browser steps, read how residential IP pools are sourced and routed.

In a test with a Browser-use 0.13.11 agent, gpt-5-mini had to log in to the quotes site and list authors on pages 1 to 3. CloakBrowser ran every browser step, with a 30-step limit:

Final thoughts

CloakBrowser fits agents built on Playwright or Puppeteer, and Camoufox fits targets that check fingerprints closely if your agent can drive Firefox without CDP. Keep undetected-chromedriver for existing Selenium code until you move to nodriver. Each one covers the fingerprint layer, so pair it with clean IPs, because a blocked IP stays blocked after you switch browsers.

The question isn't which stealth browser wins, but how few of your agent's steps need one. Run the harness on your own targets, record each failure's step index, and move read-only steps to a scraping endpoint.