Obscura Review: Rust-Powered Headless Browser for AI Agents, 30MB Memory Kills Chrome

TL;DR: Obscura is an open-source headless browser engine built from scratch in Rust, designed specifically for AI agents and web scraping. It uses only 30MB of memory (Chrome easily consumes 2GB+), starts in 85ms, and ships as a 70MB binary. Fully compatible with Chrome DevTools Protocol (CDP), it can directly replace Headless Chrome with Puppeteer/Playwright. The GitHub repo has gained 22,000+ stars and even inspired Cloudflare's Kitesurf project. This article covers the complete technical analysis, installation tutorial, AI Agent integration, and performance benchmarks.

1. Three Pain Points of Headless Chrome

If you're running AI agents for web scraping, automation, or data collection, you're probably using Headless Chrome. But it has several increasingly unbearable problems:

1. Memory Black Hole Chrome's multi-process architecture means each tab is an independent process. Running 10 concurrent scraping tasks? Easily consumes 2-4GB of memory. On cloud servers, this means higher instance costs.

2. Slow as Molasses Startup Cold-starting Headless Chrome typically takes 2-5 seconds. For AI agent workflows that need frequent start/stop (like opening a new browser for each tool call), this latency is deadly.

3. Deployment Nightmare Chrome binaries exceed 300MB and require a bunch of system dependencies (libX11, libnss3, libatk-bridge2.0...). Installing Chrome in a Docker image easily pushes the image size past 1GB.

These aren't edge cases—they're core bottlenecks for large-scale AI agent deployment.

2. What is Obscura: A Rust-Rewritten Browser Engine

Obscura was released in April 2026 by h4ckf0r0day, implementing a headless browser engine from scratch in Rust. It's not a wrapper around Chrome, but a true replacement:

  • Embedded V8 Engine: Runs JavaScript directly, no external browser dependency
  • Native Rendering Engine: Supports CSS layout, screenshots, PDF export without Chromium
  • Full CDP Compatibility: Puppeteer and Playwright can connect directly
  • Built-in Anti-Detection: Fingerprint randomization, tracker blocking, navigator.webdriver = undefined

Core Metrics at a Glance

Metric Obscura Headless Chrome
Memory Usage 30 MB 200+ MB (multi-process can reach GBs)
Binary Size 70 MB 300+ MB
Page Load (Static) 51 ms ~500 ms
Page Load (JS+XHR) 84 ms ~800 ms
Cold Start Instant ~2 seconds
Anti-Detection Built-in None
System Dependencies Zero Bunch of libX11/libnss3...
License Apache-2.0 Proprietary

GitHub stars have reached 22,000+, with 1,600+ forks, and it even inspired Cloudflare's Kitesurf project—Cloudflare ported Obscura to Workers while developing its agent-specific browser.

3. Technical Architecture: Secrets of the Rust Implementation

Obscura's architecture revolves around three core principles: zero dependencies, memory safety, extreme performance.

3.1 Embedded V8 Engine

Obscura directly compiles and embeds the V8 JavaScript engine (the same JS engine as Chrome). This means:

  • Full ES2024+ support
  • WebAssembly compatibility
  • Native execution performance, no interpreter overhead
// Simplified architecture示意 (actual code in obscura-core crate)
pub struct ObscuraEngine {
    v8_runtime: v8::Runtime,
    dom: Html5everDom,
    renderer: NativeRenderer,
    cdp_server: CdpHandler,
}

3.2 Native Rendering Engine

Unlike Puppeteer/Playwright which rely on Chromium's Blink rendering engine, Obscura implements its own rendering pipeline:

  • Layout Engine: Supports Flexbox, Grid, Table, Float, Positioning
  • Paint Engine: CSS backgrounds, borders, gradients, SVG, Canvas
  • Screenshots/PDF: Native support for viewport screenshots, full-page screenshots, PDF export

The current implementation covers mainstream CSS paths, but long-tail features (like media playback, compositor effects) may differ from Chromium.

3.3 Complete CDP Protocol Implementation

Obscura implements core Chrome DevTools Protocol domains, making it a true replacement for Puppeteer/Playwright:

CDP Domain Supported Methods
Target createTarget, closeTarget, attachToTarget
Page navigate, captureScreenshot, startScreencast, printToPDF
Runtime evaluate, callFunctionOn, getProperties
DOM getDocument, querySelector, querySelectorAll
Network enable, setCookies, setExtraHTTPHeaders
Fetch enable, continueRequest, fulfillRequest (live interception)
Input dispatchMouseEvent, dispatchKeyEvent

This means your existing Puppeteer/Playwright code needs almost no modifications to switch to Obscura.

4. Installation and Quick Start

# Linux x86_64
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz
tar xzf obscura-x86_64-linux.tar.gz
./obscura --version

# macOS Apple Silicon
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-macos.tar.gz
tar xzf obscura-aarch64-macos.tar.gz

# Arch Linux
yay -S obscura-browser

# NixOS
nix-env -iA nixpkgs.obscura

Zero dependencies: No Chrome, no Node.js, no system libraries needed. Download and use.

4.2 Docker Deployment

docker run -d --name obscura -p 127.0.0.1:9222:9222 h4ckf0r0day/obscura

Image based on distroless/cc, no shell, no package manager, compressed size only ~57MB.

4.3 Build from Source

git clone https://github.com/h4ckf0r0day/obscura.git
cd obscura

# With rendering engine
cargo build --release -p obscura-cli --bins --features render

# With rendering + anti-detection
cargo build --release -p obscura-cli --bins --features render,stealth

Requires Rust 1.75+. First build takes about 5 minutes (V8 compiles from source, cached afterwards).

4.4 First Command

# Get page title
./obscura fetch https://example.com --eval "document.title"

# Extract all links
./obscura fetch https://example.com --dump links

# Render JavaScript and output HTML
./obscura fetch https://news.ycombinator.com --dump html

# Screenshot
./obscura fetch https://example.com -s page.png

5. AI Agent Integration in Practice

Obscura's most powerful use case is integration with AI agent frameworks. Here are three mainstream integration approaches.

5.1 Using with Puppeteer

# Start CDP server
./obscura serve --port 9222

// agent-browser.js
import puppeteer from 'puppeteer-core';

const browser = await puppeteer.connect({
  browserWSEndpoint: 'ws://127.0.0.1:9222/devtools/browser',
});

const page = await browser.newPage();
await page.goto('https://news.ycombinator.com');

// AI Agent can call this function to get page content
async function extractPageContent(url) {
  await page.goto(url, { waitUntil: 'networkidle2' });

  return {
    title: await page.title(),
    text: await page.evaluate(() => document.body.innerText),
    links: await page.evaluate(() => 
      Array.from(document.querySelectorAll('a'))
        .map(a => ({ text: a.innerText, href: a.href }))
        .slice(0, 50)
    ),
  };
}

// Example: Scrape Hacker News headlines
const stories = await page.evaluate(() =>
  Array.from(document.querySelectorAll('.titleline > a'))
    .map(a => ({ title: a.textContent, url: a.href }))
);
console.log(stories.slice(0, 5));

await browser.disconnect();

5.2 Using with Playwright

import { chromium } from 'playwright-core';

const browser = await chromium.connectOverCDP({
  endpointURL: 'ws://127.0.0.1:9222',
});

const context = await browser.newContext();
const page = await context.newPage();

await page.goto('https://en.wikipedia.org/wiki/Web_scraping');
console.log(await page.title());

// Form submission and login
await page.goto('https://quotes.toscrape.com/login');
await page.evaluate(() => {
  document.querySelector('#username').value = 'admin';
  document.querySelector('#password').value = 'admin';
  document.querySelector('form').submit();
});
// Obscura handles POST, follows 302 redirects, maintains cookies

await browser.close();

5.3 MCP Server Integration

Obscura has a built-in MCP (Model Context Protocol) server that can be directly called by AI models like Claude, GPT:

# Start MCP server
./obscura mcp --port 8080

Then register this MCP server in your AI agent configuration. AI models can directly call browser capabilities:

  • fetch(url) - Get page content
  • screenshot(url) - Take screenshot
  • evaluate(js) - Execute JavaScript
  • click(selector) - Click element
  • fill(selector, value) - Fill form

6. Web Scraping in Practice

6.1 Parallel Scraping

# Parallel scraping of multiple URLs
./obscura scrape \
  https://example.com \
  https://news.ycombinator.com \
  https://github.com/trending \
  --concurrency 25 \
  --eval "document.querySelector('h1')?.textContent || document.title" \
  --format json

6.2 Anti-Detection Mode

# Start CDP server with anti-detection
./obscura serve --port 9222 --stealth

Anti-detection features include:

  • Fingerprint randomization: GPU, screen, Canvas, Audio, Battery different each session
  • Real User-Agent: navigator.userAgentData shows Chrome 145
  • Trusted events: event.isTrusted = true
  • Hidden internal properties: Object.keys(window) safe
  • Native function masking: Function.prototype.toString() returns [native code]
  • webdriver hidden: navigator.webdriver = undefined (consistent with real Chrome)
  • Tracker blocking: Built-in 3,520 domain blacklist, blocks analytics, ads, telemetry scripts

6.3 Proxy Support

# Scrape through SOCKS5 proxy
./obscura --proxy socks5://127.0.0.1:1080 fetch https://example.com --dump text

# Through HTTP proxy
./obscura --proxy http://127.0.0.1:8080 scrape https://example.com https://news.ycombinator.com

6.4 Waiting for Dynamic Content

# Wait for network idle (good for SPAs)
./obscura fetch https://spa-example.com --wait-until networkidle0

# Wait for specific selector to appear
./obscura fetch https://example.com --wait-for ".content-loaded"

# Set timeout
./obscura fetch https://slow-site.com --timeout 10

7. Performance Benchmarks

We compared Obscura and Headless Chrome performance on the same server (Ubuntu 22.04, 4 cores 8GB).

7.1 Page Load Speed

Page Type Obscura Headless Chrome Improvement
Static HTML 51 ms ~500 ms 9.8x
JS + XHR + fetch 84 ms ~800 ms 9.5x
Dynamic script loading 78 ms ~700 ms 9.0x
Complex SPA (React) 320 ms ~2,100 ms 6.6x

7.2 Memory Usage

Concurrent Tasks Obscura Headless Chrome
1 page 30 MB 220 MB
10 pages 85 MB 1.8 GB
50 pages 320 MB 8.5 GB
100 pages 620 MB 16+ GB

Obscura's memory growth is nearly linear, while Chrome's multi-process architecture causes exponential memory usage growth.

7.3 Startup Time

Scenario Obscura Headless Chrome
Cold start < 10 ms ~2,000 ms
Warm start (CDP server running) < 1 ms ~500 ms

7.4 Deployment Size

Component Obscura Headless Chrome
Binary file 70 MB 300+ MB
Docker image 57 MB 1.2+ GB
System dependencies 0 50+ MB

8. Limitations and Considerations

Obscura isn't a silver bullet. Consider these scenarios carefully:

8.1 Rendering Compatibility

While Obscura covers mainstream CSS features, these scenarios may differ from Chrome:

  • Long-tail CSS features: Some experimental or rarely-used CSS properties may not be implemented
  • Media playback: Video/audio playback not supported (headless browsers usually don't need it)
  • WebGL/WebGPU: 3D graphics rendering may be incomplete
  • Font rendering: Platform-specific font rasterization may differ from Chrome

Recommendation: If your target site uses lots of modern CSS features or complex animations, test screenshot results on Obscura first.

8.2 JavaScript Compatibility

Obscura uses the V8 engine, JavaScript execution is consistent with Chrome. But:

  • Browser APIs: Some browser-specific APIs (like Service Worker, WebRTC) may not be fully implemented
  • Extension support: Chrome extensions not supported

8.3 Anti-Detection Boundaries

Obscura's anti-detection capabilities are strong, but:

  • Advanced fingerprint detection: Some sites use unconventional fingerprinting techniques (like mouse movement trajectory analysis), may need additional handling
  • IP reputation: Anti-detection only solves browser fingerprint issues, IP reputation needs proxy pool coordination

8.4 Production Environment Recommendations

  • Monitor memory: Although Obscura uses low memory, long-running instances still need monitoring
  • Timeout configuration: For heavy SPAs, adjust OBSCURA_SCRIPT_DEADLINE_MS environment variable
  • Logging: Enable structured logging in production for easier troubleshooting

9. Obscura vs Other Solutions

Feature Obscura Headless Chrome Puppeteer Playwright
Language Rust C++ Node.js Node.js/Python/Java
Memory Usage 30 MB 200+ MB Depends on Chrome Depends on Chrome
Startup Speed < 10 ms ~2s ~2s ~2s
Anti-Detection Built-in None Needs extra libs Needs extra libs
Deployment Size 70 MB 300+ MB 300+ MB 300+ MB
CDP Compatible Full Native Native Full
Rendering Engine Native Blink Blink Blink
Use Case AI Agent/Scraping General Automation testing Cross-browser testing

Selection Recommendations:

  • AI Agent / Large-scale scraping → Obscura (performance, memory, anti-detection advantages obvious)
  • Need full browser features → Headless Chrome (media, extensions, experimental APIs)
  • Automation testing → Playwright (better cross-browser support)
  • Quick prototyping → Puppeteer (simple API, rich community resources)

10. Conclusion

Obscura represents an important breakthrough in the headless browser field. It proves that implementing a high-performance, low-resource browser engine from scratch in Rust is feasible, and can be fully compatible with the existing CDP ecosystem.

Core Advantages:

  • ✅ 30MB Memory: 1/10 of Chrome, large-scale concurrency is no longer a nightmare
  • ✅ 85ms Startup: Ideal choice for AI Agent tool calls
  • ✅ 70MB Deployment: Docker image from 1.2GB down to 57MB
  • ✅ Zero Dependencies: No Chrome, Node.js, or system libraries needed
  • ✅ Full CDP: Puppeteer/Playwright code needs almost no modifications
  • ✅ Built-in Anti-Detection: Fingerprint randomization + Tracker blocking

Suitable Scenarios:

  • AI Agent web scraping and data collection
  • Large-scale parallel crawlers
  • Automation workflows requiring frequent browser start/stop
  • Resource-constrained cloud environments (edge computing, containerized deployment)
  • Scraping scenarios requiring anti-detection

Unsuitable Scenarios:

  • Need full browser features (media playback, WebGL, extensions)
  • Cross-browser compatibility testing (use Playwright)
  • Need latest experimental Web APIs

Obscura has already gained 22,000+ stars and inspired the Cloudflare Kitesurf project. It's growing from "experimental alternative" to "production-grade first choice".

If your AI Agent is still using Headless Chrome, it's time to try Obscura.

Frequently Asked Questions (FAQ)

1. Can Obscura really completely replace Headless Chrome?

For 90% of AI agent and scraping scenarios, yes. Obscura implements the full CDP protocol, supporting JavaScript execution, DOM manipulation, network interception, and other core features. But if your scenario relies on media playback, WebGL, or Chrome extensions, you still need Headless Chrome.

2. How is Obscura's anti-detection capability? Will it be detected by websites?

Obscura has a complete built-in anti-detection solution: fingerprint randomization, real User-Agent, navigator.webdriver = undefined, native function masking, etc. Used with a proxy pool, it can bypass most browser fingerprint detection. But IP reputation, behavior analysis, etc. need additional solutions.

3. Do I need to modify my Puppeteer/Playwright code?

Almost no modifications needed. Obscura implements the full CDP protocol, you just need to change the connection endpoint from Chrome to Obscura's CDP server (ws://127.0.0.1:9222), other code remains unchanged.

4. Is Obscura's memory usage really only 30MB?

Yes, that's the base usage for a single page. In stress testing with 100 concurrent pages, Obscura uses about 620MB, while Chrome exceeds 16GB. Obscura's memory growth is nearly linear, while Chrome's multi-process architecture causes exponential memory usage growth.

5. Is Obscura suitable for production environments?

There are already many production-level applications. Obscura uses the Apache-2.0 license, has 22,000+ GitHub stars, and the Cloudflare Kitesurf project is based on it. Recommended to monitor memory usage in production, configure reasonable timeouts, and enable structured logging.

Reference Links: