Microlink Screenshot API Review: Speed, Image Quality, and Limits

Short answer: Microlink is a hosted screenshot API with controls for full-page captures, selected elements, image format, JPEG quality, and transparency. Microlink reports a screenshot P95 latency of 2.8 seconds and a 99.9% SLA for paid plans. Those are vendor-published figures, not independent benchmark results, and the available evidence does not establish how well it captures your particular sites or workload.

For a screenshot-only request, Microlink says setting meta: false is usually the largest speed improvement. You can also tune JPEG quality and device scale factor to reduce image size, with corresponding fidelity tradeoffs. Evaluate representative pages and traffic before relying on any latency, image-quality, or cost assumption.

What Microlink’s screenshot API returns

Enable the screenshot parameter to capture a URL. In the default JSON flow, the image asset is described under data.screenshot, including its URL, dimensions, type, and file size. Microlink’s guide describes a managed flow that opens a headless browser, renders the page, captures it, stores the image on its CDN, and returns asset metadata. Its embed: 'screenshot.url' option is documented for direct image delivery.

See the screenshot parameter reference and screenshot guide for current request details.

Speed: what the published numbers do and do not tell you

Microlink’s API page publishes a screenshot P95 of 2.8 seconds, a metadata P95 of 2.0 seconds, and a 99.9% uptime SLA on paid plans. These are Microlink’s figures, accessed October 3, 2026. The screenshot product page also claims sub-second cached responses and cold starts under three seconds. The available source material does not specify the test geography, sample size, page mix, cache-hit ratio, or measurement window, so treat these as vendor claims rather than expected timings for your application.

P95 means that 95% of the observations in a specified measurement set finished at or below the stated time. Without a published methodology and a workload matching yours, that number is a useful question to investigate, not a latency guarantee for a particular URL or region. Do not compare it directly with another provider’s number unless the methodology, pages, geography, concurrency, and cache behavior match.

Documented ways to reduce work and payload

Set meta: false for image-only work. Microlink says skipping metadata extraction is usually its largest speed improvement for screenshot-only requests.
Choose JPEG where lossy compression is acceptable. The optimization guide demonstrates type: 'jpeg' with quality: 60, compared with a default quality of 80 in that example. This can reduce output size, but inspect the result for text, fine edges, and other detail important to your use case.
Use device scale factor 1 when appropriate. This produces one device pixel per CSS pixel in the documented example and can lower output dimensions and payload versus a higher scale factor. Check whether that resolution is sufficient for your consumer.
Measure the returned asset. Use the reported dimensions, type, and file size, including size_pretty where shown in the optimization guide, rather than guessing from request parameters.

These are documented tuning approaches, not quantified guarantees for every page. See Microlink’s speed and file-size optimization guide.

Image quality and capture options

The API exposes capture controls; their presence does not establish that every dynamic, authenticated, or unusually laid-out page will render as intended. Validate output using your own target URLs.

Need	Control to evaluate	What to check
Capture beyond the visible viewport	Full-page capture	Whether lazy-loaded sections appear and whether page height is as expected.
Capture a chart, card, or other region	Element targeting	Selector match, element visibility, and whether the output bounds are useful.
Choose output encoding	Image type such as PNG or JPEG	Compatibility, file size, and detail for the content.
Trade JPEG size against compression	Quality setting	Text edges, gradients, and artifacts at the quality you choose.
Control the page background	Transparent-background handling	Whether transparency is needed and supported by the selected output format.

For quality comparisons, keep the URL, viewport, page state, and scale factor fixed; change one setting at a time. Record the returned width, height, type, and size alongside a visual inspection. A smaller asset is not automatically a better asset if it loses detail your application needs.

Runnable examples

These examples illustrate the documented request shape: set screenshot, disable metadata for screenshot-only work, and inspect the response. Microlink’s guide also documents direct image delivery with embed. Check the current API documentation for exact parameter syntax and response details before putting an integration into production.

cURL

curl -G 'https://api.microlink.io' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'screenshot=true' \
  --data-urlencode 'meta=false'

For a JSON response, inspect data.screenshot for the asset URL and metadata. To request direct image delivery, Microlink documents embed=screenshot.url:

curl -G 'https://api.microlink.io' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'screenshot=true' \
  --data-urlencode 'meta=false' \
  --data-urlencode 'embed=screenshot.url' \
  -o screenshot

Python

import requests

response = requests.get(
    "https://api.microlink.io",
    params={
        "url": "https://example.com",
        "screenshot": "true",
        "meta": "false",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()

screenshot = data.get("data", {}).get("screenshot")
if not screenshot or not screenshot.get("url"):
    raise RuntimeError(f"No screenshot asset in response: {data}")

print("URL:", screenshot["url"])
print("Dimensions:", screenshot.get("width"), "x", screenshot.get("height"))
print("Type:", screenshot.get("type"))
print("Size:", screenshot.get("size"))

Node.js

const params = new URLSearchParams({
  url: 'https://example.com',
  screenshot: 'true',
  meta: 'false',
});

const response = await fetch(`https://api.microlink.io?${params}`);
if (!response.ok) {
  throw new Error(`Microlink request failed: HTTP ${response.status}`);
}

const result = await response.json();
const screenshot = result?.data?.screenshot;
if (!screenshot?.url) {
  throw new Error(`No screenshot asset in response: ${JSON.stringify(result)}`);
}

console.log({
  url: screenshot.url,
  width: screenshot.width,
  height: screenshot.height,
  type: screenshot.type,
  size: screenshot.size,
});

Example image tuning request

Microlink’s optimization guide demonstrates JPEG quality 60 and a device scale factor of 1 as a way to prioritize a smaller image. The exact encoding for nested options should follow the current parameter reference and SDK guide:

const params = new URLSearchParams({
  url: 'https://example.com',
  screenshot: 'true',
  meta: 'false',
  'screenshot.type': 'jpeg',
  'screenshot.quality': '60',
  'viewport.deviceScaleFactor': '1',
});

const response = await fetch(`https://api.microlink.io?${params}`);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const result = await response.json();
console.log(result.data?.screenshot);

Microlink supports SDK examples as well as HTTP requests. Consult the parameter reference when using full-page capture, element selection, image type, quality, or transparency; parameter details can change.

How to evaluate latency, quality, and limits

Choose representative URLs. Include a short static page, a long page with below-the-fold content, a page with delayed rendering, and any important authenticated or personalized page.
Fix capture conditions. Keep viewport and capture options stable. Record whether each response is cold or cached if you can identify that from your setup.
Measure end-to-end time. Time the request from your application’s region, under realistic concurrency. Track failures and timeouts as well as successful captures; a latency average alone hides tail behavior.
Inspect the image. Check missing content, clipping, unexpected blank areas, and text legibility. Compare formats and quality settings at the resolution your users will see.
Record output metadata and request outcomes. Track response status, image type, dimensions, file size, and the rate of usable results.
Calculate cost using your actual volume. Compare your expected requests and burst pattern with the live plan quota and terms, and verify whether the allowance fits your workload.

This process gives you evidence for your pages and traffic. The dossier contains no independent service comparison or reproducible benchmark, so it would be misleading to claim a universal speed or visual-quality winner from the published claims alone.

Plans, quotas, and buying context

As accessed on October 3, 2026, Microlink’s API page listed Free at 25 requests per day and Pro at $49 per month for 46,000 requests per month. It described configurable TTL, custom headers, proxy resolution, and priority email support among plan features, and stated that paid plans have a 99.9% uptime SLA. The page distinguishes Enterprise service credits. These commercial terms can change; verify the current Microlink API plans and terms before purchasing. Do not assume the paid SLA applies to the free plan.

The guide describes a no-key free usage path and a 25-request daily allowance. The product page documents quota headers for limit, remaining requests, and reset information, and an HTTP 429 response with an ERATE code when quota is exceeded. Confirm the current behavior in Microlink’s documentation before depending on it in application logic.

Microlink may suit a prototype or production service that fits its live allowance and benefits from managed browser rendering. Whether it is economical depends on your actual volume, cache behavior, and plan fit; whether it is reliable enough depends on your own measurements and the service terms. Test first with URLs representative of your traffic.

Or skip the browser setup

ScreenshotNeo is the alternative to try first when you want a screenshot API that cleans the page before capture. It accepts one GET request with a URL and returns PNG, JPEG, WebP, or PDF. Before capture, it accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response identifies the page verdict and billing status in headers. Its MCP server gives AI agents tools for screenshots, page information, and PDF capture.

Here is a one-call example using the documented API shape. See the ScreenshotNeo docs for options.

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

ScreenshotNeo includes 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000 screenshots. Every feature is on every plan. Learn about ScreenshotNeo, then sign up for 1,000 free screenshots a month, no card required.

Troubleshooting

Symptom	Likely cause	What to do
The response has no screenshot asset	The screenshot option may be disabled, the page may have failed, or the response shape may differ from what the client expects.	Check the current response body and status; confirm screenshot generation is enabled and handle error responses before reading `data.screenshot`.
The request is slower than the published P95	The vendor figure is not a guarantee for your page, region, cache state, or concurrency.	Measure from your own region across representative pages; try `meta: false` for image-only work and compare under consistent conditions.
The image is too large	High pixel dimensions, PNG output, or a high scale factor can increase payload.	Check returned dimensions and size; evaluate JPEG and a lower device scale factor if the fidelity tradeoff is acceptable.
Text or details look degraded	Lossy JPEG compression or reduced scale may be too aggressive for the content.	Raise JPEG quality or use PNG where suitable, then inspect the result at its intended display size.
Full-page output misses lower content	Content may be lazy-loaded or only appear after page scripts run.	Confirm current full-page capture behavior in the reference and test the target URL; compare the captured image with the rendered page.
HTTP 429 or `ERATE`	The documented quota behavior indicates the request limit was exceeded.	Check quota headers for remaining allowance and reset details; reduce or schedule requests, and confirm the current plan terms.
Image URL works in a browser but not in your consumer	The consumer may expect image bytes while the API response is JSON containing an asset URL.	Read the JSON asset URL and fetch it, or use the documented direct image delivery option.

Frequently asked questions

Does Microlink’s 2.8-second P95 mean every screenshot takes under three seconds?

No. It is a vendor-reported P95 statistic, not a per-request bound. Page complexity, network conditions, cache state, and your request pattern can affect results.

Is JPEG quality 60 the recommended setting?

It is an optimization-guide example, not a universal recommendation. Choose settings by checking file size and visual fidelity for your content.

Can I decide whether Microlink is fast enough without relying on its marketing figures?

Yes. Measure from your application’s region with representative URLs and realistic concurrency, and record successful and failed outcomes along with latency.

Are Microlink’s free quota and price fixed?

No. The cited figures describe the plan page as accessed on October 3, 2026. Check the current official page before budgeting.

Does the available evidence prove Microlink has better image quality than another API?

No controlled comparison or independent image-quality result was present in the research. Compare captures from the same pages and settings for your own use case.