Recommended Free Tools
The error means Puppeteer cannot locate a usable Chrome for Testing binary in the cache it is configured to search. On Elastic Beanstalk, diagnose it in this order: confirm the browser download ran during deployment, compare the cache path and Linux user used at install and runtime, configure an explicitly managed executable when Chrome is installed elsewhere, then check shared libraries and CPU architecture if the file exists but will not launch.
What the error actually means
Puppeteer and Chrome can fail at two different stages. “Could not find Chrome” (often followed by a version such as 127.0.6533.88) normally means no matching browser exists in Puppeteer’s configured cache. A different failure occurs when the executable is present but Linux cannot start it because a shared library is missing, the binary is incompatible with the instance architecture, or permissions prevent execution.
Installing Chrome on your workstation does not install it on the EC2 instance behind Elastic Beanstalk. The deployment must download or install a browser on the target instance, and the application must be able to read and execute it.
1. Verify that Puppeteer’s browser download ran
A normal puppeteer installation downloads a compatible Chrome for Testing browser. Puppeteer’s installation guide says that, beginning with v21.6.0, it also downloads chrome-headless-shell; since v19.0.0 the default cache is $HOME/.cache/puppeteer. The guide lists approximate download sizes of 170 MB for macOS, 282 MB for Linux and 280 MB for Windows, so a deployment must have both network access and enough disk space. See the official installation guide for behavior applicable to your installed version.
#1 Best Overall
Check install-script policy
Package managers can suppress dependency install scripts. If your deployment log shows that scripts were ignored, the browser download was probably skipped. Run Puppeteer’s documented manual installer during the actual Elastic Beanstalk build or deployment:
npx puppeteer browsers installDo not run this only on a laptop. Run it in the environment that deploys to the EB instance, and fail the deployment if the command returns a non-zero status. If your package manager uses an install-script allowlist, add Puppeteer’s script according to that package manager’s current policy, then reinstall and verify the result.
Record what was installed
Capture the Puppeteer version, Node.js version, command output and the resulting browser directory in deployment logs. This turns a vague startup error into a checkable fact. Avoid assuming that a successful npm install means Chrome was downloaded; script suppression and network failures can leave the JavaScript package present without its browser.
2. Compare the cache path and runtime user
Read the complete error message. Puppeteer reports the cache path it searched. Compare that path with the directory written by npx puppeteer browsers install or the package install.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Why Elastic Beanstalk exposes this mismatch
The cache follows $HOME. AWS documents that Elastic Beanstalk platform hooks run as root, while the application process may run under another account. Therefore a hook can install Chrome under root’s home directory while the Node process searches the application user’s home directory, or the reverse. This is a condition to test on your instance, not a claim that every EB environment has it.
Rank #2
- In the deployment hook, print
id,echo "$HOME"and the Puppeteer cache setting before installing. - In the running application context, print the same values once during diagnostics.
- List the expected cache directory and confirm ownership and permissions.
- Use one deliberate cache location for both installation and runtime, or stop relying on the cache and point Puppeteer at a managed executable.
Keep secrets out of logs. Remove temporary diagnostic output after you have identified the mismatch.
3. Configure a separately managed Chrome explicitly
If your image or deployment installs Chrome outside Puppeteer’s cache, configure the exact executable path. Puppeteer supports executablePath, or channel when a browser is installed in a recognized standard location. puppeteer-core never downloads Chrome, so it always requires a browser that you manage.
const puppeteer = require('puppeteer-core');
const browser = await puppeteer.launch({
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
headless: true
});Set PUPPETEER_EXECUTABLE_PATH to a path verified on the deployed instance, not copied from another operating system, image, or CPU architecture. Before launching, check that the file exists and is executable by the same account that runs the application. A path that resolves successfully still may fail at startup if its libraries are unavailable.
4. If the file exists, inspect Linux libraries
Finding the binary changes the diagnosis from “not found” to “cannot launch.” Run the executable’s version command as the application user and inspect the operating-system error. Dynamic-linker output can identify the missing library.
/absolute/path/to/chrome --version
ldd /absolute/path/to/chrome | grep "not found"An Amazon Linux 2023 community discussion records Chrome for Testing failing because libatk-1.0.so.0 was unavailable. Reports in that discussion mention packages such as atk, pango, alsa-lib, libXcomposite, libXdamage, libXrandr, libxkbcommon, cups-libs, libdrm and mesa-libgbm; another dated example adds font packages for rendering. Treat these as investigation leads, not a universal AL2023 recipe. Package names vary by Amazon Linux release, repository configuration and architecture. Check the failing instance and install only the dependencies it actually lacks.
After installing a library, repeat the version command and launch a minimal page. A browser that prints its version but fails only when rendering may still need fonts, graphics libraries or sandbox permissions.
5. Check CPU architecture and browser compatibility
Inspect the architecture of the actual EB instances (for example, x86_64 or ARM64) and choose a browser distribution that explicitly supports it. The AL2023 discussion includes maintainer comments about Chrome binaries for x86 and community reports of separate ARM Chromium setups, but it does not establish a current compatibility matrix for every Puppeteer, Chrome, AL2023 and instance combination.
uname -m
file /absolute/path/to/chromeDo not assume an x86_64 deployment recipe works on ARM. Select a supported browser build for the target architecture, configure its verified path, and test it on that architecture before promoting the environment.
6. Put installation in the right Elastic Beanstalk lifecycle phase
AWS provides .platform/hooks/prebuild, predeploy and postdeploy for Linux platform extensions. AWS defines postdeploy as: “Files here run after the Elastic Beanstalk platform engine deploys the application and proxy server.” Hook files run in lexicographical filename order, run as root, and a non-zero exit code aborts deployment. See AWS platform hooks documentation.
Choose the phase based on what must exist when your application starts. Install-time browser downloads commonly belong in a build or deployment hook; runtime cache preparation must additionally set ownership for the application account. Source environment values as AWS documents when a hook needs them. Use configuration files where appropriate, but do not treat one community .ebextensions file or package list as a universal AL2023 solution.
Puppeteer-managed versus system-managed Chrome
| Approach | Advantages | Responsibilities |
|---|---|---|
| Puppeteer-managed download | Browser installation follows Puppeteer’s documented workflow and version pairing. | Allow install scripts and downloads; provide disk and network access; keep the cache path identical for installation and runtime. |
| System or separately managed browser | Fits controlled images and organizations that own OS patching. | Maintain a compatible executable, libraries and architecture; configure executablePath or channel; test upgrades. |
Neither approach removes the need to validate libraries, permissions and architecture on the deployed instance.
Common failures and fixes
The cache directory is empty
Cause: install scripts were blocked, the download failed, or installation ran on another machine. Fix: allow the script or run npx puppeteer browsers install during deployment, then verify the directory on the instance.
The error names a root path, but the app uses another home
Cause: a root-run hook installed into root’s cache while the application uses a different account. Fix: align $HOME and cache configuration, copy or install into a shared controlled path with correct ownership, or set executablePath.
The executable exists but launch reports a missing .so file
Cause: an OS dependency is absent. Fix: run the version command or ldd, map the missing soname to the package available in that AL release, install it, and retest.
It works on x86 but fails on ARM
Cause: the browser build does not support the instance architecture. Fix: verify uname -m, obtain a supported build, and test it on the same architecture.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Best Value
- Used Book in Good Condition
Deployment stops after adding a hook
Cause: a hook command returned non-zero; hooks are executed as root and in filename order. Fix: make the script executable, use absolute paths, log each command, handle expected conditions explicitly, and run the script manually in a staging environment.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your goal is simply to capture a website rather than operate Chrome on EB, ScreenshotNeo provides a website screenshot API and MCP server. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups and chat widgets; bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP tools—take_screenshot, get_page_info and capture_pdf—work with Claude, Cursor and other MCP clients.
One GET request returns PNG, JPEG, WebP or PDF. The API supports full-page lazy-image capture, CSS-selector elements, dark mode, device presets, custom viewports, retina scale, PDF paper and page settings, custom CSS or JavaScript, clicks, selector or network-idle waits, request and resource blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, selectable cache TTLs, signed image links, asynchronous webhooks, bulk capture of up to 100 URLs and a usage API. Parameter names used by other screenshot APIs also work.
Using cURL:
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 documentation for all options. The same request in Python:
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsimport 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)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}`);There is a free allowance of 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is included on every plan, and yearly billing provides two months free. Create a free ScreenshotNeo account to try it.
Final deployment checklist
- Confirm the Puppeteer install script ran or execute
npx puppeteer browsers installduring deployment. - Compare the cache path in the error with the path written on the instance.
- Check the Linux user,
$HOME, ownership and execute permissions. - If Chrome is managed separately, set and verify
executablePathorchannel. - Run the browser version command and inspect missing libraries.
- Verify instance and browser CPU architecture.
- Make hook timing, ordering and non-zero failure behavior intentional.
Frequently Asked Questions
Does reinstalling Puppeteer on my laptop fix the Elastic Beanstalk instance?
No. The browser must be downloaded or installed in the deployment or runtime environment used by the EB EC2 instance.
Can I use puppeteer-core without installing Chrome?
No. puppeteer-core does not download a browser; provide a compatible executable path or recognized channel.
Is there one guaranteed Amazon Linux 2023 dependency list?
No. Missing packages depend on the platform release, repositories, browser build and CPU architecture. Inspect the failing instance and install the libraries it reports.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →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.
