Free tools Windows power users keep installed
One-click scans. No signup required.
To run Puppeteer in a Firebase Function, deploy both the automation library and a browser executable that the Linux runtime can launch. Installing the puppeteer npm package is not proof that Chrome exists in the deployed function. You must choose how Chrome is supplied, set a supported Node.js runtime, configure resources, close the browser on every path, and test the exact deployment with the Emulator Suite and a real invocation.
What Puppeteer needs inside a Firebase Function
The Puppeteer project describes Puppeteer as “a JavaScript library which provides a high-level API to control Chrome or Firefox over the DevTools Protocol or WebDriver BiDi.” The library sends commands; a compatible browser executable still has to be present and launchable in Firebase’s Linux environment.
- Automation library:
puppeteerorpuppeteer-core. - Browser artifact: Chrome for Testing downloaded during installation, a serverless Chromium package, an independently installed binary, or a remote browser endpoint.
- Runtime configuration: a supported Node.js version, enough memory and timeout for the page workload, and a writable temporary directory used carefully.
- Lifecycle handling: awaited browser work, deterministic cleanup, and logs that expose launch and navigation failures.
The recurring production error is “Could not find Chrome.” It means the executable path used after deployment does not resolve to a usable browser, not that your page code is necessarily wrong.
Choose a browser-provisioning strategy
| Approach | Browser provisioning | Control and setup | Deployment and validation concerns |
|---|---|---|---|
puppeteer |
Its installation script downloads a compatible Chrome for Testing browser when the script is allowed to run. | Convenient defaults; normally no manual executable path is needed. | The browser cache must be included in the deployed artifact. Package size and install-script policies can break an otherwise successful local setup. |
puppeteer-core |
You supply a separately managed executable or connect to a remote browser. | Explicit executablePath and launch options are required. Puppeteer’s regular configuration defaults do not apply to this package. |
You own version matching, binary availability, permissions, and startup behavior in Firebase. |
puppeteer-core plus @sparticuz/chromium |
The Chromium package supplies a serverless-oriented binary and launch arguments. | Use the package’s current executablePath guidance and arguments. |
The project documents AWS Lambda examples, not a Firebase-certified recipe. Match versions, consider package size, and run an integration check in the Firebase runtime. |
There is no official Firebase compatibility matrix for current Puppeteer and @sparticuz/chromium releases in the available documentation. Pin compatible versions in your lock file and validate the pair rather than assuming a release combination is guaranteed.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
Set a supported Firebase runtime first
Firebase’s current runtime documentation lists Node.js 20 and Node.js 22 as supported and Node.js 18 as deprecated. Set the runtime in one place so local assumptions do not differ from deployment. In functions/package.json:
{
"engines": { "node": "20" },
"dependencies": {
"firebase-admin": "^latest-compatible",
"firebase-functions": "^latest-compatible",
"puppeteer": "^your-pinned-version"
}
}Alternatively, set runtime in firebase.json. Firebase says the firebase.json setting takes precedence when both are specified, so avoid contradictory values. Replace the illustrative dependency ranges with versions you have selected and lock them with your package manager; do not copy an unpinned “latest” into production.
If you are starting a project, install the Firebase CLI, initialize Functions, and keep the conventional functions/ directory with its manifest and lock file. Deployments use the CLI workflow, and Firebase documentation states that Node.js 10-and-higher runtime deployments require the pay-as-you-go Blaze plan. Confirm the project’s billing status and current pricing before running browser workloads.
Option A: use puppeteer and its downloaded Chrome
Install with scripts enabled
From the functions/ directory, install puppeteer normally and commit the resulting lock file. Its install script downloads a compatible Chrome for Testing browser. Some package managers or CI policies block lifecycle scripts; if that happens, the package can be present while the browser is absent. Configure your package manager and build environment to permit Puppeteer’s browser installation, then verify the cache exists before deploying.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows 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 reinstallMinimal HTTPS function
const { onRequest } = require('firebase-functions/v2/https');
const puppeteer = require('puppeteer');
exports.captureTitle = onRequest(
{ timeoutSeconds: 120, memory: '1GiB' },
async (req, res) => {
let browser;
try {
const target = typeof req.query.url === 'string'
? req.query.url
: 'https://example.com';
browser = await puppeteer.launch({
headless: true,
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
const page = await browser.newPage();
await page.goto(target, { waitUntil: 'networkidle2', timeout: 60000 });
const title = await page.title();
res.json({ title, url: page.url() });
} catch (error) {
console.error('Puppeteer invocation failed', error);
res.status(500).json({ error: 'Browser task failed' });
} finally {
if (browser) await browser.close().catch(err => console.error('Close failed', err));
}
}
);Validate and sanitize user-supplied URLs in a real service. An unrestricted navigation endpoint can become a server-side request forgery risk; allow only the schemes, hosts, and network destinations your application needs.
Rank #2
Option B: manage Chromium explicitly with puppeteer-core
Use a serverless Chromium package
Install puppeteer-core and a compatible @sparticuz/chromium release, then follow that project’s current compatibility notes. A typical launch shape is:
const { onRequest } = require('firebase-functions/v2/https');
const puppeteer = require('puppeteer-core');
const chromium = require('@sparticuz/chromium');
exports.captureTitle = onRequest(
{ timeoutSeconds: 120, memory: '1GiB' },
async (req, res) => {
let browser;
try {
browser = await puppeteer.launch({
executablePath: await chromium.executablePath(),
args: chromium.args,
headless: chromium.headless
});
const page = await browser.newPage();
await page.goto('https://example.com', {
waitUntil: 'networkidle2',
timeout: 60000
});
res.json({ title: await page.title() });
} catch (error) {
console.error('Chromium launch or page task failed', error);
res.status(500).json({ error: 'Browser task failed' });
} finally {
if (browser) await browser.close().catch(err => console.error(err));
}
}
);The exact property names and supported combinations can change with releases. Confirm the package’s current README, pin both packages, and test this code in the Firebase emulator and the deployed function. Do not describe the AWS Lambda example in that README as Firebase certification.
Connect to a separately managed or remote browser
With puppeteer-core, pass an explicit local executable path or use puppeteer.connect({ browserWSEndpoint }) for a remote browser. A path from your laptop is not a deployment strategy: it will not exist in Firebase unless you package or install the same binary for the function.
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 →Configure memory, timeout and temporary storage
Browser pages consume memory unevenly. Measure your actual navigation, JavaScript execution, screenshots, PDFs, concurrency and number of pages instead of adopting a universal allocation. Set function options in code and increase them only after observing failures or latency.
| Function type | Documented maximum timeout | How to use the figure |
|---|---|---|
| HTTP and callable | 3,600 seconds (60 minutes) | A ceiling, not a recommended Puppeteer timeout. |
| Scheduled and task queue | 1,800 seconds (30 minutes) | Keep browser jobs substantially below the ceiling when possible. |
| Other event-driven functions | 540 seconds (9 minutes) | Design work to finish within the event deadline and retry safely. |
Firebase guidance notes that temporary storage is memory-backed. Remove downloaded files, generated PDFs and screenshots when they are no longer needed, and do not assume a clean directory between invocations. Always await navigation and file writes; unfinished asynchronous work can be cut off when the handler returns.
Rank #3
Reuse versus close
Keeping a browser in module scope may reduce cold-start launches, but it requires health checks and recovery when a reused browser disconnects. The safest baseline is one browser per invocation, closed in finally. Add reuse only after measuring cold starts and implementing reconnection logic.
Develop locally, then deploy deliberately
- Run the Firebase Local Emulator Suite and invoke the function with a representative URL, including pages with redirects, heavy scripts, blocked resources and authentication if those are part of your workload.
- Record launch time, navigation time, peak memory, temporary file size and final response status. Repeat enough times to expose cold and warm behavior.
- Check that the browser executable is present in the emulator environment and in the built deployment artifact. A successful laptop run is not evidence of a successful cloud launch.
- Deploy with the Firebase CLI, targeting the function when appropriate, then invoke the deployed endpoint with the same test cases.
- Inspect Cloud logs for executable-path, sandbox, timeout, navigation and cleanup errors. Keep package versions and runtime settings in source control so a rollback reproduces the environment.
Troubleshooting common failures
“Could not find Chrome” or executable not found
Cause: Puppeteer’s install script was skipped, the browser cache was excluded, or puppeteer-core has no valid executablePath. Fix: allow the puppeteer install script and verify the downloaded browser is packaged, or switch to an explicitly managed Chromium binary and log the resolved path before launch.
Recommended Free Tools
Works locally, fails after deployment
Cause: your workstation’s Chrome path, fonts, permissions or Node version are not present in Firebase. Fix: use a runtime-supported Node version, avoid hard-coded desktop paths, select a serverless binary deliberately, and run an integration invocation after deployment.
Browser exits immediately or reports sandbox errors
Cause: the binary’s sandbox assumptions do not match the restricted runtime. Fix: use the launch arguments documented for your chosen serverless binary; do not add arbitrary flags without understanding their security impact.
Timeouts during goto
Cause: slow third-party resources, never-ending connections, bot checks or a wait condition that the page never satisfies. Fix: set a bounded navigation timeout, choose an appropriate waitUntil, abort unnecessary requests, and return a controlled error. Raising the Firebase maximum does not make a stalled page finish.
Rank #4
Out-of-memory or intermittent crashes
Cause: large pages, multiple tabs, screenshots, PDFs, high concurrency or retained temporary files. Fix: process fewer pages per invocation, close pages, delete files, increase memory based on measurements, and move very large jobs to a queue or batch design.
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 →Deployment rejected or package too large
Cause: a full browser artifact and dependencies exceed a deployment limit; the serverless Chromium project specifically warns that package size can matter to some vendors. Fix: inspect the packaged artifact, remove unused dependencies, pin a suitable binary package, and verify Firebase’s current limits before choosing the architecture.
Function returns before the browser finishes
Cause: a missing await or cleanup path. Fix: await every browser operation and close the browser in finally; only send the HTTP response after the required work completes.
When a screenshot API is simpler
If your requirement is a website image or PDF rather than custom browser interaction, ScreenshotNeo can remove browser packaging from your function. It is a website screenshot API and MCP server: one GET request returns PNG, JPEG, WebP or PDF. Cookie and consent banners, newsletter popups and chat widgets are removed before capture; bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and response headers report the page verdict and billing status.
Or skip the browser setup
Use your ScreenshotNeo access key and target URL (the API documentation is at https://screenshotneo.com/docs/):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport 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)const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo also provides an MCP server with take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients. Its options include full-page lazy-image loading, CSS-selector element capture, dark mode, device presets, custom viewport and retina scale, PDF paper and page-range controls, custom JavaScript/CSS, pre-capture clicks, selector waits, network-idle waits, ad and tracker blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, selectable-TTL caching, signed image links, asynchronous webhooks, bulk capture of 100 URLs per call, a usage API and an OpenAPI specification. Existing parameter names used by other screenshot APIs also work.
The Free plan includes 1,000 shots per month with no card. Starter is $5 for 3,000 shots, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000 and Business $249 for 1,000,000; yearly billing gives two months free, and every feature is on every plan. Sign up free to try it without a card.
FAQ
Does Firebase include Chrome automatically?
No. Your deployment must contain or reach a browser executable that the selected Puppeteer package can launch.
Can I use my computer’s installed Chrome path?
Not unless you separately provide an equivalent browser in the function environment. A desktop path is not portable to Firebase.
Is @sparticuz/chromium officially supported by Firebase?
The cited project documents serverless usage and AWS Lambda examples, but the available material does not establish a Firebase-specific tested matrix. Validate your pinned pair in Firebase.
Which timeout should I choose?
Choose a value from measured page workloads and leave headroom for cold starts and cleanup. Firebase’s documented maxima are ceilings only.
Frequently Asked Questions
Can Firebase Functions run Puppeteer on Node.js 22?
Node.js 22 is listed as supported in Firebase’s current runtime documentation; still verify that your pinned Puppeteer and browser package support that runtime before deployment.
Why does puppeteer-core ignore my Puppeteer config file?
puppeteer-core does not apply Puppeteer’s regular configuration defaults. Pass the executable path and launch settings explicitly in code.
Should I keep one browser open across invocations?
Start with one browser per invocation and deterministic closure. Reuse can reduce cold-start work but needs disconnect detection, cleanup and recovery logic.
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.
