Screenshot API Alternatives to Microlink: A Developer’s Guide

If you want a hosted screenshot API like Microlink, start with ScreenshotNeo: it captures PNG, JPEG, WebP, or PDF from one GET request, removes supported consent banners, popups, and chat widgets before capture, and bills only clean shots. It also offers an MCP server for AI agents. Compare it with ScreenshotOne, Browserless, and Urlbox based on the capture controls, authentication, caching, and session needs your application actually has.

Microlink may still be the right choice if you need its broader URL outputs, such as metadata, Markdown, HTML, embeds, PDFs, or browser-function results. The alternatives below focus on documented behavior; the available sources do not establish an independent speed or reliability winner.

Quick comparison

Service	Request model	Documented strengths	Consider when
ScreenshotNeo	GET with an access key	PNG, JPEG, WebP, PDF; cookie-banner and widget cleanup; 63 options; MCP tools; only clean shots billed	You want screenshot-focused capture, clean output, or agent access. Free plan: 1,000 shots/month; paid plans start at $5 for 3,000.
ScreenshotOne	GET `/take` with access key	Broad screenshot options; image or raw HTML responses; quota counts successful renders not served from cache	You want a straightforward hosted screenshot endpoint and its options match your rendering needs.
Browserless	POST `/screenshot` with token	URL or HTML input; full-page, format, quality, clip, viewport, device scale, selector; broader browser REST endpoints	You want a browser endpoint with Puppeteer-style controls or a larger browser automation workflow.
Urlbox	Render API and Render Links	Its pricing FAQ documents no charge for unsuccessful renders and cache behavior for Render Links	You need its render-link workflow and want to verify current plans, cache controls, and options against your usage.

These are vendor-documented features, not independent test results. Confirm current plan details before choosing: quotas and prices can change.

What Microlink provides

Microlink is a broader URL-processing API, not only a screenshot endpoint. Its documentation describes normalized metadata by default, with options for screenshots, PDF, Markdown, HTML, iframe embeds, and browser-function output. The screenshot guide documents full-page capture, element capture, and image type selection. Screenshot output is returned as a CDN-hosted asset; the guide says meta: false can skip metadata extraction for screenshot-only requests. Microlink documents 25 free requests per day without an API key.

If your integration uses only screenshots, compare the cost and complexity of requesting the extra URL metadata against a screenshot-focused service. If your application uses Microlink’s other outputs, replacing it may mean maintaining multiple integrations.

How to choose an alternative

List required outputs. Decide whether you need only an image or also PDF, metadata, Markdown, HTML, embeds, or browser functions.
Check capture controls. Verify full-page behavior, element selection, viewport, device scale, format, quality, and any wait or scroll behavior needed by the target pages.
Model billing rules. Estimate successful, uncached renders, cache hits, and failed captures separately. Read the current quota definition for each provider.
Check state and protection needs. Determine whether pages require persisted browser state, login flows, or handling of bot checks. A basic screenshot endpoint may not provide these.
Test representative URLs. Use pages with long lazy-loaded content, cookie banners, dynamic rendering, and any required authentication. Compare the resulting image and failure behavior in your own workload; no independent comparable performance results are established by the cited materials.
Calculate monthly cost. Use the volume you expect to be billable after caching and failures, then compare it with the current plan allowance and overage terms.

ScreenshotNeo: the alternative to try first

ScreenshotNeo is a screenshot API and MCP server from Yorker Media. It accepts one GET request with a URL and returns PNG, JPEG, WebP, or PDF. Before capture, it accepts cookie or consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Responses identify page verdict and billing status with X-Page-Verdict and X-Billed headers.

Its 63 options include full-page capture with lazy images loaded, CSS selector element capture, dark mode, 12 device presets and custom viewports, retina scale, PDF paper size and ranges, HTML/CSS capture, custom CSS and JavaScript, pre-capture clicks, hidden selectors, wait conditions, request and resource blocking, headers, cookies, user agent and Authorization, timezone and geolocation, transparency, resizing, configurable cache TTL, signed public image links, async jobs with signed webhooks, bulk capture of 100 URLs per call, a usage API, and an OpenAPI spec. Parameter names used by other screenshot APIs also work for easier migration. MCP tools include take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.

Every feature is on every plan. Free includes 1,000 shots per month with no card. Paid plans are Starter $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000; yearly billing gives two months free. Compare your expected billable volume and required options with the current plan details.

ScreenshotOne

ScreenshotOne documents GET https://api.screenshotone.com/take, using a URL and access key. Depending on options, a response can be an image or raw HTML. Its broad options reference is useful for checking whether it supports your page’s capture requirements.

The reviewed pricing page lists up to 100 free screenshots per month, Basic at $17/month for 2,000, and Growth at $79/month for 10,000. It says successfully rendered captures not served from cache count against quota. Treat these as vendor page figures and check the live pricing page before buying.

curl -G 'https://api.screenshotone.com/take' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  -o screenshot.png

For a migration, map your existing screenshot parameters to ScreenshotOne’s options reference and verify output format, full-page behavior, and cache accounting. Do not assume identical parameter semantics across providers.

Browserless

Browserless documents a token-authenticated POST request to /screenshot with either a URL or raw HTML and screenshot options. Supported controls described by its screenshot guide include full-page capture, format, quality, clip, viewport, device scale, and selector. Its guide also describes scrolling before capture to trigger lazy content.

curl -X POST 'https://production-sfo.browserless.io/screenshot?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com","options":{"fullPage":true,"type":"png"}}' \
  --output screenshot.png

Browserless offers more than screenshots: its REST API overview lists endpoints for PDFs, scraping, downloads, function execution, and website unblocking. Its documentation says independent REST responses discard session state. It also cautions that basic unblock support may not defeat advanced fingerprinting or interactive CAPTCHA. If your workflow needs persistent sessions or advanced automation, inspect its separate products and current documentation instead of assuming the screenshot endpoint covers those needs.

Urlbox

Urlbox’s reviewed pricing FAQ says unsuccessful renders are not charged and defines successful renders as those returning an image. It documents a 30-day default cache for Render Links, with TTL or a force option to override caching; cached Render Link requests do not count against monthly plan quota. The reviewed material does not establish a complete comparable price table, so check current plans directly rather than treating it as a value winner.

Before migrating, verify the exact request options and cache behavior for your selected Urlbox workflow. Confirm whether a Render Link’s cache lifetime and refresh behavior fit your freshness requirements.

Runnable client examples

The following examples capture a page with each provider’s documented request shape. Keep API credentials in environment variables or a secrets manager in production; do not commit them to source control. Save binary responses as bytes rather than decoding them as text.

ScreenshotNeo with cURL

See the ScreenshotNeo API documentation for options and response headers.

curl -G 'https://api.screenshotneo.com/v1/shot' \
  -d 'access_key=YOUR_API_KEY' \
  --data-urlencode 'url=https://stripe.com' \
  -o shot.webp

ScreenshotNeo with Python

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
with open("shot.webp", "wb") as f:
    f.write(r.content)
print("Page verdict:", r.headers.get("X-Page-Verdict"))
print("Billed:", r.headers.get("X-Billed"))

ScreenshotNeo with Node.js

const q = new URLSearchParams({
  access_key: process.env.SCREENSHOTNEO_API_KEY,
  url: 'https://stripe.com',
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`ScreenshotNeo returned HTTP ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

ScreenshotOne with Python

import os
import requests

r = requests.get(
    "https://api.screenshotone.com/take",
    params={"access_key": os.environ["SCREENSHOTONE_ACCESS_KEY"], "url": "https://example.com"},
    timeout=90,
)
r.raise_for_status()
with open("screenshot.png", "wb") as f:
    f.write(r.content)

Browserless with Node.js

const token = process.env.BROWSERLESS_TOKEN;
const res = await fetch(`https://production-sfo.browserless.io/screenshot?token=${encodeURIComponent(token)}`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ url: 'https://example.com', options: { fullPage: true, type: 'png' } }),
});
if (!res.ok) throw new Error(`Browserless returned HTTP ${res.status}`);
await import('node:fs/promises').then(fs => fs.writeFile('screenshot.png', new Uint8Array(await res.arrayBuffer())));

Or skip the browser setup

Make one request with ScreenshotNeo; the full options are in the API docs.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for free and get your API key.

Migration checklist

Inventory Microlink parameters and outputs, including any non-screenshot data your application consumes.
Choose the equivalent endpoint and authentication method; store keys and tokens outside code.
Match image type, viewport, full-page or element behavior, and waits to your existing output.
Test dynamic pages, long pages, consent banners, failures, and authenticated pages that your application actually needs.
Check cache TTL, cache-bypass behavior, and which requests count against quota.
Validate the returned content type and image dimensions before downstream processing.
Log status, provider, cache state where exposed, and billable verdicts so unexpected usage can be traced.
Roll out behind a provider setting or small traffic slice, then compare visual output and failure rates for your own URLs.

Performance, reliability, and cost

Performance

Capture latency depends on the target site, page complexity, wait conditions, and whether the page loads images or other resources. The dossier contains no comparable independent speed test, so do not choose based on a claimed performance ranking. Test a representative URL set with the same viewport and wait rules.

Reliability

Distinguish an HTTP error from a successful HTTP response that represents an unusable page. Check response status, content type, image dimensions, and provider-specific verdict headers where available. Retry transient network failures with a bounded retry policy and backoff; avoid endlessly retrying a page that consistently returns a CAPTCHA or other blocked response.

Browserless documents that independent REST responses discard session state and that its basic unblocking may not solve advanced fingerprinting or interactive CAPTCHAs. Microlink describes proxy features on paid access. Confirm the provider’s current capabilities against your target sites.

Cost

Estimate monthly billable renders, not just raw requests. ScreenshotOne says successful uncached renders count. Urlbox says failed renders are not charged and cached Render Link hits do not count against quota. ScreenshotNeo says only clean shots are billed; bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Microlink documents 25 free requests per day without a key. Recheck all vendor plan pages before selecting a paid tier.

For repeated URLs, caching can reduce repeated work, but it also makes freshness a deliberate tradeoff. Set a TTL that matches how often the source page changes, and use a force or cache-bypass option only when a fresh image is needed.

Troubleshooting

Symptom	Likely cause	What to check or change
401 or 403 response	Missing, invalid, or incorrectly passed key/token; account access restriction	Check the provider’s required parameter or token location, key value, and account permissions. Avoid printing secrets in logs.
Saved file is JSON or HTML, not an image	Error body or a response mode that returns HTML	Check HTTP status and `Content-Type` before saving. Read the error body for diagnostics and confirm options request an image.
Image is blank or incomplete	Page is still rendering, content is lazy-loaded, or the target blocks automation	Increase or configure the documented wait, use full-page/scroll behavior if available, and inspect whether the page presents a bot check or CAPTCHA.
Element capture is empty	Selector does not match, appears late, or is inside a frame	Check the selector against the rendered page, wait for it to appear, and confirm whether the provider supports the page’s frame structure.
Repeated captures are stale	Cached result is being served	Review TTL and cache rules. Refresh or force a new render when supported and needed.
Quota is higher than raw clean output count	Providers define billable renders differently; uncached attempts may count	Compare usage with the provider’s quota definition and cache-hit behavior. ScreenshotOne counts successful uncached renders; ScreenshotNeo exposes `X-Billed`.
Page requires login or retains no session	Independent REST requests may not persist browser state	Check cookie/header support and session semantics. Browserless documents that state is discarded between independent REST responses.
Advanced bot protection blocks capture	Fingerprinting or interactive CAPTCHA exceeds basic endpoint handling	Do not assume an unblock option defeats these checks; evaluate the provider’s current product and policies for your case.
Request times out	Slow target page, long waits, or large full-page capture	Set a sensible client timeout, narrow the capture or wait condition if possible, and retry transient failures with a bounded backoff.

FAQ

Can I replace Microlink if I also use its metadata or Markdown output?

Possibly, but compare the full set of outputs first. The screenshot-focused services may not be drop-in replacements for every Microlink URL-processing feature.

Which provider is the fastest?

The reviewed sources do not establish a comparable independent speed ranking. Measure latency on your own representative URLs and capture settings.

Do screenshot APIs work on every protected website?

No provider capability in the reviewed evidence guarantees success against every bot check, fingerprinting system, or interactive CAPTCHA. Test the target pages and account for failures explicitly.

Should I use a screenshot API or run a browser myself?

A hosted API avoids operating browser infrastructure and gives you an HTTP integration. Running your own browser can make sense when you need direct control over a persistent browser session or a specialized environment; it also means maintaining that infrastructure.