The ScrapingBee alternative you can forecast

On ScrapingBee, 250,000 credits buys 250,000 pages or 3,333 — the flags on each request decide which. Microlink counts one request per API call, so the number on the plan is the number of pages, and that call still returns the screenshot, the markdown and the metadata together.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://stripe.com/blog/payment-api-design' URL with 'screenshot' & 'data' API parameters:

CLI Microlink API example

microlink https://stripe.com/blog/payment-api-design&screenshot&data.markdown.attr=markdown

cURL Microlink API example

curl -G "https://api.microlink.io" \
  -d "url=https://stripe.com/blog/payment-api-design" \
  -d "screenshot=true" \
  -d "data.markdown.attr=markdown"

JavaScript Microlink API example

import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://stripe.com/blog/payment-api-design', {
  data: {
    markdown: {
      attr: "markdown"
    }
  }
})

Python Microlink API example

import requests

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

querystring = {
    "url": "https://stripe.com/blog/payment-api-design",
    "screenshot": "true",
    "data.markdown.attr": "markdown"
}

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://stripe.com/blog/payment-api-design",
  screenshot: "true",
  data.markdown.attr: "markdown"
}

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://stripe.com/blog/payment-api-design",
    "screenshot" => "true",
    "data.markdown.attr" => "markdown"
];

$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://stripe.com/blog/payment-api-design")
    q.Set("screenshot", "true")
    q.Set("data.markdown.attr", "markdown")
    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 createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://stripe.com/blog/payment-api-design', {
  data: {
    markdown: {
      attr: "markdown"
    }
  }
})

The same plan, a 75× spread.

ScrapingBee publishes a multiplier per option, so the entry Freelance plan is worth anywhere from 250,000 pages to 3,333 — decided by flags set per request, not by the plan you bought.

Configuration	Cost each	What 250,000 buys
Static page, no rendering	1 credit	250,000 pages
Rendered page	5 credits	50,000 pages
Premium proxy, no rendering	10 credits	25,000 pages
Premium proxy, rendered	25 credits	10,000 pages
Stealth proxy	75 credits	3,333 pages
Microlink — any of the above	1 request	250,000 pages

Multipliers and the 250,000-credit Freelance plan are ScrapingBee's own, published in their documentation and pricing; the third column is that arithmetic. ScrapingBee also ships an auto mode that tries the cheapest configuration first and bills nothing for an attempt that fails, which narrows this spread when it works. Microlink has no multiplier to narrow: a rendered page and a proxied page are each one request against the plan you pick on pricing, proxy resolution is included on Pro, and a cache hit costs nothing at all.

Send the URL Get every format back

2.8

secs

P95 screenshot

2.0

secs

P95 metadata

99.9

SLA Guaranteed

Start free, scale when ready

One request counted whether the call renders or proxies, and a cache hit not counted at all — there is no multiplier to budget around. Start on the free tier and move to Pro when the daily ceiling gets in the way.

Free

Try the API in seconds. No card.

$0/month

25 requests per day

Get started free

Pro

For production workloads.

$49/month

≈ $1.07 per 1,000 requests

46,000 requests / month

Cancel anytime · No setup fees

Enterprise

Dedicated infra for high-volume.

Custom

Tailored to your volume

Explore Enterprise

Need more details?

Compare every plan side by side

Start now

Point a request at the URL you are scraping today and compare the response with the one you get back now. No signup for the first call.

Run your first request

No login needed

25 reqs/day free

No credit card

Feature by feature, side by side.

Both APIs render pages in a real browser and return HTML, markdown, screenshots and extracted fields. The differences are what a request costs, what else comes back with it, and what is on by default. Every ScrapingBee row is taken from their documentation, knowledge base and pricing page, including the last three, where ScrapingBee has capabilities Microlink does not.

Capability	Microlink	ScrapingBee
Billing unit ScrapingBee: 1 credit static, 5 rendered, 10–25 premium proxy, 75 stealth. A Microlink request costs the same whatever it carries.	1 request	1–75 credits
Response caching TTL from 1 minute to 31 days and cache hits are free. ScrapingBee states it does not cache requests at all.	✓	✕
Ads, trackers and cookie banners adblock defaults to true on Microlink; block_ads defaults to false on ScrapingBee.	✓	Opt-in
Page metadata Title, description, author, date, logo, image and publisher, normalized. ScrapingBee has no metadata product — reach the meta tags with extract_rules.	✓	✕
PDF of the page pdf: true on any Microlink request. No PDF output parameter is documented for ScrapingBee.	✓	✕
Lighthouse and technology detection Lighthouse report and detected stack for any URL.	✓	✕
Markdown Microlink converts any URL, PDF or office document; ScrapingBee returns return_page_markdown for the page.	✓	✓
Screenshots	✓	✓
Structured extraction Declarative CSS and regex rules on Microlink; CSS rules plus AI-described rules on ScrapingBee.	✓	✓
Page interaction	✓	✓
Proxy for hard targets Residential routing included on Microlink Pro; ScrapingBee prices premium and stealth proxies per credit tier.	✓	✓
MCP server	✓	✓
Search results Google Search API on Microlink paid plans; included on every ScrapingBee plan.	✓	✓
Free tier Microlink renews every day with no card and no expiry; ScrapingBee gives a one-time trial allowance.	25/day	1,000 once
Geotargeting ScrapingBee country_code from the Startup plan up. Microlink has no country selector.	✕	✓
Sticky sessions ScrapingBee session_id keeps consecutive requests on one IP.	✕	✓
Dedicated retail scrapers Dedicated scraping APIs from the ScrapingBee Business plan up.	✕	✓

Last verified: August 2026. Check each product’s docs for the latest.

When ScrapingBee is the better pick.

A comparison page that only flatters the vendor writing it is worth nothing. Five cases where the answer is ScrapingBee.

Published concurrency
ScrapingBee states a concurrency figure on every plan, from 50 on Freelance up to 400 on Business+, and higher again on Enterprise tiers. Microlink does not cap requests per minute on paid plans, but it does not publish a parallel-worker number either. If a contractual concurrency figure is what you are buying against, ScrapingBee gives you one to point at.
A mode that prices itself
Auto mode tries the cheapest configuration that works and only bills the attempt that succeeds, and max_cost caps what any single request may spend. It is a real answer to the credit spread above, and Microlink has no equivalent because it has no spread to manage.
A dedicated stealth tier
Stealth proxies are a separate, explicitly priced product for the hardest targets. Microlink resolves proxies automatically and does not sell an escalation tier above that.
Extraction described in prose
ai_query and ai_extract_rules let you ask for a field in plain language. Microlink extraction is declarative CSS and regex rules — precise and repeatable, but you write the selector.
Very high scraping volume
Published Enterprise tiers run to 14, 24 and 41 million credits a month. If crawling breadth is the whole job, and metadata, PDF and insights are not, that ceiling matters more than format breadth.

Product Information

What changes, what does not, and what a migration actually involves.

Is Microlink a drop-in replacement for ScrapingBee?

No — the request shape is different. ScrapingBee takes a url plus flags such as render_js and premium_proxy; Microlink takes a url plus the products you want back, such as screenshot, pdf or a data block. Most migrations are a single call site: the target URL stays the same, render_js becomes the default behaviour, premium_proxy becomes proxy, and js_scenario becomes click, scroll and waitForSelector.

How do credits compare to requests?

ScrapingBee charges 1 credit for a static fetch with rendering off, 5 for a rendered page, 10 or 25 for a premium proxy depending on whether the page renders, and 75 for a stealth proxy. Microlink charges one request per API call regardless of what the call does, so the number on your plan is the number of pages you can fetch. Compare plans by pages, not by the headline credit figure — and note that a ScrapingBee plan is cheaper per page than Microlink when your targets are static and rendering stays off.

Does Microlink render JavaScript?

Yes. Requests run in a real browser, so single-page apps return the content a visitor would see. The prerender parameter defaults to auto, which decides per URL whether a browser is needed or a plain HTTP fetch already returns the content — the fast path when the page does not need a browser.

Can I bring my own proxy?

Yes. Pass proxy: true for managed residential routing, included on any Pro plan, or pass your own proxy server as a URL string to route through a pool you already pay for. The x-fetch-mode response header confirms which path a request took. See proxy resolution.

What does the free tier include?

Twenty-five requests per day, forever, with no credit card. Screenshot, PDF, metadata, markdown, insights and the SDK are all included, along with the global edge cache and adblock. The daily allowance renews, so evaluation never runs out mid-test.

Do cached responses still cost a request?

No. A response served from cache inside its ttl window does not count against your usage — no browser boots, and the stored response returns from the edge in milliseconds. Set ttl anywhere from 1 minute to 31 days to decide how often a URL is fetched again. ScrapingBee states that it does not cache requests at all, so the same URL scraped twice is billed twice. See caching.

Does Microlink support geotargeting like country_code?

No. ScrapingBee lets you pick an exit country with country_code from the Startup plan up, and Microlink has no equivalent country selector — proxy: true resolves a residential route automatically but you do not choose the region. If a request has to originate in a specific country, that is a reason to stay on ScrapingBee, or to pass your own proxy server to Microlink and control the region there.

Is there a concurrency limit to plan around?

The two APIs answer this differently. ScrapingBee sells concurrency as a plan attribute, from 50 parallel requests on Freelance to 400 on Business+, so a queue of workers is sized against that figure. Microlink does not apply a per-minute rate limit on paid plans and does not sell parallelism as a tier, so throughput is not something you buy up — but there is also no contractual number to design a worker pool against.