Lightpanda 1.0 vs Chrome headless: we measured it with Playwright and memory dropped from 473 MB to 29 MB ✅ yoDEV Tested

Lightpanda 1.0, the headless browser written in Zig, came out of beta on October 2: in our test with Playwright it used between 12 and 16 times less memory than Chrome headless, but was only between 1.3 and 3 times faster, not 9, and three things broke that the announcement doesn’t mention.

We installed the 1.0.0 binary, served a set of test pages locally, and ran the same Playwright script against Lightpanda, against Chromium’s headless shell, and against full Chrome in headless mode. Next: what Lightpanda is, how to install it, the numbers we got, and the list of things you should check before putting it behind a test suite or a scraping pipeline.

What is Lightpanda?

Lightpanda is a headless browser built from scratch in Zig. It runs JavaScript with V8 (version 15.5 in 1.0, the same engine as Chrome and Node.js), but it has no graphics rendering: it doesn’t calculate layout or paint the page. From that design decision come its memory and startup advantages, and also its limitations.

It speaks the Chrome DevTools Protocol (CDP), so Puppeteer, Playwright, and chromedp connect to it just like to Chrome. It also exposes a WebDriver endpoint for Selenium, a native MCP server for AI agents, and a CLI that dumps a page as HTML, markdown, or semantic tree.

The team, led by cofounderceo Francis Bouvier, built it after years of maintaining a fleet of headless Chrome instances that crawled over 20 million pages a day.

If you read our note about the beta, Lightpanda: The Headless Browser Made for AI Agents, this is the follow-up: the same tool, now stable and, this time, measured.

What changed in Lightpanda 1.0?

According to the announcement, there were two conditions to remove the beta label:

  • Web platform coverage. Lightpanda passes 1,739,845 subtests of the Web Platform Tests, compared to 2,645 in the November 2024 beta. Chrome passes 2,184,491 on wpt.fyi, so Lightpanda comes in at around 80 percent of Chrome’s score. According to the team, more than half the difference is in CSS, editing, and SVG suites: the layout and painting tests it deliberately doesn’t pursue.
  • Security. CORS is now enforced by default on every fetch() and XMLHttpRequest made by a page. This matters in a browser that loads pages nobody reviewed inside your cloud network: without CORS, a malicious page could call an internal service and read the response. Earlier 0.x versions had already added --block-private-networks and --block-cidrs to keep the browser away from private subnets and cloud metadata endpoints, and optional loading of iframes, workers, and external stylesheets with --load-resources.

The 1.0.0 release notes on GitHub list three behavior changes worth reviewing if you were using a 0.x: getComputedStyle results are now read-only, the language fallback "en" is gone (now set with --locale), and the old --experimental-features cors flag was removed. If CORS breaks something, the temporary workaround is --disable-features cors.

How to install Lightpanda?

On Linux or macOS, pin the version explicitly:

curl -fsSL https://pkg.lightpanda.io/install.sh | bash -s "1.0.0"

Always pin it: without the version argument, the installer downloads the latest nightly build, not the stable release.

The installer needs curl, jq, and sha256sum, and leaves the binary at ~/.local/bin/lightpanda. If that directory isn’t in your PATH:

export PATH="$HOME/.local/bin:$PATH"

Lightpanda sends usage telemetry by default. To turn it off:

export LIGHTPANDA_DISABLE_TELEMETRY=true

Verify it works:

lightpanda version
# 1.0.0

What about pip install lightpanda or npm install @lightpanda/browser?

Both exist, but neither is “the browser in version X”. They’re separate packages, with their own versioning and their own license. As of October 13, 2026, the npm package @lightpanda/browser is at 1.6.0 and the PyPI package lightpanda is at 1.0.0.post1, both with Apache-2.0 license. The browser is 1.0.0 and has AGPL-3.0 license. If you see “Lightpanda 1.6.0” somewhere, it refers to the npm driver, not the browser.

Does Lightpanda work on Windows?

Not natively. On Windows it works inside WSL2: install WSL and an Ubuntu distribution, then install Lightpanda inside WSL exactly like on Linux.

Does Lightpanda replace Playwright?

No: it replaces the browser behind Playwright. Your Playwright code (or Puppeteer, or Selenium) stays the same; what changes is that instead of launching Chromium, you connect to Lightpanda over CDP.

How to connect Playwright headless to Lightpanda

Start Lightpanda as a CDP server:

lightpanda serve --host 127.0.0.1 --port 9222

Then, instead of chromium.launch(), connect over CDP. This is the pattern from the official documentation:

import { chromium } from 'playwright-core';

const browser = await chromium.connectOverCDP('ws://127.0.0.1:9222');
const context = await browser.newContext({});
const page = await context.newPage();

await page.goto('https://wikipedia.com/');
console.log(await page.locator('h1').textContent());

await page.close();
await context.close();
await browser.close();

Puppeteer works the same with puppeteer.connect({ browserWSEndpoint }).

Can you use Lightpanda for web scraping with Python?

Yes. With Playwright for Python you connect exactly the same way, with connect_over_cdp. This is the example from the official documentation:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp("ws://127.0.0.1:9222")
    context = browser.new_context()
    page = context.new_page()

    page.goto("https://wikipedia.com/")

    title = page.title()
    print(title)

    page.close()
    context.close()
    browser.close()

There’s also its own SDK on PyPI (pip install lightpanda), which we didn’t test in this note.

How much memory does Lightpanda save compared to Chrome headless?

Our setup: a Linux VM with 2 vCPU and 8 GB; Lightpanda 1.0.0; Chromium 141 in two variants (the headless shell that Playwright distributes, more lightweight, and full Chrome with --headless=new); Playwright 1.56 connected to all three over CDP with the same code. The test page is a small SPA that renders a list of 50 products from two fetch() calls (the same form as the vendor’s single-page benchmark), served locally so network latency doesn’t skew the result. We measured memory as PSS of the entire browser process tree, with samples every 100 ms. Each test was run three times; the ranges cover all three.

Lightpanda 1.0 Chromium headless shell Chrome --headless=new
Startup until CDP responds 24–39 ms 82–94 ms 254–285 ms
100 sequential loads 5.5–5.8 s 7.4–7.8 s 8.6–9.4 s
Peak memory, sequential 29 MB 340 MB 473 MB
200 loads, 10 workers in parallel 6.2 s 10.6–12.9 s 19.3–19.9 s
Peak memory, 10 workers 75–78 MB ~650 MB ~910 MB

What this means:

  • Memory: the promise holds. 12 times less than the headless shell and 16 times less than full Chrome in the sequential test; between 8 and 12 times less with 10 workers. This is the number that changes how many browsers fit on the same machine.
  • Speed: real, but much less than advertised. Between 1.3 and 1.7 times faster sequentially, and between 1.7 and 3.2 times with 10 workers. The difference is most noticeable at startup: between 2.5 and 3 times faster than the headless shell and between 7 and 12 times faster than full Chrome, something that adds up if you start a new browser for each task.

The figures you’ll see cited (“9 times faster and 16 times less memory” in the Hermes Agent documentation; “4 times faster and 6 times more cost-efficient than Chromium”, from Keenable, a customer; “4 times faster and 10 times lower average load”, from DeveloperHub.io, a customer) are numbers from the vendor or its customers, not independent benchmarks. Lightpanda’s benchmarks page uses an AWS m5.xlarge instance and runs Chrome 143 with Puppeteer and chromedp. Our hypothesis on why our speed difference is smaller: Playwright adds its own cost for each navigation, the same for both browsers, and that compresses the ratio. If you use CDP directly, the difference is likely larger; through Playwright, expect something closer to ours.

What breaks when switching Chrome for Lightpanda?

We ran a compatibility script with 14 checks against all three engines. Lightpanda behaved the same as Chrome on static pages, rendering a SPA with fetch(), forms (fill, selectOption, check, click), locators inside Shadow DOM, evaluate, isVisible, click handlers, and CORS: allowed cross-origin requests passed and disallowed ones blocked, exactly like Chrome. Four things didn’t:

1. Only one browser context per connection

A second browser.newContext() fails:

Protocol error (Target.createBrowserContext): Cannot have more than one browser context at a time

Many Playwright suites isolate each test in its own context. That pattern doesn’t work against a single Lightpanda connection. The solution is to open one CDP connection per worker, each with its context, which is how we ran the 10-worker test. The serve command accepts up to 16 simultaneous CDP connections by default, adjustable with --cdp-max-connections. Note that this isn’t the same setup we used with Chrome, where we ran 10 contexts inside a single browser: it’s the natural setup for each engine.

2. boundingBox() returns incorrect numbers instead of an error

For a div with width: 300px; height: 120px; padding: 10px, Chrome returns {x: 8, y: 8, width: 320, height: 140}, the real box. Lightpanda returns {x: 0, y: 25, width: 300, height: 120}. Since there’s no layout engine, the response is approximate, but it doesn’t fail. Any test that verifies positions or sizes will pass or fail on plausible numbers that aren’t real. Treat everything geometric as unsupported.

3. Screenshots and PDFs work, but don’t show the page

page.screenshot() and page.pdf() return a valid PNG and PDF. According to Lightpanda’s own FAQ, what they render is the markdown of the page, not its actual appearance. Visual regression tests won’t fail: they’ll silently compare something else. (Hermes Agent solves this by automatically falling back to Chrome for screenshots).

4. On a real site, the load event may never arrive

On GitHub’s issues page, page.goto() with Playwright’s default value, waitUntil: 'load', timed out at 30 seconds on Lightpanda, while the headless shell loaded it. With waitUntil: 'domcontentloaded', the two GitHub pages we tested loaded on Lightpanda and returned the same number of links as Chrome (247 and 129). If you migrate, switch to domcontentloaded and add explicit waitForSelector for the content you need. One caveat: our environment only reaches a short list of public sites, through a proxy, so GitHub was the only real site we could test. Don’t draw timing conclusions from that test.

If a page breaks, the team asks you to open an issue with the URL. DeveloperHub.io opened two before moving to production, and both were fixed before the switch.

Is Lightpanda free? What the AGPL license means

The browser is free and open source under AGPL-3.0, which allows commercial use. The clause you need to understand is the network one: if you modify Lightpanda and allow users to interact with that modified version over a network, you must offer them the source code of your modified version. Running the unmodified binary behind your own scraper or test suite is a different situation from offering a modified fork as a service. If your plan looks like the latter, check with whoever handles licensing in your company before building on top of it: this is not legal advice.

Client packages (@lightpanda/browser on npm and lightpanda on PyPI) are licensed under Apache-2.0. There’s also Lightpanda Cloud, a hosted service you connect to with the same connectOverCDP call and a token; we didn’t test it.

Lightpanda or Chrome headless?

Use Lightpanda if:

  • you extract data or text from pages rendered with JavaScript at volume;
  • memory per browser is what limits how many tasks fit on a machine;
  • you start a new browser per task and startup time adds up;
  • you give a browser to an AI agent and want CORS and private network blocking turned on by default.

Stay with Chrome if:

  • your tests verify layout, positions, sizes, or any visual aspect;
  • you need screenshots or PDFs of how the page actually looks;
  • your suite depends on multiple browser contexts per connection and you can’t restructure it;
  • the sites that matter to you break on Lightpanda and you can’t wait for a fix.

The practical migration isn’t all or nothing: run extraction tasks on Lightpanda and keep a Chrome pool for visual work, which is exactly what Hermes Agent does automatically.


What about you? What consumes the most memory in your automation stack today: Chrome, the test runner, or something else?

Which headless browser do you use for automation or scraping?
  • Chrome / Chromium headless
  • Lightpanda
  • Firefox or WebKit with Playwright
  • I prefer another option (tell us which)
0 votantes

Comment below or, if this article reached you by email, reply directly to the email: your reply gets published here.

Related: How to give your AI agent a browser without loading Chromium