How to Screenshot a List of URLs (Bulk Capture for Research and Audits)

You have a spreadsheet, a sitemap, or a list of competitor pages, and you need a screenshot of each one. Doing it by hand means opening twenty tabs and pressing the capture key twenty times. This guide covers every method that actually works, from a free browser extension for a one-off batch to a scripted loop you can run on a schedule.

The short answer

To screenshot a list of URLs, loop over the list and capture each URL once. There is no magic "capture them all in one shot" primitive. Every tool, extension, or API does the same thing under the hood: it visits each page in turn and renders it. The real choice is how you drive that loop:

• One-off, a handful of URLs: a browser extension that reads a pasted list.
• Repeatable, or part of a pipeline: a short script that calls a screenshot API once per URL.
• You already write capture code: keep your headless browser, just point the loop at a managed renderer if local Chromium is flaky in CI.

Method 1: a browser extension (for a quick one-off)

If you just need to grab a dozen pages once and never again, a Chrome extension like Multiple Screenshots is the fastest path. You paste your list, it opens each page, captures it, and saves the files locally. No code.

The limits show up the moment the job repeats. Extensions run in your browser, on your machine, with your session. You cannot put that in CI, schedule it overnight, or hand it to a teammate as a reproducible step. For a true one-time audit, fine. For anything you will do again, it is a dead end.

Method 2: an open-source script (DIY headless)

The classic developer answer is a script that drives a headless browser over the list. Tools like webscreenshot or a few lines of Puppeteer read a file of URLs and capture each one:

import puppeteer from 'puppeteer';
import { readFileSync } from 'node:fs';

const urls = readFileSync('urls.txt', 'utf8').trim().split('\n');
const browser = await puppeteer.launch();
const page = await browser.newPage();

for (const url of urls) {
  await page.goto(url, { waitUntil: 'networkidle2' });
  await page.screenshot({ path: `out/${encodeURIComponent(url)}.png`, fullPage: true });
}

await browser.close();

This works, and it is free. What it does not solve is everything around the capture: keeping Chromium installed and patched, handling pages that block headless browsers, dealing with cookie banners, and surviving in a CI runner or serverless function where a real browser binary is awkward to ship. Those problems scale with the size of your list. See screenshot a website from a URL for a fuller comparison of the DIY path versus an API.

Method 3: a screenshot API in a loop (repeatable)

When the job has to run more than once, a screenshot API turns each capture into a single HTTP request, so the loop is the whole program. You send a URL, you get back a hosted image. No browser to install, nothing to keep patched.

Here is the full pattern in Node. Read the list, capture each URL, and collect the hosted image URLs:

const urls = ['https://example.com', 'https://stripe.com', 'https://vercel.com'];
const results = [];

for (const url of urls) {
  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, width: 1280, full_page: true, format: 'webp' }),
  });
  const data = await res.json();
  results.push({ url, image_url: data.image_url });
}

console.table(results);

Each response includes a hosted image_url, so you can drop the results straight into a CSV, a database, or a dashboard. Because every request is independent, you can keep the loop sequential for simplicity, or add limited concurrency if you want the batch to finish faster. This is exactly the kind of repeatable, scriptable job Grabbit's automated screenshots are built for, and you can wire it up with a free test key before adding a card.

A note on honesty: Grabbit does not expose a single "send me an array of URLs" endpoint. One request captures one URL. The loop above is the bulk pattern, and it keeps each capture independent so one bad URL never sinks the whole batch.

Choosing per-URL options

Each call in the loop is configured on its own, so a mixed list is no problem. The parameters that matter for a bulk job:

• full_page: true captures the entire scrollable page, not just the viewport. Essential for audits where you want the whole page on record.
• width sets the viewport (320 to 1920). Use a consistent width across the list so the screenshots line up for comparison.
• format can be png, jpeg, or webp. WebP keeps a large batch small on disk.
• delay_ms waits up to 10 seconds before the capture, which helps on pages that fade content in after load.

For a large list where you do not want to hold the connection open per request, the same endpoint accepts Prefer: respond-async (or ?async=true) and returns immediately with a job you poll later. That keeps a thousand-URL run from blocking your script.

Bulk screenshots for audits and monitoring

The reason most people want to screenshot a list of URLs is not the screenshots themselves, it is the comparison. Capture your competitors' landing pages today, capture them again next month, and the diff tells a story. Save each image_url next to its source URL and a timestamp, and you have the raw material for website change monitoring without building a crawler from scratch.

The same loop powers a few common jobs:

• SEO audits: snapshot every page in a sitemap to spot rendering or layout regressions.
• Competitor tracking: re-run the same list on a schedule and compare.
• QA evidence: capture key pages on every deploy and attach them to the release.

Wrapping up

Screenshotting a list of URLs always comes down to a loop. A browser extension covers a one-time batch; a DIY script works until local Chromium becomes the maintenance burden; a screenshot API turns the whole job into a few lines that run anywhere, including CI and serverless. Point the loop at your list, collect the hosted image URLs, and you have a repeatable bulk-capture pipeline. To automate it end to end, see Grabbit's automated screenshots.