Screenshot API Pricing by Page Capture: How to Compare Per-Image Costs

To compare screenshot API pricing per page, divide each plan’s monthly price by its included capture quota, then model what your workload will actually be billed for. The first figure is an allowance rate, not a guaranteed cost per usable image: providers can treat failed requests, cached results, long renders, large files, and advanced options differently. Compare plans using the same URLs, output settings, cache policy, and expected monthly volume.

Prices below are vendor-published USD list prices reported on official pricing pages checked on October 3, 2026. They can change; verify the linked plan pages before purchasing. The examples are not a complete market survey and do not establish equivalent capture quality or performance.

1. Calculate the included-quota rate

Use this basic formula:

included-quota rate = monthly plan price / included monthly captures

For a $17 plan with 2,000 included captures, the arithmetic is $17 / 2,000 = $0.0085 per included capture. This tells you how the plan fee spreads across its stated allowance. It does not automatically tell you how much a successful, uncached, production-ready image costs.

For a more useful estimate, model expected charges:

expected monthly bill = base fee
                      + expected overage
                      + weighted or advanced render charges
                      + required add-ons

expected usable-image cost = expected monthly bill / expected usable images

Keep the denominator explicit. “API calls,” “renders,” “successful screenshots,” “unique uncached outputs,” and “usable images delivered to your application” are different units.

2. Published pricing examples

The table applies simple monthly price divided by included quota. Treat the resulting amounts as list-price allowance rates, not a ranking of equivalent services.

Provider and tier	Monthly price	Included quota	Simple included rate
ScreenshotNeo Free	$0	1,000 screenshots	$0 within quota
ScreenshotNeo Starter	$5	3,000 screenshots	About $0.00167
ScreenshotNeo Growth	$15	15,000 screenshots	$0.001
ScreenshotNeo Pro	$39	60,000 screenshots	$0.00065
ScreenshotNeo Scale	$99	250,000 screenshots	$0.000396
ScreenshotNeo Business	$249	1,000,000 screenshots	$0.000249
ScreenshotOne Basic	$17	2,000 screenshots	$0.0085
ScreenshotOne Growth	$79	10,000 screenshots	$0.0079
ScreenshotOne Scale	$259	50,000 screenshots	About $0.00518
Urlbox Lo-Fi	$19	2,000 renders	$0.0095
Urlbox Hi-Fi	$49	5,000 renders	$0.0098
Urlbox Ultra	$99	15,000 renders	$0.0066
Urlbox Business	$498 total: $495 base plus usage pricing	1,000 base renders shown	Not a simple fixed-quota comparison

ScreenshotNeo plans include the same listed feature set on every plan. Prices shown are the provided product facts; the comparison does not assert that other vendors’ tiers have identical capture scope. ScreenshotOne’s page says failed screenshots and eligible cached screenshots do not count toward quota, subject to its cache behavior and rules. Urlbox’s plan labels and render accounting also differ by tier. See the official pages for the terms: ScreenshotOne pricing and Urlbox pricing.

3. Define the workload before comparing plans

A fair estimate starts with one representative capture specification. Write down the target page types, frequency, output, and options, then apply that same specification to each provider.

Workload input	What to record
Volume	Average and peak captures per day and month; number of distinct URLs
Output	PNG, JPEG, WebP, or PDF; viewport or full-page; image dimensions and scale
Page behavior	Wait condition, delayed content, lazy images, authentication, cookies, geography
Reuse	How often the same URL and options are requested; cache TTL and invalidation needs
Quality bar	What makes a capture usable: correct page, nonblank output, required content present
Operations	Peak request rate, concurrency, retry policy, storage and retention, webhook or bulk needs

For example, a monthly job that captures 10,000 distinct pages once each is not equivalent to a service making 10,000 requests for a handful of URLs with caching enabled. Nor is a viewport PNG necessarily equivalent to a full-page PDF that waits for a late-loading chart.

4. Check how the billing unit is counted

Requests, renders, successes, and unique outputs

Read the quota definition carefully. A request can fail before producing an image. A provider may still count that attempt, or it may count only successful renders. A cache hit might count as a request but not consume a render credit. ScreenshotOne says failed screenshots and eligible cached screenshots do not count toward its quota, subject to its cache behavior and rules. Confirm the exact cache eligibility and failure definitions in the current terms.

Estimate usable output separately from billable activity. If a provider charges failed attempts, model the expected failure rate rather than assuming every request yields an image. If failed attempts are excluded, still account for retries in throughput and latency planning.

Weighted renders and advanced options

Some plans use credits or weighted render units. Urlbox documents extra render use for long requests, large files, GPU acceleration, advanced features, and certified archive storage. Its documentation describes usage scaling with request duration (one render per 30-second period), file size (one per 5 MB), GPU acceleration (twice the renders), and an additional render per year of certified archive storage. Confirm the current rules and calculate using the exact options you need; do not assume each output costs one credit.

Overage and hard limits

Record whether excess usage is blocked, billed automatically, or requires a plan change. ScreenshotOne’s published examples list extra screenshot prices of $0.009 on Basic, $0.006 on Growth, and $0.004 on Scale. These rates can alter the best tier if usage is above quota. Include an overage estimate:

overage units = max(0, expected billable units - included units)
expected overage = overage units * overage price

Urlbox Business is shown as a $495 base with $3 per 1,000 renders and 1,000 base renders in its plan table; verify the current interpretation and any other fees before estimating a bill.

5. Compare feature scope and operational limits

Price per image is useful only after confirming that the plan can produce the required image. Record the exact plan and option support for:

Full-page capture, lazy-loaded images, and element-by-selector capture
Image formats, PDF output, page ranges, paper sizes, and margins
Viewport presets, custom viewport sizes, and retina scaling
Wait conditions, custom JavaScript or CSS, and hiding page elements
Cookies, headers, authentication, user agent, timezone, and geolocation
Request blocking, cache controls, signed public links, and output retention
Bulk capture, asynchronous jobs, webhooks, usage reporting, and API limits

Also compare requests per minute, concurrency, queueing behavior, timeout limits, and support or retention terms when those affect your application. The cited pricing information does not establish equivalent service performance, so a lower arithmetic rate alone cannot show which provider is more reliable or faster.

6. Build a reproducible cost worksheet

Choose a representative set of URLs that reflects production page types, including slow or interactive pages.
Fix the same output format, viewport, wait conditions, and advanced options for each provider.
Estimate monthly attempts, unique URLs, cache reuse, expected failures, and successful usable outputs.
Translate those counts into each provider’s billable units, including multipliers and cache rules.
Apply base fees, included quota, overage, and required storage or add-ons.
Calculate both the expected monthly bill and expected bill per usable output.
Repeat the calculation at average and peak volume; verify plan throughput and hard limits separately.

A worksheet can use these columns:

Provider | Plan | Base fee | Included units | Unit definition | Expected billable units
         | Overage rate | Failed attempt rule | Cache rule | Multipliers
         | Needed features included? | Throughput fit? | Expected bill | Cost per usable image

7. Bulk scheduled capture is a separate cost model

Do not compare an on-demand screenshot API quota directly with a scheduled monitoring or archive product without normalizing the deliverable. Urlbox Capturedeck is a separate bulk scheduled-capture offering with its own listed plans: Solo at $29 for up to 1,000 captures, Basic at $49 for 3,000, Standard at $99 for 10,000, and Pro at $299 for 50,000 per month. Its page warns that advanced capture scenarios can consume more credits than a typical full-page capture. Compare schedule frequency, retention, and capture scenario as well as the quota. See Urlbox Capturedeck pricing.

8. ScreenshotNeo for a predictable per-capture starting point

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its listed plans start with 1,000 shots per month free with no card, then $5 for 3,000, $15 for 15,000, $39 for 60,000, $99 for 250,000, and $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Dividing fee by quota gives a straightforward baseline for your own comparison; use the actual usage and billing behavior relevant to your workload when estimating production cost.

ScreenshotNeo says only clean shots are billed. Its response headers indicate whether a result is a bot check, CAPTCHA, blank page, timeout, failed load, or cache hit, and these cases cost nothing. Before capture it accepts cookie or consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Its feature set includes full-page and element captures, image and PDF outputs, custom waits and page settings, blocking, caching, signed links, async jobs, bulk capture, and an MCP server with take_screenshot, get_page_info, and capture_pdf. See the ScreenshotNeo API documentation for options.

Use the calls below as a concrete comparison case. The output settings can be extended to match your workload; keep those settings consistent when comparing providers.

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 = new Uint8Array(await res.arrayBuffer());
await (await import('node:fs/promises')).writeFile('shot.webp', bytes);

Request options to include in the estimate

Full-page capture with lazy images, CSS selector capture, dark mode, device presets, custom viewport, and retina scale.
PDF paper size, margins, landscape mode, and page ranges; HTML or CSS input; custom CSS and JavaScript; click-before-capture and hide selectors.
Wait for a selector, a delay, or network idle; block ads, trackers, requests, or resource types.
Custom headers, cookies, user agent, and Authorization; timezone and geolocation; transparent background and image resizing.
Chosen cache TTL, signed links for public image tags, asynchronous jobs with signed webhooks, bulk capture up to 100 URLs per call, usage API, and OpenAPI spec.

9. Performance, reliability, and cost controls

Cache deliberately: Set a TTL that matches how often pages change. Caching can reduce repeat work, but include cache hits and invalidations in the comparison because providers count them differently.
Use realistic waits: Waiting for a selector or a known event can avoid capturing incomplete content. A long fixed delay can increase latency and, for providers with duration-based credits, cost.
Control output size: Full-page images, high pixel density, and PDFs can be larger and slower to transfer or store. Choose the smallest output that satisfies the product requirement.
Bound concurrency and retries: Respect per-plan throughput and timeout limits. Use backoff for transient failures, cap attempts, and avoid retrying a permanent invalid URL or authorization error.
Separate capture from delivery: For large jobs, asynchronous jobs and webhooks can keep application requests short. Bulk capture can lower orchestration overhead, but compare its own billing and failure semantics.
Track outcomes: Log request ID, page verdict, cache status, duration, and billed units where available. This makes forecast versus invoice differences explainable.

10. Troubleshooting pricing surprises

Symptom	Likely cause	What to check or change
Invoice exceeds fee divided by quota	Usage exceeded the included amount, or some renders consume weighted credits	Review unit definitions, overage rates, advanced options, and duration or file-size multipliers.
Many requests but fewer quota units	Cache hits or failed attempts are excluded under that plan’s rules	Compare request logs with billable usage and verify cache eligibility and failure accounting.
Quota runs out early	Retries, unique URL variants, cache misses, or advanced render options increase billable use	Normalize URLs and options, set intentional cache keys/TTLs, and inspect retry and credit records.
Some output is blank or incomplete	Page load failed, a bot challenge appeared, or capture ran before content rendered	Inspect the provider’s status or verdict, wait for a specific selector, and handle failures separately in cost estimates.
Peak jobs queue or time out	Plan request rate or concurrency does not match the batch pattern	Check rate limits, reduce concurrency, batch or schedule work, and include queue time in the latency requirement.
Two plan rates look incomparable	Quota units or capture specifications differ	Recalculate both for the same deliverable and include required features, storage, and retention.

11. FAQ

Is cost per screenshot the same as cost per API request?

No. An API request may be a failure, cache hit, or weighted render. Define whether you mean an attempt, a billable unit, or a usable output.

Should I choose the plan with the lowest included rate?

Only if its quota unit, capture scope, limits, and failure behavior fit your workload. A low allowance rate can become a poor estimate if required features or overages are extra.

How should I compare plans when my volume changes month to month?

Calculate expected bills at low, typical, and peak volume. Include the cost of overage or the operational impact of a hard quota cap.

Can I compare scheduled capture pricing with an API?

Yes, after matching the deliverable. Include schedule frequency, retention, and advanced-capture credit use for the scheduled product.

Or skip the browser setup

ScreenshotNeo returns an image or PDF from one GET request. Cookie banners, popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are never billed. Its 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.webp

See the API documentation and sign up free for 1,000 screenshots a month, with no card required.