Microlink Screenshot API Free Plan Limits and Request Quotas

Microlink currently advertises 25 free API requests per day, including screenshot requests. You can start without an API key, account, or credit card. The free allowance covers Microlink’s listed products except Search. When the quota is exhausted, Microlink documents an HTTP 429 response with error code ERATE. Check the response headers to see the limit, remaining requests, and reset time. These are Microlink’s current published terms, checked October 4, 2026; verify its live API page before relying on the figures because quotas and prices can change.

What the free quota means for screenshots

Microlink’s free tier is shared across its listed API products, rather than being a separate pool for each product. A screenshot consumes a request from the advertised daily allowance. The API page says every listed product except Search is included. The current screenshot page and screenshot guide also state 25 requests per day. Microlink API plans and quota · Screenshot API plan details · Screenshot guide

Microlink is a managed browser API: send an HTTP request with a page URL and screenshot options, and receive structured response data containing a screenshot asset URL. The browser infrastructure is managed by Microlink. A default response can include metadata as well as screenshot data; set meta=false when you only need the screenshot.

Make a screenshot request and inspect your quota

The examples below request a screenshot of a public page. The API returns JSON; on success, the generated asset URL is in data.screenshot.url. The screenshot guide documents screenshot=true for a default capture and the nested object form for options. In raw query parameters, screenshot options use dot notation.

cURL

curl -sS -D headers.txt -G "https://api.microlink.io" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "screenshot=true" \
  --data-urlencode "meta=false" \
  -o response.json

cat headers.txt
cat response.json

Look in headers.txt for x-rate-limit-limit, x-rate-limit-remaining, and x-rate-limit-reset. The response JSON contains the success status and screenshot metadata. A successful response’s image URL is data.screenshot.url.

Python

import requests

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

print("HTTP", response.status_code)
for name in (
    "x-rate-limit-limit",
    "x-rate-limit-remaining",
    "x-rate-limit-reset",
):
    print(name, response.headers.get(name))

payload = response.json()
if response.status_code == 429 or payload.get("code") == "ERATE":
    raise RuntimeError(f"Microlink quota exceeded: {payload}")
if payload.get("status") != "success":
    raise RuntimeError(f"Microlink request failed: {payload}")

print("Screenshot URL:", payload["data"]["screenshot"]["url"])

Install the dependency with python -m pip install requests. The timeout is a client-side safety bound, not a Microlink quota setting.

Node.js

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

const response = await fetch(`https://api.microlink.io?${params}`);
for (const name of [
  'x-rate-limit-limit',
  'x-rate-limit-remaining',
  'x-rate-limit-reset'
]) {
  console.log(name, response.headers.get(name));
}

const payload = await response.json();
if (response.status === 429 || payload.code === 'ERATE') {
  throw new Error(`Microlink quota exceeded: ${JSON.stringify(payload)}`);
}
if (!response.ok || payload.status !== 'success') {
  throw new Error(`Microlink request failed: ${JSON.stringify(payload)}`);
}

console.log('Screenshot URL:', payload.data.screenshot.url);

This uses the built-in fetch available in current Node.js versions. No Microlink SDK is required for a direct HTTP request.

Read the rate-limit headers

Header	What it tells you	How to use it
`x-rate-limit-limit`	The request allowance for the reported window.	Confirm the limit Microlink reports for this endpoint.
`x-rate-limit-remaining`	Requests left in that window.	Track remaining capacity before queuing more captures.
`x-rate-limit-reset`	When the reported window resets.	Use it to schedule a retry after exhaustion.

Microlink says the free endpoint reports a daily window. Treat the headers returned with a request as the operational source of truth for your current allowance. Do not assume that the free plan’s daily reset works like the Pro monthly quota; Microlink describes Pro quota as resetting at the start of the next month in UTC.

What happens when you reach the limit?

Microlink documents HTTP 429 and code ERATE when you exceed the quota. Do not retry immediately in a tight loop: the request remains over quota until the window resets, and repeated retries cannot create more allowance.

Detect both the HTTP status and the API error code. Check the headers and response body rather than treating every non-success result as a screenshot.
Pause new captures and defer them until the reset indicated by x-rate-limit-reset.
Use a queue with bounded concurrency and a delayed retry policy for rate-limit responses. Keep other failures separate from quota exhaustion.
If your expected usage regularly exceeds the free allowance, compare the current paid quota or use another screenshot workflow that matches your volume.

Microlink says it does not throttle parallel requests within your quota. That does not increase the quota: concurrent calls can use the remaining requests sooner. If you need several captures of the same unchanged page, avoid unnecessary forced refreshes and account for the documented cache behavior.

Cache behavior and request costs

Microlink says responses are cached for 24 hours by default and cache hits are free. A force parameter bypasses the cache, so use it only when you need a fresh capture. On Pro, ttl and staleTtl provide cache controls. A cache hit can save a billable request according to Microlink’s published policy, but do not assume a request is free unless the response confirms the cache outcome. See the API page for its current cache details.

Microlink currently lists Pro at $49 per month for approximately 46,000 requests per month, with automatic proxy resolution, configurable TTL, custom HTTP headers, and a custom cache key. These commercial terms can change; check the live page before budgeting or choosing a plan. Microlink says Pro’s quota resets monthly in UTC, the usage counter can lag by a few minutes, and requests pause at 100% with no overage fees.

How to choose: stay on free, upgrade, or use another API

Situation	Practical next step
Prototyping or taking occasional screenshots	Start with the free endpoint; it needs no API key or card.
Usage fits within 25 requests daily	Keep an eye on the returned headers and use caching when a repeat capture can be reused.
Regular production use beyond the daily quota	Compare Microlink’s currently listed Pro allowance and controls against your monthly volume and freshness needs.
You want screenshot output with fewer failed or unwanted captures billed	Try ScreenshotNeo: it removes known consent banners, newsletter popups, and chat widgets before capture, and bills only clean shots.

Microlink’s current published comparison lists 25 daily free requests and Pro at $49 per month for approximately 46,000 monthly requests. ScreenshotNeo offers a free allowance of 1,000 screenshots per month without a card; its paid plans currently start at $5 for 3,000 screenshots. Those are different quota periods, so compare your actual daily peaks and monthly total rather than comparing the headline numbers alone. ScreenshotNeo’s plan details and options are at ScreenshotNeo and in the ScreenshotNeo API documentation.

Or skip the browser setup

ScreenshotNeo is a screenshot API and MCP server from Yorker Media. Make one GET request to capture a page as PNG, JPEG, WebP, or PDF. For a WebP screenshot:

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

See the ScreenshotNeo docs for the API options. Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. Its 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.

Troubleshooting

Symptom	Likely cause	What to do
HTTP 429 or `ERATE`	The free daily quota is exhausted.	Read the reset header, pause requests until the window resets, and avoid immediate retries.
No screenshot field in the response	The request omitted `screenshot=true`, or the API returned an error.	Check the encoded request parameters and inspect the response status and JSON before reading `data.screenshot`.
Invalid URL error	The target URL is missing, malformed, or not URL-encoded correctly.	Pass a complete URL such as `https://example.com`; use query parameter encoding rather than assembling a raw query string by hand.
The page is blocked on the free plan	Microlink says a page behind antibot protection can return `EPROXYNEEDED` on free.	Review the returned error. Microlink says Pro can automatically retry through a residential proxy; alternatively use an API suited to the target page.
The capture is stale	The default response cache can return a cached result for 24 hours.	Decide whether cached output is acceptable. Microlink documents `force` to bypass cache and configurable TTL on Pro.
The request succeeds but your app expects raw image bytes	The default endpoint response is JSON with screenshot metadata and an asset URL.	Read `data.screenshot.url` and fetch that asset, or use Microlink’s documented embed mode when a direct asset response is appropriate.
Quota display seems behind	Microlink says the Pro live counter can lag by a few minutes.	Use returned headers and account for the stated reporting delay; do not interpret a briefly stale dashboard counter as extra quota.

Performance and reliability notes

Skip metadata if you do not need it. Microlink identifies meta=false as usually the biggest speedup for screenshot-only requests.
Reuse cacheable results. The default 24-hour cache can reduce repeat work; forcing a refresh bypasses it.
Bound your own queue. Parallel requests are allowed within quota, but concurrency does not expand the daily allowance.
Handle errors as structured responses. Check HTTP status, JSON status, and error code before consuming screenshot fields.
Keep network and browser operations within an application timeout. A caller timeout helps your service recover from a slow request, but is separate from Microlink’s quota or reset window.
Plan for target-site failures. A valid API request cannot guarantee that every target page will render or permit capture. Treat API errors and target-page blocks as recoverable outcomes in production.

Frequently asked questions

Does Microlink require an API key for free screenshots?

No. Microlink says the free endpoint can be used without a key or credit card.

Is the free allowance 25 or 50 requests per day?

The current API page, screenshot page, and screenshot guide state 25 per day. A conflicting official reference has surfaced with 50 per day, but its currency is unclear. Use the current published 25-per-day figure and check the live API page before depending on it.

Does a cache hit use one of my paid requests?

Microlink says cache hits are free. The default cache period is 24 hours, and force bypasses it.

Can I make concurrent free requests?

Microlink says parallel requests are fine within your quota. They still consume the available requests, so concurrent calls can exhaust the daily limit sooner.

What is the current Microlink Pro price?

The current API page lists $49 per month and approximately 46,000 requests per month. Confirm the live pricing before purchase because these terms can change.