Thumbalizr vs Playwright Screenshots for a Website Archive

Thumbalizr and Playwright can both capture a website as an image, but they serve different workflows. Thumbalizr is a hosted screenshot service with an API; Playwright is browser automation you configure and script. Choose Thumbalizr for an API-backed capture workflow, or Playwright when you need programmable navigation, interaction, and visual regression checks. Neither screenshot is a complete website archive: an image records a rendered state, while a preservation workflow needs to collect multiple resources and their capture context.

If you need a screenshot API, try ScreenshotNeo first: cookie banners, popups, and chat widgets are removed before capture, only clean shots are billed, and its lowest paid plan is $5 for 3,000 screenshots. For a self-managed browser workflow, Playwright is the more programmable option. For preservation and replay, plan a separate WARC-producing capture workflow.

1. What Thumbalizr and Playwright do

Thumbalizr: a hosted screenshot API

Thumbalizr provides website screenshots and thumbnail embedding through a hosted service. Its documented Embed API uses an account API key and secret, and supports capture controls such as output dimensions and format, page or visible-screen capture, a delay after page load, browser dimensions, and location. Feature availability can depend on the plan, so check the current plan matrix before building around a particular parameter. The API documentation also describes queued, completed, and failed capture status headers, a generated timestamp, and an error-reason header.

Thumbalizr’s current documentation distinguishes its newer Embed API from its old API and recommends the newer API for direct page embedding. Keep the secret out of public browser code. Put API requests behind a server you control if the request requires signing or secret credentials.

Playwright: a programmable browser

Playwright lets a script open a browser, navigate to a URL, interact with the page, and save a screenshot to a file or buffer. It supports full-page captures and element screenshots. Playwright Test adds visual assertions: it can create a reference image and compare later captures against it. That makes Playwright useful when you want a repeatable capture script or visual regression workflow and can control the runtime environment.

2. Choose based on the job

Need	Better fit	Reason
Call a hosted screenshot endpoint from an application	Thumbalizr	It offers a hosted service and documented API flow using account credentials.
Control navigation and browser interaction in code	Playwright	You script the browser steps and capture settings.
Capture one element or a full scrollable page	Playwright	The screenshot API supports both element and full-page capture.
Compare current rendering with an approved visual baseline	Playwright Test	Screenshot assertions are part of Playwright Test.
Preserve a multi-resource web capture for archival use	Neither alone	A screenshot is an image of one rendered state; use a separate WARC-producing capture workflow.

This recommendation follows from the documented features and preservation guidance; it is not based on a hands-on test or benchmark. No speed, accuracy, or cost comparison is established by the available evidence.

3. Capture a site with Thumbalizr

Use the current Embed API documentation for the exact endpoint, required signing procedure, and parameter names for your account. The API uses a key and secret to sign a query; those credentials should stay on a trusted server.

1. Check that your account plan supports the output format and capture controls you need.
2. Build and sign the request on the server side according to the current API documentation.
3. Request a suitable output size, format, capture mode, delay, viewport, and location.
4. Inspect the response status headers. Handle queued, completed, and failed states instead of assuming every request is immediately ready.
5. Record the capture timestamp and any error reason alongside the resulting image if it is evidence in an archive workflow.

The assignment research does not include the exact current endpoint, signing algorithm, or a verified runnable request for Thumbalizr, so those details should be copied from its official documentation rather than guessed. See the Thumbalizr API documentation and service overview.

4. Capture a site with Playwright

The following Node.js example uses Playwright’s library API. Install Playwright and its browser before running the script. Set the target URL through an environment variable, then it saves a full-page screenshot to disk.

npm init -y
npm install playwright
npx playwright install chromium

// capture.mjs
import { chromium } from 'playwright';

const targetUrl = process.env.TARGET_URL;
if (!targetUrl) {
  throw new Error('Set TARGET_URL to the page you want to capture');
}

const browser = await chromium.launch({ headless: true });
try {
  const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
  const response = await page.goto(targetUrl, {
    waitUntil: 'networkidle',
    timeout: 60_000,
  });

  if (!response) {
    throw new Error('Navigation did not return a main-resource response');
  }
  if (!response.ok()) {
    throw new Error(`Navigation returned HTTP ${response.status()}`);
  }

  await page.screenshot({ path: 'page.png', fullPage: true });
} finally {
  await browser.close();
}

TARGET_URL=https://example.com node capture.mjs

networkidle can be unsuitable for sites with persistent connections or ongoing background requests. If it times out, use domcontentloaded or load, then explicitly wait for the page state you need—for example, a selector that marks the main content as ready.

Capture a specific element

Replace the screenshot call after navigation with an element capture. Use a selector that identifies a stable component, and fail clearly if it is absent.

const card = page.locator('main article').first();
await card.waitFor({ state: 'visible', timeout: 15_000 });
await card.screenshot({ path: 'article.png' });

Capture to a buffer

Use a buffer when the image should be uploaded or processed without first writing a local file.

const image = await page.screenshot({ fullPage: true, type: 'png' });
// Pass image to your storage or processing code.

Visual assertions with Playwright Test

Playwright Test can compare a screenshot with an expected baseline. A first run can generate the reference screenshot; later runs compare against it. Keep the browser, operating system, settings, and execution conditions aligned between baseline creation and comparison. Rendering can vary with host OS, browser version, settings, hardware, power source, and headless mode. The assertion waits for two consecutive page screenshots to match before comparing with the expectation, but that does not eliminate environmental differences or unstable content.

import { test, expect } from '@playwright/test';

test('homepage visual baseline', async ({ page }) => {
  await page.goto('https://example.com');
  await expect(page).toHaveScreenshot('homepage.png', { fullPage: true });
});

Run the test with the Playwright Test runner installed and configured. Review generated baselines before accepting them; updating a baseline should reflect an intentional UI change, not conceal an unexpected difference.

5. Make the capture useful as archive evidence

A screenshot preserves pixels from a particular rendered state. It does not by itself preserve the page’s HTML, stylesheets, scripts, images, linked documents, network responses, or interactive behavior. It also cannot show content that was inaccessible, blocked, hidden until interaction, or loaded later than the capture.

The Library of Congress describes WARC as a format for aggregating multiple digital resources and related information, and identifies it as its preferred web-archive format. For an archival deliverable, choose a capture process that produces WARC where appropriate, document the capture date and scope, and retain screenshots as visual evidence rather than treating them as the entire archive. Even web capture tools cannot capture every kind of content; examples include streaming media, deep-web content, and databases.

Practical capture checklist

• Record the original URL, capture time, selected viewport, browser and version, and any relevant capture settings.
• Decide whether the goal is a visible screen, full scrollable page, or a particular element.
• Note whether authentication, location, consent state, or other session conditions affect what is visible.
• For Playwright visual comparisons, keep the runtime environment consistent and avoid changing baselines casually.
• For preservation or replay, use a separate web-archiving workflow and document what it did not capture.

6. Or skip the browser setup

ScreenshotNeo is the alternative to try first when you want a screenshot API without installing and maintaining a browser. One GET request returns an image or PDF. Its API accepts common screenshot parameter names used by other services, which can make switching easier. See the ScreenshotNeo API documentation.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot; bot checks, blank pages, and failed loads are never billed; an MCP server lets AI agents take screenshots; and 1,000 screenshots a month are free with no card, with paid plans starting at $5 for 3,000. Every feature is on every plan. It is a screenshot service, so use a separate WARC workflow when you need a multi-resource preservation archive.

Sign up free for 1,000 screenshots a month, with no card required.

7. Troubleshooting

Symptom	Likely cause	What to do
Thumbalizr request is rejected or cannot be signed	Wrong credentials, an incorrectly signed query, or use of an obsolete API flow	Check the current Embed API instructions, keep the secret server-side, and verify that the account credentials and encoded parameters match the signing requirements.
Thumbalizr capture is queued	The API reports asynchronous capture status	Read the documented status headers and follow the API’s completion flow; do not treat a queued response as a completed image.
Thumbalizr capture failed	The page or service could not complete the capture	Inspect the error-reason header, confirm the target is reachable, and retry only when the cause is transient.
Playwright cannot launch Chromium	The browser binary was not installed for the current environment	Run npx playwright install chromium in the same environment where the script runs.
Playwright navigation times out	The page keeps network activity open or takes longer than the configured timeout	Use a suitable navigation event such as domcontentloaded, then wait for a specific content selector or a bounded delay.
Screenshot is blank or incomplete	The page had not rendered the relevant content, lazy content was not triggered, or the wrong selector was captured	Wait for the main content to become visible, scroll or interact as required by the page, and verify the selector before capture.
Visual baseline fails on another machine	Rendering differs across operating systems, browser versions, hardware, or headless settings	Run baseline generation and comparison in a consistent environment; inspect the diff and update the baseline only for intentional changes.
Archive cannot reproduce a video or interactive page	A screenshot or crawler did not preserve streaming, database-backed, restricted, or deeply linked content	Document the gap and choose a capture process suited to that content; do not describe the screenshot as a complete replayable archive.

8. Performance, reliability, and cost

There is no verified comparative benchmark here, so treat speed and throughput as workload-specific. A hosted API removes local browser installation and lifecycle management, while a Playwright deployment requires browser binaries and execution capacity. Playwright gives more control over waits, interactions, and retries, but reliability depends on the script and the environment being stable.

For either approach, bound timeouts, distinguish queued or failed captures from successful image responses, and record enough metadata to identify the conditions of a capture. Retrying every failure immediately can waste capacity or hide a persistent authentication, bot-check, or page-availability problem.

Thumbalizr feature availability may vary by plan; consult its current plan matrix and pricing before estimating cost. The research dossier does not establish a comparable current price for Thumbalizr or the operational cost of running Playwright. Playwright itself is software you run, so budget for the infrastructure and maintenance needed by your chosen environment. ScreenshotNeo offers 1,000 free screenshots per month without a card, then plans at $5 for 3,000, $15 for 15,000, $39 for 60,000, $99 for 250,000, and $249 for 1,000,000; yearly billing gives two months free. Only clean shots are billed, and response headers identify the page verdict and billing status.

9. Frequently asked questions

Can a screenshot prove exactly what a visitor saw?

It can document the pixels produced under recorded capture conditions. To make the evidence interpretable, retain the URL, time, viewport, browser details, and relevant session conditions.

Does a full-page screenshot include content below the fold?

Playwright’s full-page screenshot captures the full scrollable page as if displayed on a very tall screen. It still captures a rendered image, not the underlying resources or behavior.

Can I use Playwright screenshots as a web archive?

Use them as visual records, not as the complete archive. A preservation workflow should capture resources and related metadata in an archival format such as WARC when that suits the project.

Which should I pick for visual regression?

Playwright Test has screenshot assertions and baseline comparison. Keep the execution environment and page state consistent so unrelated rendering differences do not dominate the comparison.