Screenshot API Pricing Explained: Per-Shot, Per-Second & Self-Host

TL;DR

• Per-screenshot is the default. ScreenshotOne ≈ $0.0085/shot on the entry paid plan, ApiFlash ≈ $0.016, Urlbox ≈ $0.037. Best for predictable workloads.
• Per-second of browser compute (Browserless ~$0.00008/s, billed in 30-second units) is unpredictable for screenshots but excellent for long sessions where the screenshot is one of many actions.
• Self-host license flips you from variable to fixed cost. The crossover with SaaS typically lands around 200–500K screenshots/month, depending on emulation needs.
• SnapshotFlow has the highest free tier in this group — 200 screenshots/month free, double ScreenshotOne's 100 — and offers self-host via Docker Compose without an annual contract.
• Watch for hidden costs: overage rates, S3/R2 egress, premium features (geo / stealth / AI Vision), and the fact that cached responses on ScreenshotOne don't count against your quota.

The three pricing models in 2026

Five years ago the screenshot market was almost entirely subscription-with-a-quota. In 2026 we see three coexisting models. Choosing the right one is mostly about how predictable your workload is and how long each capture takes.

1. Per-screenshot pricing

The model: you buy a monthly bucket of screenshots — 1,000 / 10,000 / 50,000 / 250,000 — and you're charged a flat fee for the bucket, plus an overage rate if you exceed it. The bucket usually resets monthly and unused screenshots don't roll over.

Why it dominates the market: it maps cleanly to the customer's mental model of "I want N captures this month", and it shields the vendor from runaway browser costs.

Where it falls apart: if your average page takes 30+ seconds to render (heavy SPA, slow third-party scripts), the vendor still charges you 1 unit — they absorb the compute cost. That's why most per-screenshot vendors enforce hard timeouts (typically 30–60 s) and surcharge premium features like stealth proxies.

2. Per-second of browser compute

Browserless is the prominent example. You pay for browser-seconds — i.e. how long a Chromium instance is alive — usually rounded into 30-second "units". A pricing tier buys you a monthly pool of units (Prototyping $25, Starter $140, Scale $350 billed annually), and overages run at roughly $0.015 per unit, or about $0.00008 per second on enterprise pay-as-you-go.

A single screenshot of a typical SaaS landing page takes around 4–10 seconds end-to-end (DNS, TLS, navigation, fonts, fonts again, network idle). At ~$0.00008/s that's $0.0003–$0.0008 per screenshot in raw compute, before the 30-second rounding kicks in. With the rounding, a 5-second screenshot still consumes a full 30-second unit — making the effective cost closer to $0.015 per screenshot for short captures.

Per-second wins when each browser session does multiple actions — login, navigate, screenshot, scroll, screenshot again, scrape some data, screenshot. Per-screenshot vendors would charge you for each capture; per-second vendors charge once for the whole session.

3. Self-host license / open-core

Browserless ships a paid Docker image (priced via sales). SnapshotFlow ships an open Docker Compose stack that you run on your own hardware — no per-screenshot metering, you only pay the server bill. The two have very different commercial shapes but the engineering trade-off is identical: you take over operations (Chromium upgrades, memory leaks, queue management) in exchange for fixed monthly cost and total data residency.

Rough server cost. A 4 vCPU / 8 GB VPS comfortably handles ~30 concurrent Chromium tabs. At an average of 6 seconds per shot that's ~5 captures/second peak, or about 13M captures/month in theory; in practice expect 2–4M with retries, queueing and memory restarts. A box like that runs $40–80 / month on Hetzner or DigitalOcean.

Crossover with SaaS. At 100K screenshots/month a hosted plan beats self-host once you account for engineer-hours. Around 200–500K/month the math flips: a $60 VPS replaces a $259+ SaaS plan and lets you scale linearly. Above 1M/month self-host is almost always cheapest — and gives you the data-residency story your security team is going to ask for anyway.

Vendor pricing matrix (May 2026)

All numbers below are pulled from each vendor's public pricing page and cross-checked with independent comparisons (TheTechDude on Medium, derrick-app, ScreenshotEngine). Where a vendor doesn't publish a price we mark it contact.

Numbers normalised from publicly listed plans. Urlbox does not publish per-screenshot rates on all tiers and uses sales-led pricing above Lo-Fi. SnapshotFlow paid tiers omitted pending public pricing page — the free tier and self-host option are confirmed.

How cost scales with volume

The chart below plots monthly cost against monthly screenshot volume for each pricing model. It uses the entry paid plan for each vendor and extrapolates linearly to the next tier where applicable. Self-host is a flat $60/month server line.

Two things jump out. First, the per-screenshot lines fan out steeply above 25K/month — vendor choice starts mattering a lot. Second, the self-host line crosses every SaaS line between 50K and 100K shots, which is why even small startups bother containerising the workload once they cross a hundred-thousand renders.

Worked cost examples

a) OG-image generator — 8,000 unique URLs / month, 60% cache hit

Effective renders ≈ 3,200 / month. ScreenshotOne at $17 / 2,000 → one tier up at $79 / 10K, but with caching not counted you stay on the $17 plan ⇒ $17. Urlbox Lo-Fi (cache-unfriendly third-party tier) starts at $49. ApiFlash $16 / 1K plan needs an upgrade ⇒ $49. Self-host is overkill at this volume.

b) Marketing dashboard — 45,000 monthly captures, mostly fresh URLs

ScreenshotOne $259 / 50K, ApiFlash $49 ramps + extra blocks ≈ $220, Browserless Scale $350. Self-host on a $60 VPS comfortably covers this, but only if your team can handle Chromium ops.

c) Web-scraping + capture — 500,000 sessions, ~12s each

Per-second math: 500K × 12s = 6M browser-seconds ≈ 200K units. At Browserless overage rates (~$0.015/unit) that's $3,000+, but inside an annual Scale or Enterprise plan it compresses to $350–$1,200. Per-screenshot vendors would charge per capture but typically cap session length at 30–60s — making them a poor fit for this workload. Self-host wins at this scale, especially if you need stealth profiles.

d) AI-agent calls — 1,200 captures / month from a Claude/Cursor agent

Volume is tiny — any free tier covers it. The real question is whether the agent can call the screenshot as a native tool. SnapshotFlow's free 200/mo plus its Remote MCP and WebMCP endpoints make this practically zero-cost; ScreenshotOne's /agents works but you write the glue. See our full vendor comparison for the agent layer details.

Hidden costs (the line items you only see in production)

• Overage rates. Hitting a per-screenshot tier 5% over its bucket can cost the same as upgrading to the next tier. Always confirm whether overages are billed or whether requests are simply rejected with HTTP 429.
• Egress. S3 / R2 storage and CDN egress are usually billed separately. At 50K screenshots/mo × ~200KB each you're moving 10 GB — small, but worth a line item.
• Premium features. Stealth proxies, geo-targeting, AI Vision and animated captures are routinely surcharged. ScreenshotOne uses an "Extra" line item; Urlbox bumps tiers. Read the charging-extra docs before you commit.
• Per-second idle time. Per-second models keep meters running during await page.waitForLoadState('networkidle'). Pages with chatty analytics tags can quietly double your bill.
• SDK retries. Most official SDKs retry failed captures by default. A flaky upstream page can multiply your real call count by 2–3x.

Which model should you pick? A 4-step decision tree

1. Is your monthly volume < 50K and your URLs repeat? → Per-screenshot with caching is unbeatable on cost and operational simplicity.
2. Is each capture part of a longer browser session (scrape + screenshot + scrape)? → Per-second / per-unit model. You're paying for the session anyway.
3. Do you need data-residency or are you above 200K shots/month? → Self-host. Either Browserless paid Docker, or SnapshotFlow open Docker Compose.
4. Is the caller an AI agent (Claude, Cursor, Goose)? → Pick a vendor with MCP / WebMCP support — currently SnapshotFlow has both natively. Volume is usually small, free tiers cover it.

What SnapshotFlow offers concretely

Full disclosure: this article is published on the SnapshotFlow blog, so here's what we put on the table — strictly the features that ship today, with the same level of detail we used for every other vendor above. Pull from this list whatever maps to your decision-tree answers; ignore the rest.

Pricing shape

• Per-screenshot billing — no per-second metering, no surprise overages from slow pages.
• Free tier: 200 screenshots / month, no credit card. That's double ScreenshotOne's 100 and roughly the threshold most prototypes never cross.
• Self-host via open Docker Compose — flat monthly server cost, no annual license, no sales call. API_KEYS=mykey docker compose up and you have your own instance.

Endpoints (HTTP API)

Feature checklist (what's already in production)

• Full-page & viewport capture — control width, height, device scale factor, mobile emulation.
• Batch capture — up to 10 URLs per request, run in parallel.
• Visual diff endpoint — pixel-level comparison with highlighted output image; perfect for visual-regression CI without an external library.
• Async + webhooks — async=true returns a job ID, poll /jobs/:id or get a callback.
• PDF export — A4 / Letter / Tabloid, orientation, background graphics.
• Ad & cookie-banner blocking — Ghostery-based; clean shots without GDPR consent overlays.
• Content extraction — page body returned as Markdown / HTML / plain text alongside the image. Designed for LLM pipelines that want both vision and text in one call.
• Dark mode & emulation — force prefers-color-scheme: dark, set timezone, geolocation, mobile viewport, custom User-Agent, reduced-motion.
• SSRF protection + per-key rate limiting — private IP ranges and loopback blocked by default; auth via X-Api-Key header or query param.

AI-agent layer (this is where we're first-mover)

• Remote MCP server — Claude / Cursor / Goose can call screenshot, batch and visual_diff as native tools without scraping.
• WebMCP tools registered via navigator.modelContext — your own web app can expose screenshot actions to a visiting agent. No vendor in this comparison ships WebMCP today.
• LLM-friendly artefacts — llms.txt, a .well-known/api-catalog, and an MCP server-card.json are served from the root so agents can auto-discover the API.

Minimum viable example

curl "https://api.snapshotflow.com/screenshot?url=https://stripe.com&full_page=true&format=png&width=1440" \
  -H "X-Api-Key: $SNAPSHOTFLOW_KEY" --output stripe.png

# Visual diff in one request — no pixelmatch glue
curl "https://api.snapshotflow.com/diff?before=https://v1.app&after=https://v2.app&response_type=json" \
  -H "X-Api-Key: $SNAPSHOTFLOW_KEY"

# Self-host the same API locally
API_KEYS=mykey docker compose up

Caveats on the roadmap (we keep this honest): scrolling / animated MP4 captures, scheduled / cron captures, and a managed AI Vision endpoint are not in production yet — see the feature matrix for the side-by-side state.

5-minute primer on SaaS pricing models

If "per-shot vs per-second vs license" still feels abstract, this short explainer covers the broader SaaS pricing taxonomy — flat / tiered / per-user / usage-based / hybrid — which is exactly the menu Screenshot APIs pick from.

External video. We're linking, not endorsing.

Related guides

• Best Screenshot APIs in 2026: Feature Matrix, Pricing & Honest Comparison
• Full Page Screenshot API: How to Capture Long Web Pages Without Cropping or Bugs
• Webpage Screenshot API for SaaS: Monitoring, Reports, and Page Previews
• Geo-targeted Screenshot API: Capture Local Screenshots From Different Countries

FAQ

What pricing models do Screenshot APIs use?

Three: per-screenshot (most common — ScreenshotOne, Urlbox, ApiFlash, ScreenshotAPI.net, SnapshotFlow), per-second of browser compute (Browserless), and self-host license / open-core (Browserless, SnapshotFlow).

Which Screenshot API has the lowest cost per screenshot?

On an entry paid plan: ScreenshotOne at ~$0.0085 (cached responses are free), ApiFlash at ~$0.016, Urlbox at ~$0.037. Browserless varies because it bills compute. Self-host is the lowest of all once you cross ~100K shots/month.

When does self-hosting become cheaper than SaaS?

Roughly between 200K and 500K screenshots per month. Below 100K, hosted is almost always cheaper than the cost of engineering time. Above 1M, self-host is the standard answer.

Does SnapshotFlow charge per second?

No. SnapshotFlow uses per-screenshot pricing with a 200/month free tier and an open-Docker self-host option for teams that prefer a flat monthly cost.

What hidden costs should I budget for?

Overage rates, S3/R2 egress, premium-feature surcharges (geo, stealth, AI Vision), per-second idle time on chatty pages, and SDK retries that silently inflate the call count.

Try SnapshotFlow free

200 screenshots per month on the free tier — double ScreenshotOne's quota. Self-host via Docker Compose when you outgrow it. MCP-ready out of the box.