Screenshot API Pricing Comparison: 10 Vendors (2026)

Disclosure: I build RenderScreenshot, one of the ten vendors below. We are not the cheapest at every volume, and the table shows where.

Screenshot API prices are hard to compare because vendors bill different things: screenshots, credits, renders, requests, 30-second browser units or browser hours. This page puts ten vendors on one grid at 1,000, 10,000 and 100,000 screenshots a month, shows the cost per 1,000, and explains the billing rules that move the real number. The calculator script at the end reproduces every figure.

Prices as listed on each vendor's pricing page on October 14, 2026, monthly billing unless the row says otherwise, excluding VAT. Last verified: October 15, 2026.

For features, request formats and the test harness, see the companion best screenshot API comparison.

The price grid

Each cell is the cheapest listed self-serve plan (including any listed overage) that covers the volume, then the effective cost per 1,000 screenshots at that volume.

Notes on the rows:

• RenderScreenshot: Free is 150 credits every month with no credit card. Paid plans are Starter $10 (2,500 credits), Growth $40 (12,000) and Scale $100 (60,000). At 100,000 a month you need a custom arrangement today (email [email protected]). That is a real gap, and it is why this row is blank.
• ScreenshotOne: the 100,000 figure assumes you turn on extra usage: $259 for 50,000, plus 50,000 × $0.004. Annual billing gives 2 months free.
• Urlbox: Lo-Fi is sold for screenshots of sites you own; third-party pages come back as low-quality thumbnails. Hi-Fi is $49 for 5,000. Business is $495 base plus $3 per 1,000 renders.
• ScreenshotAPI.net: the page shows these prices next to higher struck-through prices ($20, $35, $200). Confirm at checkout.
• Microlink: EUR prices come from the page's structured price data. The page displayed $49 for the first Pro tier to me.
• Browserless: these are the annual-billing prices the page shows by default; monthly billing costs more. One unit covers up to 30 seconds of browser time, so a fast screenshot is one unit.
• Cloudflare Browser Run: the range assumes 2 to 10 seconds of browser time per screenshot. See the formula below.

What one "unit" really buys

The grid assumes one screenshot equals one billed unit, except for ScrapingBee and Cloudflare. On real pages, that assumption breaks in a few places. These rules come from each vendor's own docs or pricing FAQ:

Two practical effects:

1. Caching can halve your bill or do nothing. If the same URL and options repeat (social cards, link previews, thumbnails), a vendor that does not bill cache hits costs far less than the grid says. If every request is unique (monitoring, archiving), caching saves nothing, and the grid is your bill.
2. Heavy pages cost more on time-based and size-based billing. A 20,000-pixel full-page capture with lazy images can run for many seconds and produce a large file. On Urlbox, Browserless and Cloudflare that is more than one unit. On per-screenshot vendors it is still one.

Cloudflare Browser Run: the formula

Cloudflare does not sell screenshots. Quick Actions bill browser hours: the Workers Paid plan ($5 a month minimum) includes 10 browser hours, then $0.09 per hour. Daily usage is totalled in seconds and the monthly total is rounded to the nearest hour.

hours        = round(shots × seconds_per_shot / 3600)
monthly_cost = 5 + max(0, hours − 10) × 0.09

At 10,000 shots and 10 seconds each: 27.8 hours rounds to 28, so 18 billable hours × $0.09 = $1.62, plus the $5 minimum: $6.62. At 100,000 shots and 2 seconds each: 56 hours, 46 billable, $9.14. Browser sessions driven by Puppeteer or Playwright also bill concurrent browsers above 10 (averaged monthly) at $2.00 each, which Quick Actions do not.

That is the lowest list price on this page by a wide margin, and it is not a trick: RenderScreenshot renders on the same platform. The price excludes what you build around it: caching, signed public links, retries, storage, presets and per-customer billing. The Cloudflare Browser Rendering alternative page lists that layer piece by piece, with code for both paths.

Self-hosted Chrome: the formula

Puppeteer and Playwright are free software, so the cost is the server plus the time of the person who keeps it working:

monthly_cost = server_cost + engineer_hourly_cost × maintenance_hours_per_month

On a laptop, my own runs of example.com took 0.5 to 1 second (p50) with a fresh browser per shot and about 0.2 seconds with a reused browser, before any network or queue time. Server cost depends on how many browsers you keep warm, not on the shot count. The Puppeteer alternative page has a runnable calculator for this and the break-even point against an API plan.

Where RenderScreenshot sits

Plainly, from the grid:

• At 1,000 a month we are mid-pack ($10). Browserless's free tier, ApiFlash ($7), ScreenshotAPI.net ($9), Screenshot Machine (€9) and Cloudflare ($5) are lower. Our free plan covers 150 shots a month at $0.
• At 10,000 a month we are $40 for 12,000 credits. ScreenshotOne ($79) and Urlbox ($99) cost more; ScrapingBee, Browserless, ScreenshotAPI.net, ApiFlash, Screenshot Machine, Microlink and Cloudflare cost less.
• At 100,000 a month we have no self-serve answer today.

What the price buys on our side is in the comparison: presets, signed URLs with expiry, the X-Cache-URL public CDN link, a cache purge API, batch and webhooks, and six SDKs. If none of those matter to you and volume is high, a cheaper row above is the rational choice.

Estimate your real monthly volume

Count billed renders, not page views:

1. Start with unique images per month: distinct URL and option combinations.
2. Multiply by how often each must refresh. A social card that changes only when a post is edited renders once. A dashboard snapshot every hour renders 720 times a month.
3. Add retries. Your error rate on hard pages (cookie walls, bot protection, slow single-page apps) decides this. Measure it with the comparison script before you buy.
4. Subtract cache hits, if your vendor does not bill them and your traffic repeats.
5. Add headroom for growth and for re-renders after template changes. A template change on 5,000 posts is 5,000 renders in one day.

The calculator

This script holds the prices above and prints the cheapest listed plan per vendor for any volume. Change the numbers when a vendor changes its page; each tier is [included, monthly price, overage per unit].

// price-calc.mjs: cheapest listed self-serve plan per vendor for a monthly screenshot volume.
// Prices were copied from each vendor's public pricing page on 2026-10-14 (monthly billing unless noted).
// Run: node price-calc.mjs 1000 10000 100000
const plans = {
  RenderScreenshot: { cur: 'USD', tiers: [[150, 0], [2_500, 10], [12_000, 40], [60_000, 100]] },
  ScreenshotOne: { cur: 'USD', tiers: [[100, 0], [2_000, 17, 0.009], [10_000, 79, 0.006], [50_000, 259, 0.004]] },
  Urlbox: { cur: 'USD', tiers: [[2_000, 19], [5_000, 49], [15_000, 99]], business: { base: 495, per1000: 3 } },
  ApiFlash: { cur: 'USD', tiers: [[100, 0], [1_000, 7], [10_000, 35], [100_000, 180]] },
  'ScreenshotAPI.net': { cur: 'USD', tiers: [[1_000, 9], [10_000, 29], [100_000, 175]] },
  'Screenshot Machine': { cur: 'EUR', extraBlock: 1000, tiers: [[100, 0], [2_500, 9, 0.004], [20_000, 59, 0.003], [50_000, 99, 0.002]] },
  Microlink: { cur: 'EUR', tiers: [[100, 0], [46_000, 39], [84_000, 72], [140_000, 120], [280_000, 240], [420_000, 360]] },
  // Browserless: 1 unit = up to 30 s of browser time; prices are the annual-billing rates shown by default.
  Browserless: { cur: 'USD', tiers: [[1_000, 0], [20_000, 25, 0.002], [180_000, 140, 0.0017], [500_000, 350, 0.0015]] },
  // ScrapingBee: a screenshot needs JavaScript rendering, 5 credits per request.
  ScrapingBee: { cur: 'USD', creditsPerShot: 5, tiers: [[75_000, 19], [250_000, 49], [1_000_000, 99], [3_000_000, 249]] },
};

function cost(name, shots) {
  const p = plans[name];
  const units = shots * (p.creditsPerShot ?? 1);
  const options = [];
  for (const [included, price, extra] of p.tiers) {
    if (units <= included) options.push({ price, plan: `${included.toLocaleString('en-US')} incl.` });
    else if (extra) {
      const over = units - included;
      const billed = p.extraBlock ? Math.floor(over / p.extraBlock) * p.extraBlock : over; // Screenshot Machine bills whole thousands, rounded down
      options.push({ price: price + billed * extra, plan: `${included.toLocaleString('en-US')} incl. + overage` });
    }
  }
  if (p.business) options.push({ price: p.business.base + (units / 1000) * p.business.per1000, plan: 'Business' });
  if (!options.length) return null;
  return options.sort((a, b) => a.price - b.price)[0];
}

// Cloudflare Browser Run (Quick Actions) bills browser time, not screenshots.
// Workers Paid: $5/month minimum, 10 browser hours included, then $0.09/hour.
export function cloudflare(shots, secondsPerShot) {
  const hours = Math.round((shots * secondsPerShot) / 3600);
  return 5 + Math.max(0, hours - 10) * 0.09;
}

const volumes = process.argv.slice(2).map(Number);
if (!volumes.length) volumes.push(1_000, 10_000, 100_000);
for (const v of volumes) {
  console.log(`\n${v.toLocaleString('en-US')} screenshots / month`);
  for (const name of Object.keys(plans)) {
    const c = cost(name, v);
    console.log(`  ${name.padEnd(20)} ${c ? `${plans[name].cur} ${c.price.toFixed(2).padStart(8)}  (${c.plan}; ${(c.price / v * 1000).toFixed(2)} per 1,000)` : 'above self-serve plans: contact sales'}`);
  }
  for (const s of [2, 10]) console.log(`  ${`Cloudflare @${s}s/shot`.padEnd(20)} USD ${cloudflare(v, s).toFixed(2).padStart(8)}`);
}

Tested on October 15, 2026 with Node.js 22.18.0. Its output for 1,000, 10,000 and 100,000 is the price grid above. It does not model taxes, annual discounts other than Browserless's default view, currency conversion, or the extra units in the "costs more" column, so treat it as a floor.

How to read a vendor's pricing page in five minutes

1. Find the billing unit and write it next to the price: screenshot, request, credit, render, unit or hour.
2. Find the multipliers: JavaScript rendering, proxies, file size, render time, GPU, full-page length.
3. Find what is free: cache hits, failed renders, retries, HEAD requests.
4. Find what happens at 100%: overage price, hard stop, or a pause until next month.
5. Find which features are plan-gated (signed links, IP location, video, storage upload) and price the plan that has the ones you need, not the cheapest plan.

Then test. A plan that is 30% cheaper but fails on a tenth of your URLs costs more once you count retries and manual fixes. The scored checklist for choosing a screenshot API turns those failures into a number.

Check our side with real traffic: start on the free plan (150 credits a month, no credit card), run the comparison script from the best screenshot API comparison, and read X-Credits-Used on each response to see exactly what you were billed.

Changelog

• 2026-10-15: Latest revision. Prices checked on 2026-10-14 for ten vendors; calculator added.

Related guides

• Best screenshot API comparison: features, scored checklist and the test script.
• ScreenshotOne alternative and ApiFlash alternative: price at three volumes next to a parameter map.
• Cloudflare Browser Rendering alternative: what you build yourself on browser-time pricing.
• Usage endpoint: X-Credits-Used and X-Credits-Remaining headers, and the low-credit warning.