How to Compare Website Screenshot API Prices by Captured Image

To compare website screenshot API prices fairly, estimate the monthly cost of the successful, uncached images you actually need, then divide that cost by the number of images. Include the plan fee, likely overage, taxes or fees, and the provider’s rules for failures and cache hits. Before comparing price, make sure each plan can produce the kind of capture you need.

Effective cost per needed image = (monthly plan fee + expected overage + applicable taxes and fees) ÷ expected successful, billable, uncached outputs.

This is a comparison method, not a universal billing definition. A provider may count a screenshot, full-page image, PDF, or another output differently. Confirm what counts as billable with each provider before using its price in your model.

1. Define the image you need

First describe the capture job precisely. “One image” can mean different work to different APIs, and a low-priced plan is not comparable if it cannot produce the required result.

Scope: viewport screenshot, full page, or a selected element.
Target: desktop or mobile viewport, device emulation, and any required pixel density.
Output: PNG, JPEG, WebP, or PDF. Check whether PDFs or multi-page captures use a different billing unit.
Page behavior: whether the page needs JavaScript, lazy-loaded images, a wait condition, authentication, cookies, or custom headers.
Site coverage: whether the provider supports the third-party sites and bot protections relevant to your workload.
Cleanup: whether you need consent banners, popups, ads, or chat widgets removed before capture.
Operations: required throughput, burst size, storage, support, and any reliability commitments.

Compare plans only after matching these requirements. Capture fidelity, site eligibility, and plan features differ. For example, Urlbox lists Lo-Fi, Hi-Fi, and Ultra tiers and describes differences in site coverage; ScreenshotOne describes features across its tiers. Check the current plan details rather than assuming similarly named quotas mean equivalent outputs.

2. Find each provider’s actual billable event

Record what the provider charges for, not just the plan’s headline quota. Check the pricing page and billing documentation for these cases:

Successful output: Does a request count only when an image is returned? What about an image returned with a visual defect?
Failed request: Are timeouts, blocked pages, bot checks, invalid URLs, or failed loads charged?
Cache hit: Does a cached response count as a new render? Does this vary by endpoint, cache expiry, or forced refresh?
Retries: If your client retries a request, can each attempt consume a credit?
Option changes: Does changing viewport, format, or another capture option create a separately billed render?
Output type: Is a PDF, full-page capture, or bulk request counted the same way as one ordinary screenshot?

Billing rules are provider- and endpoint-specific. ScreenshotOne says only successful renders count in the described cases, while noting that an image with a visual issue can still count; its cache behavior can differ between hits and misses. Urlbox defines a successful render as an image returned, says failed requests are not charged, and describes different counting for cached Render Links and REST API requests. Do not generalize one provider’s rules to another.

3. Model monthly cost at your expected volume

Let V be the number of successful, billable, uncached outputs you expect in a month. Let Q be the included quota, P the plan fee, and R the marginal price per output above the quota. If the provider publishes a flat overage rate, a first estimate is:

expected overage = max(0, V - Q) × R
estimated monthly total = P + expected overage + applicable taxes and fees
effective cost per needed image = estimated monthly total ÷ V

Use the provider’s actual tier and overage rules; this formula does not fit every pricing model. Some plans require moving to a higher tier, impose a different charge, or do not publish enough detail to calculate overage. Model several volumes—typical month, busy month, and growth case—so the plan is not chosen from a single optimistic estimate.

Example: calculate included-quota cost and overage separately

ScreenshotOne’s published Basic plan lists $17/month for 2,000 screenshots and $0.009 per extra screenshot. At exactly 2,000 outputs, the included-quota arithmetic is $17 ÷ 2,000 = $0.0085 per output. At 2,500 outputs, applying the listed marginal rate gives $17 + (500 × $0.009) = $21.50 before taxes, or $21.50 ÷ 2,500 = $0.0086 per output. These are calculations from the published fee and quota, not a provider-quoted unit price. Recheck the current plan terms and your eligibility for the plan before relying on the result.

4. Compare published prices with their limits

The following figures were found on the providers’ official pages during the research pass on October 3, 2026. Prices and plan terms can change. Included-quota unit figures are simple monthly fee divided by listed quota; they are not apples-to-apples rankings.

Provider and plan	Published fee and quota	Included-quota arithmetic	Published billing details relevant to comparison
ScreenshotNeo Free	$0 for 1,000 shots/month	$0 at the included quota	ScreenshotNeo says only clean shots are billed; bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. See its API documentation for request options and response headers.
ScreenshotNeo Starter	$5 for 3,000 shots/month	About $0.00167 per included shot	All features are on every plan. Yearly billing gives two months free.
ScreenshotOne Basic	$17/month for 2,000 screenshots	$0.0085	$0.009 per extra screenshot; prices exclude VAT. Its billing information distinguishes successful renders and cache cases.
ScreenshotOne Growth	$79/month for 10,000 screenshots	$0.0079	$0.006 per extra screenshot; prices exclude VAT.
ScreenshotOne Scale	$259/month for 50,000 screenshots	$0.00518	$0.004 per extra screenshot; prices exclude VAT.
Urlbox Lo-Fi	$19/month for up to 2,000 renders	$0.0095	Failed requests are not charged. Render Links are cached for 30 days by default; cached Render Link requests do not count against quota, while first renders or REST API requests do. Prices exclude VAT.
Urlbox Hi-Fi	$49/month for up to 5,000 renders	$0.0098	Same published cache and failure notes apply; check current tier coverage and terms.
Urlbox Ultra	$99/month for up to 15,000 renders	About $0.0066	Same published cache and failure notes apply; check current tier coverage and terms.
ScreenshotAPI.net Essential	$9/month for 1,000 screenshots	$0.009	The reviewed official listing showed headline plan values but not enough detail to determine overage and cache billing. Do not infer them.
ScreenshotAPI.net Startup	$29/month for 10,000 screenshots	$0.0029	Headline quota arithmetic only; cache and overage terms were not established in the reviewed listing.
Screenshot Machine Basic	€9/month for 2,500 fresh screenshots	€0.0036	€0.004 per additional screenshot; the page says cached impressions are unlimited.
Screenshot Machine Pro	€59/month for 20,000 fresh screenshots	€0.00295	€0.003 per additional screenshot; cached impressions are unlimited.
Screenshot Machine Enterprise	€99/month for 50,000 fresh screenshots	€0.00198	€0.002 per additional screenshot; cached impressions are unlimited.

ScreenshotNeo is listed first because clean shots are billed, its published paid plans start at $5 for 3,000 shots, and it identifies non-clean outcomes and cache hits as free. This does not make every service equivalent for every capture job: confirm your required features, output, and site coverage. Do not compare euro figures to dollar figures without stating a dated exchange rate and method.

Sources: ScreenshotOne pricing and billing and service information; Urlbox pricing; ScreenshotAPI.net; Screenshot Machine pricing. Prices above are provider-published examples, not independent market statistics.

5. Build a cost estimate from your workload

Count required outputs. Start with the number of distinct pages and capture variants needed each month. If you capture the same page at three viewport sizes, count the three required outputs unless the provider’s billing model says otherwise.
Estimate cache reuse. Separate first renders from cache hits. Account for cache expiration, forced refreshes, and changing capture parameters.
Estimate failed attempts. Use your own expected failure rate if you have one. Do not apply a general assumed rate across providers. Verify whether each failure class is billable.
Apply the plan quota. Calculate included usage and any overage or tier jump at normal and peak volume.
Add taxes and currency. Preserve the listed currency. Add tax or fees where applicable; some cited dollar prices explicitly exclude VAT.
Check operational fit. Confirm throughput, burst handling, storage, support, and reliability commitments if the workload is production-critical.
Divide by useful outputs. Report cost per needed successful output, and state whether cached outputs are included in the denominator.

6. Automate the arithmetic with a small script

This Python example compares flat monthly plans with a published per-output overage rate. It keeps currencies separate and does not add taxes. Only enter prices that use the same currency and billing period.

plans = [
    {"name": "ScreenshotOne Basic", "currency": "USD", "fee": 17.0, "quota": 2000, "overage": 0.009},
    {"name": "ScreenshotOne Growth", "currency": "USD", "fee": 79.0, "quota": 10000, "overage": 0.006},
    {"name": "Screenshot Machine Basic", "currency": "EUR", "fee": 9.0, "quota": 2500, "overage": 0.004},
]
expected_outputs = 2500

for plan in plans:
    excess = max(0, expected_outputs - plan["quota"])
    total = plan["fee"] + excess * plan["overage"]
    unit = total / expected_outputs if expected_outputs else None
    print(
        f"{plan['name']}: {plan['currency']} {total:.2f}/month, "
        f"{plan['currency']} {unit:.5f}/output"
    )

The script is deliberately a basic arithmetic model. It does not model tier jumps, taxes, cache behavior, different output types, or providers whose overage terms are unknown. Add those rules only after verifying them in the provider’s current documentation.

7. Cost, speed, and reliability trade-offs

Quota can hide marginal cost. The fee divided by quota is useful for initial screening, but overage can change the effective unit cost at your actual volume.
Cache policy changes spend and freshness. A long-lived cache can reduce repeat render charges where cache hits are excluded, but cached pages may not reflect current content. Compare cache lifetime and refresh behavior with how fresh each image must be.
Failures affect both cost and availability. A provider may exclude failed requests from billing while those failures still force retries and delay your workflow. Track success rate and latency in your own application rather than treating “not billed” as “no operational cost.”
Throughput has a value. A plan that is inexpensive at average volume may not support your burst pattern or production needs. Check request limits and support terms before moving a real workload.
Tax and currency matter. Keep currencies explicit, include applicable taxes and fees, and avoid ranking a euro plan against a dollar plan without a dated conversion.
Match fidelity before price. A cheaper output that omits page content, fails on a target site, or lacks a required format is not a lower-cost substitute for the image you need.

8. Troubleshooting a misleading comparison

The calculated price is lower than the invoice

Cause: The calculation used included-quota arithmetic but omitted overage, taxes, a tier change, or a different billable output definition.
Fix: Reconcile the invoice against actual billable events, current overage rules, tax treatment, and the period’s successful outputs.

Usage is higher than the number of pages captured

Cause: Each viewport or option variant may be a separate output, retries may create billable attempts, or cache misses and refreshes may render again.
Fix: Count required variants, inspect retry behavior, and verify how the provider treats cache misses and forced refreshes.

Cached requests still appear in usage

Cause: Cache rules may apply only to a particular endpoint or link type, or the request may be a cache miss because it expired or its parameters changed.
Fix: Check the provider’s endpoint-specific cache documentation and test the exact production request shape before forecasting savings.

A failure is charged or a visual defect consumes a credit

Cause: “Failure” may mean a request error to one provider and may not include a returned image with missing content or a visual issue.
Fix: Read the provider’s definition of a successful render and inspect response status and billing headers where available. Keep visual quality requirements separate from HTTP success.

The lowest unit price does not meet the capture requirement

Cause: The included plan may have different fidelity, coverage, or feature limits.
Fix: Filter out plans that cannot perform the needed job, then compare effective cost among the remaining plans.

A cross-provider ranking changes after currency conversion

Cause: Prices are listed in different currencies or exclude different taxes.
Fix: Preserve source currency in the comparison, or state the conversion date, rate source, method, and tax assumptions explicitly.

9. Or skip the browser setup

For a hosted screenshot API, ScreenshotNeo takes one GET request with a URL and returns an image or PDF. It can capture full pages, selected elements, mobile and desktop viewports, PDFs, or HTML/CSS content, with options such as waits, custom CSS and JavaScript, cookies, headers, and cache TTLs. See the ScreenshotNeo API documentation for parameters and response details.

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 and consent banners, newsletter popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are never billed. Responses include X-Page-Verdict and X-Billed headers.
An MCP server gives AI agents tools for screenshots, page information, and PDF capture.
The Free plan includes 1,000 shots each month with no card; paid plans start at $5 for 3,000. All features are on every plan.

Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card.

10. Short FAQ

Should I divide the plan price by the full quota?

Use that as a first-pass figure only. Your actual cost depends on your volume, overage, taxes, cache behavior, and what the provider counts as an output.

Can I call one API the cheapest?

Only after fixing the workload, currency, tax assumptions, output requirements, and billing rules. Without those assumptions, a universal cheapest ranking is not meaningful.

Should I count cache hits as images?

For cost per useful delivered image, count them in the output total if they satisfy the need, and separately state whether they are billable. That makes both the customer-facing unit cost and provider spend understandable.

How often should I recheck prices?

Recheck official pricing and billing documentation before signing up, changing tiers, or refreshing a cost comparison. The examples in this article were collected October 3, 2026 and may change.