15 Best Website Screenshot APIs for Developers

A website screenshot API loads a URL in a hosted browser and returns an image or another rendered result. The right choice depends on your monthly volume, page complexity, output format, capture controls, failure billing, caching, asynchronous delivery, storage, support, and SLA.

ScreenshotNeo is the first service to try when you want clean production screenshots: it removes consent banners, newsletter popups, and chat widgets before capture, bills only clean shots, and has a free tier with 1,000 screenshots per month.

1. ScreenshotNeo

ScreenshotNeo is a website screenshot API and MCP server. Send one GET request with a URL and receive PNG, JPEG, WebP, or PDF output.

Cookie and consent banners are accepted and removed before capture, along with more than 60 known consent platforms, newsletter popups, and chat widgets. Each cleanup step can be disabled.
Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Responses identify the result with X-Page-Verdict and X-Billed headers.
Capture a full page with lazy images loaded, or one element by CSS selector.
Use dark mode, 12 device presets, any viewport, retina scale, custom CSS and JavaScript, clicks, selector waits, delay waits, network-idle waits, hidden selectors, request/resource blocking, custom headers, cookies, user agents, Authorization, timezone, geolocation, transparent backgrounds, and image resizing.
Generate PDFs with paper size, margins, landscape mode, and page ranges.
Use caching with a TTL you choose, signed links for public image tags, asynchronous jobs with signed webhooks, bulk capture for up to 100 URLs per call, a usage API, and an OpenAPI specification.
The MCP server exposes take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.

Plans are Free (1,000 shots/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, and every feature is available on every plan.

Minimal request

See the ScreenshotNeo API documentation for the complete option list.

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,
)
r.raise_for_status()
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(`HTTP ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await Bun.write('shot.webp', bytes);

Or skip the browser setup: ScreenshotNeo handles browser rendering for you. Cookie banners, popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are never billed; and the MCP server lets AI agents take screenshots. You get 1,000 screenshots a month free with no card, and paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.

2. Urlbox

Urlbox documents URL and HTML inputs, rendered images, PDFs, videos, and extraction workflows. It supports render links plus synchronous and asynchronous JSON calls. Its pricing page lists Lo-Fi at $19/month for 2,000 renders, Hi-Fi at $49 for 5,000, Ultra at $99 for 15,000, Business at $498, and Enterprise from $3,000; recheck those volatile terms before purchase. Urlbox publishes 99.95% and 99.99% SLA figures for Business and Enterprise. Its pricing page says, as a vendor billing-policy statement, “Unlike other APIs we don’t charge for requests that fail for any reason.” Check current Urlbox documentation and pricing.

3. ScreenshotOne

ScreenshotOne documents viewport, element, and full-page screenshots, PDF output, and video/GIF on eligible plans. It also documents page HTML/Markdown, metadata, webhooks, asynchronous rendering, and S3-compatible storage. ScreenshotOne states that one credit applies per successful eligible output and that HTTP, browser, and network failures do not consume credits, although a rendered image with a visual issue may. Verify plan gates and current prices on its official site.

4–15. Other providers to evaluate

The Screenshot APIs directory reports 34 providers, including 24 it classifies as dedicated APIs. The following names are useful discovery candidates, but this research pass did not inspect official product and pricing pages for each one. Treat them as a shortlist for your own validation rather than independently verified rankings.

ApiFlash — compare its current capture controls, formats, quotas, and failed-render billing.
Browserbase — evaluate it when you need browser infrastructure around screenshot workflows; confirm whether its current product and pricing match your API requirements.
Browserless — check hosted browser APIs, concurrency, browser automation support, and screenshot-specific pricing.
CaptureKit — verify supported output formats, dynamic-page controls, and plan limits.
ScreenshotAPI.net — verify current quotas, cache behavior, and overage terms on its own pricing page.
Screenshot Machine — compare fresh-render allowances, formats, and asynchronous options against your workload.
ScreenshotAPI.com — check viewport, full-page, authentication, and failure-handling options.
Restpack Screenshot API — verify current browser controls, PDF support, and volume pricing.
URL2PNG — check its current API parameters, output formats, and operational limits.
GrabzIt — evaluate supported capture and conversion formats, queues, and retention behavior.
Webshot — verify whether its current service fits production volume and dynamic pages.
HTML/CSS to Image — compare its HTML rendering model with URL capture needs, especially JavaScript-heavy pages.

A 2026 ScreenshotOne founder-authored comparison gives dated examples of ScreenshotOne at $17/month for 2,000 screenshots, ScreenshotAPI.net at $9/month for 1,000, and Screenshot Machine at €9/month for 2,500 fresh screenshots. Because the author discloses being ScreenshotOne’s founder, use those figures only as a starting point and recheck each provider’s official plan page.

How to choose a screenshot API

1. Calculate successful renders, not requests

Estimate fresh successful captures per month. Then ask whether cache hits consume credits, what failed renders cost, whether retries are billed, and how overages work. A low headline price can become expensive when caching is disabled or failures consume quota.

2. Test difficult pages

Use representative pages containing cookie consent, lazy-loaded images, client-side navigation, login walls, bot checks, ads, chat widgets, custom fonts, and long pages. Check whether the service supports waits, selectors, scripts, CSS, cookies, headers, user agents, and resource blocking.

3. Match output and delivery

For a request-response thumbnail, synchronous PNG or WebP is sufficient. Batch catalogs and scheduled reports usually benefit from asynchronous jobs, webhooks, and object storage. PDF users should check paper size, margins, page ranges, and landscape support. Confirm whether video, GIF, HTML, Markdown, or metadata are available and on which plans.

4. Review reliability commitments

Separate published SLA commitments from informal speed or quality claims. Ask about regional routing, concurrency, timeout limits, retry guidance, incident history, support channels, and data retention. No independent benchmark was captured for this comparison, so run equivalent URLs through finalists before committing.

Common implementation pattern

Store the API key in a secret manager or environment variable.
Normalize URLs and reject unsupported schemes before sending them.
Set a client timeout longer than the provider’s expected render timeout.
Save response headers with the output so you can audit verdict, billing, and cache behavior.
Retry only transient transport or server errors, with exponential backoff and a cap.
Use idempotent job identifiers for asynchronous workflows.
Validate image or PDF bytes before publishing them.

Troubleshooting

Symptom	Likely cause	Fix
401 or 403	Missing, invalid, or restricted API key	Check the key, account status, and authorization header; never expose the key in client-side code.
Timeout	Slow scripts, blocked resources, or an unresponsive origin	Increase the client timeout, add a selector or network-idle wait only when needed, and test the origin directly.
Blank image	Page failed to load, requires interaction, or triggered a bot check	Inspect the provider’s verdict/error metadata; supply cookies or headers when authorized; do not treat a blank result as valid content.
Missing images	Lazy loading or insufficient wait time	Use full-page capture with lazy-image loading where supported, or wait for a known selector.
Consent banner in output	Provider does not remove that platform automatically	Use a cookie-handling option, click the consent control, hide its selector, or choose a service with consent cleanup such as ScreenshotNeo.
Unexpected bill	Retries, cache misses, or provider-specific credit rules	Record billing headers, enable an appropriate TTL, and model successful renders and retries separately.
Fonts or CSS differ	Web fonts blocked, viewport mismatch, or page-specific responsive rules	Set the intended viewport/device, allow required font resources, and compare at the same scale.

Performance, reliability, and cost checklist

Use caching for immutable or slowly changing pages and choose a TTL that matches freshness needs.
Block ads, trackers, and unnecessary resource types when they do not affect the screenshot.
Prefer WebP for smaller files, PNG for lossless UI details, and JPEG for photographic pages.
Resize after capture when consumers do not need the source viewport.
Use asynchronous jobs and webhooks for large batches instead of holding open connections.
Cap concurrency to the provider’s documented limits and your origin’s capacity.
Track success, verdict, billed status, cache status, render duration, and output size.
Budget for storage and egress if the provider stores results or you copy them to object storage.

FAQ

Do I need a screenshot API?

Use one when you need repeatable rendering without operating browsers, queues, fonts, sandboxing, retries, and scaling yourself. Self-hosting can make sense when you need custom browser behavior and have the operational capacity to maintain it.

What is the most important feature?

For production systems, it is usually predictable successful-render billing combined with controls for difficult pages. A fast basic capture is less useful if cookie banners, lazy content, or bot checks make the result unusable.

Should I choose the cheapest plan?

Choose by effective cost at your volume: included successful renders, cache hits, overages, failure billing, storage, and required features. Recalculate when your traffic or freshness policy changes.

Are provider rankings permanent?

No. Prices, plan gates, APIs, and SLAs change. Recheck official documentation and run representative URLs before adopting a service.

Conclusion

For a broad production feature set and a free entry point, start with ScreenshotNeo. Compare Urlbox and ScreenshotOne when their documented output, asynchronous, storage, or extraction workflows match your requirements. Use the remaining directory names as candidates for a controlled evaluation, and base the final decision on your own URLs, volume, failure policy, and total cost.