How to Find the Chrome Executable Path in Puppeteer

The quickest way to find the Chrome executable path managed by Puppeteer is to ask Puppeteer directly:

const puppeteer = require('puppeteer');
console.log(puppeteer.executablePath());

The returned value is the executable path for Puppeteer’s default browser. Use it as-is with puppeteer.launch(), or pass a different absolute path with the executablePath option. The cache directory is only the parent location where browser builds are stored; it is not itself the executable.

This guide covers the bundled browser, system-installed Chrome, puppeteer-core, configuration, and missing-browser errors. For the API details, see Puppeteer’s PuppeteerNode reference and LaunchOptions reference.

1. Print the path to Puppeteer’s browser

With the full puppeteer package installed, puppeteer.executablePath() returns the default executable path. Run this small script from the project where Puppeteer is installed:

const puppeteer = require('puppeteer');

const executablePath = puppeteer.executablePath();
console.log(executablePath);

For an ES module project:

import puppeteer from 'puppeteer';

console.log(puppeteer.executablePath());

You can also inspect the path in a one-off command:

node -e "console.log(require('puppeteer').executablePath())"

The path depends on the installed Puppeteer version, browser build, operating system, and configured cache location. Avoid copying a cache subpath from another machine or publishing one as universal.

2. Launch Puppeteer with the default or a specific executable

If you installed puppeteer, the normal launch uses the browser Puppeteer manages, so you usually do not need to look up or set a path:

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();
  }
})();

To select a browser binary yourself, supply an absolute path:

const puppeteer = require('puppeteer');

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

Replace the example path with the value printed by executablePath(), or with the path to the browser you intend to run. Puppeteer’s launch options describe this as a path to the browser executable. Compatibility is guaranteed only with the browser Puppeteer bundles; check version compatibility when selecting another build. See the official launch options documentation.

3. Find a system-installed Chrome binary

If you deliberately manage Chrome separately, Puppeteer provides computeSystemExecutablePath() to locate Chrome at a known release channel’s expected installation location. It takes the platform and channel as arguments and throws if Chrome is not found there. This is useful when your project relies on a standard system installation rather than Puppeteer’s downloaded browser.

const { computeSystemExecutablePath } = require('puppeteer');

const executablePath = computeSystemExecutablePath({
  platform: process.platform,
  channel: 'stable',
});
console.log(executablePath);

Use a channel supported by the installed Puppeteer version and your platform. This lookup checks known locations; it does not install Chrome or search every possible custom location. If Chrome was installed somewhere nonstandard, pass its actual absolute path to launch({ executablePath }). The API is documented at computeSystemExecutablePath().

4. Choose the right setup: puppeteer or puppeteer-core

Package	Browser setup	Path behavior
`puppeteer`	Downloads and manages a compatible browser by default.	Use `puppeteer.executablePath()` to inspect its default executable. A normal launch can omit the path.
`puppeteer-core`	Does not download a browser as the full package does.	Provide `executablePath` or a `channel` when launching. Its configuration files and environment-variable settings are ignored.

A minimal puppeteer-core launch with your own Chrome binary looks like this:

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

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

For a standard Chrome installation, you can select a channel instead of specifying the path:

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

(async () => {
  const browser = await puppeteer.launch({ channel: 'chrome', headless: true });
  try {
    const page = await browser.newPage();
    await page.goto('https://example.com');
  } finally {
    await browser.close();
  }
})();

Core launch requires either options.executablePath or options.channel. Configuration differs between the packages, so verify which one your application actually imports. See Puppeteer’s PuppeteerNode reference and configuration guide.

5. Configure the executable path and browser cache

For the full puppeteer package, configuration can come from supported configuration files or environment variables. PUPPETEER_EXECUTABLE_PATH sets an executable-path override. Configuration files and environment variables are ignored by puppeteer-core, so set launch options directly when using Core. See the official Configuration interface.

# Example shell environment for a full puppeteer installation
PUPPETEER_EXECUTABLE_PATH=/absolute/path/to/chrome node app.js

Browser downloads go to ~/.cache/puppeteer by default starting with Puppeteer v19.0.0. Set PUPPETEER_CACHE_DIR to change the download location, or set cacheDirectory in a .puppeteerrc.js configuration file. When changing configuration, follow Puppeteer’s instruction to reinstall so the browser is placed in the configured cache.

// .puppeteerrc.cjs
module.exports = {
  cacheDirectory: '/var/cache/puppeteer',
};

The cache directory is not the Chrome binary path. Ask Puppeteer for the executable path after installation, or use the system-path lookup or explicit path appropriate to your setup. For the documented cache and install behavior, see Puppeteer troubleshooting.

6. Install the browser when the executable is missing

If launching reports that the expected browser cannot be found, first check whether Puppeteer’s browser download ran. Some package managers or CI configurations block install scripts. Puppeteer documents installing the required browser manually with:

npx puppeteer browsers install

Then print the executable path again and retry. If your deployment manages browsers independently, install the browser in that environment and configure executablePath or a standard channel. The browser must exist in the same runtime environment as the Node.js process, including inside a container. See the installation guide and troubleshooting guide.

7. Diagnose common path and launch errors

Symptom	Likely cause	Fix
`Could not find expected browser locally`	The browser download did not run, the cache is empty, or the configured cache location differs from the install location.	Run `npx puppeteer browsers install`; check `PUPPETEER_CACHE_DIR` and `cacheDirectory`; print `puppeteer.executablePath()` in the same environment that launches the browser.
Core complains that `executablePath` or `channel` is required	The application uses `puppeteer-core` without selecting an independently managed browser.	Pass a valid `executablePath` or a supported `channel`.
The printed path exists locally but not in production	The path belongs to a different host, container image, user, or cache configuration.	Install the browser in the deployed runtime and compute or configure the path there. Do not assume a developer-machine path transfers to CI or a container.
Chrome starts but fails or behaves unexpectedly	The external browser version or build may not be compatible with the installed Puppeteer version.	Prefer Puppeteer’s bundled browser for reproducibility, or align and verify the browser and Puppeteer versions.
The custom path is not being used	A configuration override may not apply to Core, or the app may be launching a different package or process.	Check the imported package and pass `executablePath` directly in launch options when using Core.
Chrome is not found by system lookup	The selected channel is not installed at the expected platform location.	Install that channel in the standard location, choose the correct channel, or provide the actual custom path.

8. Performance, reliability, and cost considerations

Path lookup is not normally the expensive part of browser automation. Browser installation, process startup, page loading, and rendering are the operational concerns to plan around. A browser managed by Puppeteer gives the project a known build that Puppeteer targets; an independently managed system browser gives the operator control over installation but makes version alignment and deployment setup their responsibility.

For reliable deployments, install the browser as part of the environment setup, use the same configured cache location during installation and execution, and resolve or validate the executable in the runtime where the script runs. Avoid relying on a developer’s home-directory cache being present in a CI runner or container. Puppeteer’s compatibility guarantee applies to its bundled browser, so external builds can add maintenance work.

There is no special per-screenshot cost associated with finding the path in Puppeteer; the costs are the compute and maintenance costs of running and updating the browser in your own environment. If you only need screenshots and do not want to install, cache, version, or launch Chrome yourself, ScreenshotNeo provides a screenshot API and MCP server. See ScreenshotNeo and its API documentation.

Or skip the browser setup

Instead of managing a Chrome executable, make one GET request to ScreenshotNeo. Replace the URL and API key with your target and account key. See the ScreenshotNeo API docs for request options.

cURL

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

Python

import requests

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

Node.js

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(`ScreenshotNeo returned HTTP ${res.status}`);
const bytes = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

ScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers report the page verdict and billing status. Its MCP server lets AI agents 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. Sign up free for ScreenshotNeo.

Frequently asked questions

Does Puppeteer’s cache folder give me the executable path?

No. It identifies the browser download location. Use puppeteer.executablePath() to get the executable path for Puppeteer’s default browser.

Can I use Google Chrome instead of Puppeteer’s downloaded browser?

Yes. Select an installed channel or pass Chrome’s absolute path. Puppeteer does not guarantee compatibility with every external browser build, so check version alignment.

Why does `puppeteer.executablePath()` fail or point somewhere unexpected?

Check the installed package, browser installation, and cache configuration. The full package and puppeteer-core have different browser and configuration behavior, and the active runtime may use a different cache location.

Should I set `executablePath` if the default launch works?

Usually not. Leave it unset when using Puppeteer’s managed browser unless you have a reason to select a separately managed binary.