The Jina Reader alternative that bills per request

Jina Reader meters the tokens it hands back, so a long page costs more than a short one. Microlink counts one request per call at the same price on every plan, and that single response carries the markdown, the screenshot, the PDF and the page 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"
    }
  }
})

One JSON response, PDF included.

Reader selects the output with an X-Respond-With header, and that header can combine formats, such as markdown+html+screenshot, when the request accepts JSON. Microlink takes each format as its own parameter, and the same JSON includes a PDF of the page, which Reader does not document as an output.

What you need back	Jina Reader	Microlink
Markdown of the page	X-Respond-With: markdown	data.markdown.attr=markdown
The rendered HTML	X-Respond-With: html, or markdown+html	data.html.attr=html, same response
A screenshot	X-Respond-With: screenshot, or added with +	screenshot=true, same response
A PDF of the page	Not a documented output	pdf=true, same response
Title, author, date, logo, publisher	url, title, content, timestamp	Normalized, same response
Calls for markdown, HTML, and a screenshot	1, joined with +	1

Reader values are the ones published in the Reader repository and on jina.ai/reader. Combined X-Respond-With values are the ones that source accepts, joined with +, and they need Accept: application/json. The Microlink column is the request in the URL to Markdown guide with data.html.attr=html, screenshot and pdf added to it.

One request Every format in the response

2.0

secs

P95 metadata

2.8

secs

P95 screenshot

99.9

SLA Guaranteed

Start free, scale when ready

One price per 1,000 requests on every tier, and one quota behind every product. Spend it on Markdown, screenshots, PDFs or Search in whatever mix the month needs. A page that returns 200 words and a page that returns 20,000 cost the same.

Free

Every Pro feature. No card.

$0/month

25 requests per day

Get your free API key

Pro

For production workloads.

$49/month

≈ $1.07 per 1,000 requests

46,000 requests / month

Cancel anytime · No setup fees

Business & Enterprise

Bought the way companies buy.

Everything in Pro, plus:
Card or invoice, PO number, net 30
NDA, DPA & service agreement
Vendor assessments on request
Same named contact
Annual billing, 10% discount

Enterprise adds

View details

Need more details?

Compare every plan side by side

Capability by capability, side by side.

Both services render a URL in a real browser and return clean markdown for an LLM. The differences are what a call is billed for, what else comes back with it, and how long a response can be reused. Every Reader row comes from jina.ai/reader or the Reader repository, the last three included, where Reader does things Microlink does not.

Capability	Microlink	Jina Reader
Billing unit Microlink is $1.07 per 1,000 requests on every self-serve Pro plan, from $49 for 46,000 to $450 for 420,000. Reader charges for the tokens in the response, so the same page costs more when it is longer, and its jina-ocr-v1 option costs 40× more tokens.	1 request	Output tokens
Formats in one response X-Respond-With accepts a combination such as markdown+html+screenshot when Accept is application/json. Microlink takes each format as its own parameter, including pdf, and returns them as fields of one JSON response.	Markdown, HTML, screenshot, PDF, metadata	Combined formats, no PDF
Response caching Microlink cache hits are free and fast, and ttl is settable with any API key. Reader caches a fetched page for 1 hour (3600 seconds). X-No-Cache bypasses it, and X-Cache-Tolerance sets how stale a cached page may be.	1 minute to 31 days	1 hour
Requests per minute Microlink Pro runs as many parallel requests as the monthly quota allows; the free API key runs 2 at a time. Reader publishes 20 RPM without a key and 5,000 RPM on its premium key.	No throttling on Pro	20 to 5,000
Page metadata Title, description, author, date, logo, image, publisher and brand palette, normalized across sites.	✓	url, title, content, timestamp
PDF of the page pdf=true on any Microlink request. Reader parses PDFs it reads, but documents no PDF output of its own.	✓	✕
Screenshot controls Reader returns a screenshot or a full-page pageshot, and accepts a viewport (width, height, device scale, mobile, landscape, touch). Microlink sets device, viewport, full page, and element on the same request.	Device, viewport, full page, element	Screenshot URL and viewport
Lighthouse and technology detection	✓	✕
Markdown from PDFs and office files Microlink converts a PDF, docx, xlsx or pptx URL to a DOM at fetch time. Reader parses PDFs with PDF.js and also accepts an uploaded file.	✓	✓
Structured extraction Microlink takes declarative CSS and regex rules and returns typed fields. Reader uses X-Target-Selector to narrow the page before converting it.	Typed JSON fields	Selector for the content
Proxy for blocked targets Routing through the residential proxy is a Pro capability, and proxy.location pins the exit country. A blocked request returns EPROXYNEEDED on every plan. Reader takes x-proxy: auto or a country code with a key, or forwards through the proxy URL you pass in X-Proxy-Url.	Managed on Pro	Managed with a key, or your own
Antibot reporting Microlink names the provider that blocked a request across 30+ antibot and CAPTCHA vendors.	✓	✕
Search results Microlink Search comes with every API key, the free one included. Reader search needs a key and bills a fixed amount per request, starting from 10,000 tokens, for the top five results.	✓	✓
MCP server	✓	✓
Free tier The free Microlink API key renews 25 requests every day with no card and every Pro feature, and 5 a day need no key at all. Every new Reader key comes with 10M free tokens once, and Reader answers without a key at 20 RPM.	25/day	10M tokens, 20 RPM keyless
Token trimming and chunking X-Max-Tokens trims the response, X-Token-Budget rejects a page over budget, X-Markdown-Chunking splits it by heading.	✕	✓
Generated alt text for images X-With-Generated-Alt captions images with a vision model.	✕	✓
Upload a file instead of a URL A local PDF or office file can be posted to the Reader file body field. Microlink needs a URL it can fetch.	✕	✓

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

Where Reader is the better tool.

Four jobs Reader does that Microlink does not, taken from its own documentation.

Nothing to sign up for
Reader answers a prefixed URL with no API key at 20 requests a minute, and every new key comes with 10M free tokens. Microlink answers 5 requests a day without a key; past that it needs a signup, and the free key renews 25 requests a day.
Markdown sized for a context window
X-Max-Tokens trims the response, X-Token-Budget refuses a page that would blow the budget, X-Markdown-Chunking splits by heading, and the link and image summaries collapse the rest. Microlink returns the whole document and leaves the budget to you.
Files without a public URL
A local PDF or office file can be posted straight to the Reader file body field, and jina-ocr-v1 reads a scan at 40× the tokens. Microlink converts the same file types, but only from a URL it can fetch.
Images described, not just linked
X-With-Generated-Alt captions images with a vision model, so a model reads what is in them. Microlink returns the image URLs and leaves captioning to you.

Product Information

What a call costs, what comes back in it, and what happens to the code calling r.jina.ai today.

Is Microlink a drop-in replacement for r.jina.ai?

No. Reader is a URL prefix with its options in request headers. Microlink is an API endpoint with query parameters and an SDK. The migration is usually one module: the prefixed URL becomes a request with url and data.markdown.attr=markdown, X-Target-Selector becomes a selector on that field, X-Timeout becomes timeout and X-Proxy-Url becomes proxy. The converted page arrives in data.markdown instead of the response body.

Does Microlink charge by tokens?

No. Microlink bills one request per API call, at $1.07 per 1,000 requests on every self-serve Pro plan, from $49 for 46,000 to $450 for 420,000. A 200-word page and a 20,000-word page cost the same one request, and a cache hit costs nothing at all. Reader bills the tokens its response contains, so page length decides the invoice.

Can Microlink read a PDF or a Word file as Markdown?

Yes. Point the request at a PDF, docx, xlsx or pptx file and Microlink converts it to an HTML DOM at fetch time, so the same Markdown request returns readable Markdown. The file has to live at a URL Microlink can fetch; Reader also accepts a file uploaded in the request body.

What are the rate limits?

Microlink applies no throttling on paid plans: run as many parallel requests as the monthly quota allows, and the quota is the only ceiling. The free API key runs 2 requests at a time against a daily quota. Reader publishes 20 requests per minute without an API key and 5,000 per minute on its premium key.

Is there a search API like s.jina.ai?

Yes. Microlink Search returns Google results as JSON and comes with every API key, the free one included, drawing on the same request quota as every other product. Reader search needs a key, is blocked without one, and bills a fixed amount per request starting from 10,000 tokens for the top five results.

Is the free API key enough to evaluate it?

It covers 25 requests a day with markdown, screenshot, PDF, metadata, search, insights, the SDK, the edge cache and adblock. Residential proxy routing is a Pro capability. No credit card, and the allowance renews daily, so an evaluation picks up again the next morning.

Start building

Point a request at the URL you read through Reader this morning and compare the response.