Playwright Stealth Alternative: How Damru Automates Real Android Chrome Without JS Patches

Damru is an open-source Android-native browser automation framework that solves the playwright stealth problem at a lower layer — running genuine Chrome for Android via Redroid instead of patching JavaScript APIs on a desktop browser.

Most developers reaching for a playwright stealth solution are trying to solve the same structural problem: Playwright’s default Chromium fingerprint is trivially detected by modern bot-protection systems. The popular playwright-stealth JavaScript plugin addresses this by patching browser APIs at runtime — overriding navigator.webdriver, spoofing canvas hashes, rewriting WebGL renderer strings. But those very patches are themselves detectable. Damru takes a fundamentally different approach: instead of disguising a desktop browser, it runs a real Android Chrome instance inside Docker via Redroid, then connects Playwright to it over the Chrome DevTools Protocol (CDP).

The result is playwright browser automation backed by an authentic Android fingerprint — no injected scripts, no patched navigator properties, no synthetic canvas noise.

How playwright-stealth Works — and Where It Falls Short

The playwright-stealth plugin (and its Python equivalents) patches dozens of JavaScript properties at page-load time. Covered surfaces typically include navigator.webdriver, navigator.plugins, window.chrome, canvas fingerprints, WebGL renderer strings, audio context fingerprints, and battery API responses. This approach is effective against basic bot detectors.

Advanced systems, however, do not merely inspect property values — they test for the presence of patches. Techniques like cross-comparing navigator.userAgent against the actual TLS/JA3 handshake, detecting timing artifacts introduced by JavaScript property overrides, or checking for inconsistencies between declared screen dimensions and GPU rasterization output can flag a patched desktop browser with high confidence. The core limitation is structural: you are running a non-Android engine and teaching it to lie at the application layer, while the network and system layers remain unmodified desktop signals.

How Damru Solves the Playwright Stealth Problem Below the Browser

Damru eliminates playwright fingerprint detection by running a genuine Android environment — not by patching a desktop browser after the fact.

The execution chain is straightforward:

1. Redroid (Android-in-Docker) starts a full Android system image on your Linux host or cloud VM using KVM hardware virtualization.
2. Chrome for Android launches inside that image — the real APK, on a real Android kernel, with authentic hardware emulation signals, TLS stack, and GPU renderer.
3. Damru establishes a CDP connection from the host to Chrome’s DevTools endpoint exposed by the Redroid container.
4. Your Python script drives the browser with standard async_playwright calls — the same API surface you already know.

Because the browser is genuine Android Chrome, anti-bot systems inspecting at the network layer (JA3/TLS fingerprint), the graphics layer (WebGL renderer, canvas rasterization), or the sensor layer (accelerometer, gyroscope availability) see signals identical to a real Android device. There is no JS patch to detect because no patch exists.

Getting Started with Damru

pip install damru

import asyncio
from damru import AsyncDamru

async def main():
    async with AsyncDamru() as browser:
        page = await browser.new_page()
        await page.goto("https://example.com")
        title = await page.title()
        print(title)
        await page.screenshot(path="screenshot.png")

asyncio.run(main())

AsyncDamru() acts as a context manager: it starts the Redroid container, launches Android Chrome, and wires up the CDP connection. On exit it tears everything down cleanly. You keep the full async_playwright API throughout — page.goto(), page.locator(), page.evaluate(), network interception, and expect() assertions all behave exactly as documented in Playwright.

Full setup guide, Docker prerequisites, and advanced configuration are at github.com/akwin1234/damru.

Damru vs playwright-stealth: Feature Comparison

When to Choose Damru Over the playwright-stealth Plugin

Choose Damru when your target site uses fingerprinting that extends beyond JavaScript-layer inspection.

Damru is the stronger choice for:

• TLS / JA3 fingerprinting — a desktop Chromium TLS handshake is distinct from Android Chrome; Damru sends the Android handshake because it is Android Chrome.
• UA consistency checks — if you declare Mozilla/5.0 (Linux; Android 13; Pixel 7) but your browser fingerprints like desktop Chromium, advanced detectors flag the mismatch. Damru eliminates the mismatch at the source.
• Mobile web QA testing — validate how your application actually renders and behaves in real Android Chrome, not an emulated desktop viewport.
• Fingerprinting research — study how anti-bot systems differentiate mobile from desktop at every signal layer, with a controlled, scriptable Android Chrome instance.

The playwright-stealth plugin remains a valid, low-friction option for scripts targeting sites with basic or purely JavaScript-layer bot detection. For anything more sophisticated, owning the fingerprint at the OS and network level is a structural advantage that patching cannot replicate.

Playwright Browser Automation with a Real Android Fingerprint

Playwright browser automation is the industry standard for scraping, QA, and end-to-end testing. Adding Damru to your stack does not replace Playwright — it replaces the browser underneath it. You retain the complete async_playwright API: page.goto(), page.locator(), page.fill(), page.evaluate(), network request interception, HAR recording, multi-tab management, and the full expect() assertion library.

Because Damru exposes a standard CDP endpoint, any CDP-compatible tool — Playwright, Puppeteer, custom DevTools scripts — can attach to the Android Chrome instance. Damru is a transparent enhancement to existing Playwright workflows.

Explore related Damru use cases:

• Web Scraping with Python and Damru
• Free Open-Source Antidetect Browser Comparison
• Damru on GitHub

Frequently Asked Questions

What is playwright-stealth and why would I look for an alternative? playwright-stealth is a JavaScript plugin that patches browser APIs to hide Playwright’s automation signature from bot detectors. It works well against basic checks, but advanced systems fingerprint the patches themselves. Damru is an alternative that avoids patching entirely by running a real Android Chrome browser, making it significantly harder to detect.

Does Damru work with Python? Yes. pip install damru installs a Python package that wraps async_playwright. You interact with Android Chrome using the same Playwright Python API — no JavaScript or Node.js required for your automation scripts.

Is Damru detectable by anti-bot systems like Cloudflare or DataDome? Damru uses genuine Android Chrome with an authentic fingerprint at every layer — TLS, GPU, UA, sensors. There is no JS patch for detectors to find. How any specific anti-bot vendor classifies traffic evolves continuously; Damru reduces the surface area to near zero by eliminating synthetic signals.

Can Damru run in a headless / server environment? Yes. Damru runs Android Chrome inside a Redroid Docker container on a Linux host. The host itself can be headless (no display required), making it suitable for CI/CD pipelines, cloud VMs, and server deployments.

Is Damru free and open source? Yes. Damru is released under the PolyForm Noncommercial 1.0.0 license — free for personal, educational, and noncommercial use; commercial use requires a separate license. Source code, documentation, and issue tracking are at github.com/akwin1234/damru.