Recommended Free Tools
Use Puppeteer’s page.setContent() to load an HTML string, wait for the assets and application state your template needs, then call page.screenshot(). Set the viewport and device scale explicitly so the output is reproducible. The complete Node.js example below renders a template to a full-page PNG, while later sections cover viewport, element and clipped captures, readiness checks, formats, transparency, troubleshooting and PDF output.
Install Puppeteer and prepare a template
Puppeteer controls a Chromium browser from Node.js. Create a project and install it:
mkdir html-renderer
cd html-renderer
npm init -y
npm install puppeteerUse an ES module file such as render.mjs. Keep the HTML in a string, a template function, or a file that you read before calling page.setContent(). Relative URLs need special care: a string supplied to setContent() has no normal website origin, so use absolute image/font URLs, inline assets, data URLs, or a base URL strategy appropriate to your application.
Basic HTML-to-PNG rendering
This runnable script creates a browser, fixes the viewport, injects a template, waits for network activity to settle, and writes a full-document PNG.
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 →#1 Best Overall
import puppeteer from 'puppeteer';
const html = `
Invoice preview
Invoice preview
Rendered from an HTML template.
`;
const browser = await puppeteer.launch();
try {
const page = await browser.newPage();
await page.setViewport({ width: 1200, height: 800, deviceScaleFactor: 1 });
await page.setContent(html, { waitUntil: 'networkidle0' });
await page.screenshot({
path: 'render.png',
fullPage: true,
type: 'png'
});
} finally {
await browser.close();
}page.setContent() renders the supplied markup in the page. Puppeteer’s screenshot guide recommends Page.screenshot() for captures, and the API returns an image buffer when you omit path. fullPage: true expands the capture to the document’s complete scrollable height; without it, the result is the current viewport.
Choose the capture scope
Viewport screenshot
Capture only what is visible at the configured viewport:
await page.screenshot({ path: 'viewport.png', type: 'png' });This is useful for checking a responsive breakpoint or producing a fixed social-card image.
Full document
Capture the entire page, including content below the fold:
await page.screenshot({ path: 'full-page.png', fullPage: true });Very tall documents can produce large files. Consider splitting long reports into deliberate sections when a downstream system has image-size limits.
One element
Locate a component and call its screenshot method:
const card = await page.locator('.card');
await card.screenshot({ path: 'card.png', type: 'png' });The element’s bounding box determines the image dimensions. Ensure the element is visible and has finished layout before capturing.
Rectangular clip
Use clip when you need an exact region in CSS pixels:
await page.screenshot({
path: 'region.png',
clip: { x: 100, y: 80, width: 640, height: 360 }
});Coordinates are relative to the page viewport. A clip outside the current page or with invalid dimensions causes an error.
Wait for fonts, images and JavaScript
networkidle0 waits for the network to become idle, but it is not a universal guarantee that every application is visually ready. A font may still be applying, an image may have decoded after its request completed, or client-side code may update the DOM later. Define readiness for your own template.
Wait for document fonts
await page.evaluate(async () => {
await document.fonts.ready;
});Wait for images to decode
await page.evaluate(async () => {
const images = Array.from(document.images);
await Promise.all(images.map(image => {
if (image.complete) return image.decode?.().catch(() => {});
return new Promise(resolve => {
image.addEventListener('load', resolve, { once: true });
image.addEventListener('error', resolve, { once: true });
});
}));
});The error branch prevents one broken image from blocking the entire render. If your template intentionally requires every image, reject instead and fail the job.
Add an application readiness marker
Set a marker after your data, charts or client-side components finish:
// In the page code
window.renderReady = true;
// In the renderer
await page.waitForFunction(() => window.renderReady === true);
await page.screenshot({ path: 'ready.png', fullPage: true });Alternatively, wait for a selector that your application inserts only when rendering is complete:
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesawait page.waitForSelector('[data-render-ready]', { visible: true });Use a bounded timeout so a failed application does not leave a worker hanging:
await page.waitForSelector('[data-render-ready]', { visible: true, timeout: 15000 });Make output deterministic
Viewport and device scale
Set dimensions before loading the template. CSS layout uses the viewport in CSS pixels; deviceScaleFactor controls the raster density.
await page.setViewport({
width: 1440,
height: 900,
deviceScaleFactor: 2
});A scale factor of 2 creates a sharper image but increases pixel dimensions and memory use. Keep these values fixed in tests and production jobs.
Data, time and responsive state
Pass explicit data rather than generating random values during rendering. Freeze timestamps in the input, select a known color scheme when needed, and test each viewport that matters. If your template uses lazy loading, scroll or trigger the application’s load routine before taking the screenshot.
CSS and background behavior
PNG supports lossless output and transparency workflows. To omit the default page background, use:
await page.screenshot({ path: 'transparent.png', omitBackground: true, type: 'png' });This only removes the browser’s background; CSS backgrounds you set on elements remain. JPEG is lossy and does not preserve transparency. WebP support depends on the Puppeteer/Chromium version you deploy, so verify the format in your runtime.
Screenshot options you will use most
path: saves directly to a file. Omit it to receive a buffer and upload it yourself.type: selects PNG, JPEG or WebP where supported.quality: controls lossy-image quality where the selected format supports it.fullPage: captures the complete scrollable document.clip: captures a precise rectangle.omitBackground: hides the default background for transparent PNG-style workflows.
For an API response instead of a file, use the buffer:
const buffer = await page.screenshot({ type: 'png', fullPage: true });
// Example: return buffer from an HTTP route or write it to object storage.Loading external pages versus template strings
Use page.goto(url, options) when the source is an addressable page. Use page.setContent(html, options) for a template you already have in memory. Both accept navigation wait options, but the correct readiness condition remains application-specific.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
await page.waitForSelector('main');
await page.screenshot({ path: 'site.png', fullPage: true });For untrusted HTML, isolate the browser process and avoid granting unnecessary access to local files or credentials. Do not interpolate user input into scripts or attributes without escaping it.
Screenshot versus PDF
page.screenshot() creates a raster image. page.pdf() creates a PDF and uses print CSS by default. To generate a PDF using screen media, switch media type first:
await page.emulateMediaType('screen');
await page.pdf({
path: 'document.pdf',
format: 'A4',
printBackground: true,
margin: { top: '16mm', right: '16mm', bottom: '16mm', left: '16mm' }
});Choose a PDF for selectable text, pagination and printing; choose an image for thumbnails, previews, social graphics or systems that accept only raster files.
Troubleshooting common failures
Chromium will not launch
Confirm that the package installation completed and that the deployment environment allows Chromium to start. In containers, use the documented sandbox configuration for that environment rather than blindly adding flags. Log the browser launch error and verify executable permissions.
The screenshot is blank or only partly rendered
Usually the capture ran before the application finished. Add a readiness selector or function, wait for document.fonts.ready, and decode images. Check the console and page errors:
page.on('console', message => console.log('browser:', message.text()));
page.on('pageerror', error => console.error('page error:', error));Images or fonts are missing
Check that URLs are absolute and reachable from the browser process, that HTTPS certificates are valid, and that servers permit the request. For local assets, serve them over a controlled HTTP origin or inline them as data when appropriate. Wait for the relevant network and font conditions rather than relying on a fixed sleep.
Lazy content is absent
Lazy loaders often wait for visibility. Scroll through the page or call the application’s documented load method, then wait for the resulting elements before capture.
The layout differs between machines
Pin the Puppeteer version, use the same Chromium build, set viewport and device scale, and package the fonts your design requires. Differences in installed fonts, timezone, locale or device metrics can change line wrapping and therefore image dimensions.
Best Value
The job times out
Find the request or script that never settles. Replace an overly broad networkidle0 wait with a selector or application marker, or allow known long-lived connections to remain while you wait for the actual content. Always close the browser in a finally block.
Performance, reliability and cost considerations
Launching a browser is expensive compared with reusing one. For a service that renders many templates, launch one browser per worker, create and close pages per job, and enforce navigation, readiness and overall job timeouts. Limit concurrent pages to the memory available to your host. Full-page captures and high device scale factors increase memory and output size.
Cache stable assets, avoid unnecessary third-party requests, and block analytics or advertising requests when they are not part of the design. Record the template identifier, viewport, browser version, readiness result and elapsed time so a visually different output can be diagnosed. Retry transient navigation failures, but do not retry deterministic template errors indefinitely.
Or skip the browser setup
ScreenshotNeo provides a hosted screenshot API when you want one request instead of managing Chromium. It accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups and chat widgets before capture. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and whether the shot was billed.
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 reinstallOne GET request returns PNG, JPEG, WebP or a PDF. The API supports full-page and element captures, custom CSS and JavaScript, selector or network-idle waits, viewport and device presets, retina scale, lazy-image loading, request blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, configurable caching, signed links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API and an OpenAPI specification. Parameter names used by other screenshot APIs also work for easier migration. An MCP server provides take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients.
cURL example (see the ScreenshotNeo documentation):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
r.raise_for_status()
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}`);
if (!res.ok) throw new Error(`Screenshot failed: ${res.status}`);
const data = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', data));The Free plan includes 1,000 shots each month with no card. Paid plans start at $5 for 3,000 shots; yearly billing gives two months free, and every feature is available on every plan. Create a free ScreenshotNeo account to try it.
Frequently Asked Questions
Can I render a template without navigating to a URL?
Yes. Pass the HTML string to page.setContent(), then wait for the assets and application state your template requires before calling page.screenshot().
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 →Why does networkidle0 not guarantee a correct image?
Network idleness does not prove that fonts, image decoding or client-side rendering has completed. Add an application readiness marker, selector, font wait and image wait that match your template.
Should I use PNG, JPEG or PDF?
Use PNG for lossless UI and transparency workflows, JPEG for smaller lossy photos, and PDF when selectable text and print pagination matter.
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.
