Obscura: The Rust Browser Built for AI Agents — What It Really Is (and What the Viral Post Gets Wrong)

Obscura is a real open-source headless browser written in Rust, built for web scraping and AI agents — and it is genuinely light: a single ~70MB binary, about 30MB of RAM per session by the project's own numbers, no Chrome and no Node.js required. It runs real JavaScript through V8, speaks the Chrome DevTools Protocol, and plugs into Puppeteer, Playwright and MCP. But the viral post about it overstates almost everything else. It does not make you undetectable, it does not behave exactly like real Chrome, and it is a young, early-stage project. This post separates the real thing from the hype.

What Obscura is

Obscura is a headless browser engine written from scratch in Rust, created by developer h4ckf0r0day. The repository (github.com/h4ckf0r0day/obscura) was created on 13 April 2026, is licensed Apache-2.0, and has grown fast: 31,588 stars and 2,397 forks as of 10 November 2026, with 80+ contributors and a latest release, v0.2.6, published 31 October 2026. The project is under active development — the last code push landed 9 November 2026, the day before this post.

The problem it solves is a real one. A headless Chrome instance typically needs 200MB or more of RAM and around two seconds to start. An AI agent that opens hundreds of short-lived browser sessions a day pays that cost every single time — in memory, in startup time, and in a 300MB+ Chromium download. Obscura's answer is to skip Chromium entirely: a single static binary of about 70MB that starts instantly, runs JavaScript through the V8 engine (via the deno_core crate, V8 150.4.0), parses HTML with html5ever, and lays out and paints pages with its own native Rust rendering engine.

What you get in the box: a CLI with fetch (grab one page, with JavaScript evaluated), scrape (fetch many URLs in parallel across worker processes), and serve (expose a Chrome DevTools Protocol endpoint so existing automation code connects without changes). It captures native screenshots, exports PDFs, records screencasts, and converts cluttered pages into clean, token-efficient Markdown for language models. Since v0.1.7 it also ships as an embeddable Rust library (the obscura crate) and as a built-in MCP server (obscura mcp), so AI agents can drive pages natively.

One detail worth knowing: Cloudflare's engineering blog for Kitesurf — Cloudflare's agent-first browser — says the team "got the initial inspiration from obscura". A project that inspires the company whose bot detection it is often compared against is a sign the idea is taken seriously, even at version 0.2.x.

What the viral post gets wrong

The viral post is not wrong that Obscura exists, or that it is light. It is wrong about what that lightness buys you. The corrections:

Correction 2 — "Behaves exactly like real Chrome" is false. Obscura is not Chrome and does not try to be a pixel-perfect clone. Its rendering engine is its own Rust layout and paint code, there is no GPU rasterization path, and WebGL is unavailable — getContext('webgl') returns null. Pages that need WebGL, heavy GPU compositing or exact Chrome rendering behaviour will not work the same way. For reading articles, scraping data and driving forms it is fine; for anything that leans on Chrome's graphics stack it is not a Chrome.

Correction 3 — "30MB of RAM, 85ms page loads" are the project's own numbers, not lab results. They come from Obscura's own benchmark suite, which lives in a separate repository (obscura-benchmark) and is run by the project itself. One independent test, by flowtivity.ai on 5 September 2026 on a production VPS, measured 34MB of peak RAM — close to the claim, and a good sign, but a single test on one machine is not proof. Treat 30MB as a credible claim, not a certified fact.

Correction 4 — "A direct replacement for Puppeteer and Playwright" is misleading. Obscura does not replace those libraries. It works with them: it exposes a CDP server, and your existing Puppeteer or Playwright code connects to it instead of to headless Chrome. Obscura replaces the browser under the automation library, not the library itself. If you have no Puppeteer or Playwright code, Obscura's own CLI and MCP server are the tools you use directly.

Correction 5 — "No Chromium" is true, but read it carefully. The binary contains no Chromium, and that is the point — no 300MB download, no browser process to manage. But Obscura still runs real JavaScript through Google's V8 engine and still speaks Chrome's DevTools Protocol. "No Chromium" means no Chromium browser, not no Google technology at all.

Correction 6 — The project is young. Created in April 2026, at version 0.2.6, with 215 open issues as of November 2026. That is normal for a fast-moving open-source project, and the release cadence (v0.2.1 in August, v0.2.2 in September, v0.2.3 and v0.2.4 in October, v0.2.5 and v0.2.6 after that) shows steady work. But young means rough edges: expect missing features, occasional rendering quirks and breaking changes between releases. This is not a finished, battle-tested browser yet.

The numbers, honestly

Obscura's README publishes a comparison table against headless Chrome: about 30MB of memory per session versus 200+MB, page loads in 85ms versus roughly 500ms, instant startup versus about two seconds, and a 70MB binary versus 300+MB. Those are the project's own figures, and they are the numbers the viral post repeats as fact.

The honest version is shorter: the memory claim has one independent check behind it. On 5 September 2026, flowtivity.ai downloaded the v0.2.1 Linux binary, ran four tests on a production VPS and measured wall-clock time and peak resident memory with GNU time. Peak RAM came out at 34MB, against the 200+MB that headless Chrome typically consumes per instance. That is a real, repeatable measurement — and it is one test, on one machine, on one version (v0.2.1). The 85ms page-load figure and the startup figures have no independent verification published so far.

None of this makes the claims false. A 34MB measurement landing within a few megabytes of a 30MB claim is a good sign, and the architecture explains the gap: no Chromium process tree, no GPU process, no extension system, no full browser UI. But the numbers should be quoted as what they are — a project benchmark, plus one independent test — and the chart below labels them that way.

How it works

Obscura is built from four pieces. First, the JavaScript engine: real V8, through the deno_core crate, so pages that depend on JavaScript actually run — this is not a static HTML fetcher. Second, the HTML parser: html5ever, a Rust HTML5 parser that builds the DOM tree. Third, the rendering engine: native Rust layout and paint code, added in v0.2.0, which handles block, inline and flex layout and produces the screenshots and PDFs. Fourth, the protocol layer: a Chrome DevTools Protocol server, which is what makes the whole thing compatible with the existing automation ecosystem.

The CDP layer is the clever part. Puppeteer and Playwright do not care which browser is on the other end of the CDP socket, as long as it speaks the protocol. Obscura implements enough of CDP for the common commands — navigation, evaluation, screenshots, PDF export — so existing scripts connect with one line changed: the endpoint URL. The connection looks like this in Puppeteer:

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

Rendering is a build-time feature, not an unconditional one: the default build does not include it, and the render path has real limits. There is no GPU rasterization, so anything that needs the GPU — WebGL, some canvas workloads, heavy CSS animation compositing — either falls back to software or does not work. The project is upfront about this in its own docs. For scraping and agent work, where the goal is usually the DOM, the text and a screenshot, those limits rarely matter. For visual testing of a WebGL app, they are a deal-breaker.

Stealth is also a build-time choice. The stealth features only work if the binary was built with the --features stealth flag; a prebuilt binary without that flag does not have them. When enabled, the --stealth flag randomizes the fingerprint each session — GPU, canvas, audio, battery, User-Agent and navigator.webdriver — and blocks more than 3,500 known tracker and telemetry domains before they load. That is genuinely useful for scraping, and it is also the feature most likely to be oversold: it is a fingerprint randomizer and a blocklist, not invisibility.

Setup: install and first run

Installation is the part the viral post gets right: a single binary, no dependencies. On Linux x86_64, download the latest release directly from GitHub:

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

Extract it and you have the binary — no Chrome, no Node.js, no Python, no WebDriver to install. To build from source instead, clone the repository and build with Rust 1.75 or newer (the first build takes a few minutes because V8 compiles from source, and is cached after that):

git clone https://github.com/h4ckf0r0day/obscura.git
cd obscura
cargo build --release

To build with stealth features included, add the feature flag — without it, the --stealth flag does nothing:

cargo build --release --features stealth

Three commands cover most first uses. fetch grabs one page with JavaScript evaluated. serve starts the CDP endpoint your Puppeteer or Playwright code connects to. scrape fans out across many URLs with a worker pool:

obscura fetch https://example.com
obscura serve --port 9222
obscura scrape --concurrency 20 --format json https://example.com/page-1 https://example.com/page-2

For AI agents, the MCP server is the interesting piece — see the MCP section below. macOS builds (aarch64) are published alongside the Linux builds on the releases page.

Stealth mode, honestly

Stealth is Obscura's most talked-about feature and its most misunderstood one. Here is what it actually does, and what it does not do.

What it does: with the stealth build and the --stealth flag, every session gets a different fingerprint. GPU details, canvas fingerprints, audio context values, battery status and User-Agent are randomized per session, and navigator.webdriver — the flag headless browsers normally leak — is handled. On top of that, Obscura blocks more than 3,500 tracker and telemetry domains natively, so analytics and tracking scripts never load. For a scraper, that means less noise, fewer fingerprints left behind, and pages that load faster because the tracking scripts are gone.

What it does not do: it does not bypass interactive bot challenges. Cloudflare's interactive challenges, DataDome, Akamai Bot Manager and CAPTCHAs are all listed in the project's own stealth documentation as not handled. It does not help with IP-based rate limiting either — if a site blocks your IP after too many requests, a new fingerprint changes nothing. And fingerprint randomization is an arms race: detection systems adapt, and a randomized fingerprint that looks inconsistent (a mobile GPU with a desktop screen, for example) can be more suspicious than a plain one. The project's own framing is the honest one — basic bot detection, not invisibility — and any post that promises more is selling something the project itself does not claim.

MCP for AI agents

The built-in MCP server is what makes Obscura an agent tool rather than just a scraper. Run obscura mcp and an AI agent gets browser tools natively — navigate, evaluate, screenshot, extract — without the agent having to launch a browser process, manage a CDP connection, or write automation code. Combined with the Markdown extraction (a custom CDP method that strips headers, footers and page noise into clean, token-friendly Markdown), the design is clearly aimed at agents that read the web: less context burned on boilerplate, no Chromium to install in the agent's sandbox, and sessions light enough to open and close by the dozen.

This is also where the memory numbers matter most in practice. An agent workflow that opens a browser for every page it reads — research agents, monitoring agents, test agents — pays the browser cost on every call. At 30MB a session, an agent can keep many sessions alive or spin them up freely; at 200MB+, it cannot. The MCP server plus the small footprint is the combination the project is really selling, more than any single benchmark number.

Where it wins — and where it loses

Obscura is not a browser for everyone. It is a specialist tool, and the honest way to judge it is by workload:

The pattern is consistent: Obscura wins wherever the browser is a means to the data — reading, scraping, agent work — and loses wherever the browser's rendering or its ability to pass as Chrome is the product. Choose it for the first kind of job; keep a real browser for the second.

Security and privacy

Obscura's privacy story is strong on paper. Blocking 3,500+ tracker and telemetry domains by default means analytics, advertising and fingerprinting scripts simply do not run — pages load faster and leak less. Per-session fingerprint randomization means each session looks different, which helps against cross-session tracking of automated traffic. And because the binary is a single static build with no Chromium, there is no browser auto-update channel, no extension store and no Google account sync to worry about. The Apache-2.0 license means the code is auditable — anyone can read exactly what the browser does, which is more than can be said for most anti-detect tools.

Two honest caveats. First, fingerprint randomization is an arms race, not a solved problem. Detection vendors study tools like this one, and a fingerprint that is random but internally inconsistent can stand out more than a normal one. Second, the legal and ethical line: using stealth features to evade a site's bot defences can violate that site's terms of service, and scraping at scale can breach terms, rate limits or local law depending on what you take and how you use it. Obscura is a tool; whether a given scrape is acceptable depends on the target site's rules and on your jurisdiction, not on the browser. Use it for public data, respect robots.txt and rate limits, and do not treat "the browser can do it" as "it is fine to do it".

Obscura vs headless Chrome

The table makes the trade-off visible: Obscura wins on weight, speed and agent features, and loses on rendering maturity and graphics. That is not a flaw in the project — it is the design. A browser built for agents does not need to be a browser built for people.

Frequently asked questions

Is Obscura really free?

Yes. It is open source under the Apache-2.0 license, with no feature gating and no paid tier. You can use it, modify it and ship it commercially. The project lists proxy sponsors, but the browser itself costs nothing.

Does Obscura replace Puppeteer or Playwright?

No — it works with them. Obscura exposes a Chrome DevTools Protocol server, and your existing Puppeteer or Playwright code connects to it instead of headless Chrome. It replaces the browser under your automation code, not the automation library. You can also use Obscura on its own through its CLI or its built-in MCP server.

Can Obscura bypass Cloudflare?

No. The project's own documentation says stealth handles basic bot detection only, and explicitly lists Cloudflare, DataDome and Akamai interactive challenges, CAPTCHAs and IP-based rate limiting as not handled. If a site uses those protections, Obscura will not get you through on its own.

Is the 30MB memory figure real?

It is the project's own benchmark claim, and one independent test measured 34MB of peak RAM on a production VPS in September 2026 — close to the claim, and far below headless Chrome's 200+MB. Treat it as a credible, roughly-verified figure rather than a certified one.

Does Obscura run on Windows and macOS?

Linux x86_64 and macOS (aarch64) binaries are published on the GitHub releases page. The project is written in Rust, so it builds from source on other platforms with Rust 1.75 or newer, but prebuilt binaries are published for Linux and macOS.

Is Obscura ready for production use?

It depends on the job. For agent browsing, scraping and CI automation it is already useful, with active development and a fast release cadence. For anything that needs WebGL, pixel-perfect Chrome rendering or passing commercial bot managers, it is not ready — and its own documentation says so. It is a young project at v0.2.6; expect rough edges and check the release notes before upgrading.

Sources

• GitHub — h4ckf0r0day/obscura (repository, releases, README)
• Flowtivity — Obscura: The Rust Headless Browser Built for AI Agents (Tested)
• Bitnesia — Obscura: A Rust Headless Browser for Web Scraping
• GitHub — Obscura deep technical analysis (anti-detect browser tools comparison)
• Global AI Force — Obscura: How to Install and Set Up (2026 Guide)