What Obscura is, the Rust headless browser for AI agents

Obscura landed on GitHub in April 2026 and has collected 24,624 stars in five months. Cloudflare’s engineering team credits it as the starting point for their own agent browser, and the project already advertises a managed version. Here is what it actually does, what the numbers looked like when I ran it on my own machine, and where it genuinely replaces headless Chrome.

Key takeaways

• Obscura is a headless browser engine written in Rust under an Apache-2.0 licence. It runs JavaScript on V8 and speaks the Chrome DevTools Protocol.
• Playwright and Puppeteer connect without a single code change: point connectOverCDP at the port obscura serve opens.
• Its reproducible advantage is memory. In my tests it used about 38 MB per session against 532 MB for headless Chromium on the same page.
• The speed advantage depends on the page: obvious on static HTML, absent on a real site where network latency dominates.
• Since version 0.2.0 (August 2026) it renders and captures without Chromium, but it does not match Chromium yet, and I hit that on the very first page I gave it.

What Obscura is and what problem it solves

Obscura is a browser engine with no graphical interface, written from scratch in Rust. It is not a Chromium fork or a WebKit patch: it embeds V8 to run the page’s JavaScript, builds its own DOM, and exposes the Chrome DevTools Protocol so existing automation tools treat it as if it were Chrome. The official documentation defines it this way: "Obscura is an open-source headless browser engine written in Rust. It runs JavaScript via V8, speaks the Chrome DevTools Protocol, and works as a drop-in replacement for headless Chrome with Puppeteer and Playwright"^[1].

The problem it attacks is cost, not capability. Headless Chrome automates a page perfectly well, but it was designed for one person looking at one tab. When a swarm of agents opens thousands of concurrent sessions, every process drags along a compositor, a rendering stack and dozens of subsystems no agent ever touches. You pay for that in gigabytes of memory and in seconds of startup. Obscura’s proposal is to keep only the part that matters for reading data: run the JavaScript, build the DOM, hand it back.

The Cloudflare connection is the strongest signal that the idea holds up. In the Kitesurf announcement, describing their agent browser built on Workers, the team writes: "We got the initial inspiration from obscura, a headless engine written in Rust for AI automation that has ‘no Chrome, no Node.js, no dependencies’"^[2]. Cloudflare ported Obscura to Workers as a first proof of concept in May 2026 and built the product from there. Kitesurf is still a Cloudflare service in free beta; Obscura is the engine you can download today.

How it works inside

The binary bundles three pieces. The first is V8, the same JavaScript engine Chrome uses, embedded directly in the Rust process. The second is its own implementation of the DOM and the web APIs a modern page needs: fetch, XHR, observers, Shadow DOM, custom elements, WebCrypto and the rest. The third is the CDP server, which translates Puppeteer or Playwright calls into operations on that DOM.

Since version 0.2.0, released on 8 August 2026 with 449 accumulated commits, there is a fourth piece: a layout and paint engine also written in Rust, which allows screenshots, screencasting and PDF export without starting Chromium. Version 0.2.1, from 23 August, added dedicated V8 realms for child iframes.

Installing it needs neither Node.js nor Chrome. The project publishes binaries for Linux, macOS and Windows, in variants with and without rendering and with and without stealth mode, plus an official image on Docker Hub^[3] with 45,789 pulls.

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

./obscura fetch https://example.com --eval "document.title"
./obscura fetch https://example.com --dump markdown

./obscura serve --port 9222 --stealth

Stealth mode is a separate build variant. According to the project README it randomises the GPU, screen, canvas, audio and battery fingerprint on every session, leaves navigator.webdriver undefined and blocks 3,520 tracking domains. Those are the project’s own figures, not a third party’s.

It also ships an embedded Model Context Protocol server with fourteen browser tools an assistant can call directly. If you have built your own servers before, the complete MCP guide has the context for that protocol.

What happened when I ran it on my own machine

I downloaded the aarch64-linux variant of v0.2.1 and ran it in an ARM64 Linux container on 4 September 2026, measuring wall time and peak resident memory across the process tree. Facing it I put headless Chromium driven by Playwright, on the same URLs and the same network. Three passes per combination.

The honest reading of those numbers has two halves. The memory advantage is huge and it holds: roughly thirteen times less on the real page. The speed advantage evaporates as soon as the page stops being a static 500-byte file. On Hacker News, Chromium was even slightly faster, because what dominates the median is the network, not the engine. Dropping --wait to zero changed nothing.

The project’s own benchmark repository reaches the same conclusion with more data: over a corpus of 98 real public pages, Obscura rendered 94 and headless Chrome rendered 85, with a median memory of 64.2 MB against 201.2 MB, but with a median latency of 5.2 seconds against Chrome’s 2.1 seconds. That is how the cards actually fall.

Playwright compatibility turned out to be literal. I started obscura serve --port 9333 and connected with chromium.connectOverCDP('ws://127.0.0.1:9333') without touching anything else: navigation, page.title() and page.evaluate() all answered in 100 milliseconds.

Then I tried the new rendering path on the front page of a Tailwind-based WordPress site. The capture took 587 milliseconds and produced a valid PNG, but with clear differences against Chromium.

The most concrete difference: the theme declares its navigation-bar labels as ::after pseudo-elements with content: attr(data-tooltip) and opacity: 0, visible only on hover. Obscura painted the pseudo-element but ignored the opacity, so the header came out covered in overlapping labels. The search panel also rendered open and the cookie notice was missing. This is exactly the class of gap the project declares in its release notes, found on the first page I fed it.

How it compares with headless Chrome and Lightpanda

There are four families of solutions and it is worth keeping them apart, because they solve different things. GitHub figures from 4 September 2026.

Lightpanda is the direct rival: same premise of a new engine, written in Zig, two years older and with more stars. The difference that decides it for many teams is legal rather than technical. Lightpanda uses AGPL-3.0, which propagates to any service that exposes it over the network. Obscura uses Apache-2.0, which does not. If you plan to embed it in a closed product, that line in the LICENSE file weighs more than any benchmark.

Steel Browser and Browserless do not compete with Obscura: they wrap Chromium with queues, sessions and an API. They solve operations, not cost per session. Browserless is also not open source, it is free only for non-commercial use.

Then there is the agent ecosystem that already drives a browser. If what you want is an agent that browses for you, Browser Use works one layer above; if what you want is clean web data, Firecrawl does the extraction for you. Obscura lives underneath all of them, as an engine replacement.

What it does not do well yet

The rendering path is less than a month old and does not reach Chromium parity. The v0.2.0 notes say so plainly: long-tail CSS, some web APIs, native media playback and GPU compositor effects may still differ. My test confirmed it on the first try. The PDF output is also raster-backed, so the text cannot be selected.

Conformance is not complete either. The benchmark repository publishes an 83.3% subtest pass rate on the Core tier of the Web Platform Tests (318,916 of 382,891) and 60.0% on the full suite. That 60% is not a hidden defect, it is the consequence of deliberately not implementing whole layers of the platform, and the project documents it.

The README figures age quickly. It advertises a 70 MB binary, but the ARM64 build with rendering that I downloaded takes 100 MB unpacked, plus another 92 MB for the worker process. The Docker image went from 53.2 MB in 0.1.11 to 87.1 MB in 0.2.1. None of this is serious, but measure on your own platform before quoting the table.

The project is young and highly concentrated. It was created on 13 April 2026 and, of the twenty contributors the GitHub API lists, a single one accounts for 733 commits. Stealth mode reduces automation signals, but it does not prevent blocks based on IP reputation or behaviour patterns. And Obscura Cloud, the managed version, is still a waiting list rather than a product you can buy.

When it is worth it and when it is not

It is worth it when your bill is a memory bill. If you run hundreds or thousands of concurrent sessions extracting data, going from 500 MB to 38 MB per session changes machine sizing in a way no code optimisation can match. It is also worth it when you want to package a browser inside a small image with no Node.js and no Chrome, or when you need genuinely clean, reproducible sessions.

It is not worth it if your workload is a few dozen pages and already works. The per-page latency gain on real sites is zero or negative, and you would be swapping a mature engine for a five-month-old one. It is also not worth it if you depend on visual fidelity: visual regression testing, client-facing captures, anything where the pixel matters, all of that remains Chromium territory. And if your problem is getting blocked, the engine is not the lever; proxies and request pacing are.

My practical advice: run it alongside. Start obscura serve next to your current headless Chrome, point a percentage of traffic at it with connectOverCDP and compare results on your own target pages for a week. Migration costs one environment variable, so the experiment is cheap. If you are curious about the language underneath, Rust for backend work with Axum and Tokio has the context for why this class of project gets written that way.

Frequently asked questions

Does Obscura replace Playwright or Puppeteer?

No, it complements them. Playwright and Puppeteer are the libraries you write the automation script in; Obscura is the browser that script drives. You keep the same Playwright code and only change the connection target, from a Chromium launched by the library to an obscura serve listening over CDP.

Can I use Obscura in a closed commercial product?

Yes. The licence is Apache-2.0, which permits commercial use and integration into proprietary software with no obligation to publish your code. That is the most practical difference against Lightpanda, which uses AGPL-3.0 and requires releasing the source of any networked service that embeds it.

Is Obscura good enough for reliable screenshots?

Only with caution. Since v0.2.0 it does screenshots, screencasting and PDF without Chromium, and they work. But the paint engine is new and the project itself warns that it does not match Chromium. In my test it ignored an opacity rule on a pseudo-element and the header came out wrong. For visual regression testing, stay on Chromium.

Conclusion

Obscura solves a specific problem and solves it well: the memory cost of giving every agent its own browser. Thirteen times less RAM per session is a figure that changes architecture decisions, and CDP compatibility makes trying it almost free. What you should not expect is the speed gain the home page advertises, because it does not appear on real pages, nor rendering fidelity equal to Chromium, because the project itself warns that it is not there yet.

That Cloudflare started from this code to build Kitesurf says a good deal about the quality of the idea. Five months of life says a good deal about the risk. Measure it against your own pages before moving anything.

Sources: [1] Obscura, official GitHub repository^[5], [2] Obscura, published release notes^[6], [3] obscura-benchmark, measured conformance and performance^[7], [4] Official Obscura documentation^[1], [5] Cloudflare, introducing Kitesurf^[2], [6] Official Obscura image on Docker Hub^[3], [7] Official Obscura website^[8], [8] wpt.fyi, Web Platform Test results by engine^[9].

Spanish version: Qué es Obscura, el navegador headless en Rust para agentes de IA.

Sources

1. "Obscura is an open-source headless browser engine written in Rust. It runs JavaScript via V8, speaks the Chrome DevTools Protocol, and works as a drop-in replacement for headless Chrome with Puppeteer and Playwright"
2. "We got the initial inspiration from obscura, a headless engine written in Rust for AI automation that has ‘no Chrome, no Node.js, no dependencies’"
3. official image on Docker Hub
4. Lightpanda
5. Obscura, official GitHub repository
6. Obscura, published release notes
7. obscura-benchmark, measured conformance and performance
8. Official Obscura website
9. wpt.fyi, Web Platform Test results by engine