How to Take a Website Screenshot in Node.js (4 Ways)

Node.js has no shortage of ways to screenshot a website. The honest list is four: Puppeteer, Playwright, a thin wrapper like capture-website, or a hosted API. The first three all run Chromium on your server; the fourth does not. This guide shows each with working code and the trade-off that decides which one you want.

1. Puppeteer (the default)

Puppeteer is the most common choice and drives headless Chrome directly:

import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'networkidle0' });
await page.screenshot({ path: 'example.png', fullPage: true });
await browser.close();

The detail that matters is waitUntil: 'networkidle0', which waits for the network to settle before capturing so you do not screenshot a half-loaded page. fullPage: true captures the whole scrolling page. For elements, quality, and the lazy-load gotchas, see full-page screenshots in Puppeteer.

2. Playwright (cross-browser)

Playwright has nearly identical code and adds Firefox and WebKit with one API:

import { chromium } from 'playwright';

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await page.screenshot({ path: 'example.png', fullPage: true });
await browser.close();

The practical wins over Puppeteer are auto-waiting (less timing code) and being able to capture the same page in three engines, including the engine behind Safari. See screenshots in Playwright for the details.

3. capture-website (the short wrapper)

If you just want one screenshot and do not want to manage a browser lifecycle, capture-website wraps Puppeteer into one call:

import captureWebsite from 'capture-website';

await captureWebsite.file('https://example.com', 'example.png', {
  fullPage: true,
});

It still installs and runs Chromium under the hood, so the operational cost is the same as Puppeteer. It just hides the boilerplate. Avoid older packages like node-webshot that wrap the abandoned PhantomJS; do not build new code on them.

The cost the first three share

All three options above mean you run a browser on your server. None of the hard parts are the screenshot call:

• Provisioning Chromium. It needs a long list of system libraries. Slim containers and serverless functions hit missing-dependency errors before the first capture.
• Memory and zombie processes. A browser not closed on every error path leaks memory and orphans processes under load.
• Patching and scaling. Chromium ships security updates constantly, and one browser handles one job at a time, so volume means a pool and a queue.

If screenshots are a production feature rather than a script, this is infrastructure you now own.

4. A hosted API (no browser to run)

A screenshot API runs the browser fleet for you. From Node.js it is one fetch:

const res = await fetch('https://api.grabbit.live/v1/grabs', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer sk_live_...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    url: 'https://example.com',
    width: 1280,
    full_page: true,
    format: 'webp',
  }),
});

const { image_url } = await res.json();

The response is a hosted image URL:

{
  "id": "grb_01jx...",
  "status": "done",
  "image_url": "https://cdn.grabbit.live/grabs/grb_01jx....webp",
  "width": 1280,
  "format": "webp",
  "bytes": 48210,
  "execution_ms": 1180
}

The library options map onto request parameters: viewport is width (320 to 1920) and height (240 to 1080), full page is full_page, the element pattern is a selector field, and the manual wait becomes delay_ms (0 to 10000). format is png, jpeg, or webp.

Which to use

• Already running Puppeteer or Playwright for tests or scraping: add the screenshot call, you are done.
• A quick one-off script: capture-website is the least code.
• Screenshots are a production feature: an API, so you do not operate Chromium in your Node service at all.

For the framework deep dives, see screenshots in Puppeteer and screenshots in Playwright. If you are weighing hosted options, the honest comparison of screenshot APIs covers the trade-offs without the marketing.