Free tools Windows power users keep installed
One-click scans. No signup required.
The quickest documented way to run Puppeteer in Docker is to use the official ghcr.io/puppeteer/puppeteer image. It includes Chrome for Testing and its required dependencies, and the documented launch uses Docker’s --init and --cap-add=SYS_ADMIN flags so Chrome can run in sandbox mode. If you need a custom base image or stricter filesystem controls, build around a compatible browser, libraries, runtime user, and writable Chrome profile paths rather than reaching for --no-sandbox.
Run Puppeteer with the official Docker image
The Puppeteer image is published to GitHub Container Registry as ghcr.io/puppeteer/puppeteer. It includes Chrome for Testing, required dependencies, and a preinstalled Puppeteer version. The official Docker guide documents this basic invocation:
docker pull ghcr.io/puppeteer/puppeteer:latest
docker run -i --init --cap-add=SYS_ADMIN --rm
ghcr.io/puppeteer/puppeteer:latest
node -e "// your Puppeteer script here"Replace the comment with JavaScript that launches Puppeteer and performs the work you need. The command runs Node inside the container, removes the container after exit with --rm, and keeps standard input attached with -i. --init supplies an init process to help manage browser child processes. --cap-add=SYS_ADMIN is part of the documented setup for this image’s sandboxed Chrome configuration; it grants a capability, so check your container platform’s security policy before deploying it.
The latest tag can move as releases change. The Docker guide says other tags correspond to Puppeteer versions. For repeatable builds, choose a version tag that matches the Puppeteer version your application expects, then update that pairing deliberately rather than assuming latest stays fixed.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
Run a mounted script instead of an inline command
For an application script in your current directory, mount the project into the container and set its working directory. For example, if the script is named capture.js:
docker run --init --cap-add=SYS_ADMIN --rm
-v "$PWD:/work" -w /work
ghcr.io/puppeteer/puppeteer:latest
node capture.jsThis assumes the script and any files it needs are in the mounted directory. Do not mount over a path containing image-provided files your application needs. If the container runs as a non-root user, make sure mounted files and any output directory are accessible to that user.
Write a minimal Puppeteer script
A basic script launches the browser, opens a page, performs an action, and closes the browser even if an operation fails. This example writes a screenshot to the mounted working directory:
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch({ headless: true });
try {
const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'networkidle2' });
await page.screenshot({ path: 'page.png', fullPage: true });
} finally {
await browser.close();
}
})().catch((error) => {
console.error(error);
process.exitCode = 1;
});The script uses the Puppeteer package already installed in the official image. If you use a custom image, install the package in your application and make sure the browser executable it uses is installed and compatible. The image command above does not itself create a screenshot; the Node script is what defines the browser task.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchBuild a custom image when you need control
A custom Docker image is appropriate when your service needs a particular base image, application layout, package set, or filesystem policy. It also makes you responsible for keeping Node, Puppeteer, Chrome for Testing (or another intentionally selected browser), and Linux libraries compatible. Use Puppeteer’s Docker guide as the starting point for its image and Dockerfile approach instead of copying an old Dockerfile without checking the current requirements.
Install the browser and system dependencies deliberately
The system requirements page lists Node 22.12 or newer and Chrome for Testing support on Debian/Ubuntu Linux for x64 and arm64 among its current platform entries. These are version-sensitive requirements; confirm the page for the exact Puppeteer release and image you build. The browser installation documentation describes installing Chrome for Testing and, on Debian or Ubuntu, installing its system dependencies with:
npx puppeteer browsers install chrome --install-depsThe --install-deps option requires root. Run it in an image-build step with appropriate privileges, not as an assumption that it will work under a restricted runtime user. Browser installation and OS libraries should be handled during the image build so the running service does not depend on an interactive package-install step.
Keep the browser executable and Puppeteer configuration aligned
Puppeteer normally manages a browser download as part of installation, but configuration can intentionally skip that download or select an executable path. The configuration reference documents executablePath and skipDownload. Use these only when you are managing the browser yourself: set the executable path to the actual browser binary and check that its version and dependencies work with your Puppeteer package. Setting a path does not install a browser or resolve a version mismatch.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →When a container says the browser cannot be found, check whether package installation scripts were disabled or browser downloads were skipped. Puppeteer documents this as a reason the expected browser may be absent; review the installation settings and configuration before adding an unrelated system browser.
Choose the right container approach
| Approach | What it gives you | What you must manage |
|---|---|---|
| Official Puppeteer image | Chrome for Testing, required dependencies, and a preinstalled Puppeteer version. | Choose and update an appropriate image tag; allow the documented sandbox capability and provide an init process, subject to your platform’s policy. |
| Custom Debian/Ubuntu image | Control over the base OS, application packaging, and runtime layout. | Keep Node, Puppeteer, browser version, system libraries, executable path, and writable paths compatible. |
| Alpine-based setup | An Alpine base if the surrounding application requires it. | Additional browser and dependency compatibility work; Chrome is not supported on Alpine out of the box, so validate the exact Chromium/Puppeteer pairing. |
The official image is the lower-setup route when its runtime requirements fit. A custom image is not automatically smaller, faster, or more reliable; no performance figures are established here. Prefer a browser and operating-system combination Puppeteer documents as supported over assumptions based on image size.
Rank #3
Keep Chrome sandboxing enabled where possible
Chrome’s sandbox is a security boundary. The official container example adds SYS_ADMIN and runs Chrome in sandbox mode. Puppeteer’s troubleshooting guidance strongly discourages running without the sandbox. Treat --no-sandbox as a last resort only when the page content is absolutely trusted and the deployment’s security requirements permit it; it is not a general Docker fix.
If Chrome reports a sandbox or namespace failure, first confirm that the image is being run with the documented capability and that the hosting environment allows it. Some managed container platforms restrict Linux capabilities. If that restriction prevents the supported sandbox configuration, consult the platform’s security guidance and choose an approved execution environment rather than silently disabling the browser sandbox.
Recommended Free Tools
Run in a read-only container
A read-only root filesystem can work only if Chrome’s mutable data has somewhere writable to go. Chrome writes profile, configuration, and cache data; crashes or launch failures can result when those locations cannot be created. Puppeteer’s troubleshooting page recommends writable locations such as /tmp for XDG directories and an explicit userDataDir, or writable mounted directories owned by the Chrome user.
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch({
headless: true,
userDataDir: '/tmp/puppeteer-profile',
env: {
...process.env,
XDG_CONFIG_HOME: '/tmp/xdg-config',
XDG_CACHE_HOME: '/tmp/xdg-cache'
}
});
try {
const page = await browser.newPage();
await page.goto('https://example.com');
console.log(await page.title());
} finally {
await browser.close();
}
})().catch((error) => {
console.error(error);
process.exitCode = 1;
});Make sure the configured temporary paths exist or can be created, have sufficient space, and are writable by the runtime user. If you mount profile or cache directories instead, ensure their ownership and permissions match that user. A read-only root filesystem does not imply that /tmp is writable: configure a temporary filesystem mount or another writable volume in your Docker runtime when necessary.
Troubleshoot common Puppeteer Docker failures
“Failed to launch” or a missing shared library
A browser binary can be present while one of its linked system libraries is missing. Use ldd on the Chrome executable in the container to identify unresolved libraries, then install the packages required by the browser on a supported distribution. Puppeteer cautions that dependency lists can become outdated, so diagnose the actual binary and current base image rather than relying on a copied list from an older Dockerfile.
Sandbox errors
Check that the container command includes the documented --cap-add=SYS_ADMIN when using the official image setup, and verify the platform permits that capability. Do not reflexively add --no-sandbox; the Puppeteer troubleshooting guidance says this is strongly discouraged except for absolutely trusted content.
Browser processes remain or the container behaves badly on exit
Ensure the container has an init process. Use Docker’s --init flag as in the official example, or provide a custom entrypoint that handles process management properly.
Crashpad, profile, or configuration errors in a read-only container
Give Chrome writable XDG config and cache directories and a writable userDataDir, for example under /tmp. If using mounted directories, check that they exist and belong to the user that runs Chrome.
Alpine cannot launch Chrome
Chrome does not support Alpine out of the box. Do not assume that a Debian/Ubuntu dependency list transfers directly. If Alpine is mandatory, validate the exact browser, Puppeteer version, and compatible dependencies you plan to ship; otherwise choose a documented supported base.
“Could not find Chrome” after installing Puppeteer
Check whether browser downloads were skipped by package-manager settings or Puppeteer configuration. If you deliberately install a separate browser, configure its real executable path and keep its version compatible with Puppeteer. The browser installation and configuration documentation cover those controls.
Best Value
- Docker, Docker Swarm, Docker Compose, Programmer, Developer, Coding, Programming, Software Engineer, Code, DevOps, Deploy, Deployment, Kubernetes, Salt, Puppet, Chef, Terraform, Container, AWS, Azure, Cloud, Geek, Funny, Computer, Software, Tech, IT
- Integration, Scrum, Compile, Compilation, Science, Bug, Debug, Python, Linux, Java, Javascript, Scala, Dotnet, Kotlin
- Lightweight, Classic fit, Double-needle sleeve and bottom hem
Performance, reliability, and cost considerations
Container startup time, browser launch time, image size, and throughput depend on the base image, browser, workload, host resources, and concurrency; the cited Puppeteer documentation does not establish universal benchmark figures for them. Build dependencies into the image, avoid downloading a browser at application startup, and reuse a browser process only when your application’s isolation and lifecycle design support it. Always close pages and browsers deliberately, and test resource use under the concurrency you intend to run.
For reliability, pin a deliberate Puppeteer/image version pairing, rebuild when security or compatibility updates are needed, and exercise the image after updates. Chrome’s writable paths and the host’s allowed capabilities are deployment requirements, not incidental details. Docker images and browser builds consume storage and compute according to your environment; no fixed hosting cost follows from Puppeteer itself.
Or skip the browser setup
If your job is to get a website screenshot or PDF rather than operate Chrome yourself, ScreenshotNeo provides a website screenshot API and MCP server. Its API takes a URL in a GET request and returns an image or PDF. For example, 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 API documentation for setup and options. It removes cookie banners, newsletter popups, and chat widgets before capture; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents use screenshot tools. The Free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000. Sign up for the free plan.
FAQ
Can I use the latest Puppeteer image in production?
You can, but its contents may change as releases move. Prefer an intentional version tag when repeatability matters, and update it on a schedule that lets you validate the browser and application together.
Can I use Puppeteer with a browser other than Chrome for Testing?
Puppeteer configuration allows an executable path, but a different browser is not guaranteed to be interchangeable. Check the Puppeteer documentation and validate the exact browser/version pairing in your image.
Does running Puppeteer in Docker require a paid browser license?
The cited Puppeteer setup documentation describes the software, browser image, and dependencies; it does not state a Puppeteer usage fee. Hosting and compute costs depend on your Docker environment.
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.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →
