Best Free Screenshot APIs for Testing Webpage Captures

A free screenshot API can help you check how a webpage renders at different sizes without running a browser on your own machine. Among the offers in the reviewed vendor documentation, ScreenshotNeo is the first service to try: it has a free allowance of 1,000 screenshots per month, requires no card, and bills only clean captures. Other offers differ: ScreenshotOne advertises 100 screenshots per month, Thum.io advertises up to 1,000 impressions per month without signup, and Urlbox documents a seven-day free trial rather than a verified recurring monthly quota.

Those allowances are not directly equivalent. Before choosing, check whether the offer recurs monthly, whether signup is required, which viewport and full-page controls are available, how authentication works, and what happens when a page fails or a result is cached. Then compare your own representative pages using consistent capture settings. The official sources reviewed do not provide an independent head-to-head rendering benchmark.

1. Free screenshot API offers at a glance

Service	Published free offer	What the reviewed documentation establishes	Useful checks for your test
ScreenshotNeo	1,000 screenshots per month, no card	Website screenshot API and MCP server. Supports PNG, JPEG, WebP, or PDF output. Clean shots are billed; failed loads, bot checks, blank pages, timeouts, and cache hits cost nothing.	Try your own pages and viewport settings; inspect the page-verdict and billing headers. See the API documentation.
ScreenshotOne	100 screenshots per month; no credit card required according to its pricing page	Its pricing page says successful uncached screenshots count toward the plan limit. Documentation describes GET and POST, access keys, configurable capture options, and HTTPS use.	Check how its cache and failed-request behavior affect your quota, then test its viewport, full-page, and response-format options.
Thum.io	Up to 1,000 impressions per month without signup	The service describes a 1200-by-1200 browser, width and crop controls, mobile emulation, and full-page capture use cases.	Confirm how its impression allowance maps to your use and whether its output and integration suit your workflow.
Urlbox	Seven-day free trial	The quickstart describes signup for a trial, API and secret keys, and a mobile viewport example. The reviewed sources do not establish a recurring free monthly quota.	Check current trial and pricing terms, then test the viewport and rendering behavior you need.

Offers can change. The figures above reflect the vendor pages reviewed on October 3, 2026; reconfirm them on the linked pricing or documentation pages before adopting a service. ScreenshotOne’s pricing page describes its quota rules and usage notifications; Thum.io and Urlbox describe different kinds of free access, so compare recurring quota and trial time separately.

2. Choose a service by the test you need to run

Start with the free offer, but compare what counts

A monthly screenshot quota, an impression allowance, and a time-limited trial measure different things. Ask whether each successful capture uses quota, whether cached results count, whether failures count, and whether the allowance renews. For ScreenshotNeo, only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Each response includes X-Page-Verdict and X-Billed headers so you can see the result classification and billing status.

Match the viewport to the question

Use the CSS viewport that matters to your users rather than comparing providers at arbitrary defaults. Test at least one desktop size and the actual mobile dimensions relevant to your application. A device preset and a custom viewport are not always interchangeable: device emulation may also affect device scale, user agent, and other browser characteristics.

Check full-page behavior on long pages

For full-page capture, test pages with lazy-loaded images, sticky headers, long lists, and fixed banners. Check whether content loads before capture and whether fixed elements repeat or obscure content. ScreenshotOne and Thum.io document full-page capture options or use cases; ScreenshotNeo supports full-page capture with lazy images loaded. Provider descriptions do not establish identical stitching or rendering behavior.

Decide how much repeatability you need

Keep the viewport, page state, timing, and cache policy fixed when comparing results. Dynamic ads, animations, canvas content, timestamps, and rotating content can change pixels between runs. ScreenshotOne’s options documentation warns that animations, canvas rendering, and animated images may still move, and that pixel-identical captures are not guaranteed. Treat any provider’s feature list as a guide to options, then verify the output your own test requires.

Keep credentials out of browser code

Use HTTPS and keep API credentials on a server or in a protected test environment. ScreenshotOne’s documentation warns that HTTP does not encrypt requests and can expose API keys, authorization headers, cookies, and other sensitive data in transit. Urlbox’s quickstart also requires API and secret keys. Do not put a secret key in frontend JavaScript, a public repository, or a shared screenshot URL.

3. Make a fair screenshot API comparison

1. Choose representative pages. Include a typical page, a page with a consent banner or popup, a page with lazy images, and a page that requires authentication if that is part of your use case.
2. Fix the capture conditions. Use the same URL, viewport dimensions, output format, page state, and wait condition wherever the APIs allow it.
3. Separate first and repeat captures. A second request may be a cache hit. Record that separately from a newly rendered capture so you do not confuse caching with rendering speed or quota use.
4. Inspect more than the image. Check the HTTP status, response type, error details, and any provider-specific verdict or billing metadata. Save the request parameters with each result.
5. Repeat dynamic pages. Capture a few times to see whether animations, ads, or changing content make comparisons noisy. Do not describe this as a controlled benchmark unless you have designed and run one.
6. Estimate your expected monthly volume. Multiply the number of pages by viewports and runs, then account for retries and scheduled checks. Compare that estimate with the current free allowance and the paid plan you would actually need.

A simple comparison record can include provider, date, URL, viewport, options, cache state, status, output format, and whether the page contents were correct. This makes it easier to reproduce a result when a provider or page changes.

4. Example: request a screenshot from ScreenshotOne

ScreenshotOne’s getting-started documentation supports GET and POST requests and requires an access key. Its exact parameter names and available options are documented in its getting-started guide and options reference. Keep the key private and use HTTPS.

cURL

curl -G "https://api.screenshotone.com/take" \
  --data-urlencode "access_key=YOUR_ACCESS_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "format=png" \
  -o screenshot.png

Python

import requests

response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "access_key": "YOUR_ACCESS_KEY",
        "url": "https://example.com",
        "format": "png",
    },
    timeout=90,
)
response.raise_for_status()

content_type = response.headers.get("content-type", "")
if not content_type.startswith("image/"):
    raise RuntimeError(f"Expected an image, got {content_type}: {response.text[:500]}")

with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

Node.js

const params = new URLSearchParams({
  access_key: process.env.SCREENSHOTONE_ACCESS_KEY,
  url: "https://example.com",
  format: "png",
});

const response = await fetch(`https://api.screenshotone.com/take?${params}`);
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${await response.text()}`);
}

const contentType = response.headers.get("content-type") ?? "";
if (!contentType.startsWith("image/")) {
  throw new Error(`Expected an image, got ${contentType}`);
}

const image = Buffer.from(await response.arrayBuffer());
await import("node:fs/promises").then(({ writeFile }) => writeFile("screenshot.png", image));

The examples show the basic request shape. Use the vendor’s current options reference for full-page behavior, viewport, and other capture controls; do not assume a parameter supported by one API is accepted by another.

5. Or skip the browser setup

ScreenshotNeo provides a screenshot API and an MCP server for developers. One GET request can return a PNG, JPEG, WebP, or PDF. The request below saves a WebP screenshot of a page. See the ScreenshotNeo API documentation for options and response details.

cURL

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

Python

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 request failed: ${res.status}`);
const bytes = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(({ writeFile }) => writeFile('shot.webp', bytes));

• Cookie and consent banners are accepted like a visitor, then removed along with 60+ known consent platforms, newsletter popups, and chat widgets. Each step can be turned off.
• Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are never billed; response headers show the page verdict and billing status.
• An MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf.
• 1,000 screenshots per month are free with no card. Paid plans start at $5 for 3,000 screenshots; all features are on every plan.

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

6. Capture controls that matter for testing

Options vary by provider. Confirm availability and exact parameter names in the provider’s current documentation before building a shared test harness.

Control	Why it matters	Test consideration
Viewport and device	Changes responsive breakpoints and layout.	Record width, height, and device scale; use the same values across runs.
Full page and element capture	Determines whether you capture the whole document or a component.	Check page height, sticky/fixed elements, lazy loading, and selector stability.
Wait conditions	A page may be visually incomplete immediately after navigation.	Use a selector, delay, or network-idle condition where available; avoid waiting indefinitely on pages with persistent network activity.
Output format and scale	PNG, JPEG, and WebP differ in transparency and file size; scale affects detail and bytes.	Use one format and scale for pixel comparisons. Confirm whether a response is an image or an error payload.
Authentication and page state	Protected pages may need cookies, headers, or a user agent.	Use test credentials, keep secrets private, and avoid logging sensitive headers or cookies.
Cache behavior	A cached image can differ from a fresh render if the page changed.	Control or record cache state and TTL during comparisons.

ScreenshotNeo lists controls including full-page capture with lazy images loaded, CSS-selector element capture, dark mode, device presets and custom viewports, retina scale, PDF settings, custom CSS and JavaScript, pre-capture clicks, hidden selectors, wait conditions, request blocking, headers, cookies, user agent, timezone and geolocation, transparency, resizing, configurable caching, signed image links, async jobs with signed webhooks, bulk capture, a usage API, and an OpenAPI spec. The parameter names used by other screenshot APIs also work, which can make switching easier. Check the docs for the exact accepted values and request format.

7. Troubleshooting common capture problems

Symptom	Likely cause	What to do
The response is an error or text file instead of an image	Invalid credentials, malformed parameters, inaccessible URL, or an API error response.	Check the HTTP status and response body before saving it as an image. Verify the URL and required key in the provider’s current docs.
The screenshot is blank or incomplete	The page did not finish loading, scripts failed, or the capture happened before content appeared.	Check the page in a normal browser, then use a suitable selector or wait condition and retry. Inspect provider error and verdict metadata.
Images are missing on a full-page capture	Images load lazily only after scrolling or after a delay.	Enable the provider’s lazy-image or full-page loading behavior if available; allow the page enough time and inspect a long page separately.
The output changes from run to run	Animation, ads, timestamps, rotating content, or other dynamic page state.	Capture at a consistent point, disable animation where possible, hide irrelevant selectors, and repeat the capture. Pixel-identical output may not be possible on dynamic pages.
The screenshot has the wrong responsive layout	Viewport dimensions, device emulation, or device scale differ from the intended test.	Set explicit dimensions and scale. Confirm the API’s meaning of viewport and device presets.
A request times out	The site responds slowly, hangs on network activity, or has a transient failure.	Use a realistic client timeout, choose a bounded wait strategy, and retry transient failures with a limit and backoff. Do not retry indefinitely.
The API key is rejected or exposed	Wrong key, wrong environment, or a secret placed in client-side code or a URL that is logged.	Check the key and account configuration. Keep secret credentials server-side, use HTTPS, and avoid sharing logged request URLs.
Quota runs out sooner than expected	Each viewport, retry, or uncached page may consume allowance, or the offer may be a trial/impression quota rather than monthly screenshots.	Read the current quota definition, separate cache hits from fresh captures, and estimate volume before rolling the API into a recurring job.

8. Performance, reliability, and cost

Performance

Capture time depends on the target site, the content it loads, the wait condition, and the requested output. The reviewed sources do not establish an independent speed comparison, so do not infer one from a free quota or feature list. For your pages, record request duration alongside whether the output was correct and whether it came from cache.

Reliability

For production tests, track your own success rate, timeout rate, and image correctness over representative pages. ScreenshotOne’s homepage advertises 99.957% uptime over the previous 30 days, but that is a vendor claim, not an independent benchmark. A provider’s uptime statement does not guarantee that a particular target website will load successfully.

Cost

Estimate monthly demand as pages × viewport variants × capture frequency, then add expected retries and manual checks. Compare that number with the current free allowance and the paid tier you would need. Distinguish new renders from cached responses and successful captures from errors according to each vendor’s billing rules. ScreenshotNeo lists Free at 1,000 shots per month, Starter at $5 for 3,000, Growth at $15 for 15,000, Pro at $39 for 60,000, Scale at $99 for 250,000, and Business at $249 for 1,000,000; yearly billing gives two months free. Every feature is available on every plan. Recheck current terms before purchasing.

9. Frequently asked questions

What is the best free screenshot API?

For a first trial, ScreenshotNeo combines 1,000 free screenshots per month with no card and billing only for clean shots. Thum.io also advertises up to 1,000 monthly impressions without signup, but an impression allowance is a different offer. Choose based on your actual pages and required controls.

Is Urlbox free every month?

The reviewed quickstart documents a seven-day free trial. The reviewed sources do not establish an ongoing monthly free quota, so check its current pricing page for updated terms.

Can I test screenshots at mobile sizes?

Yes. Use an explicit mobile viewport or a documented device preset, and record the dimensions and scale so you can reproduce the capture. Urlbox’s quickstart demonstrates a 390-by-844 mobile viewport; Thum.io describes mobile emulation.

Are screenshots guaranteed to match pixel for pixel?

No. Dynamic page content and rendering differences can change pixels. ScreenshotOne’s documentation explicitly cautions that animations, canvas, and animated images may move and that identical captures are not guaranteed.

Should I use a screenshot API key in frontend code?

Keep secret API credentials on a server or in a protected test runner. A key embedded in public frontend code can be copied and reused.

Sources

• ScreenshotOne pricing, for its advertised free quota and plan usage notes.
• ScreenshotOne getting started and screenshot options, for request setup, security, and capture behavior.
• Thum.io website screenshot API, for its advertised impression allowance and capture descriptions.
• Urlbox quickstart, documentation, and pricing, for trial, authentication, and API details.
• ScreenshotOne homepage, for its vendor-reported uptime figure.