Guide

Jina Reader: r.jina.ai, the API, and where it stops

How Jina Reader turns a URL into Markdown, how to use r.jina.ai, its rate limits and token model, PDF and OCR support, licensing, and where it stops.

Jina Reader has one of the shortest interfaces in web data: put https://r.jina.ai/ in front of a public URL and you get Markdown back. No SDK, no account, no schema to write. That is why it turns up in RAG pipelines, agent toolchains, and quick scripts.

Past a demo, four choices matter: the endpoint, the auth tier, the output mode, and the license. Reader's landing page covers all four, though not in one place.

Facts about Reader come from jina.ai/reader and the jina-ai/reader GitHub repository, read on 20 October 2026. The landing page contradicts itself in one place on rate limits, noted below.

The one-line version

Prefix a public URL with https://r.jina.ai/:

curl "https://r.jina.ai/https://example.com"

The response is Markdown with the page's main content and the navigation, ads, and boilerplate removed. By default Reader fetches the page with a headless browser, so client-side JavaScript runs before extraction.

An API key raises the rate limit and enables token billing:

curl "https://r.jina.ai/https://example.com" \
  -H "Authorization: Bearer $JINA_API_KEY"

The Reader landing page says to send the key in the request header but does not print the header name. The bearer form above is the convention used in Jina's client guides and third-party tutorials. If a request returns an auth error, check the dashboard for the current header before changing the code.

What Reader does

Reader is a server-side fetcher and readability extractor. You give it one URL. It loads the page, waits for the content to settle, strips the chrome, and converts the result to Markdown. The output is designed for an LLM context window rather than for pixel-perfect fidelity.

Reader does not crawl or index the web. It fetches the URL you give it. The search endpoint, covered below, wraps Reader around the top results for a query, which is a different operation.

The default engine is a headless browser. A plain HTTP mode is available for pages that do not need JavaScript, and the Reader page describes an experimental Cloudflare browser-rendering engine.

Use it from Python or JavaScript

The HTTP interface is simple enough that most clients are a few lines. A Python request with a key:

import os
import requests

response = requests.get(
    "https://r.jina.ai/https://example.com",
    headers={"Authorization": f"Bearer {os.environ['JINA_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
print(response.text)

The same call with fetch:

const response = await fetch("https://r.jina.ai/https://example.com", {
  headers: { Authorization: `Bearer ${process.env.JINA_API_KEY}` },
});
console.log(await response.text());

For a hash-routed single-page app, the target URL cannot be expressed as a path suffix. Send the URL in a POST body instead:

curl -X POST "https://r.jina.ai/" \
  -H "Authorization: Bearer $JINA_API_KEY" \
  -d "url=https://example.com/#/route"

JSON output and structured extraction

Markdown is the default. Add Accept: application/json and Reader wraps the result in a JSON object with the URL, title, content, and timestamp when available:

curl "https://r.jina.ai/https://example.com" \
  -H "Accept: application/json"

The x-respond-with header selects other shapes: markdown, html, text, screenshot, pageshot, frontmatter, or markdown+frontmatter. x-target-selector limits extraction to a CSS selector, and x-wait-for-selector waits for an element before reading.

Reader also accepts x-json-schema and x-instruction headers for structured extraction. A schema request looks like this:

curl "https://r.jina.ai/https://example.com" \
  -H "Authorization: Bearer $JINA_API_KEY" \
  -H 'x-json-schema: {"type":"object","properties":{"title":{"type":"string"},"price":{"type":"number"}}}'

That returns JSON shaped by the schema. The Reader page does not describe a validation step that rejects a response when it fails the schema. If the next system needs a hard guarantee, validate the object yourself or use a service that makes validation part of the request.

Search with s.jina.ai

The search endpoint takes a query and returns the top five results with their content already converted to Markdown:

curl "https://s.jina.ai/?q=web+scraping+api" \
  -H "Authorization: Bearer $JINA_API_KEY"

Search is blocked without a key. Site-restricted search uses a repeated site parameter:

curl "https://s.jina.ai/?q=web+scraping+api&site=jina.ai&site=github.com" \
  -H "Authorization: Bearer $JINA_API_KEY"

Search is billed differently from a page read. It costs a fixed token amount starting from 10,000 tokens per request, regardless of how much text comes back.

PDFs, images, and OCR

Reader handles PDFs by passing the file URL to the same endpoint. The page documents an X-Page header for multipage documents. Image-heavy documents can go through jina-ocr-v1, which returns Markdown with text, formulas, tables, and reading order. OCR costs 40 times the normal token rate.

Images can be captioned automatically with x-with-generated-alt: true. x-retain-images controls whether images stay as links, alt text, or are dropped.

Caching

Repeated requests to the same URL within five minutes are served from cache. x-no-cache: true bypasses the cache, and x-cache-tolerance sets how stale a cached copy may be. Requests that carry cookies are never cached.

If you re-crawl stable documentation, the cache is useful. If you need a fresh price or inventory number, bypass it.

Rate limits

The Reader page publishes a per-endpoint table:

  • r.jina.ai: 20 RPM without a key, 500 RPM with a free or paid key, 5,000 RPM on a premium key.
  • s.jina.ai: blocked without a key, 100 RPM with a free or paid key, 1,000 RPM on a premium key.

The same page's general FAQ lists different numbers: 100 RPM and 100K tokens per minute on the free tier, 500 RPM and 2M TPM on paid, 5,000 RPM and 50M TPM on premium, plus an IP limit of 10,000 requests per 60 seconds. The page does not reconcile the two tables. Treat the Reader-specific numbers as the starting point and confirm the current limits in your dashboard before sizing a pipeline.

Limits apply per IP or API key and trigger on either requests per minute or tokens per minute, whichever is reached first.

What it costs

Anonymous use is free. A free API key includes 10 million tokens and raises the rate limits. Keyed use bills output tokens: the token count of the response is what you pay for.

Search costs a fixed token amount starting from 10,000 tokens per request. OCR costs 40 times the normal rate. Failed requests are not charged. One key works across Jina's APIs and draws on a shared token balance.

The Reader page does not publish a per-token dollar rate. The repository README describes Reader output as free and production use as "free, stable and scalable," which describes the open-source path more than the hosted API. For budgeting, use the rate shown in your Jina dashboard rather than a number from a third-party comparison.

What it does not do

Reader respects website access controls and does not bypass anti-bot protection. A paid key does not unlock additional websites. If a target sits behind Cloudflare, DataDome, or a login wall, Reader is the wrong layer.

Cookie forwarding with X-Set-Cookie replays credentials you already have. It does not perform a login, handle MFA, or fetch bearer tokens for you.

The page also states that Reader returns content in the page's original language and does not translate, and that video summarization is planned rather than available.

The licensing is split. The jina-ai/reader repository is Apache-2.0. The Reader landing page separately states that its Reader models are licensed CC-BY-NC 4.0 and that commercial production use requires a separate license. If you plan to ship Reader inside a commercial product, confirm which license covers your deployment before you build on it.

When Reader is the right tool

Reader fits when the page is publicly accessible and you need clean text quickly. Documentation, blogs, product pages, help centers, and PDFs are its natural targets. It is also a good fit for prototyping a RAG ingestion path, for adding a search-to-Markdown step to an agent, and for jobs where Markdown is the final format.

It fits less well when the page is defended, when the output must validate against a schema, or when you need a predictable per-page price. Those are transport and contract problems, which Reader does not solve.

Jina Reader alternatives

The full comparison is in the Jina Reader alternatives page. Three options cover most of the ground.

datamint takes a URL and returns Markdown or JSON validated against a schema. It routes each request across a static fetch, a headless render, and stealth routing, with published credit costs of 1, 5, and 15 credits per page plus 2 for a schema pass. PII stripping at ingestion and configurable robots.txt compliance are part of the product. See the URL to Markdown API, pricing, or the MCP server docs.

Firecrawl adds crawl, map, search, agent, and monitoring tools on top of scraping. Its MCP server is covered in the Firecrawl MCP guide, and the Firecrawl alternatives page has the pricing comparison.

Crawl4AI is the open-source, self-hosted option. It gives you control over the browser and the pipeline, and it inherits the maintenance that comes with that control. The Crawl4AI Cloudflare guide covers where it breaks and how to fix it.

FAQ

What is Jina Reader?

Jina Reader is a hosted service that fetches a URL, removes boilerplate, and returns clean Markdown for LLM input. The main endpoint is https://r.jina.ai/<URL>. It also offers JSON output, structured extraction headers, PDF and OCR handling, and a search endpoint at s.jina.ai.

Is Jina Reader free?

Anonymous use is free at 20 requests per minute on r.jina.ai. A free API key includes 10 million tokens and raises the limits. Keyed use then bills output tokens, and search costs at least 10,000 tokens per request.

Does Jina Reader bypass Cloudflare?

No. The Reader page says it respects website access controls and does not bypass anti-bot protection. A paid key does not unlock more sites. For defended targets you need a transport layer that handles fingerprinting and residential routing.

Does Jina Reader return JSON?

Yes. Markdown is the default, and Accept: application/json returns a JSON object with the URL, title, content, and timestamp. The x-json-schema and x-instruction headers support structured extraction, and x-respond-with selects other formats.

What is the rate limit for Jina Reader?

The Reader page lists 20 RPM without a key, 500 RPM with a free or paid key, and 5,000 RPM on premium for r.jina.ai. Search is blocked without a key, then 100 RPM on free or paid and 1,000 RPM on premium. The page's general FAQ lists different free-tier numbers, so confirm the current limit in your dashboard.

Can I use Jina Reader commercially?

Check the license. The open-source repository is Apache-2.0. The Reader page states that the Reader models are CC-BY-NC 4.0 and that commercial production use requires a separate license. The two statements cover different deployments, so confirm which one applies to you.

Does Jina Reader have an MCP server?

Yes. The Reader page lists an MCP server at mcp.jina.ai. For a comparison of MCP servers, see the Firecrawl MCP guide and the datamint MCP docs.

Sources

All three were read on 20 October 2026. Reader's limits, headers, and licensing can change, so verify them against the current pages before relying on a number in production.

This guide covers retrieving publicly accessible data. Check the target's robots.txt and terms before crawling it, and do not use Reader to access authenticated or paywalled content.

datamint returns schema-validated JSON and LLM-ready Markdown from bot-defended sites through one API call, with routing across transport tiers handled on our side.

All guides