How to Compare Screenshot API Pricing by Rendered Pages and Options

Compare screenshot API plans by the cost of producing the renders your workload actually needs—not by dividing the monthly fee by the advertised quota and stopping there. First normalize what counts as a billable render, then check cache and failure rules, overage rates, request throughput, and whether the required capture options are included. A low per-render price is useful only if the plan can serve the workload and capture the pages you need.

Prices and plan rules below were checked on October 3, 2026, and can change. Vendor examples are not an independent market survey. The reviewed sources do not establish comparative render quality, speed, or uptime, so this guide does not rank providers on those grounds.

1. Define what you are comparing

Start with one month of expected usage and a concrete capture specification. Count requests separately from successful, billable renders: one request may fail, return a cached result, or require a new browser render, and each provider can treat those cases differently.

• Monthly volume: expected capture requests, split by page type or workflow if needed.
• Billable volume: expected fresh successful renders after cache behavior and failure rules.
• Peak rate: highest requests per minute, including batch jobs and retries.
• Capture requirements: viewport, full-page or scrolling capture, delay or interaction, output format, location, and any special handling.
• Budget behavior: overage price, whether overages are enabled, and any spending cap or hard limit.

A screenshot is not always equivalent to another screenshot for plan comparison. If a workflow requires PDF output, a specific format, full-page capture, geographic selection, stealth handling, or another advanced option, verify that the plan supports it before comparing its unit price.

2. Normalize the vendor’s counting rules

Find the provider’s definition of a billable unit in its pricing page and documentation. Record whether the unit is a request, a successful render, a credit, or a more complex measure. Then check how it treats these cases:

Case	What to verify	Why it changes the estimate
Successful fresh render	Does it count toward the included quota?	This is usually the central billable unit, but definitions vary.
Failed request	Are browser, network, timeout, or HTTP failures charged?	Failure retries can inflate requests without producing usable images.
Cache hit	Does a response served from cache use quota or credits?	Repeated URLs may cost less than unique captures, depending on cache policy.
Cache miss	Can a miss trigger a new render and count against quota?	Do not assume every request to a cache-enabled endpoint is free.
Capture complexity	Do advanced modes consume extra credits or require another plan?	Page count alone can understate cost or make a plan ineligible.

For example, ScreenshotOne says only successfully rendered, non-cached screenshots count toward quota, and notes a cache miss may cause a rerender that counts. Urlbox says failed requests do not count and cache-served requests generally do not count against quota. These are vendor-specific policies, not a universal definition of a screenshot render. See the [ScreenshotOne pricing page](https://screenshotone.com/pricing/) and [Urlbox pricing page](https://urlbox.com/pricing/).

3. Check the options that affect plan eligibility

Write down the exact options your implementation will send. A plan comparison should separate price from eligibility: a cheap tier is not a real candidate if it lacks a required output, capture mode, or rate limit.

Option area	Questions to answer
Page dimensions	What viewport width and height are required? Is full-page capture needed, or only the visible viewport?
Timing and interaction	Do pages need a wait delay, a selector to appear, scrolling, or clicks before capture?
Output	Do you need PNG, JPEG, WebP, or PDF? Is the output rendered pixels, or does the API offer other representations such as HTML or Markdown?
Location and access	Does the use case need geographic selection, stealth or anti-blocking handling, custom headers, or authentication?
Complex rendering	Are GPU rendering, video output, storage, webhooks, signed links, or integrations part of the workflow?
Cache controls	Can you set the cache lifetime? How are cache keys formed, and what happens on a miss or expiry?

ScreenshotOne’s options documentation lists request controls and output formats including PNG, JPEG, WebP, GIF, TIFF, AVIF, HEIF, and PDF; availability can vary by plan. Its pricing page lists features such as HTML rendering, full-page screenshots, caching, webhooks, signed links, stealth mode, geographic selection, scrolling screenshots, video, and GPU rendering across different tiers. Check the current [ScreenshotOne options documentation](https://screenshotone.com/docs/options/) and pricing page for the exact plan boundary.

4. Calculate cost at the same workload

Use the same monthly workload for every candidate. For a simple subscription-plus-overage plan:

billable_renders = fresh_successful_renders_after_cache_and_failure_rules
paid_overage = max(0, billable_renders - included_renders)
monthly_cost = subscription_fee + paid_overage * overage_price

This formula is not sufficient if credits are consumed differently by capture complexity, a separate overage switch is required, or a hard cap changes behavior. Apply those rules explicitly. Do not count failed requests or cache hits as free unless the provider’s published policy says they are free for your case.

Worked example: 12,000 billable renders per month

Assumptions: 12,000 successful, fresh renders; no cache hits or failures; all required options are available; the listed overage rates apply; and there are no taxes or other charges. This isolates quota math—it does not establish that the plans are equivalent for every use case.

ScreenshotOne plan	Included renders	Monthly fee	Overage calculation	Estimated total
Basic	2,000	$17	10,000 × $0.009 = $90	$107
Growth	10,000	$79	2,000 × $0.006 = $12	$91
Scale	50,000	$259	No overage	$259

Under these assumptions, Growth has the lowest calculated price. But if peak demand is 100 requests per minute, Growth’s listed limit of 80 RPM does not satisfy that requirement; Scale lists 150 RPM. The lowest-cost eligible plan may therefore differ from the lowest-cost plan in the table. ScreenshotOne lists $17/month for 2,000 renders and $0.009 per extra on Basic, $79/month for 10,000 and $0.006 per extra on Growth, and $259/month for 50,000 and $0.004 per extra on Scale. Its listed request limits are 40, 80, and 150 RPM, respectively. Recheck [current vendor pricing](https://screenshotone.com/pricing/) before purchase.

Compare the published plan figures carefully

Urlbox lists Lo-Fi at $19/month for 2,000 renders, Hi-Fi at $49/month for 5,000, and Ultra at $99/month for 15,000. Its listed request rates are 30, 60, and 250 RPM, respectively. The reviewed pricing information does not provide an overage rate to use in the calculation above, so do not invent one or extrapolate a total above quota. Urlbox describes Lo-Fi for thumbnails and basic capture, Hi-Fi for more accurate rendering, and Ultra for complex capture scenarios; it also says advanced scenarios can consume more credits. Match the required fidelity and complexity to the relevant tier, and confirm the current details on [Urlbox pricing](https://urlbox.com/pricing/).

These published figures are a starting point, not a complete apples-to-apples comparison. The sources do not establish independent evidence about how accurately or quickly either service renders your target sites. Run your own representative evaluation if those properties decide the purchase.

5. Include caching, failures, and retries in the model

Estimate request counts and billable renders separately. For example, if an application makes 20,000 capture requests, some could be cache hits, while timeouts and blocked pages could lead to retries. The cost depends on the service’s exact policy, cache key, retention period, and whether a miss triggers a new render.

1. Estimate requests per month by workflow, not from a single average if traffic is bursty.
2. Estimate the share that will be cache hits using your expected URL and option reuse.
3. Estimate expected failures and retries. Keep failed requests separate until you verify whether they count.
4. Use the vendor’s documented rule to convert requests into billable renders or credits.
5. Check the cache lifetime and key behavior; changing a viewport or output option may create a distinct result.
6. Model a high-usage month as well as the average month, then check any spending cap or hard limit.

ScreenshotOne documents caching separately from pricing, including configurable cache lifetime. Its pricing FAQ says cached results generally do not count, while a cache miss can trigger a rerender that does. Read the [caching documentation](https://screenshotone.com/docs/caching/) alongside the [pricing FAQ](https://screenshotone.com/pricing/); a cache feature by itself does not tell you its billing effect.

6. Compare throughput with quota

A monthly quota answers how many renders a plan includes; a request-per-minute limit answers how quickly your system can submit work. Check both. Compare the plan’s published rate with the peak rate you need, accounting for bulk imports, scheduled jobs, retries, and other services sharing the account.

For the published tiers in this dossier, ScreenshotOne lists 40, 80, and 150 requests per minute for Basic, Growth, and Scale. Urlbox lists 30 RPM for Lo-Fi, 60 for Hi-Fi, and 250 for Ultra. These rates are plan-specific and should be rechecked. A workload that fits the monthly quota may still exceed a tier’s request rate; you may need queueing, backoff, a higher tier, or a smaller burst.

7. Use a repeatable comparison worksheet

1. Describe the workload: monthly requests, expected peak RPM, page types, and the busiest month you need to support.
2. Normalize usage: calculate likely successful fresh renders, cache hits, failures, and retries separately.
3. Lock the capture spec: dimensions, full-page or scrolling behavior, wait/interactions, output format, location, and access requirements.
4. Check tier eligibility: record which plan supports each required option and throughput target.
5. Calculate total monthly cost: subscription plus documented overage or credits, using the same billable workload.
6. Model edge cases: cache expiry, long or media-heavy pages, protected targets, peak traffic, and a high-usage month.
7. Verify vendor terms: confirm current quotas, overages, taxes, billing definitions, and caps before committing.

Keep unknowns visible in the worksheet. Mark an overage rate or complexity charge as “not published” or “confirm with vendor” rather than filling the gap with an assumption.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Compare its published price and options against the same workload above. Cookie banners, newsletter popups, and chat widgets are removed before the shot; those steps can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and responses say which outcome occurred in headers. AI agents can use its MCP server tools: take_screenshot, get_page_info, and capture_pdf.

One GET request returns an image or PDF. The request below saves a WebP screenshot; see the ScreenshotNeo API documentation for the API options.

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()
with open("shot.webp", "wb") as f:
    f.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}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

ScreenshotNeo has 1,000 screenshots per month free with no card; paid plans are $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. Sign up free and compare it with your workload.

Performance, reliability, and cost checks

Performance

For an estimate, use documented request limits and your own peak traffic shape. The sources here do not establish comparative render speed. A small representative capture set can reveal whether your own pages need longer waits, larger full-page captures, or different output formats; use the same URLs and capture settings for each vendor.

Reliability

Check how each provider defines success, handles timeouts and browser or network errors, and treats retries and cached responses. Do not treat “successful request” as proof of a visually correct result: ScreenshotOne’s pricing FAQ says a screenshot with visual issues still counts, subject to its stated defect review policy. The reviewed sources do not establish comparative uptime or render reliability, so do not infer either from plan prices or quotas.

Cost controls

• Set a monthly hard limit or disable overages if the provider offers that control and unlimited spend is not acceptable.
• Alert before the included quota is exhausted.
• Use caching when the result can be reused, but confirm how cache keys, expiry, misses, and billing interact.
• Choose output dimensions and formats that meet the use case; do not pay for a capture mode or fidelity tier your application does not need.
• Recalculate after adding options, destinations, or traffic. A new format or viewport can change cache reuse or plan eligibility.

Troubleshooting pricing comparisons

Symptom	Likely cause	What to do
Your estimated cost is far below the invoice or dashboard usage.	You counted requests instead of the vendor’s billable units, missed cache misses, or ignored complexity credits.	Re-read the billing definition and reconcile actual requests, cache outcomes, and credits against usage records.
The plan fits the monthly page count but jobs queue or throttle.	The peak request rate exceeds the plan’s RPM limit.	Compare peak bursts with the tier limit; queue and back off, reduce concurrency, or consider an eligible higher tier.
Two plans with similar quotas have very different totals.	Overage rates, included options, or credit use differ.	Recalculate using identical billable renders and list missing features separately from cost.
Repeated screenshots still consume quota.	Requests may differ by URL or options, the cache may have expired, or the request may have missed cache.	Inspect cache key and lifetime rules and confirm whether a miss triggers a billable rerender.
A listed plan price does not cover your required workflow.	A needed feature, geographic choice, fidelity level, or complex capture may require another tier or extra credits.	Verify feature eligibility and complexity rules before using the tier in the comparison.
Your total changes from month to month.	Traffic, retries, cache reuse, or overage settings vary.	Model average and high-usage months; use a cap or alert where available.
A comparison seems to show one provider is faster or more reliable.	Plan pages do not establish a controlled performance comparison.	Use a consistent representative evaluation for your target URLs; do not infer speed or uptime from price or quota.

FAQ

Should I compare the price per included screenshot?

Use it as a quick reference, not the decision metric. It ignores overages, billable definitions, cache behavior, request rates, and feature eligibility.

Are cached screenshots always free?

No universal rule applies. Check the specific provider’s cache-hit and cache-miss billing rules, plus cache expiry and key behavior.

Can I use the cheapest plan if my monthly total fits?

Only if its request rate and capture options also meet the workload. A quota match alone does not establish eligibility.

Do the listed prices prove which API renders best?

No. Prices and quotas describe commercial terms, not comparative quality. Evaluate your own target pages if render fidelity or speed matters to the decision.