Screenshot API Pricing: Pay-as-You-Go vs. Monthly Plans

Direct answer: Pay-as-you-go usually fits irregular workloads when credits do not expire and you want to avoid a recurring fee. A monthly plan usually fits steady usage when its included quota, rate limits, and overage terms match your expected volume. The billing label alone does not reveal the cost: compare the provider’s billable unit, failed-request rules, expiry, quota reset, overage, and features against your actual workload.

Prices below are vendor-published snapshots checked on 2026-10-03. They can change, and the services use different capture definitions and plan structures. Check the linked pricing pages and checkout total before choosing.

How much does a screenshot API cost?

There is no single market price or universal break-even point. In the reviewed examples, one-time packs start at $7 per 1,000 API calls from ScreenshotDEV; monthly examples range from $8 per month for ScreenshotCore Starter to higher-volume tiers. These are not directly equivalent products: a call, successful image, render, PDF, or video segment may consume usage differently.

For a useful estimate, divide the expected bill by the number of units you expect to consume—not simply by the plan’s maximum quota. Include recurring fees, overage, top-ups, taxes, currency conversion, and any unused credits that expire.

Pay-as-you-go versus monthly plans

Question	Pay-as-you-go credits	Monthly plan
When it tends to fit	Variable, seasonal, testing, or occasional captures	Steady recurring captures and predictable budgets
Quiet month	May avoid a subscription; check credit expiry	Unused allowance may reset or disappear
Busy month	Buy another pack, subject to availability and terms	Overage, top-up, hard cap, or upgrade may apply
Budget predictability	Depends on pack size and consumption controls	Base fee is known; overage can still change the bill
Key billing detail	Pack size, unit definition, expiry, failed requests	Reset date, included quota, overage, quota exhaustion

Some services combine both models. ScreenshotAPI.to allows paid-plan overage or credit packs after the subscription allowance is used. ScreenshotDEV describes plan overage and separately sold credit packs. Confirm which route activates at exhaustion and whether you can set alerts or a hard spending limit.

Published pricing examples

The table summarizes vendor terms checked on 2026-10-03. Treat each row as that vendor’s own billing model, not as a like-for-like ranking by unit price.

Provider	Published example	Billing details to account for
ScreenshotNeo	Free: 1,000 shots/month; Starter $5 for 3,000; Growth $15 for 15,000; Pro $39 for 60,000; Scale $99 for 250,000; Business $249 for 1,000,000.	Only clean shots are billed; cache hits and failed, blank, timed-out, or bot-check captures cost nothing. Every feature is on every plan. Yearly billing gives two months free. See the docs.
ScreenshotAPI.to	200 free screenshots/month; $9 for 2,000/month; $29 for 10,000; $99 for 50,000; $149 for 100,000.	Monthly allowance resets each period. Paid plans allow overage or credit packs. The page says purchased packs do not expire; a credit equals one screenshot. Check its current overage rates.
ScreenshotDEV	$7 per 1,000 API calls, no monthly commitment.	Published page says credits do not expire, failed calls are not charged, and successful 2xx calls count. It also describes plan overage and separate packs.
ScreenshotAPI.to one-time packs	$9 for 1,000 credits; $29 for 5,000; $99 for 25,000; $299 for 100,000.	Its FAQ says packs do not expire. Check current pack availability and how pack credits interact with a subscription.
ScreenshotCore	Starter $8/month for 5,000 screenshots; Pro $25/month with shared 20,000 screenshot/video pool; Max $65/month with shared 60,000 pool.	Published overage rates are $0.005, $0.0035, and $0.0025 per capture respectively. Starter screenshot and video allowances are separate; Pro and Max share a pool.
ScreenshotCenter	Free 500 captures/month; Starter $15 for 2,000; Plus $35 for 5,000; Business $70 for 10,000; Enterprise $250 for 50,000.	Outputs, geography, support, team features, and SSO vary by tier. PDFs count as one screenshot; video counts as one screenshot per five seconds. Annual billing is offered with two months free.
ScreenshotAPIs.org	Free 100 renders/month; monthly plans from $19 for 2,000 renders; one-time packs include 500 for $9 and 2,000 for $29.	One credit equals one render and purchased credits do not expire. Its reviewed page says webhooks were not available on that deployment.
ScreenshotAPI.com	Advertises pay-as-you-go without subscriptions and credit bundles.	Its FAQ says a screenshot counts when a successful image is taken, and lists PNG, JPG, and GIF. The reviewed page and search snippet showed different promotional details; verify live pricing before relying on an exact figure.

ScreenshotNeo is the first option to consider if you want a clear monthly allowance and clean captures: cookie and consent banners, newsletter popups, and chat widgets are removed before capture, and unsuccessful or cached captures are not billed. The listed ScreenshotNeo prices are product terms supplied for this article; confirm the current plan page before purchase.

How to calculate which model costs less

Estimate billable volume. Count successful renders in an ordinary month and in a peak month. Separate retries, monitoring, bulk jobs, PDFs, and video if the provider bills them differently.
Verify the billing unit. It may be an API call, successful image, render, screenshot, PDF, or time-based video unit. Do not assume one request equals one charged screenshot.
Calculate the monthly-plan bill. Use the base fee plus expected overage or top-ups. Include any quota you expect to leave unused.
Calculate the credit bill. Use the pack size and price you would actually buy, then account for expiration and leftover balances. A non-expiring pack can suit irregular use, but only if the service’s rules fit.
Include constraints. Check rate limits, output formats, geography, features, and spending controls. A low per-unit price does not help if the plan cannot handle the workload.
Compare peak behavior. See what happens at quota exhaustion: requests may fail, trigger overage, use credits, or require a plan change.

For one provider, the basic comparison is:

monthly plan cost = plan fee + expected overage + expected top-ups
pay-as-you-go cost = packs needed for expected billable units

Then compare those totals for ordinary and peak months. Do not combine one provider’s pack price with another provider’s quota or failure policy to create a hypothetical unit rate.

What to check before choosing

Quota reset: Does the allowance reset monthly on a calendar date or billing anniversary? Do unused units roll over?
Credit expiry: Purchased credits are provider-specific. ScreenshotAPI.to, ScreenshotDEV, and ScreenshotAPIs.org said their reviewed packs do not expire; this is not a market-wide rule.
Success and failure billing: Ask whether timeouts, blocked pages, blank pages, bot checks, invalid URLs, or server errors consume quota. ScreenshotDEV says failed calls are not charged; ScreenshotAPI.com’s FAQ describes successful images as counted.
Cache treatment: Determine whether a cache hit consumes a unit and whether the cache lifetime is configurable.
Overage and caps: Check the marginal rate, whether overage is automatic, and whether you can set a hard cap or alert.
Rate limits and concurrency: A large monthly allowance does not guarantee high throughput. Check request-per-second and parallel job limits.
Output accounting: Verify whether PNG/JPEG/WebP, PDF pages, or video duration consume different units. ScreenshotCenter’s reviewed terms count a PDF as one screenshot and video as one per five seconds.
Plan features: Geography, team access, support, output formats, and callbacks may vary by tier. ScreenshotCenter’s tiers vary by outputs and geography; ScreenshotCore distinguishes separate and shared pools.
Final amount: Check billing currency, tax, annual commitment, and the checkout total.

Or skip the browser setup

If the decision is also about the operational cost of running captures, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns PNG, JPEG, WebP, or PDF. It offers full-page and element captures, device presets and custom viewports, dark mode, PDF controls, HTML/CSS capture, custom CSS and JavaScript, waits, request blocking, headers and cookies, geolocation, caching, signed image links, async jobs, bulk capture, and a usage API. Its parameter names also work with those used by other screenshot APIs, which can make switching easier. See ScreenshotNeo API documentation.

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);

For Node.js versions without Bun.write, use a file writer:

import { writeFile } from 'node:fs/promises';
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 writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed; response headers report the page verdict and billing status. An MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000, and every feature is available on every plan. Sign up for 1,000 free screenshots a month.

Performance, reliability, and cost in production

Keep usage estimates tied to successful work

Estimate from billable outcomes rather than raw attempts when the provider does not charge for failures. At the same time, allow for retries: retrying a slow request can increase usage on services that bill attempts. Record request IDs, status, cache state, and provider billing headers where available so your forecast can be checked against invoices.

Set headroom for peaks

Monthly quotas and rate limits solve different problems. A plan can include enough monthly captures but throttle a burst. Use a queue for bulk work, cap concurrency to the documented limit, and decide what the application should do when the quota is near exhaustion. For scheduled jobs, stagger non-urgent captures across the month.

Reduce duplicate captures

Cache stable pages, choose a TTL that matches how often the page changes, and avoid capturing the same URL concurrently when one result can be shared. For ScreenshotNeo, cache hits cost nothing; its cache TTL is configurable. For other providers, check their cache billing rules rather than assuming the same policy.

Protect access and budget

Keep API keys on the server, not in public frontend code. Set usage alerts or hard caps where offered, and review usage before enabling a high-volume crawler or retry loop. Recalculate after changing page lists, capture frequency, output type, or viewport strategy.

Troubleshooting billing surprises

Symptom	Likely cause	What to do
Bill is higher than the plan fee	Overage, top-ups, taxes, or another unit definition.	Compare invoice line items with usage logs; check whether overage activated automatically and whether PDF/video units are different.
Allowance reached before month end	Quota is based on requests, successful renders, pages, or other units you did not include in the estimate.	Inspect the provider’s quota definition, reset date, and dashboard. Reduce duplicate work or upgrade only after recalculating peak usage.
Purchased credits disappeared	Credits expired, were consumed before subscription quota, or belong to a different account/key.	Check purchase terms and consumption order. Do not assume packs are non-expiring unless the provider says so.
Requests stopped at the limit	Plan has a hard cap, no overage, or a rate/concurrency throttle.	Check quota and rate-limit responses separately; configure a fallback or spending alert before the next peak.
Usage differs from capture count	Failed attempts, retries, cache hits, PDF/video rules, or async jobs may be accounted for differently.	Match request logs to the provider’s definition of billable usage and check retry behavior.
Price page and checkout disagree	Promotional copy, changed prices, currency, billing period, or tax treatment.	Use the checkout total and current terms as the final decision point; save the plan details used for your estimate.

Frequently asked questions

Can I change my plan later?

Some providers say plans can be upgraded or downgraded, but timing, proration, and credit treatment vary. Check the provider’s current account and billing terms before changing plans.

What counts as a screenshot in my monthly quota?

There is no shared definition. It may mean a successful image, API call, render, PDF, or a time slice of video. Read the provider’s quota definition and test representative output types.

Do credits expire?

It depends on the provider and credit type. The reviewed ScreenshotAPI.to, ScreenshotDEV, and ScreenshotAPIs.org pages say their purchased credits do not expire. Monthly allowances can still reset separately.

What happens when I exceed my plan limit?

Depending on the plan, requests may be rejected, charged as overage, draw down top-up credits, or require an upgrade. Check this before putting an unattended production job on the plan.

Is a non-expiring credit pack always cheaper?

No. Compare the amount you will actually use, the pack size, the price, and any limits on rate, features, or outputs. Unused credits have value only if they remain usable for your workload.