Best website screenshot tools for capturing pages in multiple languages

For scripted screenshots of pages in multiple languages, Playwright is a direct option: it can capture the visible viewport, a selected element, or the full scrollable page. For visual regression review, Playwright Test can compare screenshots with baselines, and BrowserStack Percy offers a hosted review workflow that integrates with Playwright screenshot tests. ScreenshotNeo is the first screenshot API to try when you want a one-call capture without managing browser setup: it supports timezone and geolocation settings, and bills only clean captures.

There is no evidence here to rank these tools by multilingual superiority, regional coverage, or pricing beyond ScreenshotNeo’s published plans. A screenshot’s language and content depend on how the target site chooses its locale. Verify that behavior with the site’s own locale selector, URL pattern, cookies, headers, or account settings before capturing.

1. Choose a capture workflow

Need	Workflow	What to check
Capture pages from a repeatable script	Playwright	How the site selects locale; viewport, browser, and state consistency
Review screenshot changes against a baseline	Playwright Test	Keep operating system, browser version, settings, hardware, and headless mode consistent where possible
Hosted review of visual changes	BrowserStack Percy integrated with Playwright	Project and package prerequisites, project type, and how Percy renders snapshots
Capture through an HTTP API	ScreenshotNeo	Pass the appropriate locale-setting inputs for the target site and inspect the response verdict and billing headers

Playwright documents viewport, element, and full-page screenshots, along with image type and scale options. Its screenshot documentation does not establish an automatic multilingual test matrix or a specific locale feature. For visual comparisons, Playwright Test warns that rendering can vary with the host OS, browser version, settings, hardware, and headless mode. Playwright screenshot documentation · Playwright visual comparisons.

Percy’s documented Playwright integration uses existing toHaveScreenshot() tests and requires a Percy project and versioned package setup. Percy maintains a base build and presents visual changes for review. See Percy’s Playwright integration.

2. Decide how the site selects its language

Before choosing capture settings, determine how the page gets its language. A site may use a localized path such as /fr/, a query parameter, a locale cookie, a request header, a language selector stored in browser state, or an account preference. These are site-specific possibilities, not a universal behavior guaranteed by screenshot tools.

Open the target page and select the desired language using the site’s supported mechanism.
Record the resulting URL and any required cookie, header, or account state.
Check that the page content actually changed; a different locale setting can still lead to fallback content.
Capture each locale with the same viewport, browser version, device scale, and interaction sequence.
Keep locale-specific baselines separate when comparing screenshots.

Timezone and geolocation may affect region-sensitive content, but they do not necessarily choose the interface language. Set them only when the page uses them, and verify the result on the page itself.

3. Capture multilingual pages with Playwright

The following JavaScript example visits explicit localized URLs and writes viewport screenshots. Replace the URLs with real locale routes on your site. Install Playwright in your project with npm install -D playwright, then run the script with Node.js. The browser binary may need to be installed for your environment using Playwright’s documented setup.

const { chromium } = require('playwright');

(async () => {
  const cases = [
    { locale: 'en', url: 'https://example.com/en/' },
    { locale: 'fr', url: 'https://example.com/fr/' },
  ];

  const browser = await chromium.launch({ headless: true });
  try {
    for (const item of cases) {
      const context = await browser.newContext({
        viewport: { width: 1440, height: 1000 },
        deviceScaleFactor: 1,
      });
      const page = await context.newPage();
      const response = await page.goto(item.url, {
        waitUntil: 'networkidle',
        timeout: 45000,
      });
      if (!response || !response.ok()) {
        throw new Error(`${item.locale}: navigation failed (${response?.status() ?? 'no response'})`);
      }
      await page.screenshot({ path: `page-${item.locale}.png`, fullPage: true });
      await context.close();
    }
  } finally {
    await browser.close();
  }
})().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

This uses isolated browser contexts so cookies or storage from one locale do not leak into the next. If your application selects locale through a cookie or local storage, set that state before navigation using Playwright’s context APIs, following the mechanism your application actually uses. For a viewport-only capture, remove fullPage: true. For an element capture, locate the intended element and use its screenshot method, for example await page.locator('main').screenshot({ path: 'main.png' });. See Playwright’s screenshot options.

Use Playwright Test for visual comparisons

For repeatable regression checks, Playwright Test can compare a page screenshot with a stored baseline using toHaveScreenshot(). A basic test can look like this:

const { test, expect } = require('@playwright/test');

test('French landing page', async ({ page }) => {
  await page.setViewportSize({ width: 1440, height: 1000 });
  await page.goto('https://example.com/fr/');
  await expect(page).toHaveScreenshot('landing-fr.png', { fullPage: true });
});

Review the Playwright documentation for baseline creation and updates. Rendering differences can arise across operating systems, browser versions, settings, hardware, and headless mode; keep the comparison environment stable and avoid accepting a changed baseline without reviewing it. Visual comparisons in Playwright Test.

4. Use Percy when hosted visual review fits

BrowserStack documents an integration for existing Playwright toHaveScreenshot() tests. Its workflow keeps a base build and surfaces visual changes for review. Setup requires a Percy project and the relevant versioned package, so confirm the current prerequisites in the integration documentation.

Percy’s SDK workflow captures DOM state and assets, then renders snapshots in Percy infrastructure. JavaScript is disabled by default during rendering because the page state has already been serialized; BrowserStack notes that enabling JavaScript can cause unexpected behavior, such as redirects or loss of serialized state. Treat this as a workflow setting to evaluate for your application, not as a universal defect. Percy SDK and capture workflow.

Percy also documents full-page capture, with details that differ between Percy Web and Percy on Automate. Select the project type based on whether you want its web visual testing workflow or screenshots made during a BrowserStack Automate session. Full-page screenshots · Percy project types.

5. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. A GET request with a URL returns a PNG, JPEG, WebP, or PDF. To capture a localized route, pass that route as the URL; use ScreenshotNeo’s timezone and geolocation options when the target site relies on them. Check the ScreenshotNeo API documentation for parameter names and configuration.

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

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

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com/fr/' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

ScreenshotNeo removes cookie and consent banners, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and the response identifies the page verdict and billing status in headers. Its MCP server gives AI agents tools for screenshots, page information, and PDF capture. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. Plans and features are listed at ScreenshotNeo. Sign up for 1,000 free screenshots a month, with no card.

6. Keep screenshots comparable

Fix the capture environment: use the same browser engine/version, operating system, viewport, and device scale for each run.
Fix the page state: use stable locale routes or consistently apply the same cookie, header, and account state.
Wait for meaningful readiness: choose a page-specific selector or loading condition when generic network idle is unreliable on pages with persistent requests.
Separate locale baselines: expected text, line breaks, fonts, and page heights can differ across languages.
Control dynamic content: freeze or mask timestamps, rotating promotions, and user-specific content when they are not the subject of review.
Choose capture scope intentionally: viewport captures are smaller and focus on the initial view; full-page captures include below-the-fold content and may expose lazy-loaded sections.

7. Troubleshooting

Symptom	Likely cause	Fix
Every screenshot shows the default language	The route, cookie, header, or account state did not select the requested locale	Use the site’s supported language selector, inspect the resulting URL/state, and verify the rendered page before capture.
Some locales redirect to another route	The site applies locale negotiation or fallback rules	Check the final URL after navigation and use the actual supported localized route or required session state.
Text or layout changes between runs	Different browser environment, fonts, dynamic content, or rendering settings	Stabilize OS/browser/settings and page state; mask or freeze content that should not trigger a visual change.
Screenshot is cut off	Viewport capture was used where a full-page capture was needed, or the page had not finished layout	Use full-page capture and wait for a stable page condition; for a specific section, capture the element directly.
Lazy-loaded content is missing	The page loads content only as it approaches the viewport	Scroll through the page or use a capture workflow that loads lazy images, then wait for the content to settle.
Percy snapshot differs from the browser screenshot	Percy captures DOM and assets and renders in its infrastructure; its JavaScript setting affects rendering behavior	Review the workflow and project type, then evaluate whether the documented JavaScript setting matches the page’s serialized state.
Playwright navigation times out	Slow page, persistent network activity, or unsuitable wait condition	Increase the timeout where appropriate and wait for a page-specific readiness signal instead of relying on network idle for every site.
API response is not an image	The request may have returned an error or a non-success page verdict	Inspect the HTTP response and ScreenshotNeo’s `X-Page-Verdict` and `X-Billed` headers; check the URL and API key.

8. Performance, reliability, and cost

Local Playwright captures avoid a hosted rendering workflow but require you to install and maintain browser automation and keep the environment stable. Capture only the scope you need: full-page shots involve more content than a viewport image. For repeatable visual review, stable environments and baselines matter because rendering can vary with OS, browser version, settings, hardware, and headless mode, as Playwright documents.

Percy adds hosted snapshot rendering and visual review, with project and package setup to manage. Its DOM-and-assets workflow means its result is not simply a pixel capture of the original live browser session; assess the documented rendering behavior against your app.

ScreenshotNeo charges only for clean shots: bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Its plans are Free (1,000 per month, no card), Starter ($5 for 3,000), 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. Every feature is available on every plan. Use its response headers to distinguish billed captures from other verdicts.

FAQ

Does a screenshot tool translate a page into another language?

No. A capture tool records what the site renders. The site or your test setup must select and render the locale.

Should I use geolocation to test translated pages?

Only if the site uses location to select language or regional content. Language and location are separate inputs on many sites, so verify both behaviors.

Can I compare localized screenshots against one shared baseline?

Usually each locale needs its own expected baseline because translated text and line wrapping change the layout.

Which option is best for my team?

Use Playwright for scriptable local capture, Percy when its hosted visual review workflow fits, and ScreenshotNeo when a screenshot API call or MCP tool fits your capture pipeline. The sources reviewed do not support a general ranking of locale controls across these products.