Which Browsers Does Puppeteer Support?

Puppeteer officially supports Chrome and Firefox. Chrome automation uses the Chrome DevTools Protocol (CDP) by default; Firefox uses WebDriver BiDi by default. WebDriver BiDi can also automate Chrome. The exact browser build depends on your Puppeteer version, so check the supported browser table for the package you install.

Supported browsers and protocols

Browser	Default protocol	What to know
Chrome	CDP	Puppeteer continues to support Chrome through CDP, including Chrome-specific functionality.
Firefox	WebDriver BiDi	Puppeteer uses BiDi by default for Firefox.

Puppeteer’s documented supported-browser choices are Chrome and Firefox. Do not infer official support for Safari or Edge just because they share an engine or have similar behavior. Third-party integrations and remote browser services are separate from Puppeteer’s own support statement.

According to the Puppeteer FAQ, support for both Chrome and Firefox applies from Puppeteer v23.0.0 onward. WebDriver BiDi support for both browsers is described as production-ready from that release. Chrome automation through CDP remains supported.

Match the browser to your Puppeteer version

Puppeteer releases are bundled with specific browser releases to keep the underlying CDP and WebDriver BiDi implementations compatible. A browser working with one Puppeteer version does not mean an arbitrary newer or older build will work with another.

Find the exact Puppeteer version in your project: npm ls puppeteer or inspect your lockfile.
Open the supported browser table and locate that Puppeteer release.
Use its paired browser build. If your exact Puppeteer version is not listed, the documentation says to use the browser version from the immediately preceding Puppeteer entry.
When reporting a bug, include the Puppeteer version, browser version, operating system, architecture, and launch options.

The table changes as Puppeteer ships releases. Avoid copying a browser build number from an old article or pinning a mismatched browser without checking the current mapping.

Chrome, Chromium, and headless mode

The supported family is called Chrome, but the downloaded browser has changed over time:

Puppeteer v20 and later: Puppeteer downloads and works with Chrome for Testing.
Before v20: Puppeteer downloaded and worked with Chromium.
Regular headless and headful: Current documentation describes them as sharing a code path.
Old headless mode: This is the separate chrome-headless-shell program. Select it with headless: 'shell'.

“Chrome,” “Chromium,” and “Chrome for Testing” are related terms, but they do not identify one interchangeable build for every Puppeteer release. Check the version table before substituting a locally installed browser.

Install and launch Chrome

For a current Puppeteer project, install Puppeteer and launch its compatible downloaded browser:

npm install puppeteer

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
    console.log(await page.title());
  } finally {
    await browser.close();
  }
})();

By default, Puppeteer uses Chrome. If you configure it to skip browser downloads, provide an executable path for a compatible browser build; skipping downloads does not remove the version compatibility requirement.

Use Firefox

Install Puppeteer, then explicitly select Firefox when launching. The browser must be available to Puppeteer, either through the package’s browser installation workflow or a correctly configured executable.

npm install puppeteer

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    browser: 'firefox',
    headless: true
  });
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
    console.log(await page.title());
  } finally {
    await browser.close();
  }
})();

Protocol and feature coverage can differ between browser families. If your automation relies on a browser-specific capability, check Puppeteer’s current API documentation for that capability and protocol rather than assuming identical behavior.

Runtime, operating systems, and configuration

The current system requirements list Node.js 22.12 or later and TypeScript 5.0.1 or later when using TypeScript. Chrome for Testing is listed for Windows x64; macOS x64 and arm64; Debian or Ubuntu Linux x64 and arm64; and openSUSE or Fedora Linux x64 and arm64. Linux may need additional system packages.

Firefox has separate requirements maintained by Mozilla. Puppeteer’s requirements documentation notes that Linux needs xz or bzip2 to unpack Firefox versions. Check the live requirements pages before provisioning CI images because platform support and dependencies can change.

Puppeteer’s configuration defaults to Chrome and offers supported-browser selection and skipDownload settings. A supported browser family does not mean a binary is downloaded in every setup. Review the configuration guide when controlling browser downloads, cache locations, or executable paths.

Common compatibility problems

Symptom	Likely cause	What to do
Browser fails to launch after upgrading Puppeteer	A manually supplied browser build does not match the Puppeteer release.	Check the supported-browser table and use the paired build, or use the browser installed for that Puppeteer version.
Executable not found	Browser downloads were skipped, or the configured path is wrong.	Install the browser or correct the executable path and download configuration.
Missing shared library or launch dependency on Linux	The environment lacks required system packages.	Compare the OS image with Puppeteer’s system requirements and install the listed dependencies.
Firefox download cannot be unpacked on Linux	`xz` or `bzip2` is missing.	Install one of the required unpacking tools, then retry the browser installation.
Firefox or Chrome API behavior differs from examples	The example may rely on a protocol-specific feature or a different Puppeteer release.	Confirm the browser, Puppeteer version, and protocol, then consult the API documentation for that feature.
Old headless behavior changed	The old headless implementation is a separate shell binary.	Use `headless: 'shell'` when that mode is specifically required, and make sure its binary is installed.

Performance, reliability, and cost considerations

For repeatable automation, use the browser build paired with the Puppeteer release and pin the package version in your lockfile. This reduces surprises from browser protocol changes. In CI, install browser binaries and required OS libraries as part of image setup, and verify that the runner architecture is among the documented platforms.

Launching a browser has setup and resource costs; reusing a browser process for related tasks can avoid repeated startup work, while creating isolated pages or contexts helps separate jobs. Always close pages and browsers when work finishes, including error paths. For parallel workloads, size concurrency to the memory and CPU available to the runner.

Puppeteer itself is a Node.js automation library; browser hosting, infrastructure, and operational cost depend on where and how you run it. Its FAQ positions Selenium as broader in language bindings and notes that Selenium Grid style large-scale orchestration is beyond Puppeteer’s scope. Choose based on language coverage, browser/version requirements, protocol features, and orchestration needs.

Or skip the browser setup

If your task is to capture a website rather than automate browser interactions, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns an image or PDF; see the API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Cookie banners, newsletter popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. Responses include page-verdict and billing headers.
An MCP server lets Claude, Cursor, and other MCP clients take screenshots, inspect page info, and capture PDFs.
The free plan includes 1,000 screenshots a month with no card. Paid plans start at $5 for 3,000 screenshots.

FAQ

Does Puppeteer support Firefox?

Yes. Puppeteer v23.0.0 onward supports Firefox, using WebDriver BiDi by default.

Does Puppeteer support Microsoft Edge or Safari?

The official supported-browser type names Chrome and Firefox. Similar engines do not establish official support for another browser.

Can I use my installed Chrome?

Configuration can use a supplied executable, but compatibility still depends on the Puppeteer and browser versions. Consult the supported-browser table before pinning a system browser.

Does Puppeteer always download a browser?

No. Download behavior can be changed through configuration, including skip-download settings. Ensure a compatible executable is available if downloads are disabled.