Puppeteer Chrome Release Channels Explained

Chrome has four release channels: Stable, Beta, Dev, and Canary. They expose browser changes at different stages of maturity. For routine Puppeteer automation, start with the Chrome for Testing version Puppeteer downloads and supports. Use channel when you specifically need an installed system Chrome channel, such as Beta for compatibility checks. Puppeteer’s channel option selects an installation; it does not install Chrome for you.

What are the Chrome release channels?

Each channel trades maturity for earlier access to browser changes:

Channel	What it is for	Practical fit
Stable	The broadly released Chrome stream.	Routine checks that should resemble the browser most users have.
Beta	A preview of an upcoming Stable release.	Check compatibility with changes before they reach Stable.
Dev	A stream for active development.	Prototype against newer behavior, accepting a greater chance of breakage.
Canary	The most experimental stream, with early features and less testing.	Exploratory checks, not a dependable production baseline.

These are stages in Chrome’s release process, not promises that every channel has a particular feature or version. See [Chrome’s release-channel guide](https://developer.chrome.com/docs/automation-and-testing/release-channels?authuser=0&hl=en) for the channel overview.

Chrome for Testing is not a fifth channel

Chrome for Testing is a Chrome flavor designed for web application testing and automation. It is distinct from the regular system Chrome installations selected by Puppeteer’s channel option. Puppeteer works best with the Chrome for Testing version it downloads; it does not guarantee operation with an arbitrary Chrome version. Check the [supported browsers table](https://pptr.dev/chromium-support/) for the browser associated with your installed Puppeteer release.

For example, the research snapshot maps Puppeteer 25.12.0 to Chrome for Testing 154.0.8037.57. Treat that as a versioned example, not as a current mapping for other Puppeteer releases or all Chrome channels.

Which channel should I use with Puppeteer?

Routine automation: use the Puppeteer-matched Chrome for Testing installation. This gives you the compatibility pairing Puppeteer documents.
Upcoming Stable compatibility: keep the supported browser as your baseline and add Beta as a separate check.
Early prototyping: try Dev when you need changes earlier in development and can tolerate instability.
Experimental feature exploration: use Canary for early checks. Do not assume it is a stable production baseline.

Keep the browser version and Puppeteer version visible in CI logs. When a failure appears, this makes it easier to tell whether it followed a Puppeteer update, a browser update, or a channel change.

Launch an installed Chrome channel

The following complete Node.js example launches installed Chrome Beta, navigates to a page, prints its title, and closes the browser even if navigation fails:

const puppeteer = require('puppeteer');

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

Install puppeteer in your project first. The package includes the browser Puppeteer supports; when using a channel, install that regular Chrome channel separately on the machine running the script. The available channel values are stable, beta, dev, and canary, as documented by the [ChromeReleaseChannel enum](https://pptr.dev/browsers-api/browsers.chromereleasechannel).

Use puppeteer-core with an installed browser

puppeteer-core does not download a browser. Supply either a channel or an explicit executable path. For a channel installation:

const puppeteer = require('puppeteer-core');

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

For a nonstandard installation location, pass executablePath instead. Puppeteer’s [LaunchOptions reference](https://pptr.dev/api/puppeteer.launchoptions) documents these launch options. Avoid specifying both when you do not need to: choose the channel lookup or the exact executable you intend to run.

Install Chrome for Testing by channel or version

If you want a downloaded Chrome for Testing browser, use the @puppeteer/browsers tooling rather than expecting channel to install it. The official CLI example installs the Stable-tagged build:

npx @puppeteer/browsers install chrome@stable

The CLI also accepts tags such as chrome@canary and exact versions. Pin an exact browser version in repeatable CI when your workflow requires a fixed browser, and review the supported-browser table when upgrading Puppeteer. See [Puppeteer browser installation](https://pptr.dev/guides/installation) and the [@puppeteer/browsers API](https://pptr.dev/browsers-api/).

What changed in the release schedule?

Google announced that Beta and Stable would move to a two-week milestone cycle beginning with Chrome 153 Stable on September 8, 2026. The announcement said Dev and Canary would not change as part of that schedule change. Release schedules are date-sensitive, so consult [Google’s announcement](https://developer.chrome.com/blog/chrome-two-week-release) for the stated change and check the live schedule before planning around a milestone. Do not infer current versions for every channel from Puppeteer’s supported-browser table: it maps Puppeteer to its supported browser, not to all live channel releases.

Common problems and fixes

Symptom	Likely cause	What to do
Chrome channel executable cannot be found	The requested regular Chrome channel is not installed, or the environment does not expose it in a location Puppeteer recognizes.	Install that channel on the machine, or use `executablePath` for its actual location. For a managed test browser, install Chrome for Testing with `@puppeteer/browsers`.
`puppeteer-core` reports that an executable path or channel is required	`puppeteer-core` does not supply a browser automatically.	Pass `channel` for a recognized system installation or `executablePath` for a specific binary.
Browser starts but automation fails after a Chrome update	The installed Chrome version may not match the Puppeteer release’s supported browser.	Check the supported-browser table. Restore the matched Chrome for Testing version or update Puppeteer and browser together.
Canary or Dev behaves differently between runs	These streams expose active or experimental changes and are less suitable as fixed baselines.	Use the Puppeteer-matched browser for the baseline. Keep experimental-channel checks separate and record the version.
CI works locally but cannot launch the selected channel	The CI image may not have the regular system Chrome installation available.	Install the browser in the image or use a downloaded Chrome for Testing build that your job manages explicitly.

Performance, reliability, and cost considerations

The channel name alone does not establish a speed advantage. Choose based on the browser behavior you need to cover, then keep the browser setup consistent when comparing runs. Stable is a practical representative baseline; Beta, Dev, and Canary help expose changes earlier but can introduce differences your users do not yet encounter.

For reliable automation, pin or otherwise control browser and Puppeteer versions in CI, use the documented supported-browser pairing, and log both versions with failures. Add early-channel testing as a separate compatibility signal rather than replacing the baseline. Browser installation and CI execution costs depend on your own infrastructure; the research sources provide no benchmark or price comparison.

Or skip the browser setup

If your goal is to capture a website image rather than test Chrome behavior, [ScreenshotNeo](https://screenshotneo.com) offers a website screenshot API and MCP server. One GET request can return a PNG, JPEG, WebP, or PDF. The API accepts the parameter names used by other screenshot APIs, which can make switching easier. See the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/) for configuration details.

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}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

Cookie and consent banners are accepted and removed before capture; more than 60 known consent platforms, newsletter popups, and chat widgets are covered, and each cleanup step can be turned off.
Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Response headers report the page verdict and billing status.
An MCP server lets Claude, Cursor, and other MCP clients use take_screenshot, get_page_info, and capture_pdf.
The Free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 screenshots; every feature is available on every plan.

FAQ

Does Puppeteer support Chrome Canary?

Puppeteer’s channel type includes canary. It can select an installed Canary channel, but Canary is experimental and Puppeteer does not guarantee compatibility with arbitrary Chrome versions.

Does `channel: 'beta'` download Chrome Beta?

No. It asks Puppeteer to locate and use an installed Chrome Beta. Install that channel separately, or use browser tooling to install Chrome for Testing.

Is Chrome for Testing the same as Stable?

It is a Chrome flavor intended for testing and automation, not a release channel. Puppeteer downloads a version matched to its release.

Should production automation run Canary?

Use Canary only when you deliberately want an experimental check and can handle changes. For a predictable baseline, use the Puppeteer-supported Chrome for Testing version.