CloakBrowser: The Chromium Fork That Scores 0.9 on reCAPTCHA (and Why AI Agents Need It)

Let me paint you a picture.

You've got a perfectly good browser automation script. It logs in, navigates a few pages, extracts some data. Then Cloudflare hits you with a Turnstile challenge. Or Google's reCAPTCHA scores you at 0.1 — straight-up bot. Halfway through the run, everything grinds to a halt.

We've all been there. And for the longest time, the playbook was: add playwright-stealth, inject some JS overrides, cross your fingers, and hope the next Chrome update doesn't break everything.

CloakBrowser takes a completely different approach. Instead of patching things at the JavaScript layer — which anti-bot systems have gotten very good at detecting — it modifies Chromium at the C++ source level, then compiles it into a binary.

Twenty-two thousand GitHub stars later, it's clear this resonates.

What It Actually Does

At the heart of every browser automation framework — Playwright, Puppeteer, Selenium — is a flag: navigator.webdriver. When an automation script controls the browser, this property reads true. Anti-bot systems check it, among dozens of other signals.

CloakBrowser hardcodes it to false. At the C++ layer. Before compilation.

That's one change. There are 57 more:

The anti-bot system sees a normal browser. Because it is a normal browser — just with modified underlying data.

The Numbers That Matter

I ran the benchmarks. Here's what you care about:

Google reCAPTCHA v3 score of 0.9 is human-level. Server-side verified. The same script, same logic, same selectors — just swap the browser binary — and you go from immediate rejection to flying under the radar.

The humanize Switch

Fingerprint evasion is only half the battle. Behavioral analysis is the other half.

A bot moves the mouse in straight lines. A human's mousepath curves, overshoots slightly, decelerates near targets. Bots type instantly. Humans have inter-key delays.

CloakBrowser's humanize=True flag handles all three input dimensions:

• Mouse: Bézier-curve paths with natural jitter and deceleration on approach
• Keyboard: Per-character timing with human-like "thinking pauses"
• Scroll: Acceleration → constant speed → deceleration rhythm

This isn't a heuristic wrapper. The original Playwright mouse, keyboard, and scroll APIs are completely replaced when humanize is on.

Drop-In Installation

This is where CloakBrowser really shines. It's designed as a drop-in replacement.

# Python
pip install cloakbrowser

# Node.js
npm install cloakbrowser

First run downloads a ~200MB Chromium binary (cross-platform: Linux, macOS x64/arm64, Windows x64) and caches it locally. After that, it's instant.

The API is identical to Playwright:

from cloakbrowser import sync_api

browser = sync_api.launch(humanize=True)
page = browser.new_page()
page.goto("https://www.google.com/recaptcha/api2/demo")
# reCAPTCHA score: 0.9 — human

Three lines. That's it.

Why This Matters for AI Agents

CloakBrowser's timing couldn't be better. AI Agents are racing into production, and the browser is their primary entry point — booking flights, running automated tests, scraping data for model training. Every single action goes through the browser.

The problem? Most websites treat AI-driven browsers as bots and slam the door.

This is where CloakBrowser fills a critical gap. It already integrates with the major AI Agent frameworks:

• browser-use (70K+ stars) — the go-to for agentic browser automation
• Crawl4AI (58K+ stars) — LLM-friendly web crawling
• LangChain (100K+ stars) — the largest AI agent framework
• Crawlee, Scrapling, Stagehand, Selenium — all supported

CloakBrowser also ships a Browser Profile Manager as a self-hosted alternative to commercial anti-detect browsers like Multilogin, GoLogin, and AdsPower. Each profile gets its own persistent fingerprint seed, cookies, and storage.

For deployment, there's a pre-built Docker image, Docker Compose support, and an AWS Lambda container recipe.

The Competition

The single biggest differentiator: CloakBrowser patches at the C++ source level of Chromium, then compiles. JS-injection-based approaches (playwright-stealth, undetected-chromedriver) break every time Chrome pushes an update. Camoufox patches Firefox at C++ level but isn't Chromium, which matters for sites optimized for Chrome's rendering engine.

Caveats

A few things to keep in mind:

• Binary licensing: The Python/JS wrapper is MIT, but the binary itself has restrictions — free to use, no redistribution
• Binary size: First download is ~200MB. Cached after that
• Not a silver bullet: Sophisticated anti-bot services (DataDome, Akamai, PerimeterX) continuously evolve. CloakBrowser wins the current round, but it's an arms race
• Windows first-run: May trigger SmartScreen. The binary is digitally signed, but the auto-download pattern can flag

The Bottom Line

CloakBrowser represents a shift in how we think about browser automation. Instead of layering JavaScript hacks on top of a stock browser, it goes to the source — literally — and builds a browser that was never designed to be detectable in the first place.

For AI Agents that need to interact with the real web — the one with Cloudflare challenges and reCAPTCHA walls — this is rapidly becoming essential infrastructure.

22K stars in a few months says the community agrees.

GitHub: github.com/CloakHQ/CloakBrowser
Docs: cloakbrowser.com

What's your go-to solution for bypassing anti-bot detection? Drop a comment — curious what's working for everyone in 2026.