Free Screenshot API — Honest Free Tier Comparison

Most screenshot APIs advertise a free tier. Few of them tell you what that free tier actually buys. Fifty screenshots a month sounds usable until you realize half your requests are cache misses that count double, or that the "free trial" expires in seven days and silently upgrades to a paid plan. I spent a week testing every free screenshot API I could find, and the differences between them aren't in the marketing copy. They're in the billing fine print.

Full disclosure: I built screenshotrun, so I have a bias here. I'll be upfront about where it sits in this comparison and where other services genuinely offer more. The goal is to save you the signup-and-test loop across eight different dashboards.

Bias disclosure and how I tested

I signed up for every API on this list with a fresh email. No credit card unless the service required one. I ran the same 20 URLs through each: SPAs, static sites, cookie-heavy European pages, and one infinite-scroll feed. I noted what counted as a "screenshot" in each billing system, because that definition varies more than you'd expect.

My own service is one of the eight. I'll call out where it falls short the same way I call out the others.

Free tier sizes in June 2026

Microlink leads the pack with roughly 1,500 free screenshots per month (50 per day, resetting daily). You don't even need an account or API key to start — just hit the endpoint. The tradeoff: Microlink is a broader headless browser platform, not a dedicated screenshot API, so the documentation is spread across multiple products and the response format is more complex than a simple image URL. But on pure volume, nothing else comes close on the free tier.

ScreenshotAPI.to and screenshotrun both offer 200 per month with no feature gating on the free plan. ScreenshotOne and ApiFlash sit at 100. All four require no credit card. That no-card detail matters more than it sounds: no surprise charge if you forget to cancel, and no billing friction when you're prototyping.

CaptureKit, Urlbox, and Screenshotlayer skip the free tier entirely. Urlbox is a polished product with strong rendering quality, but you're paying from day one. That's a defensible choice for a business targeting enterprise buyers, but it rules them out for side projects and experiments.

What 200 screenshots per month actually covers

Two hundred sounds small. In practice it covers more ground than you'd think.

A personal blog that publishes twice a week needs about 8 link preview thumbnails per month. A SaaS directory with 50 listings needs one screenshot per listing and maybe a refresh once a quarter, so that's 50 captures a month in steady state. If you're building an AI agent that takes screenshots of web pages as part of its reasoning loop, 200 calls lets you run roughly 6-7 sessions per day during development. I wrote about that workflow in more detail for screenshots as an AI agent tool.

Where 200 runs out fast: automated monitoring. If you're checking 10 competitor pages daily for visual changes, that's 300 screenshots a month just for one monitoring job. Generating link previews for a site with 500+ pages will blow through the free tier in one batch. For anything with a recurring daily schedule, you're likely buying a paid plan within the first month.

Billing gotchas that inflate your count

Not every "screenshot" costs the same across these APIs. The billing differences are where the real surprises hide.

Some services count cache hits against your quota. You request the same URL twice in an hour, the second response comes from cache, but it still burns a credit. Others (screenshotrun and ScreenshotOne among them) only count actual renders. That distinction can cut your effective usage in half on URLs you capture repeatedly.

Trial expiration is another trap. A few APIs outside this list offer "free trials" that expire after 7 or 14 days, then auto-convert to a paid plan. Every API in the table above uses a permanent free tier, not a trial. But if you're evaluating services beyond this list, check whether "free" means "free forever at this volume" or "free for two weeks."

Response format can affect pricing too. On some services, requesting a PDF instead of a PNG counts as two credits because the rendering pipeline is more expensive. On my own API, a website-to-PDF conversion costs the same as a screenshot. Same with HTML-to-image rendering, one credit regardless of output format.

Feature parity: what you get for free

The interesting thing about the free tiers in this group is that none of them gate features by plan. You don't get "full-page screenshots only on Pro" or "custom viewports on Business." The free plan and the paid plan use the same API. The only difference is volume.

That means on the free tier you can still test full-page screenshot capture on long pages, set custom viewport sizes for responsive testing, use wait-for-selector to handle SPAs that load content after the initial render, and block cookie banners that cover 40% of your capture area on European sites.

This is true across ScreenshotOne, ApiFlash, ScreenshotAPI.to, and screenshotrun. I didn't find a single free-tier API in this list that restricts which parameters you can pass. The "free" limitation is purely about how many times you can call the endpoint per month.

A quick test: the same URL across five APIs

I picked a tricky URL (a React dashboard with client-side rendering, a cookie consent overlay, and lazy-loaded charts) and ran it through the five free-tier APIs without any special parameters beyond full_page: true.

Here's what a generic request looks like. Every API in the comparison accepts something close to this shape:

curl "https://api.example.com/v1/screenshot?url=https://app.example.com/dashboard&full_page=true" \
  -H "Authorization: Bearer YOUR_API_KEY"

The results split into two groups. ScreenshotOne and screenshotrun returned the full rendered page with charts visible. Both have built-in wait logic that handles SPA rendering. ApiFlash and ScreenshotAPI.to returned the page skeleton with empty chart containers, because the JavaScript hadn't finished executing before capture. Microlink got the charts and auto-dismissed the cookie banner thanks to its built-in adblocker, but the response wraps the image in a JSON envelope that takes an extra step to extract.

When I added explicit wait and cookie-blocking parameters, all five returned usable results. The difference is how much configuration you need out of the box versus how much the API's defaults handle for you. If you're screenshotting single-page applications, test the defaults before committing. The parameter you don't have to pass is time you don't spend debugging.

The "free" self-hosted alternative

Before you sign up for any API, there's an option that costs zero dollars and zero credits: run Playwright yourself.

const { chromium } = require('playwright');

async function capture(url) {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: 'networkidle' });
  await page.screenshot({ path: 'output.png', fullPage: true });
  await browser.close();
}

That's 7 lines. It works for prototyping, personal projects, and any situation where you control the target page. I covered the long-term maintenance costs of this approach in my comparison of Puppeteer vs. a managed screenshot API. The short version: self-hosting is free until you account for the hours spent on Chrome crashes, cookie banner maintenance, and memory leaks. For a side project that captures 20 screenshots a week, though, it's genuinely the right choice. No API needed.

I'd be dishonest if I didn't say this: for developers who are comfortable with headless browsers and only need screenshots of their own sites, a free API tier is solving a problem they don't have. The API value shows up when you're capturing third-party sites you don't control, at volumes where reliability matters, or when you'd rather not keep a Chromium process alive on your server.

When free stops being enough

The transition from free to paid usually happens for one of three reasons.

Volume is the obvious one. You launch a feature, users adopt it, and suddenly 200 screenshots a month doesn't cover Tuesday. Paid tiers across these APIs typically start at $7-15/month for 1,000-5,000 screenshots. That cost is trivial compared to what it replaces, but the jump still feels sharp when you've been running on zero.

Concurrency is the second trigger. Free tiers on most services limit you to 1-2 concurrent requests. If your application needs to batch-process 50 URLs at once, the queue time on a free plan makes the feature unusable. Paid plans open up 5-10 concurrent slots.

SLA is the third. Free tiers don't come with uptime guarantees or priority support. For a personal project, that's fine. For a feature your paying customers rely on, it's a risk. Paid plans typically include 99.5-99.9% uptime commitments and faster response queues.

My honest ranking for different situations

There's no single "best free screenshot API." The right pick depends on what you're building.

For pure volume on free, Microlink wins at ~1,500/month (50/day). No contest. The docs are spread across their broader platform and the response format is more complex, but 1,500 free captures gives you real room to build and iterate without even creating an account.

If you want a mature, well-documented API to learn on: ScreenshotOne. Their documentation is the best in the group, and the 100/month free tier is enough for tutorials and prototyping. I've referenced their docs myself when building features.

Full feature access without restrictions comes from screenshotrun, ScreenshotAPI.to, and ScreenshotOne. The first two match at 200/month. The difference comes down to which defaults and rendering behavior fit your use case, so test both.

If you're going to pay anyway, look at Urlbox. No free tier, but the rendering quality and feature set justify the price for production use. Their full-page captures handled the most edge cases in my testing.

Where screenshotrun sits honestly: middle of the pack on free volume (tied at 200), competitive on features, and the service I know best because I built it. I'm not going to pretend it's the best choice for everyone. If you need maximum free captures, Microlink gives you ~1,500/month without even signing up. If documentation quality matters most, ScreenshotOne's is better than mine right now.

If you're evaluating APIs for a specific workflow, a few of the deep dives I've written might save you time: how full-page capture handles lazy-loaded content, how wait-for-selector prevents blank screenshots on SPAs, the rendering differences between PDF and image output, and whether a managed API is worth it at all compared to running Puppeteer yourself. Pick the API that fits, not the one with the best marketing page.