Best website screenshot APIs for automated captures
Compare website screenshot APIs by capture needs, workflow, reliability, and cost. Find the right fit for one-off renders, complex pages, and recurring jobs.
The right website screenshot API depends on what happens before and after the capture. For a straightforward URL-to-image request, use a screenshot endpoint; for pages that need waits, scrolling, or selector capture, verify those controls against your target pages; for multi-step work that clicks, fills forms, or carries cookies between actions, use a browser workflow with persistent state. ScreenshotNeo is the first API to consider when you want clean captures, transparent billing for failed or cached requests, and a free monthly allowance.
This guide compares the documented options and gives you a practical selection checklist. It does not claim hands-on benchmark results. Confirm current features and prices on each provider’s own site before committing.
1. ScreenshotNeo: clean captures with clear billing
ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. A GET request with a URL returns a PNG, JPEG, WebP, or PDF. It is the first option to evaluate if your workflow benefits from cookie and consent banners, newsletter popups, and chat widgets being removed before capture, and from bot checks, blank pages, failed loads, timeouts, and cache hits costing nothing. Each response includes X-Page-Verdict and X-Billed headers to indicate the result and billing status.
Its feature set includes full-page screenshots with lazy images loaded, CSS selector capture, dark mode, 12 device presets or custom viewports, retina scale, PDF settings, HTML or CSS input, custom CSS and JavaScript, pre-capture clicks, hidden selectors, wait conditions, request and resource blocking, custom headers and cookies, user agents and Authorization, timezone and geolocation, transparent backgrounds, resizing, configurable cache TTL, signed image links, asynchronous jobs with signed webhooks, batches of up to 100 URLs, a usage API, and an OpenAPI specification. Parameter names used by other screenshot APIs also work, which can ease migration. All features are available on every plan.
For AI workflows, its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
Pricing: Free includes 1,000 shots per month with no card; Starter is $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. These are published plan details supplied for this article; review the current plan page before purchase.
2. Browserless: screenshot endpoint within a broader browser API
Browserless documents a REST screenshot endpoint that accepts a URL or inline HTML and returns PNG, JPEG, or WebP. Its documented controls include full-page capture, Puppeteer-style screenshot settings, CSS selector capture, custom styles and scripts, waits, resource blocking, and optional scrolling to trigger lazy-loaded content. The documentation explains that selector capture waits for the element and crops to its bounding box, avoiding manual clip-coordinate calculations.
Browserless may fit teams that want screenshot capture alongside other browser tasks. Its REST overview also lists PDF generation, scraping, file downloads, function execution, website unblocking, and Lighthouse audits. The REST endpoints are stateless single-action requests: cookies and browser state do not persist between responses. If a task depends on a click in one step followed by a form submission in another, verify that the chosen interface supports the needed session model.
Browserless documentation: screenshot endpoint and REST API overview.
3. ScreenshotOne: direct GET and POST screenshot API
ScreenshotOne documents a direct screenshot API workflow with GET and POST requests. Its documentation recommends HTTPS because HTTP does not encrypt API keys, authorization headers, cookies, or other sensitive request data in transit. The response is determined by the options you request.
Choose it for a direct API workflow after checking that its current options cover your page’s waits, viewport, output, and capture boundaries. The dossier does not establish a complete feature-by-feature comparison or current plan terms, so verify those in the ScreenshotOne documentation and current pricing page.
4. Urlbox: verify fit directly before shortlisting
Urlbox is a relevant screenshot API candidate, but the reviewed material did not establish enough current feature or pricing detail to compare it accurately. Check its official documentation and pricing against your requirements before treating it as equivalent to the documented options above. Avoid choosing from a comparison table that lists unsupported or stale details.
How to choose an API for your capture workload
| Your workload | What to verify | Starting point |
|---|---|---|
| A single URL rendered to an image | Accepted URL formats, image types, response format, authentication, quota | ScreenshotNeo, ScreenshotOne, or Browserless |
| A page that needs rendering time or lazy content | Wait-for-selector, delay or network-idle behavior; scroll-to-load support; timeouts | Compare documented wait and scrolling options, then validate representative pages |
| A specific element or region | CSS selector capture, behavior when selector is absent or duplicated, crop boundaries | Browserless documents selector capture; check the equivalent option in other providers |
| A multi-step interactive flow | Persistent cookies and browser state, click/fill support, session lifetime, branching | Use a browser workflow that explicitly supports state across actions |
| High-volume recurring jobs | Billable unit, failed and cached requests, quotas, overages, batch size, async jobs | Compare effective cost using your expected successful and unsuccessful captures |
| Public page with consent overlays | Whether the provider can remove the exact banner or widget before capture | ScreenshotNeo documents removal of 60+ known consent platforms plus newsletter popups and chat widgets |
Capture options that matter in practice
Viewport, full page, and lazy-loaded sections
A viewport screenshot captures only what is visible at the selected dimensions. Full-page mode captures the document beyond the initial viewport, but long pages may rely on scroll-triggered loading. Check whether the service scrolls the page before capture and how it handles sticky headers, infinite feeds, and images that load only after entering the viewport. Compare screenshots of the same representative URLs; do not assume that a full-page flag alone triggers every lazy-loaded element.
Selector capture and waits
Selector capture is useful for cards, charts, product details, or a particular component. Decide what should happen if the element is missing, appears late, or matches more than once. A wait condition can improve timing, but a fixed delay adds latency even when a page is already ready. Prefer a selector or network condition that reflects the content you need, where available, and set a bounded timeout.
Dimensions, device scale, and output
Specify the viewport width and height for consistent layouts. Device scale or retina settings affect pixel dimensions and file size. PNG is useful when lossless edges or transparency matter; JPEG can reduce photographic image size; WebP can be a compact delivery format when downstream tools support it. Confirm whether the API returns raw binary, a URL, or an asynchronous job result. For PDFs, check paper size, margins, orientation, and page selection.
Authentication, cookies, and network controls
Private pages may require cookies, headers, user-agent settings, or Authorization. Treat these values as credentials: use HTTPS, avoid putting secrets in logs or public URLs, and restrict access to generated files. Request blocking can reduce unnecessary assets, but blocking scripts, fonts, or styles can change the rendered result. Test resource filters against real pages.
Runnable requests
The following examples use ScreenshotNeo’s documented endpoint and save the returned image bytes. Replace YOUR_API_KEY with an API key and change the target URL. See the ScreenshotNeo API documentation for capture parameters such as format, full-page mode, viewport, and waits.
cURL
curl -G "https://api.screenshotneo.com/v1/shot" \
-d access_key=YOUR_API_KEY \
--data-urlencode url=https://stripe.com \
-o shot.webpPython
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()
with open("shot.webp", "wb") as f:
f.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 = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));Keep API keys on a server or in a secret manager. A browser-side request can expose the key to visitors. When adapting these patterns to another provider, use its documented authentication and response handling; do not assume endpoint parameters or error formats are interchangeable.
Or skip the browser setup
ScreenshotNeo makes the capture a single HTTP request. Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed. An MCP server lets AI agents take screenshots. The Free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpRead the API docs and sign up for 1,000 free screenshots a month with no card.
Reliability, performance, and cost
Validate reliability on your own pages
Build a small representative set: a static page, a JavaScript-heavy page, a long page with lazy images, a page with overlays, and any authenticated page in scope. Inspect output for blank or incomplete captures, challenge pages, missing fonts, and content that arrives after the capture. Bot protections can block or alter automated browsing; no provider should be assumed to capture every protected site successfully.
Control latency and retries
Rendering time depends on the page and the waits you request. Full-page scrolling and long fixed delays can add work. Set request timeouts appropriate to the slowest pages you support. Retry transient network failures with a limit and backoff, but avoid retry loops for permanent conditions such as an invalid URL, missing selector, or blocked page. Make scheduled capture jobs idempotent so a retry does not create duplicate downstream records.
Compare effective cost, not headline price
Compare the billable unit and treatment of failures, cache hits, overages, annual commitment, and included quota. Estimate your workload as scheduled attempts per month, then separate successful captures from failures and cache hits according to each provider’s billing policy. Pricing figures from third-party comparisons are snapshots and may use different units; verify current prices and terms directly. ScreenshotNeo’s stated plans are listed above, and its response headers identify verdict and billed status.
Common problems and fixes
| Symptom | Likely cause | Fix |
|---|---|---|
| Image is blank or shows a challenge | The target blocked automation, a bot check appeared, or rendering did not complete | Inspect the returned page verdict and capture; validate the target’s access policy and use a supported browser or access path |
| Text or images are missing | Capture started before content loaded, or lazy content was never triggered | Wait for a meaningful selector or readiness condition; enable supported scrolling/full-page loading; increase timeout modestly |
| Selector capture fails | Selector is incorrect, appears late, or does not match the expected page variant | Check the selector in the target page, wait for it explicitly, and handle missing-element cases in the job |
| Unexpected crop or dimensions | Viewport and device scale differ from expectations, or selector bounds changed | Set dimensions and scale explicitly; inspect the element bounds and responsive breakpoint |
| Request times out | Slow navigation, overlong wait, large page, or blocked resources | Use a bounded, relevant wait; remove unnecessary waits; retry transient failures with backoff |
| Image file contains an error response | Client saved an HTTP error body as if it were an image | Check status and response headers before saving; log a bounded error body securely |
| API key appears in logs or browser code | Credential passed in a public context or URL logging | Move capture server-side, rotate exposed credentials, and redact secrets from logs |
| Cost differs from request count | Providers count units differently, or retries, caching, and failures are treated differently | Review billable headers or usage reports and reconcile by outcome rather than raw attempts |
Pricing comparison: what can be stated safely
Published third-party reporting in the research dossier lists Browserless at $25/month billed annually for 20,000 units, ScreenshotOne at $17/month for 2,000 screenshots, and Urlbox at $19/month for 2,000 renders. These are secondary-source snapshots, not confirmed current vendor quotes, and the units and overage behavior differ. They are not directly comparable and should not be treated as current offers. Recheck each official pricing page for regional currency, billing period, quota, overages, and billable-render rules. ScreenshotNeo’s listed pricing is included in its section above.
Frequently asked questions
What is the difference between a screenshot API and a browser automation API?
A screenshot API is optimized for producing a capture from a request. A browser automation interface can expose multiple actions and may preserve a session so later steps can use earlier cookies or page state. Check the exact session behavior: Browserless REST screenshot calls are stateless.
Can an API screenshot a site behind a CAPTCHA?
Not reliably by default. Bot challenges can produce a blocked or challenge-page capture. Test access on the target sites and do not assume a provider can bypass every protection.
Can I use screenshot APIs in scheduled jobs?
Yes. Use a server-side worker, bounded timeouts, limited retries, and a way to detect whether each result is a successful image, a failure, or a cache hit. For large batches, verify provider limits and asynchronous options.
Do I need a physical product to choose a screenshot API?
No. These are hosted software services; a physical product is not needed for selection or use.
