Puppeteer’s executablePath() returns the default executable location for the browser setup in use. It is not one universal Chrome path: the result depends on the selected browser, build, cache directory and platform, or can be redirected by an explicit executable path or a Chrome release channel. First establish whether you want Puppeteer’s managed browser, a specific executable, or system Chrome.
Which browser path is Puppeteer resolving?
There are three distinct routes, and confusing them is a common cause of “executable not found” errors:
- Puppeteer-managed browser: Puppeteer downloads a supported browser build and locates it in its configured cache.
- Explicit executable: Your configuration or launch options specify a path directly.
- Chrome channel: Puppeteer looks for a regular Chrome installation in a known system location for the selected release channel.
The current Puppeteer API references identify themselves as version 25.12.0. Check the version installed in your project and use the documentation matching that version, because defaults and deployment layouts can differ across releases.
How Puppeteer computes a managed browser path
The public @puppeteer/browsers API describes computeExecutablePath in terms of four inputs: browser, build ID, cache directory and platform. Platform is detected automatically if not supplied. The browser provider determines the executable’s location within the extracted browser download, so the final path is not safely reducible to one literal path for every operating system and browser build.
#1 Best Overall
Puppeteer’s configuration reference gives the default cache directory as path.join(os.homedir(), '.cache', 'puppeteer'). The PUPPETEER_CACHE_DIR environment variable can override it. If cacheDir is null in the browser API, the computed executable path is relative to the extracted download location—for example, ./chrome-linux64/chrome. That example is not a universal path.
Use executablePath() to ask Puppeteer for its default executable location:
import puppeteer from 'puppeteer';
const executable = puppeteer.executablePath();
console.log(executable);This prints the path Puppeteer calculates for the configured setup. Do not treat the returned string alone as proof that the file exists or that the browser can launch; verify the installation and test the launch separately.
Rank #2
- HTML CSS Design and Build Web Sites
- Comes with secure packaging
- It can be a gift option
Configuration that can change the result
The configuration API marks executablePath as auto-computed by default, but it can be overridden with PUPPETEER_EXECUTABLE_PATH. Environment variables override applicable values from a configuration file. The browser selection, cache location, and download settings also matter.
PUPPETEER_EXECUTABLE_PATH: points Puppeteer to a chosen executable.PUPPETEER_CACHE_DIR: changes the managed browser cache directory.PUPPETEER_BROWSER: affects which browser is selected.- Browser-specific download settings and download-skipping configuration: determine whether Puppeteer installs a managed browser at all.
At launch, the executablePath option selects a specific executable rather than relying on the bundled browser. A channel option instead requests a Chrome release channel and directs Puppeteer to a system installation. These are different choices: an explicit path names a file; a channel asks Puppeteer to locate an installation.
System Chrome and channel lookup
When you pass a Chrome channel in launch options, Puppeteer searches known system locations for that release channel. The computeSystemExecutablePath() API likewise checks known locations for a channel and throws if the expected executable is absent. The API references do not establish a complete location table for every platform, so do not assume a path copied from another machine or operating system applies to yours.
Rank #3
import puppeteer from 'puppeteer';
const browser = await puppeteer.launch({ channel: 'chrome' });
try {
const page = await browser.newPage();
await page.goto('https://example.com');
} finally {
await browser.close();
}If you need a specific Chrome or Chromium binary rather than the channel installation, pass its path explicitly using executablePath. For either externally selected route, confirm that the target file exists and is executable in the environment where the Node.js process runs.
What changes with puppeteer-core?
Do not assume puppeteer-core has the full puppeteer package’s download and configuration defaults. Puppeteer’s PuppeteerNode reference states that when using puppeteer-core, options.executablePath or options.channel must be provided. The same reference says Puppeteer configuration files and environment variables are ignored by puppeteer-core.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
import puppeteer from 'puppeteer-core';
const browser = await puppeteer.launch({
executablePath: '/absolute/path/to/chrome',
});
try {
const page = await browser.newPage();
await page.goto('https://example.com');
} finally {
await browser.close();
}Replace the example path with a real executable available to the process. Alternatively, provide a supported channel when you intend to use system Chrome.
Rank #4
- Brand: Wiley
- Set of 2 Volumes
- A handy two-book set that uniquely combines related technologies Highly visual format and accessible language makes these books highly effective learning tools Perfect for beginning web designers and front-end developers
Why deployment can break a path that worked locally
Starting in Puppeteer v19.0.0, browser downloads are stored in ~/.cache/puppeteer by default so that the cache can be shared globally. That location may not travel with your application when a package is built in one environment and moved to a fresh deployment environment. A path computed against a cache that was not installed or copied into the runtime environment can therefore fail at launch.
The Puppeteer configuration guide suggests changing cacheDirectory and reinstalling Puppeteer when the global cache layout causes this kind of deployment issue. Keep installation and runtime aligned: use the same effective cache directory, and ensure the browser download is present in the deployed environment.
Troubleshoot “executable not found” and launch errors
- Identify the package and version. Check whether the project uses
puppeteerorpuppeteer-coreand inspect the installed version. Use matching documentation rather than assuming current defaults describe an older installation. - Check the effective configuration. Review the configuration file and the process environment for
PUPPETEER_EXECUTABLE_PATH,PUPPETEER_CACHE_DIR,PUPPETEER_BROWSERand browser-specific download settings. Environment variables override applicable configuration-file values. - Check whether a browser was installed. Inspect whether browser downloading was skipped and whether the selected browser and build are present in the cache directory used at runtime.
- Inspect launch options. Look for
executablePathorchannel; either can direct launch away from the managed browser you expected to use. - For a managed browser, align the inputs. Verify browser, build ID, platform and cache directory across installation, path calculation and runtime.
- For a channel, verify system Chrome. Confirm the requested release channel is installed where Puppeteer can find it. Channel lookup can throw if the expected executable is absent.
- Test the file and compatibility separately. A calculated path does not by itself establish that the file exists or can run. Puppeteer guarantees compatibility with its bundled browser; another Chrome or Chromium executable carries compatibility risk.
Or skip the browser setup
If the goal is simply to capture a website rather than automate a browser locally, ScreenshotNeo can return a screenshot through one GET request. The request below saves a WebP screenshot of https://stripe.com:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation. ScreenshotNeo accepts cookie and consent banners before capture and removes 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 cost nothing, with the result identified in response headers. Its MCP server provides take_screenshot, get_page_info and capture_pdf for AI agents. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.
Sign up for ScreenshotNeo’s free plan.
Frequently Asked Questions
Does Puppeteer’s executablePath() launch Chrome?
No. It returns a path string; launching the browser is a separate operation.
Why does my local path work but the deployed path fail?
A common cause is that the managed browser cache was not installed or carried into the runtime environment. Check the effective cache directory and browser installation there.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
