Lightpanda Review: 16x Lighter Than Chrome, and a $19 Cloud Catch

Every AI agent eventually needs a browser. Price checks, form fills, research runs, lead lists: the web is where the work is. And right now, almost every agent does that work inside headless Chrome: a full desktop browser with the screen switched off, carrying a rendering engine, a GPU pipeline, a PDF reader and an extension system that no scraper will ever touch. Lightpanda is a bet that this is wasteful. It is a headless browser written from scratch in Zig, not a Chromium fork or a WebKit patch, built only for machines: no pixels, no layout painting, no compositing, just the network, the DOM, and JavaScript.

The bet is getting attention. The project has passed 40,000 GitHub stars, hit 1.0 on October 2, 2026, and keeps showing up on GitHub's daily trending page. Its headline numbers are startling: 16 times less memory and 9 times faster page loads than headless Chrome. But those numbers come from Lightpanda's own benchmark, the free tier has a hard 10-hour monthly cap, and the license is AGPL-3.0, which matters more than most people realize. Here is what Lightpanda actually is, what it costs, and where the catches are.

What Lightpanda actually is

Lightpanda is a new browser engine, not a diet version of an old one. The project, built by Selecy SAS, a French company, reimplemented the pieces an automation workload needs and skipped everything else. HTML parsing comes from html5ever (the Rust parser behind Servo), HTTP from libcurl, JavaScript from V8. There is no rendering engine at all, which is the whole point. Chrome spends most of its budget on layout, painting and compositing, work a scraper or an agent never uses.

What you get is a single small binary that speaks the protocols your existing tooling already speaks. It runs a Chrome DevTools Protocol server on port 9222, so Puppeteer, Playwright and chromedp scripts connect to it exactly the way they connect to Chrome. The project's documentation describes its CDP support as reimplemented from the public spec. It also supports WebDriver BiDi. On the feature checklist: CORS, AJAX, DOM APIs, click, screenshots as text-only renders, and a public Web Platform Tests results page tracking standards conformance.

The open-source binary is free under AGPL-3.0, with nightly builds for Linux and macOS (Apple Silicon and Intel), Homebrew and AUR packages, an official Docker image, and a Nix flake. There is no native Windows build: on Windows you run it inside WSL2. Version 1.0.0 landed October 2, 2026, with 1.0.2 following on October 23; before that, the project spent years in beta, and the README still reads like software that knows it has rough edges.

Official links: GitHub repository, pricing page, and benchmark details.

The 16x and 9x numbers — and what they really prove

Lightpanda's benchmark is specific and reproducible, which is more than most vendor benchmarks manage. The project requested 933 real web pages over the network on an AWS EC2 m5.large instance, then compared 100-page runs: peak memory of 123 MB against roughly 2 GB for headless Chrome, and 5 seconds of execution time against 46 seconds. That is where "16x lighter, 9x faster" comes from, and the full methodology is published in the project's demo repository.

The honest framing matters. This is Lightpanda measuring itself against Chrome, and no independent head-to-head I could find has replicated the exact setup. But third parties keep landing in the same neighborhood. An independent production guide estimates that running 1,000 Chrome instances for data extraction costs roughly $6,000 a month on AWS against about $600 on Lightpanda. A separate developer walkthrough measured its own AWS bill falling from $300 a month (a t3.xlarge keeping Chrome alive) to $80 (a t3.large), though those figures predate the 1.0 release. And a package-review site measured per-instance memory around 27 MB against Chrome's ~1.3 GB. The direction is consistent; only the exact multiple moves around.

Where does the saving come from? Cold start is effectively instant from a single binary, idle instances hold tens of megabytes instead of hundreds, and there is no GPU process, no font cache, no renderer to warm up. If your workload is fetching pages and pulling structured data at scale, that is pure margin. If your workload needs pixels, it is a non-starter (more on that in the catches).

Four ways to run it

Lightpanda ships four modes in the one binary, and they map neatly onto how people actually automate the web.

1. Fetch: the one-liner

The fetch command dumps a URL without writing any script:

./lightpanda fetch --obey-robots --dump markdown https://example.com

Output formats include HTML, Markdown, PNG, PDF and structured data (the page's JSON-LD, OpenGraph, Twitter card, meta and link tags as JSON). Waiting is configurable with --wait-until, --wait-ms, --wait-selector and --wait-script, and there is a --obey-robots flag for respecting robots.txt. This is the mode for quick extraction jobs and for piping page content into an LLM.

2. Serve: the drop-in Chrome replacement

./lightpanda serve --obey-robots --host 127.0.0.1 --port 9222

Once the CDP server is up, existing Puppeteer or Playwright scripts connect by pointing browserWSEndpoint at it. The rest of the script stays the same. For teams with a fleet of Chrome-driven scrapers, this is the migration path: change the connection string, keep the logic, watch the memory graph collapse.

3. Agent mode: plain-English browsing that compiles to scripts

This is the new idea. lightpanda agent drives the browser from a natural-language task (navigating pages, clicking through flows, filling forms, extracting structured data) with the agent running inside the same process as the browser, so every tool call is a direct operation rather than a CDP round trip.

The clever part is what happens after. The session exports as PandaScript: vanilla JavaScript with a small set of native browser primitives. Save it with /save, replay it later with lightpanda run session.js. The replayed script is deterministic and token-free: you prototype with the LLM, then ship the output to production with no model in the loop and no per-run inference bill. That two-phase pattern (expensive exploration, cheap replay) is the right shape for production automation, and few tools make it this explicit.

Agent mode supports Anthropic, OpenAI, Gemini, Google Vertex AI, Mistral, Hugging Face, the Vercel AI Gateway and OpenRouter, any OpenAI-compatible endpoint, and local models via Ollama, llama.cpp or LLMD. You bring your own keys. Lightpanda sells no model access, so the LLM side of the bill is entirely yours. Vercel's agent-browser CLI even accepts --engine lightpanda, handing agents compact accessibility-tree snapshots of roughly 200 to 400 tokens instead of the 3,000 to 5,000 a raw DOM dump costs.

4. MCP server: one browser per agent

lightpanda mcp exposes the browser as a Model Context Protocol server over stdio or HTTP. The HTTP mode is the interesting one. Each connection gets its own browsing session (its own page, cookies and memory), so two agents stop clobbering each other's state, while agents that deliberately share a session ID can collaborate on the same page. A run tool executes PandaScript in the caller's session, with cookies and storage persisting between calls so a login survives across tool invocations. There is also an installable agent skill in the project's agent-skill repository. Coding agents like the ones in our roundup of the 7 best AI coding agents in 2026 can pick this up as a standard tool, and task-running agents in the OpenClaw mold get a real browser without a Chrome install.

Pricing: free to self-host, $19 to rent

Lightpanda's business model is the classic open-core split: the engine is free, the managed infrastructure is the product. The rate card on the official pricing page is short and readable:

Currency conversions use November 2, 2026 market rates, verified at publication, and are approximations. Lightpanda bills in US dollars. The overage rate of $0.08 per browser hour works out to roughly £0.06 or C$0.11 per hour.

The fine print is where the real cost picture lives. First, the cloud tiers say "bring your own proxy": there is no bundled residential or datacenter proxy network, so serious scraping workloads add a proxy bill on top. Second, the cloud offers a choice of engines: Chrome or Lightpanda's own browser, so compatibility-fallback traffic runs at Chrome's resource profile. Third, the free tier's 10 hours a month is a trial-shaped allowance, not a production tier. It is enough to verify the performance claims on your own workload, not to run one.

The biggest pricing-adjacent catch is not on the pricing page at all: it is the license. AGPL-3.0 is a network copyleft license: if you run modified Lightpanda code as a network service, you must offer the source to your users. Self-hosting the unmodified binary inside your own stack is fine, but if you build a hosted scraping product on a forked engine, the AGPL follows you. Teams evaluating this against MIT-licensed alternatives should get the license question answered before the benchmark question.

Lightpanda vs the alternatives

The honest summary: Lightpanda does not replace Chrome. It replaces the specific, expensive habit of running Chrome for workloads that never look at a pixel. If your automation needs screenshots that match what a user sees, canvas rendering, or the long tail of web-platform quirks, you still need a real rendering engine. Lightpanda's own cloud knows it, which is why the Chrome option exists.

The catches

No rendering engine means no pixels. PNG and PDF output are text-only renders, and the project's own coverage is blunt about it: use Lightpanda for scraping, form-filling and crawling at scale; do not buy it for visual QA. Anything that depends on layout (visual regression tests, screenshot diffing, canvas-based CAPTCHAs) is out of scope by design.

Compatibility is the second catch. Independent reviewers note crashes on dynamic or complex sites, incomplete Web API coverage, and gaps in JavaScript framework support. The project publishes its Web Platform Tests results openly, which is commendable. But the practical advice from production users is the same: run your own workload through the free tier before committing. Heavy single-page apps with deferred hydration can return incomplete HTML from a plain fetch. The agent mode exists partly to work around that by driving the page like a user would.

Third: it is not an antidetect browser. There is no fingerprint spoofing: a pricing survey of the browser market explicitly files it under "scraping and AI agents, not multi-accounting." If your use case is evading bot detection, this is the wrong tool and the wrong vendor.

Fourth, the agent-mode economics. Lightpanda charges nothing for the agent itself, but every token the agent burns goes on your own API key: Anthropic, OpenAI, Gemini, or a local model. The PandaScript replay pattern exists precisely to keep that bill small in production, but the exploration phase is metered by your model provider, not by Lightpanda.

Fifth, telemetry. The binary collects and sends usage telemetry by default, and you opt out with the LIGHTPANDA_DISABLE_TELEMETRY environment variable. It is disclosed in the README with a

Pro tips and common mistakes

Start with the free cloud tier, not a self-hosted benchmark. Ten browser hours is enough to run your actual workload (your pages, your selectors), and the only benchmark that matters is yours. Vendor numbers are a reason to test, not a reason to migrate.

Use agent mode as a script generator, not a runtime. The intended workflow is prototype in plain English, export the PandaScript, and replay it token-free. Running the LLM agent in a loop on a schedule is the most expensive way to use this tool and misses the point of the design.

Mind the AGPL before you build a service on it. If you are shipping a product where Lightpanda runs on your servers and users hit it over the network, talk to whoever approves licenses first. The unmodified binary for internal automation is the safe zone, while a forked engine behind your API is not.

Keep Chrome in the loop for the long tail. The pragmatic setup is Lightpanda for the 90% of pages it handles and the cloud's Chrome fallback (or your existing Playwright grid) for the rest. The project's own pricing page concedes this architecture, so adopt it deliberately instead of discovering it at 2 a.m.

Frequently asked questions

Is Lightpanda really 9x faster than Chrome?

On its own published benchmark (933 real pages on an AWS EC2 m5.large instance), yes: 5 seconds against 46 for 100 pages, with 123 MB peak memory against roughly 2 GB. No independent replication of that exact setup exists, but third-party production estimates land in the same neighborhood. Treat it as a strong directional claim, then verify with your own pages on the free tier.

Is Lightpanda free?

The browser binary is free and open source under AGPL-3.0, and you can self-host as much as you want. The managed cloud has a free Explorer tier (10 browser hours a month), a $19-a-month Builder tier with 300 hours, and custom Enterprise pricing. If you use agent mode, the LLM tokens are billed by your own model provider.

Can Lightpanda replace Puppeteer or Playwright?

It does not replace the libraries. It replaces the browser underneath them. Your Puppeteer or Playwright scripts connect to Lightpanda's CDP server the same way they connect to Chrome. Playwright's multi-browser testing features still need real Chromium, WebKit or Firefox.

Does Lightpanda work on Windows?

There is no native Windows binary, so you run it inside WSL2, and your automation client can live either inside WSL or on the Windows host. Linux and macOS have native binaries, plus Docker images and a Nix flake.

What can't Lightpanda do?

Anything that needs pixels: visual QA, screenshot testing, canvas rendering, and sites that depend on full layout behavior. It also lacks fingerprint spoofing, so it is not a tool for evading bot detection, and very dynamic JavaScript-heavy apps can still trip it up.

The browser market spent a decade converging on Chromium for everything, including jobs Chromium was never designed for. Lightpanda is the first serious attempt to build the other thing: a browser for machines, priced for fleets, with an agent workflow that treats LLM calls as a prototyping cost rather than a runtime tax. The 40,000 stars say developers are hungry for it. The AGPL license, the rendering gap and the bring-your-own-proxy cloud say to evaluate it like infrastructure, not magic. Run your own ten hours (they are free) and let your workload decide.

Sources: Lightpanda GitHub repository and README; Lightpanda official pricing page and homepage (both read live November 2, 2026); SiliconNoon's Open Source Radar, October 31, 2026; Roundproxies' production Lightpanda guide; AlternativeTo's Lightpanda listing; the AlienCPA antidetect pricing survey (October 2026); a dev.to Lightpanda walkthrough; and x-cmd's Lightpanda install notes.

This is general information, not procurement or legal advice.