The Screenshot API
Performance Benchmark

Q: Is Microlink open source?

Yes. Microlink is powered by browserless, an open-source headless Chrome/Chromium driver built on top of Puppeteer. The entire stack is available on GitHub under the microlinkhq organization. You can self-host it for full control, or use the managed API to skip infrastructure work and get automatic scaling, proxy rotation, and global edge deployment.

Cold-start latency across 6 providers and 7 URLs. Zero caching.
Which is the fastest screenshot API?

Measuring cold-start speed across 6 screenshot APIs

ApiFlash

Microlink

ScreenshotAPI

ScreenshotMachine

ScreenshotOne

Urlbox

Screenshot API speed comparison

Average cold-start latency per provider

Provider	Avg Cold Duration	versus. Microlink
Microlink	4,111.84 ms	—
ScreenshotAPI	5,915.71 ms	+44% slower
ScreenshotMachine	6,099.77 ms	+48% slower
Urlbox	7,334.22 ms	+78% slower
ScreenshotOne	7,711.14 ms	+88% slower
ApiFlash	9,463.2 ms	+130% slower

Cold-start latency breakdown by URL

URL	Microlink	ScreenshotAPI	ScreenshotMachine	Urlbox	ScreenshotOne	ApiFlash
vercel.com	6,361	6,143	9,791	14,953	12,695	14,233
example.com	968	4,988	1,321	2,331	3,135	1,820
stripe.com	3,217	5,614	3,167	3,679	5,678	5,900
screenshotone.com	5,474	6,805	12,404	14,976	12,139	9,802
news.ycombinator.com	3,435	5,385	4,329	4,748	6,857	1,968
github.com	3,060	6,174	3,898	4,267	6,059	5,366
framer.com	6,267	6,301	7,789	6,386	7,415	27,154
Total	28.8 s	41.4 s	42.7 s	51.3 s	54.0 s	66.2 s

vercel.com

Microlink6,361 ms

ScreenshotAPI6,143 ms

ScreenshotMachine9,791 ms

Urlbox14,953 ms

ScreenshotOne12,695 ms

ApiFlash14,233 ms

example.com

Microlink968 ms

ScreenshotAPI4,988 ms

ScreenshotMachine1,321 ms

Urlbox2,331 ms

ScreenshotOne3,135 ms

ApiFlash1,820 ms

stripe.com

Microlink3,217 ms

ScreenshotAPI5,614 ms

ScreenshotMachine3,167 ms

Urlbox3,679 ms

ScreenshotOne5,678 ms

ApiFlash5,900 ms

screenshotone.com

Microlink5,474 ms

ScreenshotAPI6,805 ms

ScreenshotMachine12,404 ms

Urlbox14,976 ms

ScreenshotOne12,139 ms

ApiFlash9,802 ms

news.ycombinator.com

Microlink3,435 ms

ScreenshotAPI5,385 ms

ScreenshotMachine4,329 ms

Urlbox4,748 ms

ScreenshotOne6,857 ms

ApiFlash1,968 ms

github.com

Microlink3,060 ms

ScreenshotAPI6,174 ms

ScreenshotMachine3,898 ms

Urlbox4,267 ms

ScreenshotOne6,059 ms

ApiFlash5,366 ms

framer.com

Microlink6,267 ms

ScreenshotAPI6,301 ms

ScreenshotMachine7,789 ms

Urlbox6,386 ms

ScreenshotOne7,415 ms

ApiFlash27,154 ms

Total

Microlink28.8 s

ScreenshotAPI41.4 s

ScreenshotMachine42.7 s

Urlbox51.3 s

ScreenshotOne54.0 s

ApiFlash66.2 s

Fastest

2nd fastest

Slowest

·Times in milliseconds (ms), totals in seconds (s)

Provider-by-provider performance breakdown

Below is a provider-by-provider breakdown of speed, latency, response time, and overall performance. Each comparison uses the same 7-URL test suite so the numbers are directly comparable.

vs Urlbox

When evaluating a Urlbox alternative, cold-start latency is a primary concern. In our tests, Urlbox averaged 7,334.22 ms per request. Microlink processed the same suite at an average of 4,111.84 ms, making it roughly 44% faster overall. The performance gap is most noticeable on heavy DOMs; for instance, on vercel.com, Urlbox took nearly 15 seconds to resolve and capture, whereas Microlink completed the task in 6.3 seconds.

vs ApiFlash

ApiFlash demonstrated significant variance depending on the target URL. While it handled lightweight pages like example.com reasonably well (1,820 ms), it struggled with complex SPAs, resulting in the highest average cold duration in our test at 9,463.2 ms. On framer.com, ApiFlash took over 27 seconds to return a payload. For developers seeking an ApiFlash alternative for latency-sensitive workloads, Microlink offers a much tighter performance baseline, handling the same URL in 6.2 seconds.

vs ScreenshotAPI & ScreenshotMachine

ScreenshotAPI (5,915.71 ms avg) and ScreenshotMachine (6,099.77 ms avg) performed consistently, placing them in the middle of the pack. Both services handle standard web pages well, but still lag behind Microlink's optimized browser infrastructure. Microlink outperformed both services by roughly 30–32% on average, demonstrating consistently lower latency across all 7 test URLs.

vs ScreenshotOne

ScreenshotOne averaged 7,711.14 ms across the test suite. Interestingly, when capturing its own domain (screenshotone.com), it required over 12 seconds to resolve the request. Microlink handled the same domain in 5.4 seconds. For teams already utilizing ScreenshotOne, switching to Microlink provides the same headless browser capabilities while cutting the average response time nearly in half.

Benchmark methodology & testing architecture

To ensure a strictly objective baseline, we built a reproducible testing suite targeting 6 screenshot API providers (Microlink, ApiFlash, ScreenshotAPI, ScreenshotMachine, ScreenshotOne, and Urlbox) against 7 real-world URLs.

Here is exactly how the data was captured and aggregated:

True Cold Starts: Every request bypassed edge caching and warm browser pools. We measured the total round-trip latency: HTTP request to Headless Chrome boot to DOM render to pixel capture.
Concurrent Execution: All 6 APIs were triggered simultaneously for each target URL. If a target website (e.g., Vercel or Stripe) experienced a latency spike or routing bottleneck, every screenshot provider faced the exact same conditions.
10× Global Polling: To account for AWS/GCP load balancing and natural internet traffic fluctuations, the benchmark was executed 10 separate times at different hours of the day.
Heavy Browser Workloads: We didn't just test simple viewport captures. The payload configurations forced high device scale factors (Retina/2× resolution), full-page scrolling, and active ad-blocking across a mix of static HTML and heavy React SPAs.
Outlier & Error Mitigation: Real-world networks occasionally drop packets. To prevent a single anomalous DNS timeout (e.g., a 25,000 ms spike) from corrupting the dataset, we systematically dropped the single slowest execution out of the 10 runs. Any request returning a non-200 HTTP error was also isolated and removed.
Final Aggregation: After cleaning the dataset, we calculated the strict avg cold duration per URL, and summed them to find the total cold duration to determine the fastest overall provider.
Image Parity: All screenshots were captured at the same resolution and quality settings per URL. The compression algorithms used by each provider produce nearly identical output quality, with no visible difference between them. Because the variance was negligible, we chose not to include image-quality metrics in this benchmark. On the caching side, warm-cache performance is also comparable across providers, with a few exceptions we plan to document in a future update.
Public Data: All raw metrics, scripts, and configurations are
public on GitHub
. Anyone can inspect, reproduce, or challenge the results.

Transparency note
Regarding ApiFlash: During our testing, ApiFlash consistently struggled with the framer.com payload, returning response times approaching 30 seconds. Because this metric was a significant outlier, we paused the benchmark publication and re-ran this specific configuration multiple times across different days and server locations. The response times remained consistently slow.

In the interest of absolute transparency and fairness to the other providers who successfully handled the complex DOM, we have chosen to publish the raw, unedited data exactly as it was recorded.

For context: if framer.com were excluded from the dataset, ApiFlash's average cold duration would drop from 9,702.57 ms to 6,731.14 ms, moving it from last place to 4th in average latency (behind Microlink, ScreenshotAPI, and ScreenshotMachine). Its total cold duration would fall to 40,386.86 ms, ranking 4th overall — right behind ScreenshotMachine.

The complete testing data is

open source on GitHub

. Last run: March, 2026.

Why latency matters for AI agents & puppeteer alternatives

When you transition from managing your own headless browser infrastructure (like

Puppeteer

Playwright

) to outsourcing it to a managed API, you introduce a network hop into your critical path. If your provider is slow, every downstream system inherits that latency.

The "observe" phase in agentic workflows

For multimodal AI agents and LLMs, browser latency compounds exponentially. Modern agents rely on both structured DOM extraction and visual grounding (screenshots) to observe web state and make decisions. When a single page capture takes 10–15 seconds, a multi-step reasoning loop quickly stalls out.

Microlink is built to keep this cycle as tight as physically possible. It includes a built-in proxy layer that handles IP rotation and mitigates anti-bot blocking (403s, CAPTCHAs) out-of-the-box. This ensures your agents get reliable access to target URLs without you having to maintain complex, failing proxy pools.

Reducing architectural overhead

Even a highly optimized Headless Chrome boot and SPA render takes 3–4 seconds. Because browser automation is inherently heavy, your infrastructure provider shouldn't add unnecessary network or routing overhead.

When cold starts consistently stretch beyond 8 seconds, you are forced to abandon synchronous code. Developers have to over-engineer workarounds: webhook callbacks, background job queues (Redis/Celery), and aggressive retry logic to handle timeouts. By minimizing cold-start latency, Microlink keeps response times within manageable synchronous limits, simplifying your system architecture.

Ship faster screenshots

50 requests/day free — no account, no credit card. Start capturing screenshots at the speed your users deserve.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://www.apple.com' URL with 'screenshot' & 'embed' API parameters:

CLI Microlink API example

microlink https://www.apple.com&screenshot&embed=screenshot

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://www.apple.com" \
  -d "screenshot=true" \
  -d "embed=screenshot"

JavaScript Microlink API example

import mql from '@microlink/mql'

const { data } = await mql('https://www.apple.com', {
  screenshot: true,
  embed: "screenshot"
})

Python Microlink API example

import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://www.apple.com",
    "screenshot": "true",
    "embed": "screenshot"
}

response = requests.get(url, params=querystring)

print(response.json())

Ruby Microlink API example

require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://www.apple.com",
  screenshot: "true",
  embed: "screenshot"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body

PHP Microlink API example

<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://www.apple.com",
    "screenshot" => "true",
    "embed" => "screenshot"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}

Golang Microlink API example

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "io"
)

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://www.apple.com")
    q.Set("screenshot", "true")
    q.Set("embed", "screenshot")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import mql from '@microlink/mql'

const { data } = await mql('https://www.apple.com', {
  screenshot: true,
  embed: "screenshot"
})

Start now for free

50 requests/day free

No login required

No credit card

Frequently Asked Questions

What is the fastest screenshot API in 2026?

Based on our independent benchmark testing 7 real-world URLs with zero caching, Microlink is the fastest screenshot API with an average cold-start latency of 4,111.84 ms. The next closest provider averaged 5,915.71 ms, making Microlink roughly 30–44% faster than every competitor tested.

What is cold-start latency?

Cold-start latency is the total time from sending an HTTP request to receiving the final screenshot, with no warm caches or pre-booted browsers. It measures the real-world worst case: Headless Chrome boot, DNS resolution, DOM render, and pixel capture.

This metric matters because it determines whether your system can handle screenshots synchronously or needs complex async workarounds like webhook callbacks and job queues.

Is there a free screenshot API?

Yes. Microlink offers 50 free screenshot requests per day with no account, no login, and no credit card required. The free tier includes adblock, cookie banner removal, metadata extraction, and full browser control.

For production workloads, the Pro plan starts at €39/month for 46,000 requests with automatic proxy resolution and antibot protection.

What is a screenshot API?

A screenshot API is a managed service that captures visual snapshots of web pages by running a headless browser (typically Chrome) in the cloud. Instead of maintaining your own

Puppeteer

Playwright

infrastructure, you send an HTTP request with a URL and receive a rendered image.

Screenshot APIs handle browser lifecycle, rendering, caching, scaling, and anti-bot mitigation so developers can focus on their product. See how it works.

Can I try the screenshot API without signing up?

Yes. The screenshot playground lets you capture any URL directly from the browser — no API key, no account, no setup. Configure viewport, format, full-page mode, and device emulation, then preview the result instantly.

If you need specific workflows like mobile device emulation, scrolling animations, or bulk URL processing, you can test them all for free on our developer tools page.

Can I use a screenshot API for AI agents?

Yes, and speed is critical for this use case. AI agents rely on screenshots for visual grounding during multi-step reasoning loops. When a single capture takes 10-15 seconds, the entire agent workflow stalls.

Microlink is built to be the eyes of AI agents: sub-5-second cold starts, built-in proxy rotation to bypass CAPTCHAs and anti-bot blocking, and structured DOM extraction alongside visual capture.

Is Microlink open source?

Yes. Microlink is powered by

browserless

, an open-source headless Chrome/Chromium driver built on top of Puppeteer. The entire stack is available on GitHub under the microlinkhq organization.

You can self-host it for full control, or use the managed API to skip infrastructure work and get automatic scaling, proxy rotation, and global edge deployment.

How was this benchmark conducted?

We tested 6 screenshot API providers against 7 real-world URLs using true cold starts (no caching). All providers were triggered simultaneously for each URL to ensure identical network conditions.

The benchmark ran 10 times at different hours, the single slowest run was dropped to remove outliers, and non-200 responses were excluded. The full testing architecture is