· 7 min read

Cloudflare Open-Sourced Kitesurf, Its Chrome-Free Browser for Agents, Under Apache 2.0. It Ships With No Authentication. Here Is How I'd Try It.

Cloudflare open-sourced Kitesurf on November 13 under the Apache 2.0 license. It's an experimental browser engine that runs on Cloudflare Workers, parses HTML, applies CSS, runs page JavaScript and renders screenshots without Chrome or a browser container. It exposes a Chrome DevTools Protocol endpoint, so Puppeteer can connect to it. The README also has a line I'd put at the top of any post about it: don't deploy Kitesurf without authentication in front of it, because the engine has none of its own.

What Kitesurf is, and what it isn't

Cloudflare launched Kitesurf in August as an "agent-first" option inside its Browser Run product. The pitch is simple. Most of what agents and scrapers do in a browser is load a page, run its JavaScript, read the DOM and maybe take a screenshot. You don't need a full Chromium for that, and Chromium is the expensive part of every headless browser setup I've run.

The repo is mostly Rust compiled to WebAssembly, built on open-source pieces like Stylo for CSS and Boa for JavaScript, plus a Worker that serves the CDP endpoint. Cloudflare is clear that it's a CDP endpoint, "not a full Chrome implementation," and that some DevTools features don't work yet.

In the August launch post, Cloudflare reported that for screenshots Kitesurf used roughly a third of Chromium's CPU time and about a fifth of its memory, on a 14-URL test set. It was also slower on wall-clock time, by about 1.7 to 1.8x. Cloudflare says it passes more than 200,000 Web Platform Tests. Those are the vendor's own benchmarks on its own corpus, so treat them as a reason to test, not as a result.

The launch post was also honest about where it doesn't fit yet: video, WebGL, bot challenges that need real browser TLS fingerprints, and long logged-in sessions that need persistent state.

Running it locally

Locally, the setup is a normal monorepo with a Rust core. You need Bazelisk available as bazel, Node.js 22 or newer, and pnpm. Then:

git clone https://github.com/cloudflare/kitesurf.git
cd kitesurf
pnpm install --frozen-lockfile
pnpm run dev

The first build compiles the Rust core and is slow. After that, the engine listens on http://127.0.0.1:8787, with a health check at /health. Pointing an existing Puppeteer script at it is one line:

import puppeteer from "puppeteer-core";

const browser = await puppeteer.connect({
  browserWSEndpoint: "ws://127.0.0.1:8787/devtools/browser",
});
const page = await browser.newPage();
await page.goto("https://example.com");
await page.screenshot({ path: "example.png" });
await browser.close();

That's the part that makes it worth an afternoon. If your scraper already talks CDP, you don't have to rewrite it to find out whether Kitesurf handles your pages.

Deploying it, and the auth warning

To run it on Cloudflare, pnpm run deploy builds with Bazel and uploads with Wrangler. You need the Workers Paid plan, because Kitesurf uses Dynamic Workers to spin up an isolated worker per page, and Dynamic Workers are part of that plan.

Then comes the part people will skip. The default workers.dev URL is public, and so are version preview URLs. Anyone who finds the URL can drive your browser engine, on your bill, to fetch whatever they like. The README says to protect it with Cloudflare Access before or right after deploying, and to connect from Puppeteer with an Access service token in the CF-Access-Client-Id and CF-Access-Client-Secret headers. I'd set up Access first and deploy second, not the other way around.

This month already had a reminder of what happens to exposed endpoints. Cloudflare's own security team reported on November 13 that traffic from AI pentesting tools against its customers jumped sharply since October, and a public, unauthenticated browser endpoint is the kind of thing those tools find.

Where it fits in a solo stack

The obvious fit is a scraping or monitoring product that renders a few thousand pages a day: price trackers, link previews, SEO checkers, change detection. Those jobs mostly need the DOM and a screenshot, and the cost of running Chromium is a real line on the bill. If Kitesurf handles your page set, the memory numbers alone could change what you pay to host it.

The second fit is an agent that browses. Agents mostly read pages and click links, and a lighter engine is easier to sandbox per task.

It's a bad fit for anything that needs to look exactly like a real Chrome to the site, anything with WebGL or video, and anything that has to stay logged in for hours. Keep Chromium for those.

Where I could be wrong

The repo had 53 stars and one fork when it was checked on release day, and Cloudflare calls it experimental and under heavy development. Building on it now means tracking a moving engine. The wall-clock numbers also go the wrong way for anything latency-sensitive: if a user is waiting on the screenshot, Chromium was faster in Cloudflare's own tests.

There's also a platform question. Open source helps, but the deploy path assumes Workers Paid and Dynamic Workers. You can run it locally anywhere, but running it in production off Cloudflare isn't what it's built for today.

What I'd actually do

Take your real page list, the 50 URLs your product actually renders, and run your existing Puppeteer script against a local Kitesurf. Count how many pages come out correct, compare the screenshots to Chromium's, and time it. If more than nine in ten render correctly and latency doesn't matter for the job, deploy it behind Cloudflare Access and move your background jobs over. If not, star the repo and check again in three months.

Author

Sources

Newsletter

The week, in one email.

The weekly summary of what happened and what it means for people who build alone. No spam, unsubscribe any time.

Form not showing? Subscribe on this page instead.

Related Posts