Our stake, declared: we are Geonode and we sell proxies, which is one input to the self-hosted option. The honest framing is that the self-hosted route is not obviously cheaper, because a headless browser fetches every image, font and script on a page, so a rendered screenshot moves an order of magnitude more data than an HTTP request. On metered bandwidth that cost is real and it is the thing people forget when they compare a monthly subscription against "just running Playwright". The arithmetic is below, and it does not always favour us.
What These Services Actually Are
Underneath, every screenshot API is a headless Chrome farm with an HTTP interface. You send a URL and some parameters; a browser renders the page; you get back a PNG, a JPEG, a WebP or a PDF.
The differentiators are therefore operational rather than visual:
Reliability at scale — enough browsers running to absorb your traffic without queueing. Rendering fidelity options — full-page capture, viewport size, device emulation, waiting conditions. Blocking and cleanup — dismissing cookie banners, hiding elements, blocking ads and trackers. Geographic rendering — capturing from a specific country, which is a proxy feature wearing a screenshot API's clothes. Delivery — direct response, S3 upload, a CDN URL, webhooks. Caching — whether a repeat request for the same URL costs you anything.
That last one is worth flagging early because it changes the economics substantially. If your use case is thumbnails for a link preview, a cached result serves most requests and your effective cost per unique URL is what matters.
The Options, With Verified Pricing
From each vendor's own pricing page, checked September 2026. Verify before committing.
| Service | Free tier | Entry paid | Mid tier | Overage |
|---|---|---|---|---|
| ScreenshotOne | 100/month, all features | $17/mo — 2,000 | $79/mo — 10,000 | $0.009 → $0.004 |
| Urlbox | 7-day trial, no card | $19/mo — 2,000 | $49/mo — 5,000 | $9.50 → $3 per 1,000 |
| Browserless | 1,000 units/month | $25/mo — 20,000 units | $140/mo — 180,000 units | $0.0020 → $0.0015/unit |
ScreenshotOne is the most straightforward on pricing. $17/month for 2,000 screenshots, $79 for 10,000, $259 for 50,000, with the per-screenshot overage falling from $0.009 to $0.004 as you scale. Annual billing gives two months free.
Its free tier is unusually good — 100 screenshots a month with access to all features, no card required — which means you can evaluate the real product rather than a limited one. Its quota rule is also worth knowing: "only screenshots that are successfully rendered... and not served from cache count toward your quota". Failed renders and cache hits are free, which materially changes the effective price for repetitive workloads.
Feature tiering is sensible: the $17 plan includes PDF rendering, multiple output formats, full-page capture, caching, S3 upload, webhooks and stealth mode. IP location selection — geographic rendering — appears at the $79 Growth tier, along with scrolling screenshots and video generation.
Urlbox prices per thousand renders and is more expensive at the low end: $19/month for 2,000 works out at $9.50 per thousand, and $49/month for 5,000 at $9.80 per thousand. The rate improves sharply with volume — $99/month for 15,000 is $6.60 per thousand, and the $498/month Business plan is $3 per thousand above a $495 base.
The point to check before choosing it: full-page screenshots, JavaScript rendering and emoji/font support unlock at the Hi-Fi tier and above, not on the entry plan. If you need those — and full-page and JavaScript cover most real use cases — the $19 tier is not the plan you are buying. Trials are seven days with no card on the three lower tiers.
Browserless is a different product that happens to do screenshots. It sells browser time rather than images: "a 'Unit' is a block of browser time of up to 30 seconds per browser connection". So 20,000 units at $25/month is roughly 166 hours of browser time, usable for screenshots, scraping, PDF generation, form automation or anything else you can drive.
Its plans run from a free tier of 1,000 units with 2 concurrent browsers, through $25/month for 20,000 units and 15 concurrent, to $140/month for 180,000 units and 40 concurrent, and $350/month for 500,000 units and 100 concurrent — all billed annually. Notably, the free tier includes proxies and captcha solving, which most free tiers do not.
Choose Browserless when screenshots are one of several browser automation jobs. Choose a dedicated screenshot API when images are the whole requirement, because you are then paying for a simpler interface and per-image pricing that is easier to forecast.
The Self-Hosted Arithmetic
The comparison most articles skip, done honestly.
Running Playwright yourself costs three things: compute, bandwidth, and your time.
Compute. A small cloud instance capable of running headless Chrome reliably is perhaps $20–40/month. Concurrency is limited by memory — each browser context holds a few hundred megabytes once a page is loaded — so a 4 GB instance handles four or five concurrent renders comfortably.
Bandwidth. This is the term people omit. A page whose HTML is 200 KB may transfer 3–4 MB once every image, font, tracking script and video preload is fetched. At 10,000 screenshots a month that is 30–40 GB. Direct from a cloud instance, egress on the response side is small and ingress is usually free — so on your own infrastructure this is mostly a time cost rather than a money cost.
Through a metered proxy it is a money cost, and a significant one. At residential rates of $0.79/GB — our figures, from our pricing page, checked September 2026 — those same 10,000 screenshots cost roughly $24–32 in bandwidth alone, on top of compute. Against ScreenshotOne's $79/month for 10,000 including geographic rendering, self-hosting through residential proxies is not the saving it appears to be.
Blocking resources changes this substantially. Aborting images, fonts and media cuts traffic by most of the total — but if the screenshot is the deliverable you cannot block images, which is exactly the case where the saving is unavailable.
Your time is the largest term and the hardest to price. Browser installation in containers, memory limits, zombie processes, font packages for non-Latin scripts, retry logic, concurrency management, and the ongoing maintenance of all of it. Half a day to a first working screenshot; considerably more to something that runs unattended for a year.
The honest thresholds:
Under a few thousand a month: use a service. The free tiers may cover you entirely, and the paid entry plans cost less than the instance would.
A few thousand to tens of thousands: roughly a wash on money, and services win on time. Self-host if you already run browser infrastructure for other reasons.
Hundreds of thousands and up: self-hosting wins on cost, and by then you have the operational competence for it. This is also where Browserless's model becomes interesting as a middle path — someone else's browsers, your automation code.
Anything geography-dependent: compare carefully. A service with built-in location selection may be cheaper than assembling rendering plus residential proxies yourself, and it is certainly less work.
Getting Good Screenshots, Whichever Route You Take
The parameters that separate a usable capture from an unusable one are the same across services and self-hosted code.
Wait for an element, never for a fixed delay. A three-second sleep is too short on a bad day and wasteful on a good one, and the failure is intermittent — the worst kind. Waiting for a selector you know appears when the page is ready is both faster and reliable. Every serious service exposes this; check that the one you pick does.
Do not wait for network idle. Pages with analytics beacons, websockets or polling never go quiet, so a network-idle condition simply times out. This catches people constantly and the symptom — captures that take exactly the timeout duration and then fail — is distinctive once you have seen it.
Set the viewport deliberately. The default is usually 1280 or 1920 wide, and a responsive site renders differently at each. If you are comparing screenshots over time, the viewport must be fixed or every comparison is noise.
Disable animations. Any CSS transition mid-flight produces a different image on every capture. For visual comparison this is the single largest source of false differences.
Scroll before a full-page capture. Lazy-loaded images below the fold have not been requested when the page first settles, so a full-page screenshot of an unscrolled page has empty spaces where images should be. Scroll to the bottom, wait, scroll back, then capture.
Handle sticky headers. Elements with position: fixed behave unpredictably in a stitched full-page capture — commonly repeating down the image. Injecting CSS to make them absolute for the duration of the capture fixes it, and most services expose a way to inject CSS for exactly this reason.
Choose the format for the job. PNG is lossless and large; JPEG at quality 80 is a fraction of the size and visually indistinguishable for most content; WebP splits the difference. For thumbnails and human review, PNG is usually paying for precision nobody will see. For pixel comparison, it is not.
What to Check Before Choosing
Criteria that outlast any pricing table.
Does the free tier let you test the real thing? ScreenshotOne's 100 monthly screenshots with all features enabled is a genuine evaluation; a trial that excludes the feature you need is not.
Are the features you need on the plan you can afford? The Urlbox tiering is the cautionary example — full-page and JavaScript rendering are not on the entry plan, and both are things most people assume are table stakes.
How are failures and cache hits billed? ScreenshotOne excludes both from quota. Others do not. Over a workload with any repetition, this is a larger factor than the headline rate.
Can you specify the rendering geography? If you need to see what a page looks like from another country, check which tier that appears on. It is a proxy capability being resold, and it is priced accordingly.
What waiting conditions are available? A screenshot taken before the page finished loading is worthless. Waiting for a selector is far more reliable than waiting a fixed number of seconds, and not every service offers it.
Can you block or hide elements? Cookie banners appear in every screenshot unless something dismisses them. Built-in blocking saves you writing selectors for every site.
And what happens at your peak? Concurrency limits are the constraint that bites in production. Browserless states them explicitly per plan; check the equivalent for whichever service you consider.
When Not to Use a Screenshot API
Cases where the answer is something else entirely.
When you want the data, not the picture. A screenshot of a price is a price you then have to read out of an image. If the value is in the content, extract the content — selectors and structured data are cheaper, faster and machine-readable.
When you want a PDF of your own content. Rendering your own HTML to PDF is a local operation. A round trip to an external service to render a document you generated is unnecessary latency and unnecessary cost.
When it is a one-off. Your browser has a screenshot function. So does your operating system.
When you need many screenshots of pages you control. A build-time step generating them once is cheaper than an API call per request, and it removes an external dependency from your runtime path.
When the site forbids it. Automated access is automated access whether or not the output is an image, and terms of service apply regardless of the tool.
People Also Ask
What is a screenshot API?
A hosted service that takes a URL and returns a rendered image. Underneath it is a headless browser farm with an HTTP interface, so the differentiators are reliability, rendering options, geographic capture and delivery rather than image quality.
How much does a screenshot API cost?
ScreenshotOne is $17/month for 2,000 screenshots and $79 for 10,000. Urlbox is $19/month for 2,000 renders, rising to better per-thousand rates at higher tiers. Browserless sells browser time instead — $25/month for 20,000 units, where a unit is up to 30 seconds of browser time.
Is there a free screenshot API?
ScreenshotOne offers 100 screenshots a month with all features and no card required. Browserless has a free tier of 1,000 units that includes proxies and captcha solving. Urlbox offers a seven-day trial without a card on its lower tiers.
Should I use a screenshot API or Playwright?
A service below a few thousand screenshots a month, since the entry plans cost less than the instance would. Self-hosted above a few hundred thousand, where the economics reverse. In between it is roughly a wash on money and the service wins on maintenance time.
Why are my screenshots blank or incomplete?
Usually a timing problem: the capture happened before the page finished rendering. Wait for a specific element rather than a fixed delay. Lazy-loaded images may also need a scroll before capture, and full-page mode has its own quirks with sticky headers.
Can I take screenshots from a specific country?
Yes, with services that offer location selection — though check which tier it appears on, since it is usually a paid feature. It is a proxy capability being resold, so compare against the cost of running a browser through a residential proxy yourself.
How do I remove cookie banners from screenshots?
Most services offer element blocking or hiding by selector, and some have built-in banner dismissal. Self-hosted, you dismiss them with a click or hide them by injecting CSS before capture. Either way it needs handling deliberately — otherwise every screenshot has one.
Do screenshot APIs handle JavaScript-heavy sites?
They render with a real browser, so yes in principle — but check the tier. Urlbox, for instance, unlocks JavaScript rendering and full-page capture at Hi-Fi rather than on its entry plan. The waiting conditions available matter more than the rendering engine.
Wrapping Up
Every service here renders with the same browser engine, so the choice is about operations and pricing rather than image quality.
The pricing questions that matter are not the headline rates. Whether failures and cache hits count against quota changes the effective cost more than the per-screenshot price does. Whether the features you need — full-page capture, JavaScript rendering, geographic selection — are on the tier you can afford is worth checking before committing, because tiering in this category is not uniform. And concurrency limits, not monthly quotas, are what constrain you at peak.
On self-hosting, the honest arithmetic is less favourable than it looks. Compute is cheap and your time is not, and if the rendering has to happen through a metered proxy, the bandwidth cost of a browser fetching every asset closes most of the gap — with the added irony that the one thing you cannot block to save money is the images, since the images are the point.
Below a few thousand a month, use a service and probably a free tier. Above a few hundred thousand, run it yourself. In between, decide on how much you want to own browser infrastructure, because that is the real question and the money is close to a tie.