Damru
♥ Donate ★ GitHub

Damru: The Open-Source Antidetect Browser for Android (2026)

Damru is a free, open-source framework that delivers genuine Android browser sessions — using Redroid (Android-in-Docker), Playwright, and the Chrome DevTools Protocol — making it the only antidetect browser automation tool for Android that produces native mobile fingerprints without a physical device.

Most antidetect browsers target desktop environments. They modify Chromium or Firefox to randomize or spoof desktop-origin fingerprints: user agent strings, canvas hashes, WebGL parameters, font sets, screen resolution. That approach works for desktop-targeted detection. Android browser automation is a different problem entirely.

A real Android browser running on ARM hardware produces a fingerprint profile that is structurally distinct from any desktop browser session — even one convincingly spoofed to appear mobile. When detection logic cross-correlates platform identifiers, GPU renderer strings, touch event stack behavior, HTTP client hints, and system APIs, desktop-origin signals are inconsistent with each other in ways that reveal the deception.

Damru solves this by running the actual Chrome for Android APK inside Redroid — a containerized Android environment — and driving it programmatically through Playwright + CDP. The fingerprint is not simulated. It comes from a genuine Android operating system.

What Is an Antidetect Browser and Why Does the Android Gap Exist?

An antidetect browser is a browser environment engineered to isolate, authenticate, or randomize its fingerprint so that automated sessions resist identification by bot-detection systems.

Commercial antidetect browsers — Multilogin, GoLogin, AdsPower, Dolphin Anty — are purpose-built for multi-account desktop workflows. They isolate Chromium profiles, randomize canvas and WebGL values, and manage cookies per session. They are effective on desktop. They do not run Android Chrome natively. When they claim Android support, they are injecting Android-looking values into a desktop Chromium process — a fundamentally different operation.

The Android gap manifests in these concrete fingerprint signals:

Damru closes this gap by running a real Android OS and a real Android browser, not by injecting overrides into a desktop process.

Damru’s Architecture: Why It Differs from Desktop Antidetect Tools

LayerComponentWhat It Provides
OS RuntimeRedroid (AOSP-in-Docker)Full Android system: Binder IPC, SurfaceFlinger, Android framework services, GPU passthrough via KVM
BrowserChrome for Android APKReal Android Chrome — native platform APIs, ARM WebGL, genuine Sec-CH-UA headers
Automation LayerPlaywright + CDPPython async control: navigation, DOM interaction, network interception, JS evaluation, screenshots
Host InfrastructureLinux + Docker + KVMHardware virtualization enabling the Android kernel inside a container

Every fingerprint signal Damru emits originates from this genuine Android stack — not from a JavaScript hook or a header override applied to a desktop process.

Damru vs Commercial Antidetect Browsers for Android Use Cases

CapabilityDamruCommercial Antidetect Browsers
CostFree (open-source)Paid subscription ($30–$300+/month)
Android fingerprint authenticity✅ Native Android runtime⚠️ Desktop Chromium + injected Android values
ARM WebGL renderer strings✅ Real (Adreno / Mali)❌ Desktop GPU renderer (Intel / NVIDIA)
Native touch and sensor APIs✅ Android OS level❌ Simulated or shimmed
Sec-CH-UA-Platform: Android✅ Native HTTP header⚠️ May be overridden at header level only
Programmable Python automation✅ Playwright async API⚠️ Primarily GUI-focused; scripting varies
Self-hosted, no vendor dependency✅ Fully self-hosted❌ Cloud/subscription dependency
Primary use caseAutomation, QA, fingerprint researchMulti-account desktop session management

Getting Started with Damru

Install Damru:

pip install damru

Minimal AsyncDamru session — with a platform check to confirm Android origin:

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")
        # Returns a genuine Android platform string, not a JS override
        platform = await page.evaluate("navigator.platform")
        touch_support = await page.evaluate("'ontouchstart' in window")
        print(f"Platform: {platform}")
        print(f"Touch support: {touch_support}")
        print(f"Title: {await page.title()}")

asyncio.run(main())

navigator.platform in this example returns a genuine Android value because the session runs on a real Android OS, not a desktop Chrome process with injected values. Full setup documentation: github.com/akwin1234/damru.

Use Cases: Where Android Browser Automation Genuinely Matters

Mobile QA and Regression Testing

Development teams shipping mobile web applications need browser sessions that faithfully represent what real Android users experience. Damru provides reproducible, headless Android Chrome sessions for CI/CD pipelines — ensuring that touch event handlers, viewport-specific CSS layouts, mobile-only JavaScript APIs, and responsive UI components are validated against a genuine Android runtime, not a desktop browser resized to a mobile viewport.

Anti-Bot and Fingerprinting Research

Security researchers and detection engineers studying mobile anti-bot systems need to understand precisely which signals Android browsers emit and how they differ from desktop sessions. Damru enables systematic fingerprint auditing — capturing, comparing, and stress-testing the full mobile signal set in a controlled, reproducible environment without maintaining a physical device fleet.

Web Scraping with Genuine Android Browser Sessions

Some sites deliver different content, enforce different rate limits, or apply different bot-detection policies to mobile versus desktop traffic. Damru enables scraping those targets with a session that passes mobile-detection checks authentically — not by injecting a mobile user agent string, but by actually running a mobile browser.

FAQ: Antidetect Browser for Android

Q: Does Damru work as a mobile antidetect browser for multi-account profile management? No — Damru is an automation framework, not a GUI multi-account management tool. It is designed for programmatic Android browser sessions in automated pipelines (QA, scraping research, fingerprint analysis). Commercial antidetect browsers like GoLogin or AdsPower serve the manual profile-switching workflow; Damru serves developers and researchers who need a programmable mobile browser environment.

Q: Can Damru run multiple independent Android browser sessions simultaneously? Yes. Multiple AsyncDamru contexts can be instantiated and run concurrently within the same Redroid environment, each representing an isolated Android Chrome session. The practical limit is determined by host machine resources (CPU, RAM, GPU VRAM for display rendering). You can manage that pool of workers — and watch any session live — from the Damru instance manager.

Q: How is Damru different from a standard Android emulator like Android Studio AVD? Android Virtual Device (AVD) uses QEMU-based full hardware emulation — accurate but heavyweight and slow to start. Redroid, which Damru uses, is a container-based Android environment: faster startup, lower memory overhead, better suited to headless automation. Damru adds the Playwright + CDP control layer that AVD does not provide.

Q: Is Damru legal to use for web scraping and fingerprinting research? Damru is a neutral automation tool. Legality depends on the target site’s terms of service, the type of data collected, and the laws applicable in your jurisdiction. Always review the target’s terms and consult applicable law before conducting scraping or fingerprinting research.

Q: Does Damru support proxy routing for isolated Android sessions? Proxy integration is available through Playwright’s network configuration APIs and Redroid’s network stack. Refer to the Damru GitHub repository for current proxy setup documentation and configuration examples.