How to Install Chrome for Puppeteer Website Screenshots on Windows

For the standard Windows setup, install puppeteer in your Node.js project and let its install step download the compatible Chrome for Testing browser. You usually do not need to install regular Chrome separately. If package manager install scripts are disabled, run npx puppeteer browsers install after installing the package.

This guide covers a local Windows x64 setup, a runnable screenshot script, using an existing Chrome installation, and fixes for common browser installation and launch errors. Puppeteer’s current system requirements list Node.js 22.12 or newer. Check the live system requirements before you begin, since requirements and browser mappings can change.

1. Check Node.js and Windows requirements

Open PowerShell or Windows Terminal and check Node.js and npm:

node --version
npm --version

Use Node.js 22.12 or newer for the requirements documented for Puppeteer 25.12.0. The installation guide supports Windows x64 and notes that unpacking Chrome for Testing on Windows requires tar.exe or PowerShell, unless the optional yauzl dependency is installed. The guide does not establish a universal supported-edition matrix for Windows, so check current documentation for your environment.

2. Install Puppeteer and its browser

In your project directory, initialize a project if needed and install Puppeteer:

mkdir puppeteer-screenshots
cd puppeteer-screenshots
npm init -y
npm install puppeteer

The Puppeteer package normally downloads the compatible Chrome for Testing browser during installation. The documented Windows download is approximately 280 MB, so allow time and disk space for it. Puppeteer caches the browser under your user home directory in .cache/puppeteer by default. You can change that location with PUPPETEER_CACHE_DIR or Puppeteer configuration.

Equivalent package installs include:

# Yarn
 yarn add puppeteer

# pnpm
 pnpm add puppeteer

# Bun
 bun add puppeteer

Use the command for your package manager and omit the leading indentation if copying into a shell. Package managers and project policies can differ in how they run install scripts.

3. Install Chrome explicitly if install scripts were blocked

If your package manager skipped Puppeteer’s install script, the package may be present without its browser. From the project directory, run:

npx puppeteer browsers install

To inspect browsers Puppeteer knows about, run:

npx puppeteer browsers list

The browser management CLI can also install stable or version-specific Chrome for Testing builds. See the official browser management documentation for the current CLI syntax and options.

4. Capture a website screenshot

Create screenshot.js in the project folder. This complete example launches Puppeteer’s downloaded browser, sets a viewport, waits for the page load event, and writes a full-page PNG:

const puppeteer = require('puppeteer');

async function main() {
  const browser = await puppeteer.launch();
  try {
    const page = await browser.newPage();
    await page.setViewport({ width: 1440, height: 900, deviceScaleFactor: 1 });
    await page.goto('https://example.com', {
      waitUntil: 'load',
      timeout: 30000,
    });
    await page.screenshot({
      path: 'screenshot.png',
      fullPage: true,
      type: 'png',
    });
    console.log('Saved screenshot.png');
  } finally {
    await browser.close();
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Run it with:

node screenshot.js

fullPage: true captures beyond the initial viewport. For pages that load images as you scroll, full-page capture does not guarantee every lazy-loaded image will have loaded; sites may need a scrolling or site-specific wait strategy. Rendering also depends on the site, network, fonts, and browser environment, so do not assume identical output across machines without checking it.

5. Choose the right browser installation method

Approach	When to use it	Browser responsibility
`puppeteer` default	Typical local automation and screenshots	Puppeteer installs and manages its compatible Chrome for Testing browser.
`channel`	You want Puppeteer to find a regular installed Chrome channel	You manage the installed Chrome and should validate it against your Puppeteer release.
`executablePath`	You need to launch a browser at a specific executable path	You manage the executable, its path, and version compatibility.
`puppeteer-core`	You manage the browser yourself or connect to a remote browser workflow	No browser is downloaded automatically; provide a browser path or channel at launch.

Puppeteer guarantees compatibility with its bundled browser. A separate Chrome installation gives you more control over browser management, but you take responsibility for version compatibility and for keeping the executable path valid for the Windows account and machine running the script.

Use an installed Chrome channel

For a regular Chrome installation, specify a channel in launch. The launch option names and availability are documented in the Puppeteer launch options reference:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({ channel: 'chrome' });
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'load' });
    await page.screenshot({ path: 'chrome-channel.png', fullPage: true });
  } finally {
    await browser.close();
  }
})();

Use this when the channel is installed where the process runs and Puppeteer can locate it. For controlled deployments, verify the selected Chrome version whenever Puppeteer changes.

Use a specific executable path

Set executablePath if you maintain a known browser executable at a stable path. The path below is only an example; replace it with the actual path on your machine:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    executablePath: 'C:\\path\\to\\chrome.exe',
  });
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'load' });
    await page.screenshot({ path: 'specific-chrome.png', fullPage: true });
  } finally {
    await browser.close();
  }
})();

Use a path that exists for the Windows user running Node. Avoid relying on a developer-specific path in a script that runs on another machine or in a service account.

Use puppeteer-core when you manage Chrome

puppeteer-core does not download a browser. Install it with:

npm install puppeteer-core

Then provide a path or channel explicitly. For example:

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

(async () => {
  const browser = await puppeteer.launch({
    executablePath: 'C:\\path\\to\\chrome.exe',
  });
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'load' });
    await page.screenshot({ path: 'managed-chrome.png', fullPage: true });
  } finally {
    await browser.close();
  }
})();

This is useful when a browser is supplied by a remote service or managed separately. It is not the simplest choice when you want Puppeteer to install its own compatible browser.

6. Configure cache location and browser versions

The default browser cache is under the user home directory at .cache/puppeteer. When the process cannot find an installed browser, confirm that install and runtime use the same cache location. You can set a custom cache directory in the environment before installation, for example in PowerShell:

$env:PUPPETEER_CACHE_DIR = 'D:\puppeteer-cache'
npm install puppeteer

Use the same value when running the script in that shell. Alternatively, configure the cache directory in Puppeteer configuration; see the official configuration guide. Keep the cache available to the account that launches Chrome, especially in scheduled tasks or service processes.

For a deliberately managed browser, check the official supported browsers page for the mapping that matches your Puppeteer release. At research time, Puppeteer 25.12.0 mapped to Chrome for Testing 154.0.8037.57; that is a dated mapping, not a permanent version recommendation.

7. Troubleshooting Chrome installation and launch on Windows

Symptom	Likely cause	What to do
`Could not find Chrome`	The browser download did not run, often because install scripts were blocked.	Run `npx puppeteer browsers install`, then check `npx puppeteer browsers list`.
Puppeteer cannot find a browser that was downloaded	The cache directory differs between install and runtime, or the process runs under another user.	Check `PUPPETEER_CACHE_DIR` and configured `cacheDirectory`; make the browser cache accessible to the runtime account.
Chrome does not launch under a Windows extension policy	Puppeteer disables extensions by default, which may conflict with policy enforcement in some environments.	The troubleshooting guide documents `enableExtensions: true` as a workaround when policy requires extensions. Review the current launch options and your organization’s policy.
Sandbox access denied for downloaded Chrome	Chrome’s sandbox permissions may not be configured as expected, particularly with older Puppeteer versions or restrictive environments.	From Puppeteer 22.14.0 onward, Puppeteer attempts to configure sandbox permissions through the browser’s `setup.exe`. For persistent issues, follow the official Windows permissions guidance and apply the narrowest suitable policy.
Chrome starts but the screenshot is blank or incomplete	The page may not have finished rendering, may require application-specific interaction, or may defer images until scroll.	Choose an appropriate navigation wait condition, wait for a known selector or site-specific readiness signal, and check the result at the selected viewport. A generic load event cannot guarantee an application is visually ready.
Chrome fails after updating Puppeteer or Chrome	A separately managed browser version may no longer match the Puppeteer release.	Use the bundled browser, or check the supported browser mapping and validate the managed executable with the installed Puppeteer version.
Browser installation cannot unpack the download	The Windows environment may lack the expected extraction support.	Ensure `tar.exe` or PowerShell is available, or use the optional `yauzl` dependency as documented by Puppeteer.

For current troubleshooting details, use Puppeteer’s official troubleshooting guide. Do not use --no-sandbox as a routine Windows fix: the cited sandbox warning and example address Linux troubleshooting, not a general Windows installation procedure.

8. Performance, reliability, and cost considerations

Browser download: Chrome for Testing is a substantial download (approximately 280 MB for Windows in the cited guide). Cache it where the running account can reuse it rather than repeatedly installing it.
Repeatability: Puppeteer’s bundled browser is the documented compatibility target. A system Chrome can update independently, so pin and validate the browser workflow used by your project.
Capture time: Page load time varies with the target site and its network resources. Set a suitable navigation timeout and wait for the page condition the screenshot actually needs.
Resource use: Each launched browser consumes machine resources. Close browser instances in a finally block, as in the examples, so failed navigations do not leave processes running.
Screenshot fidelity: Viewport size, device scale factor, fonts, browser version, site state, and delayed content can change the image. Specify viewport settings and a relevant readiness condition for repeatable captures.
Direct software cost: Puppeteer and Chrome for Testing installation are software setup choices; operational costs depend on the Windows machine or hosting environment you use. The research sources do not provide a universal cost estimate.

Or skip the browser setup

If you need website screenshots without installing and maintaining Chrome, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a screenshot or PDF. Its API also supports full-page capture, viewport and device presets, element selection, wait conditions, custom CSS and JavaScript, and other capture options. See the ScreenshotNeo API docs.

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 require('node:fs/promises').writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

ScreenshotNeo accepts cookie and consent banners as a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.

Frequently asked questions

Do I need to install Google Chrome before installing Puppeteer?

No. For the normal workflow, install puppeteer and use its downloaded Chrome for Testing browser. Install regular Chrome separately only when you specifically want to manage and select that browser.

Why does puppeteer-core not include Chrome?

puppeteer-core is intended for workflows where you manage or connect to a browser yourself. Supply an executable path or channel when launching it.

Can I use Puppeteer screenshots on Windows without a visible browser window?

Puppeteer’s launch options include headless operation; check the current launch reference for the option supported by your installed release. The examples in this guide use the default launch configuration.

Will the screenshot look identical on every Windows computer?

Not necessarily. Browser version, viewport, device scale, fonts, page state, and network timing can affect rendering. Use a consistent browser setup and explicit capture settings, then validate the output in the environment that matters.