What Is Obscura? The Rust Headless Browser for AI Agents

TL;DR:

• Obscura is an open-source headless browser engine written in Rust, licensed Apache-2.0, that runs real JavaScript through V8 and speaks the Chrome DevTools Protocol — so Puppeteer and Playwright scripts connect to it the same way they connect to headless Chrome.
• Obscura's published benchmarks report roughly 30 MB of memory per instance against 200+ MB for headless Chrome, with a smaller binary and near-instant startup — the reason it crossed 10,000 GitHub stars shortly after launch.
• You connect over a single WebSocket endpoint: start obscura serve --port 9222, then point puppeteer.connect or Playwright's connectOverCDP at ws://127.0.0.1:9222.
• The engine is only half of a scraping stack. Obscura gives you rendering and built-in stealth, but you still operate the servers, supply proxy egress, and handle challenge pages yourself — the parts that decide whether requests succeed at scale.
• Scrapeless Scraping Browser covers that operational half: the same Puppeteer connect workflow, but the session comes from a managed cloud browser with residential proxies in 195+ countries and anti-detection built in — no server to run.
• Free to start. New Scrapeless accounts include free Scraping Browser runtime — sign up at app.scrapeless.com.

Introduction: a headless browser small enough to give every agent its own

AI agents and scraping pipelines now spin up browsers the way earlier systems spun up threads — dozens or hundreds at a time, each one rendering JavaScript before a single byte of useful data comes back. Headless Chrome was never designed for that shape of workload: each instance carries the memory footprint of a desktop browser, and fleets of them get expensive fast.

Obscura is a new answer to that mismatch. It is a headless browser engine written in Rust that executes real JavaScript via the V8 engine and exposes the Chrome DevTools Protocol, which makes it a drop-in target for the Puppeteer and Playwright scripts teams already have. The project is open source under the Apache-2.0 license and passed 10,000 GitHub stars shortly after launch.

This guide walks through what Obscura is, how to install it, how to connect Puppeteer and Playwright to it, and — just as important — where a self-hosted engine stops and a managed cloud browser takes over.

What is Obscura?

Obscura is a lightweight, open-source headless browser engine built in Rust for web scraping and AI-agent automation. Instead of embedding a full desktop browser, it implements the rendering and protocol surface automation actually uses: a JavaScript runtime (V8), page loading, DOM access, and the Chrome DevTools Protocol for remote control.

Three design choices define it:

• Rust core, V8 execution. The engine itself is native Rust; page JavaScript runs in V8, so client-rendered sites behave the way they do in Chrome rather than the way they do in a JS-less HTTP client.
• CDP compatibility. Because Obscura speaks the DevTools Protocol, existing Puppeteer and Playwright code targets it without a rewrite — you change the connection line, not the script.
• Automation-first footprint. The project's published benchmarks report about 30 MB of memory per instance versus 200+ MB for headless Chrome, a ~70 MB binary versus 300+ MB, and page loads plus startup times measured in milliseconds rather than seconds. Those are the project's own figures — the honest takeaway is the order of magnitude, which is what matters when you run browsers per-agent instead of per-machine.

Obscura also ships anti-detection behavior as a built-in rather than a plugin, which headless Chrome does not. The team is building a hosted version, Obscura Cloud, which is waitlist-only as of publication — so running Obscura today means self-hosting it.

Install Obscura

Prebuilt binaries cover Linux (x86_64 and aarch64), macOS, and Windows. On Linux x86_64:

# Download the latest release tarball and unpack it
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz
tar xzf obscura-x86_64-linux.tar.gz

# The archive contains two binaries that must stay in the same directory:
# obscura (the CLI/server) and obscura-worker (the render process)
./obscura --version

Linux builds require glibc 2.35 or newer (Ubuntu 22.04+). If you prefer containers, the official image is a distroless build around 57 MB compressed:

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

A quick smoke test that exercises the full render path — fetch a page and evaluate JavaScript against it:

./obscura fetch https://example.com --eval "document.title"
# "Example Domain"

Connect Puppeteer or Playwright

Start Obscura as a CDP server:

obscura serve --port 9222

It listens on ws://127.0.0.1:9222. From Puppeteer, install puppeteer-core (the connect-only package — you do not want the bundled Chromium download) and connect:

import puppeteer from 'puppeteer-core';

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

const page = await browser.newPage();
await page.goto('https://example.com');
console.log(await page.title());

await browser.disconnect();

From Playwright, the equivalent is connectOverCDP. The distinction matters: Playwright's connectOverCDP speaks the DevTools Protocol, while plain connect speaks Playwright's own protocol, which Obscura does not implement.

import { chromium } from 'playwright';

const browser = await chromium.connectOverCDP('ws://127.0.0.1:9222');
const context = browser.contexts()[0] || await browser.newContext();
const page = await context.newPage();

await page.goto('https://example.com');
console.log(await page.title());

await browser.close();

That is the whole integration. Any script built on page.goto, selectors, and page.evaluate now runs against a browser engine an order of magnitude lighter than the one it was written for.

Get your API key on the free plan: app.scrapeless.com

Where Obscura stops

Obscura solves the engine problem — rendering JavaScript cheaply, at fleet scale, with stealth characteristics baked in. It deliberately does not solve the operations problem, and for production scraping the operations problem is usually the harder one:

• You run the infrastructure. Obscura is a binary (or container) you deploy, monitor, patch, and scale. A hundred concurrent sessions means capacity planning and an orchestration layer you own.
• Egress is yours to supply. Every request leaves from your server's IP. Sites that rate-limit or block datacenter ranges will do so regardless of how convincing the browser fingerprint is — Obscura's own ecosystem points users at third-party proxy providers for exactly this reason. Rotating residential egress is a separate product you must buy and wire in.
• Challenge pages are your problem. A stealthy engine reduces how often traffic-validation interstitials appear; it does not resolve the ones that do. Handling them means additional tooling and per-site work.
• The managed option is not shipping yet. Obscura Cloud — the hosted version with managed infrastructure and residential proxies — is waitlist-only as of publication. Today, adopting Obscura means adopting all of the above.

None of this is a criticism; it is the standard shape of a self-hosted engine. It just means the comparison worth making is not "Obscura versus headless Chrome" — Obscura wins that one comfortably — but "self-hosted engine versus managed cloud browser."

The managed path: Scrapeless Scraping Browser

Scrapeless Scraping Browser is a customizable, anti-detection cloud browser designed for web crawlers and AI agents. It occupies the same slot in your code that Obscura does — a CDP endpoint Puppeteer connects to — but the session is created in Scrapeless's cloud with the operational half already handled:

• Residential proxies in 195+ countries, selected per session with a proxy_country parameter — no separate proxy contract.
• Cloud-side JavaScript rendering on anti-detection browser infrastructure powered by self-developed Chromium.
• Session persistence for login-gated and multi-step flows.
• No servers to run — sessions are minted by API and expire on a TTL you set.

The workflow mirrors the Obscura one exactly: the Scrapeless SDK mints a session, and Puppeteer connects to the WebSocket endpoint it returns:

import { Scrapeless } from '@scrapeless-ai/sdk';
import puppeteer from 'puppeteer-core';

const client = new Scrapeless({ apiKey: process.env.SCRAPELESS_API_KEY });

// Mint a cloud browser session with US residential egress
const session = await client.browser.create({
  session_name: 'obscura-guide-demo',
  session_ttl: 180,
  proxy_country: 'US',
});

// Same connect call you used for Obscura — only the endpoint changes
const browser = await puppeteer.connect({
  browserWSEndpoint: session.browserWSEndpoint,
  defaultViewport: null,
});

const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
console.log(await page.title()); // "Example Domain"

await browser.close();

Because both sides are plain CDP, the two compose naturally: Obscura for high-volume rendering of sites that do not resist automation, Scrapeless Scraping Browser for the targets where egress quality and challenge handling decide the outcome. Pricing is usage-based, and the free plan is enough to run everything in this guide. For a deeper look at proxy wiring in this ecosystem, the Puppeteer undetected fingerprint browser guide shows the same session-minting workflow pointed at detection-heavy targets.

How to choose

If your workload is thousands of lightweight renders of sites that do not fight back, Obscura's footprint is a genuine advantage and the self-hosting cost is low. If the data you need lives behind rate limits, geo walls, or traffic validation, the engine was never the bottleneck — the session quality was, and that is the managed side's job.

Conclusion: the engine and the operation

Obscura is a real engineering achievement: a Rust headless browser with V8 execution and CDP compatibility that makes per-agent browsers economically sane, open source under Apache-2.0. Install it, point puppeteer-core at ws://127.0.0.1:9222, and existing automation just works — that part of the promise holds.

Treat it as the engine layer, and be clear-eyed that production scraping also has an operations layer: proxy egress, challenge handling, and fleet infrastructure. Scrapeless Scraping Browser supplies that layer through the identical puppeteer.connect workflow, so the two are an easy pairing rather than a hard choice — render cheap where you can, and route through the cloud browser where the target demands it.

Ready to Build Your AI-Powered Data Pipeline?

Join our community to claim a free plan and connect with developers building browser-automation pipelines: Discord · Telegram.

Sign up at app.scrapeless.com for free Scraping Browser runtime and pair it with the patterns above wherever your targets push back.

FAQ

Q: Is Obscura a fork of Chromium?
No. Obscura is an independent headless browser engine written in Rust. It embeds V8 for JavaScript execution and implements the Chrome DevTools Protocol for compatibility, but the engine itself is not Chromium.

Q: Does my existing Puppeteer or Playwright code work with Obscura?
Largely yes, because the integration surface is CDP. Puppeteer connects via puppeteer.connect({ browserWSEndpoint }) using puppeteer-core; Playwright must use connectOverCDP, not connect, because Obscura does not implement Playwright's native protocol. As a young engine, feature coverage is still maturing — test your specific script rather than assuming full parity with Chrome.

Q: Is Obscura free to use?
Yes. The engine is open source under the Apache-2.0 license with no feature gating. The hosted Obscura Cloud offering is a separate, waitlist-only product.

Q: Do I still need proxies if Obscura has anti-detection built in?
Yes, for any site that filters by IP. Fingerprint stealth and egress quality are independent problems: a convincing browser identity does not help when the request arrives from a flagged address range. Self-hosted Obscura leaves egress to you; Scrapeless Scraping Browser includes residential proxies in 195+ countries per session.

Q: Can Obscura and Scrapeless Scraping Browser be used in the same project?
Yes, and it is a natural split. Both expose CDP endpoints, so one Puppeteer codebase can route cooperative, high-volume targets to a local Obscura instance and protected or geo-specific targets to a Scrapeless cloud session — the only difference per target is which WebSocket endpoint the script connects to.