Skip to content

The Thum.io alternative
for final screenshots

Thum.io is clever for ultra-cheap streamed website thumbnails. When you need final screenshots, selectors, PDFs, metadata, and fewer workarounds around modern pages, Microlink gives you a broader API and 6× lower average cold-start latency.

Get Started Free
Measuring cold-start speed across 2 screenshot APIs
Microlink
Thum.io

6× lower average cold-start latency

Same request shape. Same URLs. Measured at final screenshot completion.

We tested 7 real-world URLs with true cold starts (no caching) from a New York server. This comparison measures when the final screenshot was ready, not when a streamed loader first appeared. Thum.io did not finish ahead on any URL in this suite, and Microlink still finished the full suite 541% faster on average.
Cold-start latency by URL
URLMicrolinkThum.io
vercel.com7,85134,920
example.com1,21430,688
stripe.com3,25413,063
screenshotone.com4,98951,776
news.ycombinator.com3,42620,817
github.com3,0134,302
framer.com5,96634,931
Total29.7 s190.5 s
vercel.com
Microlink7,851 ms
Thum.io34,920 ms
example.com
Microlink1,214 ms
Thum.io30,688 ms
stripe.com
Microlink3,254 ms
Thum.io13,063 ms
screenshotone.com
Microlink4,989 ms
Thum.io51,776 ms
news.ycombinator.com
Microlink3,426 ms
Thum.io20,817 ms
github.com
Microlink3,013 ms
Thum.io4,302 ms
framer.com
Microlink5,966 ms
Thum.io34,931 ms
Average cold-start latency
ProviderAvg Cold Durationvs. Microlink
Microlink4,244.7 ms—
Thum.io27,213.74 ms+541% slower
Average image size
ProviderAvg Image Size
Microlink0.55 MB
Thum.io1.02 MB
Microlink images come out 45% smaller on average while staying in a similar quality range. Smaller image size matters when screenshots need to load fast without looking obviously over-compressed.

Why Developers Switch

What usually changes when a team outgrows Thum.io.

Final screenshot time matters more than loader time
Thum.io's standout trick is streaming an animated initial render. That is useful for embeds. Our benchmark measured when the final screenshot was actually ready. On that metric, Microlink averaged 4,244.70 ms versus 27,213.74 ms for Thum.io.
More control once pages stop being simple
Thum.io's URL API focuses on width, crop, fullpage, wait, and a few device presets. Microlink adds selector capture, JS/CSS injection, cookies, custom headers, click/scroll interactions, and ad blocking when real browser state starts to matter.
Built to stay fast under serious load
Microlink is built for teams that need to handle thousands of concurrent requests and still keep latency predictable. It is shaped by both enterprise workloads and smaller developers who need a screenshot API they can trust to stay fast when traffic spikes.
Cheaper per hit, narrower per request
If all you need is high-volume site preview thumbnails, Thum.io is legitimately cheaper. Microlink becomes more attractive when one request needs to replace multiple browser or extraction tools instead of just returning an image.
Built for harder pages
Microlink includes built-in residential proxying and antibot detection for 30+ providers. If your targets sit behind Cloudflare, DataDome, or similar protections, that removes operational work from the screenshot pipeline.
Auditable core, not a black box
Metascraper, MQL, and Browserless are MIT-licensed. You can audit the core pieces, self-host them, or fork them. Thum.io is proprietary, so the rendering internals are not inspectable.

Cheaper per screenshot. Broader per request.

There is no perfect apples-to-apples plan match here. Thum.io prices simple website screenshot hits aggressively; Microlink charges more, but bundles a wider browser and data surface into each request.

Microlink
$49/mo
46,000 requests/month
  • Screenshots + PDF + metadata + previews + remote JS
  • 25 requests/day free, no credit card required
  • No requests-per-minute cap on paid plans
  • Built-in proxy + antibot handling for harder targets
  • 340+ edge nodes, 99.9% SLA
  • One request can replace multiple screenshot-side tools
Start for free
Thum.io
$20/mo min
$1 per 10,000 screenshot hits
  • At 46,000 screenshots, this tier still bills its $20 monthly minimum
  • Full-page screenshots and adjustable viewport width
  • Animated initial render with unbranded loader options
  • Queue priority on paid usage
  • First 1,000 screenshot hits free
  • Strong fit for cheap, high-volume website preview embeds
If your job is mostly simple website snapshots at scale, Thum.io wins raw pricing. If each screenshot request also needs metadata, PDF, browser logic, or antibot help, Microlink trades higher cost for a much broader request surface.

Ready to move past streamed thumbnails?

Start with 25 requests/day free and see whether your workload needs simple snapshots or a broader browser API.

Start Building Free

Feature-by-Feature Comparison

An honest look at what each API offers.

FeatureMicrolinkThum.io
Screenshot capture✓✓
Full-page screenshots
Thum.io documents full-page capture on a paid plan.
✓✓
Device emulation presets
Thum.io documents iPhone and Galaxy presets on a paid plan.
✓✓
Signed request URLs✓✓
Built-in response cache
Thum.io exposes cache freshness via maxAge and a prefetch cache workflow.
✓✓
Direct embed (no backend needed)✓✓
Element-level capture (CSS selector)✓✕
PDF generation✓✕
HTML rendering✓✕
Custom JS/CSS injection✓✕
Custom HTTP headers✓✕
Custom cookies✓✕
Hide/remove elements (CSS selectors)✓✕
Click/scroll interactions✓✕
Wait for selector✓✕
Cookie banner blocking✓✕
Ad blocking✓✕
Built-in proxy✓✕
Antibot detection (30+ providers)✓✕
Metadata extraction✓✕
Link previews
Link preview API returns the oEmbed iframe, card fields, and media in one call.
✓✕
Open-source core✓✕
Remote JS execution✓✕
MCP server✓✕
Animated initial render
Thum.io streams an animated initial render while the final screenshot completes.
✕✓
Prefetch + callback batch workflow
Thum.io documents prefetch requests plus optional callbackUrl delivery.
✕✓
Image resizing API✕✓
PDF-to-image conversion✕✓
Last verified: April 2026. See each product's docs for the latest.

Where Thum.io
Might Be the Right Choice

Streaming initial render
Thum.io streams an animated initial render immediately, which can make embeds feel responsive before the final screenshot is done. Microlink focuses on returning the completed capture.
Very cheap simple screenshot pricing
Thum.io lists a paid screenshot tier at $1 per 10,000 screenshot hits with a $20 monthly minimum. If your workload is mostly simple website snapshots at scale, that raw per-hit pricing is hard to beat.
Free usage with almost no friction
Thum.io says you can use up to 1,000 screenshot impressions per month for free without even signing up. That is a low-friction way to test basic website previews.
Path-based image embeds are extremely simple
The product is designed around direct image URLs such as image.thum.io/get/... which makes it easy to drop screenshots into an img tag or CMS field without much application code.
Prefetch plus callback workflows
Thum.io documents a prefetch endpoint with optional callback delivery when the image is ready. Microlink does not have native async callback workflows or webhooks.
Image resizing and PDF-to-image utilities
Beyond screenshots, Thum.io also exposes direct image resizing and PDF-to-image conversion endpoints. If those utilities are central to your workflow, they are meaningful built-in extras.

Ship final screenshots faster

25 requests/day free. Start with screenshots, then add metadata, PDF output, or browser automation only when your workflow needs it.

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' API parameter:

CLI Microlink API example

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

cURL Microlink API example

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

JavaScript Microlink API example

import mql from '@microlink/mql'

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

Python Microlink API example

import requests

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

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

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"
}

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"
];

$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")
    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))
}
Start now for free

What is a good Thum.io alternative for final screenshot APIs?

If your workload is moving beyond cheap embedded thumbnails, Microlink is a strong Thum.io alternative. It covers screenshots, PDF generation, metadata extraction, link previews, and remote JS from one platform.
Thum.io stays compelling for ultra-cheap site preview images and streamed initial renders. Microlink is the better fit when the request needs to do more than return a simple snapshot.

Does this benchmark include Thum.io's streamed GIF behavior?

No. This benchmark measures final cold-start completion time: when the requested screenshot payload was fully ready. It does not score how fast a loading spinner or animated initial render appears.
That distinction matters with Thum.io because its main differentiator is perceived speed during streaming. For synchronous server-side screenshot workflows, the final completion time is usually the more important number.

How hard is it to migrate from Thum.io URLs to Microlink?

Usually not very hard. Thum.io encodes options as readable path segments like fullpage, viewportWidth, wait, and device names. Microlink expresses the same capture intent through its own parameter model and screenshot guides.
The migration is mostly about mapping screenshot intent, not rewriting your app from scratch. Start from the screenshot docs, then adapt any Thum.io-specific loader or prefetch logic separately.

When does Thum.io still make more sense than Microlink?

Thum.io still makes a lot of sense when your main goal is cheap, high-volume website preview images, especially if you like its streamed initial render and direct image URL model.
It also has built-in prefetch + callback workflows, image resizing, and PDF-to-image conversion. If those utilities are central to your pipeline, Thum.io has real advantages.

Is Microlink better if I need metadata or PDF from same request?

Yes. That is one of the clearest differences. Microlink covers screenshots, PDF generation, metadata extraction, link previews, and remote JS in one platform.
Thum.io documents screenshots, image resizing, and PDF-to-image conversion, but not metadata extraction, webpage-to-PDF generation, or the broader browser workflow surface that Microlink exposes.

Which service is cheaper for simple thumbnail embeds?

Thum.io is cheaper for that specific use case. Its paid screenshot tier is priced at $1 per 10,000 screenshot hits with a $20 monthly minimum, and the product is clearly optimized for embedded website preview images.
Microlink costs more, but each request can cover more work. If your workflow needs screenshot output plus metadata, browser logic, or blocked-page handling, price alone stops being the full story.

Do both Microlink and Thum.io support signed URLs and direct embeds?

Yes. Thum.io documents signed requests and simple img srcembeds. Microlink also supports signed request URLs and direct embed flows, so both products can power frontend-friendly image delivery.

Can Microlink replace Thum.io prefetch and callback workflows?

Not one-to-one. Thum.io documents a native prefetch endpoint with optional callbacks when the image is ready. Microlink does not expose native async callbacks or webhooks for screenshot completion.
If that exact pattern is important, you would keep the async orchestration in your own app: request Microlink, store the result, then fire your own callback or queue event downstream.