Website screenshot API comparison: features, limits, and rendering

For a hosted website screenshot API, compare how you submit work, receive results, control what gets captured, and handle dynamic pages. ScreenshotNeo is the first service to consider when clean captures and clear billing outcomes matter: it removes common consent banners, popups, and chat widgets before capture, and only clean shots are billed. ScreenshotOne, Browserless, and Urlbox document different request and rendering workflows; the sources reviewed do not establish a fair winner for price, speed, or pixel fidelity.

This comparison summarizes provider documentation, not side-by-side testing. Providers may define full-page capture differently, and a feature or limit absent from a reviewed page should not be assumed to be absent from the product.

1. Choose by workflow and capture requirements

Service	Request and response workflow	Capture controls documented in reviewed sources	Explicit limit in reviewed sources
ScreenshotNeo	One GET request returns an image or PDF. An MCP server provides screenshot and page-information tools for AI agents.	Full-page, CSS-selector element capture, device and viewport controls, formats, page-state options, request blocking, custom headers and cookies, caching, async jobs, bulk capture, and more.	The product facts provided for this article state plan quotas and prices; see the current plan figures below.
ScreenshotOne	GET and POST. POST options go in a JSON body. Binary-by-format responses are not stored by default unless caching, storage, or related options are enabled.	Full-page and selector capture, viewport settings, formats, motion options, custom scripts and styles, and GPU rendering request. GPU rendering is best-effort and can fall back to software.	Maximum POST request body: 100 MiB, per its documentation observed 2026-10-03.
Browserless	POST to `/screenshot`, with token authentication. The request can provide a URL or inline HTML.	Full-page, format, quality, clip region, viewport, device scale factor, selectors, and scrolling to trigger lazy-loaded content.	No comparable body-size ceiling or plan quota was identified in the reviewed endpoint page.
Urlbox	GET render links are synchronous. POST supports synchronous or asynchronous workflows; async results can be polled or delivered by webhook.	Responsive, full-page, and CSS-selector capture; product pages also describe hiding overlays, popups, and banners.	No comparable body-size ceiling or plan quota was identified in the reviewed pages.

Sources: ScreenshotNeo documentation; ScreenshotOne Getting Started and Screenshot Options; Browserless Screenshot API; Urlbox Screenshot API and Urlbox docs overview.

2. Understand synchronous and asynchronous capture

Synchronous requests

A synchronous request waits for rendering and returns the image or another response directly. This is convenient for a user-triggered preview, thumbnail generation, or a simple integration that can wait for one capture. ScreenshotOne documents GET and POST; Browserless documents a POST screenshot endpoint; Urlbox documents synchronous GET and POST options. ScreenshotNeo returns an image or PDF from a GET request.

For binary responses, save the response body as bytes. Do not print it as text or assume a successful HTTP transport means the page itself rendered successfully. Inspect the provider’s status and response metadata where available. ScreenshotNeo identifies page outcomes and billing using X-Page-Verdict and X-Billed headers.

Asynchronous jobs

Async rendering is useful when a capture takes too long for a web request, when many pages can be rendered independently, or when a worker should process results later. Urlbox documents polling or webhook delivery for asynchronous POST workflows. ScreenshotNeo supports async jobs with signed webhooks and bulk capture of up to 100 URLs per call. Read the provider’s current docs for the exact job submission and retrieval schema; do not assume those schemas are interchangeable.

For webhook-based systems, validate the provider’s signature before trusting a callback, make handlers idempotent, and record a job identifier so retries do not create duplicate downstream work. These are integration safeguards; the exact signature and retry behavior are provider-specific.

3. Compare capture scope and page state

Viewport, full-page, and element captures

Viewport capture is appropriate for social previews, cards, or monitoring a fixed screen region. Choose a viewport that matches the expected consumer.
Full-page capture is useful for long articles and page archives, but can produce tall images, take longer, and expose lazy-loading or sticky-element behavior. ScreenshotOne and Browserless describe scrolling or rendering steps related to lazy-loaded content; Urlbox and ScreenshotNeo document full-page capture.
Element capture limits the result to a CSS selector, such as a chart or product card. Check whether the service waits for the selector, how it handles nested or off-screen elements, and whether the resulting crop includes shadows or overflow. Browserless documents waiting for the selector and cropping to its bounding box; ScreenshotNeo and ScreenshotOne document selector capture.
Clip regions are useful when coordinates are stable. Browserless documents a clip region; selector capture is usually more resilient than hard-coded coordinates when layout changes.

Lazy content, motion, and overlays

Pages can render differently depending on scroll position, animation, consent prompts, and network activity. Browserless says lazy-loaded content renders when scrolled into view and recommends scrollPage: true, optionally with full-page mode. ScreenshotOne’s guide notes that scrolling, reducing motion, or waiting longer can improve full-page results at a performance cost. ScreenshotNeo accepts consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Urlbox advertises controls for hiding overlays, popups, or banners.

If a page uses a consent wall or requires a login, determine whether the intended capture should show the prompt, accept it, or use supplied credentials. Use only accounts and pages you are authorized to access. A screenshot API cannot reliably capture content that the page does not expose to the rendering session.

4. Compare output formats and rendering options

Choose the output based on the next step in your system:

PNG is a sensible default for sharp UI details and text.
JPEG can reduce file size for photographic pages, with a quality tradeoff.
WebP is useful when downstream systems support it and smaller files matter.
PDF suits document-like output and printing. Check paper size, margins, orientation, and page-range support.
HTML, text, or metadata may be available as additional representations from some workflows; these are not interchangeable with an image.

Browserless documents PNG, JPEG, and WebP responses and screenshot settings such as quality and device scale factor. ScreenshotOne’s options reference lists PNG, JPEG, WebP, GIF, JP2, TIFF, AVIF, HEIF, PDF, HTML, and Markdown. Urlbox’s POST workflow can return JSON with screenshot URLs and optional metadata or content URLs. ScreenshotNeo supports PNG, JPEG, WebP, and PDF, plus image resizing and transparent backgrounds.

For high-density displays, use an appropriate device scale factor or retina setting, then check the actual pixel dimensions and file size. For repeatable visual comparisons, keep viewport, scale, format, locale, timezone, and page state consistent. A different font load or animation frame can cause visual differences even if the page content is unchanged.

5. Request and response examples

Request schemas differ between providers, so there is no single portable request. The following examples show the documented workflow shapes without inventing provider-specific option names beyond those stated in the reviewed sources.

ScreenshotOne: GET or POST

ScreenshotOne documents both GET and POST. For POST, options are JSON in the request body and the documented maximum body size is 100 MiB. Use its Getting Started guide and options reference for the current authentication and parameter schema. Larger HTML or Markdown inputs should be hosted and passed as a URL, as the provider recommends.

Browserless: POST screenshot endpoint

Browserless documents a POST request to /screenshot with token authentication. A request can use a URL or inline HTML; when using html, do not also send url. The exact endpoint host and supported request fields depend on the Browserless deployment and plan, so follow its current endpoint documentation.

POST /screenshot
Content-Type: application/json

{
  "url": "https://example.com",
  "options": {
    "fullPage": true
  }
}

The endpoint documentation also describes selectors, clip regions, viewport, device scale factor, and scrollPage. Confirm the exact schema and token placement in the current docs before adapting this illustrative shape.

Urlbox: synchronous or asynchronous POST

Urlbox documents GET render links for synchronous binary output and POST for synchronous or asynchronous workflows. The async path supports polling or a webhook. POST may return JSON containing screenshot URLs and optional metadata/content URLs. Consult the Urlbox API documentation for the current authentication, parameter, and job schema.

6. Published limits, pricing, and what cannot be compared

The clearest numeric request limit in the reviewed third-party source set is ScreenshotOne’s maximum 100 MiB POST body, as observed in its official documentation on 2026-10-03. The reviewed Browserless and Urlbox pages did not provide a comparable request-body ceiling or plan quota. That absence does not establish that requests are unlimited.

The source set does not support a like-for-like comparison of ScreenshotOne, Browserless, and Urlbox plan prices, monthly quotas, latency, regional coverage, or pixel fidelity. It also does not contain standardized benchmark results. Check each provider’s current plan and limit pages before committing, because quotas and prices can change.

ScreenshotNeo’s stated plans are 1,000 free screenshots per month with no card, 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, and every feature is on every plan. These are ScreenshotNeo product facts, not a price comparison against providers whose current plan terms were not established by the reviewed sources.

7. Selection checklist

Match the integration: do you need a direct GET, JSON POST, inline HTML, async jobs, webhooks, or bulk requests?
Specify the output: image format, PDF page setup, response binary versus URL, and any metadata or content required downstream.
Define the capture area: viewport, full page, selector, or clip region. Test long pages and off-screen elements.
Model page state: lazy-loaded content, consent prompts, animations, overlays, authentication, locale, and time-dependent content.
Set rendering controls: viewport, device scale factor, wait condition, delay, custom CSS or JavaScript, headers, cookies, and resource blocking as needed.
Check documented limits: body size, quotas, concurrency, retention, and request rate. Verify current terms instead of inferring a limit from silence.
Plan failure handling: timeouts, navigation errors, bot checks, blank pages, retries, and duplicate webhook delivery.
Estimate total cost: include successful captures, retries, storage, bandwidth, async orchestration, and the provider’s definition of a billable result.
Run representative pages: compare the pages your product actually needs, with fixed settings and a written acceptance check. The documentation comparison here is not a substitute for that evaluation.

8. Performance, reliability, and cost considerations

Performance

Full-page rendering and pages with lazy content can require scrolling and additional waits. Larger viewports, high device scale factors, PDF output, custom scripts, and heavy pages can also increase work or output size. ScreenshotOne explicitly notes that full-page quality improvements can reduce performance. Prefer the smallest capture scope that meets the requirement; for many independent captures, consider an async workflow where the provider supports it.

Reliability

A browser render depends on the target site’s availability, bot defenses, network requests, and client-side application state. Use finite timeouts, bounded retries with backoff, and idempotent processing. Capture response metadata so you can distinguish transport failures from a rendered page that is blank or blocked. ScreenshotNeo marks page verdict and billing state in response headers; check those headers when deciding whether a result should be retried or recorded.

Cost

Compare the unit that each vendor bills, what counts as a failed capture, and whether retries, storage, or bandwidth are charged. Do not turn a free allowance from a live homepage into a permanent offer. ScreenshotOne’s homepage showed 100 free screenshots per month when observed on 2026-10-03; that offer is volatile and should be verified before use. The reviewed materials did not establish comparable quotas or prices for Browserless and Urlbox.

9. Troubleshooting

Symptom	Likely cause	What to do
Response is not a valid image	An HTTP or provider error was saved as if it were binary output, or the requested representation differs from what the client expects.	Check the HTTP status, content type, and provider-specific response metadata before saving. Preserve error bodies for diagnosis.
Page is blank or incomplete	Navigation has not finished, client-side content is still loading, a resource failed, or a bot check blocked rendering.	Use a suitable wait condition or delay, inspect page outcome metadata, and verify that the same URL is reachable in an authorized browser session.
Images or below-the-fold content are missing	Lazy-loaded assets were never brought into view.	Use the provider’s documented scroll behavior or full-page mode. Browserless documents `scrollPage: true` for this case.
Element capture times out or returns the wrong crop	The selector is absent, late, ambiguous, or changes with responsive layout.	Use a stable selector, wait for it, and verify the viewport and page state. Browserless documents waiting for the selector before cropping its bounding box.
POST fails for large HTML or Markdown	The input exceeds the provider’s request-body limit.	For ScreenshotOne, keep the POST body within its documented 100 MiB maximum; host large input and pass a URL as the docs recommend.
Browserless request rejects the input fields	Both `url` and `html` were sent, or a field does not match the endpoint schema.	When supplying inline HTML, omit `url`; verify property names against the current endpoint documentation.
Full-page image has repeated or misplaced sticky content	Scrolling changes sticky elements or animations during capture.	Reduce motion, use a stable wait, or capture a specific element/viewport instead. Review the provider’s full-page controls.
Output is much larger than expected	Full-page dimensions, retina scale, or a lossless format increased pixel count and file size.	Reduce capture area or scale, use an appropriate compressed format, or resize the resulting image.
Webhook processing happens more than once	Webhook delivery may be retried, or the consumer does not deduplicate jobs.	Verify signatures, store job identifiers, and make result handling idempotent. Confirm the provider’s retry policy in its docs.

10. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its one-call GET endpoint returns an image or PDF, and the parameter names used by other screenshot APIs also work to make switching easier. See the ScreenshotNeo API documentation for options and setup.

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

import requests

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

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}`);
await Bun.write('shot.webp', res);

Cookie banners, popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks, blank pages, timeouts, and failed loads are never billed; cache hits are also free. Response headers report the page verdict and billing status.
An MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs.
1,000 screenshots per month are free with no card; paid plans start at $5 for 3,000 screenshots.

11. Frequently asked questions

Can these APIs return a screenshot without storing it?

ScreenshotOne says binary-by-format responses are not stored by default unless caching, storage, or related options are enabled. Storage behavior for other providers depends on their workflow and settings; check the current documentation for retention and URL lifetime.

Is there a single best API for pixel fidelity?

The reviewed sources include no standardized side-by-side fidelity benchmark. Render representative pages with consistent viewport, scale, wait, and output settings before deciding.

Some services document custom headers or cookies, and ScreenshotNeo supports custom headers, cookies, user agent, and Authorization. Access and behavior depend on the target site and credentials. Follow the provider’s documentation and only capture content you are authorized to access.

Does full-page capture always include every lazy-loaded section?

No. Lazy content may load only after scrolling or waiting, and implementations differ. Configure the provider’s documented scroll behavior and inspect representative results.

How should I compare monthly cost?

Use current plan pages and compare the same expected number of billable captures, failure policy, storage, bandwidth, and concurrency. The reviewed third-party sources do not provide a comparable price and quota table.