Recommended Free Tools
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Short answer: chrome-aws-lambda can launch Chromium with Puppeteer in an AWS Lambda function, using the package’s documented launch options. That example is not proof that the same package works inside an AWS Amplify SSR deployment. Amplify Hosting SSR is a separate Node.js compute target with its own bundle format, runtime versions and limits. Decide where the browser will run before installing anything.
First, identify which “Amplify” runtime you mean
There are two substantially different designs:
| Target | How it runs | Packaging model | Important limits or requirements |
|---|---|---|---|
| Separate AWS Lambda function | A Lambda handler is invoked directly or by your Amplify-hosted application. | Deploy a ZIP containing the function and dependencies, or attach a Lambda layer. These are Lambda-specific packaging methods. | The chrome-aws-lambda project recommends at least 512 MB of RAM and recommends 1,600 MB or more for browser work. |
| Amplify Hosting SSR compute | Amplify runs your framework’s server-side application for web requests. | The compute output must be self-contained; do not assume a Lambda layer recipe transfers unchanged. | The deployment specification requires a Node.js HTTP server on port 3000, 512 MB of ephemeral storage, a 15-minute maximum execution time and an uncompressed bundle no larger than 220 MB. |
The two 512 MB figures are different resources: the package’s number is Lambda memory guidance, while Amplify’s number is ephemeral storage. Do not use one as evidence that the other environment has the same capacity.
Compatibility reality in 2026
The chrome-aws-lambda README’s version table lists its 10.1 line with Chromium 92.0.4512.0 and asks you to pair it with a corresponding puppeteer-core or puppeteer release. Amplify’s current SSR documentation lists Node.js 20, 22 and 24. The available documentation does not verify that this older Chromium/package line runs in Amplify SSR, nor does it provide a current end-to-end Amplify recipe.
Free tools Windows power users keep installed
One-click scans. No signup required.
Therefore, treat this as a compatibility investigation. Pin matching package versions, test on the exact deployment target and do not promise a working combination merely because a local script launches.
#1 Best Overall
Option A: run the browser in a dedicated Lambda function
1. Choose the runtime and architecture
Select a Node.js runtime supported by your Lambda function and confirm that the chrome-aws-lambda binary, Puppeteer release and CPU architecture match it. The documentation establishes the ZIP/layer model and launch pattern, but not a universal current runtime pairing. Check the function’s architecture, timeout, memory, temporary storage and deployment-size settings before publishing.
2. Install matching dependencies
Install chrome-aws-lambda together with the corresponding puppeteer-core (or the puppeteer version required by the package’s table). Keep the dependency versions explicit in package.json. Build the production directory for the same operating system and architecture used by Lambda, then place the handler and its dependencies in the deployment ZIP, or put dependencies in a Lambda layer.
3. Use the documented launch pattern
const chromium = require('chrome-aws-lambda');
exports.handler = async (event) => {
let browser;
try {
browser = await chromium.puppeteer.launch({
args: chromium.args,
defaultViewport: chromium.defaultViewport,
executablePath: await chromium.executablePath,
headless: chromium.headless,
});
const page = await browser.newPage();
await page.goto(event.url || 'https://example.com');
return await page.title();
} finally {
if (browser) await browser.close();
}
};This is the package project’s Lambda example, not an Amplify-tested deployment. The finally block matters: closing Chromium on success and failure prevents orphaned browser processes and exhausted execution environments.
4. Configure memory and timeouts deliberately
The package documentation recommends at least 512 MB Lambda memory and recommends 1,600 MB or more. Start with a setting that leaves headroom for page content, fonts and multiple tabs, then measure your own workload. Set a timeout longer than the slowest expected navigation, while keeping navigation and wait operations bounded in code. The cited material does not establish a performance benchmark, so do not infer throughput from these recommendations.
Option B: invoke browser work from an Amplify SSR application
Understand the SSR contract
Amplify Hosting supports SSR applications and framework adapters that emit the expected output structure. Its deployment specification says: “The entry point file must be a Node.js module and it must start an HTTP server that listens on port 3000.” The compute bundle must be self-contained.
That contract is not the Lambda handler contract. A Lambda layer attached to another function is not automatically available to SSR compute, and a Lambda-oriented Chromium extraction path may not exist or be writable in the same way. Verify that the browser executable, native libraries and all JavaScript dependencies are inside the SSR bundle and fit the 220 MB uncompressed limit.
Align build and deployed Node versions
Amplify documents Node.js 20, 22 and 24 for SSR. For a Next.js compute application, the runtime major version follows the major version used to build the app. Amplify’s build configuration separately selects the Node version; its AL2023 build image supports 20, 22 and 24, with 22 described as the default in that guide. These settings are related but do not prove that an old native browser package is compatible.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →SSR deployments using Node.js 14, 16 or 18 are blocked effective September 15, 2025. Test a Node upgrade on a new branch before changing production, and inspect the generated artifact rather than relying on local node_modules.
Rank #3
Keep browser work off the critical request path when possible
A screenshot or PDF operation can consume substantial CPU, memory and time. If every page request launches Chromium, cold starts and browser startup can increase response latency. Prefer a queue or separate Lambda for scheduled, user-triggered or bulk captures; reserve SSR execution for work that genuinely must happen while rendering a request. This is an architectural trade-off, not a claim that one target universally wins.
Deployment checklist
- Write down the target: Lambda handler or Amplify SSR compute.
- Pin a Puppeteer release that matches the Chromium revision expected by your chrome-aws-lambda package.
- Confirm Node.js major version, operating system and CPU architecture on the target.
- Inspect the final ZIP or SSR bundle for the Chromium executable and required native libraries.
- For Lambda, choose ZIP or layer packaging and configure memory, timeout and temporary storage.
- For Amplify SSR, produce a self-contained Node.js server listening on port 3000.
- Check the Amplify 220 MB uncompressed compute-bundle limit and 512 MB ephemeral-storage limit.
- Run a real deployment on a branch, then test navigation, JavaScript execution, fonts, images and browser cleanup.
Troubleshooting
“Executable doesn’t exist” or launch fails
Confirm that await chromium.executablePath resolves in the deployed environment and that the package’s extracted binary is included or can be written to the permitted temporary directory. A local Chromium installation is not evidence that the deployment contains the binary. On SSR, inspect the self-contained artifact and verify that the build did not prune it as an optional dependency.
“Cannot find module puppeteer”
Install the package in the production dependency set, not only as a development dependency, and deploy the resulting files. Use the Puppeteer package version that the chrome-aws-lambda release documents; mixing arbitrary versions can produce protocol errors.
Outdated 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 matchWindows 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 reinstallBrowser starts locally but crashes in production
Compare Node major version, CPU architecture, native libraries, memory and writable storage. Increase Lambda memory in line with the package’s guidance, reduce concurrent pages and close the browser in finally. For Amplify, verify the 512 MB ephemeral-storage and 220 MB bundle constraints rather than applying Lambda memory advice.
Amplify build succeeds but SSR deployment fails
Check that the framework adapter emitted the required server structure and that the entry point starts an HTTP server on port 3000. Ensure the browser and dependencies are inside the compute bundle. A successful build does not validate runtime native-library compatibility.
Navigation hangs or times out
Set explicit Puppeteer navigation and selector timeouts, handle redirects and authentication deliberately, and close every page. A page may also be blocked by a bot check or require resources unavailable from the deployment network. Capture logs for the URL, elapsed time and failure stage without logging secrets.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.When a managed screenshot endpoint is simpler
Or skip the browser setup
ScreenshotNeo provides a website screenshot API and MCP server, so your application or AI agent can request a capture without packaging Chromium in Amplify.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minutecurl -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 request options. It accepts cookie/consent banners before capture and removes more than 60 known consent platforms, newsletter popups and chat widgets; each step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients. Plans include 1,000 screenshots per month free with no card; paid plans start at $5 for 3,000. Every plan includes the feature set, including full-page and element capture, device and retina settings, PDFs, custom CSS/JavaScript, waits, request blocking, headers, cookies, geolocation, caching, signed links, asynchronous webhooks, bulk capture and a usage API.
Create a free ScreenshotNeo account to use the monthly allowance without a card.
Best Value
Cost, reliability and security considerations
Self-hosting gives you control over browser versions and network credentials, but you own binary compatibility, cold-start behavior, patching and observability. Keep authorization headers, cookies and URLs out of logs; limit which callers can trigger arbitrary navigation; and apply SSRF protections if users supply URLs. A managed endpoint shifts browser maintenance away from your deployment, but you still need to protect API keys, handle HTTP failures and set an application-level timeout.
There is no documented universal winner between Lambda and Amplify SSR. Choose the target that matches your request path, packaging model, workload duration and operational ownership, then validate it on the production-like environment.
FAQ
Does chrome-aws-lambda officially support Amplify SSR?
The available documentation does not establish that it does. The package documents a Lambda-oriented Chromium bundle, while Amplify SSR has a separate compute contract.
Can I attach my Lambda layer to Amplify Hosting?
Do not assume so. Lambda layers are part of Lambda’s packaging model; Amplify SSR requires a self-contained compute bundle.
Which Node.js version should I use?
Amplify’s documented SSR choices are Node.js 20, 22 and 24. Select one supported by your framework and verify that your chosen Puppeteer and Chromium releases run on it; the supplied material does not name a verified chrome-aws-lambda pairing.
Frequently Asked Questions
Can I reuse the exact Lambda handler in Amplify SSR?
No. SSR requires a self-contained Node.js HTTP server listening on port 3000, not a Lambda handler export. Adapt the browser call to your framework’s server code and validate the generated bundle.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What is the safest way to prove compatibility?
Deploy a pinned dependency set to a test branch or test Lambda, run real navigations, inspect browser startup and cleanup, and only then promote it.
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.
