A cold-start screenshot of a media-heavy homepage takes anywhere from 2.6 seconds to over 14 seconds depending on which API handles it. That range is wide enough to break a production pipeline or make it feel instant. I tested eight screenshot APIs — including ScreenshotRun — by sending the same batch of URLs to each provider and recording cold-start latency, cached response time, success rate under concurrent load, and full-page capture speed.
The goal was straightforward: find out which APIs are genuinely fast and which ones fall apart on complex pages. I also wanted to see where the published marketing claims diverge from what actually happens on the wire. Every test ran from a US-East server between November 10–17, 2026. No cherry-picking, no outlier removal beyond the standard practice of dropping the single slowest run per batch.
What actually determines screenshot API speed
Before looking at the numbers, it helps to understand why two APIs can differ by 8x on the same URL. Four factors control the total response time:
The first is browser pool management. Every screenshot starts with a Chromium instance. Some providers spin up a fresh browser per request (cold start). Others keep a pool of warm browsers waiting. ScreenshotRun maintains a pre-warmed pool — the browser is already running when your request arrives, so the only delay is page loading and rendering.
Then there is the wait strategy — when does the browser consider the page "done"? Some APIs wait for networkidle0 (zero network activity for 500ms), which works on static sites but adds unnecessary delay on pages with analytics beacons and tracking pixels that never fully stop. Others use domcontentloaded plus a fixed delay, which is faster but misses late-loading content. The sweet spot is waiting for the DOM, then for critical resources, then capturing.
Resource blocking makes a bigger difference than most developers expect. Pages load dozens of third-party scripts — analytics tags, live chat pop-ups, ad networks, consent overlays. Each script adds 100–800ms of load time. APIs with built-in ad and tracker blocking finish faster because the browser simply has less work to do.
Finally, caching and CDN delivery. Once a screenshot is rendered, serving it from cache on a subsequent request should take under 200ms. The gap between providers comes down to cache hit rates, TTL policies, edge location proximity, whether the provider serves from a single origin or distributes globally.
Benchmark methodology
Transparency matters. Every vendor-published benchmark has the publisher winning. I wanted numbers that anyone could reproduce, so the setup is documented in full.
Test parameters
- Server: DigitalOcean Droplet, 2 vCPU / 4 GB RAM, NYC3 region
- Script: Node.js 20, sequential requests (no parallel batching to avoid rate-limiting distortion)
- Runs: 20 captures per URL per provider, spread across four days within that window, at different hours (morning, midday, evening, late night EST)
- Caching: Disabled where the API supports cache bypass. For providers without a cache-bypass flag, a unique query string was appended to force fresh renders
- Timeout: 30 seconds per request. Anything beyond 30s counted as a failure
- Metric: Wall-clock time from request sent to response body fully received
- Outlier handling: Single slowest run per URL/provider dropped. All other data points kept
- Viewport: 1280×960, desktop user agent
- Format: PNG output, default quality settings per provider
Test URLs (8 pages covering different complexity levels)
| URL type | Example | Why included |
|---|---|---|
| Static HTML | example.com | Baseline — almost no JavaScript, minimal assets |
| News site | reuters.com | Heavy third-party scripts, consent banner, lazy images |
| SPA (React) | Linear.app marketing site | Client-side rendering, hydration delay, animated elements, scroll-triggered content |
| E-commerce | amazon.com product page | Anti-bot protection, dynamic pricing, personalized banners, A/B test variants |
| Long page | Wikipedia "United States" article | Extreme page length (full-page test), many images |
| Dashboard (auth) | Vercel dashboard (public demo) | JavaScript-heavy, real-time data, WebSocket connections |
| Cloudflare-protected | Medium.com article | Bot detection, challenge pages, stealth mode required |
| Media-heavy | Unsplash homepage | Large images, masonry layout, Intersection Observer lazy loading |
Cold-start latency results
Cold-start measures the time for a completely fresh capture — no browser pre-warming, no cache hit. This is the worst-case scenario you hit when your first request reaches the API after an idle period, or when a provider needs to spin up new rendering capacity.
| Provider | Avg (ms) | P50 (ms) | P95 (ms) | Failures |
|---|---|---|---|---|
| ScreenshotRun | 2,840 | 2,610 | 4,920 | 1.2% |
| Microlink | 4,090 | 3,780 | 7,450 | 2.5% |
| Urlbox | 3,420 | 3,150 | 6,100 | 1.8% |
| ScreenshotOne | 3,890 | 3,540 | 7,710 | 3.1% |
| ApiFlash | 5,260 | 4,180 | 11,300 | 4.4% |
| CaptureKit | 4,750 | 4,290 | 8,600 | 3.8% |
| Screenshotlayer | 6,980 | 6,100 | 14,200 | 12.5% |
| Browshot | 5,640 | 5,010 | 9,800 | 5.2% |
ScreenshotRun posted the lowest average cold-start at 2,840ms. The gap between P50 and P95 is worth paying attention to — a tight ratio signals consistent performance. ScreenshotRun's P95 is 1.88x its P50. Compare that to ApiFlash, where P95 is 2.7x the median. That means ApiFlash is fast sometimes and very slow other times, which makes it unreliable for latency-sensitive workflows.
Urlbox came in second overall with solid consistency. Their rendering pipeline has been around since 2016 and it shows in the tight P50/P95 spread.
Screenshotlayer had the roughest showing. A 12.5% failure rate across the test set is too high for production use. Most failures came from the anti-bot and SPA URLs — their older rendering engine struggles with modern JavaScript-heavy pages.
Cached response speed
Once a screenshot is rendered and stored, the next request for the same URL should be fast. This is the metric that matters for use cases like generating link previews and thumbnail grids, where the same pages get captured repeatedly.
| Provider | Avg cached (ms) | P50 cached (ms) | Cache TTL |
|---|---|---|---|
| ScreenshotRun | 95 | 82 | Configurable (cache_ttl param) |
| Urlbox | 175 | 160 | Configurable |
| ScreenshotOne | 205 | 190 | Configurable |
| Microlink | 140 | 125 | 24h default, configurable |
| ApiFlash | 280 | 240 | 1 hour max |
| CaptureKit | 310 | 270 | Not configurable |
| Screenshotlayer | 420 | 380 | Not documented |
| Browshot | 350 | 310 | Configurable |
The cached numbers tell a different story than cold starts. ScreenshotRun serves cached screenshots in under 100ms on average because cached images are delivered from edge locations closest to the caller — not pulled from a single origin server on the other side of the country. That 82ms median puts it in the same latency range as a static CDN asset.
ApiFlash's 1-hour maximum cache TTL is a constraint worth knowing. If your use case relies on longer cache windows (say, daily snapshots of competitor pages), you will re-render more often than necessary, which both costs more and adds latency to your pipeline.
Full-page capture performance
Full-page screenshots are fundamentally slower than viewport captures. The browser has to scroll the entire page, trigger lazy-loaded images at each scroll position, wait for Intersection Observer callbacks to fire. Then it stitches everything into a single tall image. Some pages generate output files over 10MB.
I tested full-page capture specifically on the Wikipedia "United States" article (~47,000 pixels tall) and the Unsplash homepage (~12,000 pixels).
| Provider | Wikipedia full-page (ms) | Unsplash full-page (ms) | Notes |
|---|---|---|---|
| ScreenshotRun | 6,400 | 4,800 | Auto-scroll with lazy image detection |
| Urlbox | 7,200 | 5,500 | Reliable, consistent |
| ScreenshotOne | 8,900 | 6,100 | Occasional missing images at bottom |
| Microlink | 9,500 | 7,800 | Timeout on 2 of 20 Wikipedia runs |
| ApiFlash | Timeout (30s+) | 8,200 | Wikipedia page too long for their pipeline |
| CaptureKit | 11,400 | 7,900 | Completed but with blank sections |
| Browshot | 10,200 | 7,100 | Slow but complete renders |
| Screenshotlayer | 13,800 | 9,400 | Missing lazy-loaded images throughout |
Full-page is where ScreenshotRun's auto-scroll pipeline earns its keep. The renderer scrolls in increments, waits for each batch of lazy images to load (by watching data-src swaps and Intersection Observer triggers), then captures. The result is a complete screenshot without the white gaps that plague simpler approaches.
ApiFlash timed out on the Wikipedia article in every run. Their architecture appears to have a hard execution limit that extremely long pages exceed. If your use case involves archiving long-form content, that is a dealbreaker.
Reliability under concurrent load
Benchmarks with sequential requests paint an optimistic picture. Production traffic comes in bursts. I sent 20 simultaneous requests to each provider (the same URL, to isolate API capacity from page variance) and tracked four things: completions under 10 seconds, completions under 30 seconds, outright failures, average response time under load.
| Provider | Completed <10s | Completed <30s | Failed | Avg response (ms) |
|---|---|---|---|---|
| ScreenshotRun | 18/20 | 20/20 | 0 | 4,200 |
| Urlbox | 17/20 | 20/20 | 0 | 4,800 |
| ScreenshotOne | 14/20 | 19/20 | 1 | 6,100 |
| Microlink | 12/20 | 18/20 | 2 | 7,400 |
| ApiFlash | 10/20 | 16/20 | 4 | 8,900 |
| CaptureKit | 11/20 | 17/20 | 3 | 8,200 |
| Browshot | 8/20 | 15/20 | 5 | 9,500 |
| Screenshotlayer | 6/20 | 13/20 | 7 | 11,200 |
ScreenshotRun and Urlbox were the only two providers that completed all 20 concurrent requests without a single failure. The difference showed up in the under-10-second bucket: ScreenshotRun finished 18 of 20 within 10 seconds, Urlbox finished 17.
Browshot struggled the most with concurrency — 5 outright failures and only 8 of 20 finishing within 10 seconds. Their architecture seems to queue requests sequentially rather than processing them in parallel, which makes burst traffic problematic.
Anti-bot handling and stealth performance
Modern websites increasingly use Cloudflare Turnstile, DataDome, PerimeterX, custom fingerprinting scripts. A screenshot API that returns a Cloudflare challenge page instead of the actual content is useless, no matter how fast the response came back.
I tested each provider against five pages known to have active bot protection, using whatever stealth or anti-detection features each provider offers.
| Provider | Successful renders (out of 5) | Stealth mode available |
|---|---|---|
| ScreenshotRun | 4/5 | All plans |
| Urlbox | 4/5 | All plans |
| ScreenshotOne | 3/5 | Growth ($79+) |
| Microlink | 2/5 | Pro plans |
| ApiFlash | 1/5 | Enterprise only |
| CaptureKit | 2/5 | All plans |
| Browshot | 1/5 | Not available |
| Screenshotlayer | 0/5 | Not available |
ScreenshotRun and Urlbox tied at 4 out of 5. The one site both failed on used a custom JavaScript fingerprinting challenge that required browser-level patching beyond standard stealth techniques. ScreenshotOne managed 3 out of 5 but only on their Growth plan — the $17 Basic plan does not include stealth capabilities, which makes their effective entry price $79 for anti-bot use cases.
Screenshotlayer returned a Cloudflare challenge page for every protected URL. Their rendering engine has not been updated to handle modern bot detection.
What the numbers mean for different use cases
Raw speed numbers only matter in context. A 200ms difference in cached response time is irrelevant for a nightly archival job but critical for a real-time link preview API.
If your primary use case is link previews or thumbnail grids, cached speed dominates. ScreenshotRun's 82ms cached median means your preview endpoint can return an image within a single API round-trip. That is fast enough to feel synchronous to the user.
For visual regression testing in CI, cold-start consistency matters more than raw speed. You want tight P50/P95 ratios so your pipeline finishes in predictable time. ScreenshotRun (1.88x ratio) and Urlbox (1.94x) posted the most consistent numbers in this test.
Bulk workflows tell yet another story. If you are capturing 500 pages per batch for website archiving or compliance monitoring, the provider's queue depth and failure rate under burst traffic matter more than individual capture speed.
And if you are building AI training datasets, anti-bot success rate is the gating factor. When 12% of your captures fail because of bot protection (Screenshotlayer's rate in our test), you need 12% more API calls to assemble the same dataset. ScreenshotRun's stealth mode cuts that waste down.
How these results compare to published benchmarks
Several competitors publish their own benchmark data. It is useful to see how those claims align with independent testing.
Microlink is the only provider that publishes a benchmark page with an open-source CLI tool on GitHub. Their reported 4,112ms average cold-start is in the same ballpark as our measured 4,090ms. The small gap likely comes from our harder URL set (anti-bot, long-scroll pages). Their test covers 7 URLs from New York only — a narrower but reproducible data point.
SnapAPI's marketing page cites 1,180ms average response time across 10,000 screenshots. That number likely mixes cached responses with fresh renders, which explains why it is lower than any cold-start figure in our test. Their published methodology does not clarify how cache was handled, so a direct comparison is not meaningful.
On ApiFlash's landing page, the claim is "sub-second" screenshots. In our test, ApiFlash averaged 5,260ms on cold starts and 280ms cached. The "sub-second" figure holds for cached simple pages. It falls apart on fresh renders of complex sites.
Methodology limitations
No benchmark is perfect. These are the known limits of this test:
- All requests originated from a single geographic region (US-East). Latency would differ for EU or Asia-Pacific callers. I plan to add multi-region testing in a future update.
- Provider pricing tiers vary. All tests used mid-range plans ($29–$79/month). Enterprise tiers with dedicated infrastructure would likely show different numbers.
- Website content changes constantly. Reuters.com on November 10 may have been running different ad configs than on November 17. The 20-run spread across four days reduces but does not eliminate this variable.
- Rate limiting may have affected some providers during the concurrency test. ScreenshotRun and Urlbox did not throttle at 20 concurrent requests on their tested plans. Others may have lower concurrency limits that introduced queuing.
If you want to verify these results, the approach is simple: sign up for free tiers on two or three providers, capture the same URL 10 times on each, and compare the response times. Even 10 data points will tell you whether a provider's speed matches your expectations.
Bottom line
ScreenshotRun posted the fastest cold-start (2,840ms avg) and the fastest cached response (95ms avg). It also handled 20 concurrent requests without a single failure. Urlbox was a close second in most categories — a strong choice for teams already integrated with their API. The biggest drop-off came from Screenshotlayer and Browshot, where failure rates and concurrency limits rule them out for production workloads.
Speed is one axis. The pricing comparison covers the cost side, and the individual comparison pages for Urlbox, ScreenshotOne, ApiFlash, and Microlink go deeper on features, rendering quality, and documentation.
FAQ#
The current results are from November 2026. I plan to re-run the full test quarterly and add multi-region testing in a future update. Provider infrastructure changes over time, so older benchmark data should be treated as a snapshot, not a permanent verdict.
I focused on APIs with public pricing, documented endpoints, and enough market presence to be a realistic choice for production use. Niche providers with no free tier or no public documentation were excluded because developers cannot easily verify the results themselves.
The cold-start test specifically disables caching to measure worst-case latency. The cached response test measures best-case latency. Both metrics matter for different use cases. If your workflow hits the same URLs repeatedly, cached speed is more relevant. If you capture unique URLs, cold-start numbers apply.
Yes. Sign up for free tiers on two or three providers, write a simple Node.js or Python script that captures the same URL 10+ times on each, and compare the wall-clock response times. The methodology section above describes the full setup. Even a small sample will show whether a provider matches its published speed claims.