Obscura is a headless browser written in Rust that brings its own MCP server: your AI agent navigates, takes screenshots, and executes JavaScript without Chromium, using around 30 MB of memory instead of over 200 MB, according to the project’s own measurements. It’s Apache 2.0, distributed as a single binary, and still in version 0.1.x.
That last detail matters as much as the first, and almost all coverage overlooked it.
What is Obscura and what does it replace?
Obscura is not a wrapper around Chrome. It’s a browser engine built from scratch in Rust that executes real JavaScript through V8 and implements enough of the Chrome DevTools Protocol for automation clients you already use to connect without changing a line of code.
What it replaces is the part of your stack you probably never deliberately chose: the several hundred megabytes of Chromium that npm install puppeteer drags along. If you run a scraper on a single machine, that cost is invisible. If you run fifty containers, or if you’re building an AI agent that needs to look at a page, it stops being invisible.
The project has 26.3k stars and 1.9k forks at the time of writing this note.
How do you install it?
Binary download, according to the repository README:
# 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
# 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
Docker:
docker run -d --name obscura -p 127.0.0.1:9222:9222 h4ckf0r0day/obscura
From source, with Rust 1.75 or higher:
git clone https://github.com/h4ckf0r0day/obscura.git
cd obscura
cargo build --release -p obscura-cli --bins --features render
A first command to confirm it’s working:
obscura fetch https://example.com --eval "document.title"
How do you connect your AI agent?
This is the more interesting half of the project. Obscura includes an MCP server:
obscura mcp
obscura mcp --http --port 8080
According to the README, it exposes navigation, screenshots, PDF output, element interaction, and JavaScript evaluation as MCP tools. Your agent gets a browser without you having to write a Puppeteer bridge to join the two pieces. If you’ve been building agents that need to read pages, this eliminates one moving part from the design.
Does it work the same with Puppeteer and Playwright?
Yes, and it’s the part that decides whether the tool is worth your afternoon. Spin up the CDP server:
obscura serve --port 9222
Connect with puppeteer-core — note: puppeteer-core, not puppeteer, precisely because you don’t want the browser that comes bundled with the package:
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');
Playwright connects over CDP:
import { chromium } from 'playwright-core';
const browser = await chromium.connectOverCDP({
endpointURL: 'ws://127.0.0.1:9222',
});
For batch work, the CLI handles concurrency without needing a client library:
obscura scrape url1 url2 url3 --concurrency 25 --eval "document.title"
How much memory do you actually save?
These are the figures published by the project itself, not independently verified benchmarks:
| Metric | Obscura | Chrome headless |
|---|---|---|
| Memory | 30 MB | 200+ MB |
| Binary size | 70 MB | 300+ MB |
| Page load | 85 ms | ~500 ms |
| Startup | Instant | ~2 s |
Take them as an order-of-magnitude claim rather than a precise measurement: a project chooses the benchmarks for its own project. The direction is credible though: a purpose-built engine in Rust, which doesn’t load Chrome’s extension system, its sandbox architecture, or its UI layer, should be much lighter. Whether your pages hit that 30 MB depends on what your pages do.
Where the proportion really matters is in density. At roughly one-seventh of the memory, a machine that ran seven concurrent Chrome instances runs significantly more, and that’s the real argument for the tool, more than raw speed.
What is stealth mode and when should you not use it?
Obscura includes anti-detection features, exposed with the --stealth flag in fetch, serve, and mcp. Version v0.1.9 made it global across all subcommands, and the project reports that creepjs registers 0% detection against it — again, self-reported data.
It’s worth being clear about what this does. Bot detection also blocks credential stuffing and scraping that sites explicitly rejected, and a tool that evades it doesn’t distinguish between your use and anyone else’s. Evading detection doesn’t change a site’s terms of service, and in several jurisdictions it doesn’t change the law either. If you’re scraping your own properties, testing your own detection stack, or extracting public data that the site allows, this is a convenience. If you’re resorting to this flag because something blocked you, the block was the answer.
Is it ready for production?
Here it’s worth slowing down. Obscura has 26.3k stars and 1.9k forks. At the time of publishing this note, in September 2026, its most recent version is v0.1.10, released on July 11, 2026.
Think about those two data points together. Twenty-six thousand stars is the profile of infrastructure people depend on; 0.1.10 is the version number of software that’s still deciding what it is.
The version history is honest about that gap. v0.1.10 mentions that controlled inputs from React and Vue “now work end-to-end” and that heavy pages “no longer crash or hang”, which tells you that until recently, they did. v0.1.7 added a V8 watchdog for runaway scripts. Several versions cite advances in WPT compliance, and advances implies gap: this engine still doesn’t implement everything expected of a browser.
None of that is criticism of the project, which is moving fast and documenting its rough edges honestly. It’s a warning about the phrase “drop-in replacement”, which is carrying a lot of weight. A drop-in replacement for Chrome has to render what Chrome renders, and an engine built from scratch in v0.1.x is going to have pages where it doesn’t. You won’t discover which ones by reading the README. You’ll discover them against your own targets.
The practical takeaway: run it against the sites you actually need, compare the output to your current stack, and keep the previous path until the comparison stops surprising you.
Obscura or Chrome headless?
Use Obscura if your bottleneck is density or footprint: many concurrent sessions, tight containers, an agent that needs a browser without depending on Chromium, or CI where a 70 MB binary beats a 300 MB one. The efficiency argument is real and is the reason to look at it.
Stay with Chrome headless if you need rendering fidelity you can’t personally verify, if you depend on Chrome-specific behavior, or if a silent difference in what a page renders would cost you more than you save in memory. That describes most scraping in production today.
And if what you’re looking for is not managing the browser at all, there’s a third path: expose it as a service. We covered it when Cloudflare turned a Chrome headless into an HTTP endpoint, in Browser Run.The honest summary is that this is a promising and fast-moving engine at an early version number, and the gap between 26.3k stars and v0.1.10 is wider than usual. It’s worth keeping a close eye on and testing carefully; it’s not worth putting it into a pipeline on a Friday.