# Jina Reader alternative: per-page credits instead of tokens

> Jina Reader alternative: per-page credits instead of tokens, from $0.07/1K pages, robots.txt always checked, no KYC, crypto. Prices dated 2026-10-22.

- URL: https://webreaderapi.com/alternatives/jina-reader/
- Last updated: 2026-10-22
- Publisher: WebReaderAPI (https://webreaderapi.com)

Jina Reader made the URL-prefix trick famous: put r.jina.ai/ in front of a link and get Markdown back. This page explains how Jina bills, when it is the right tool, and when a per-page price is easier to plan with.

**Quick answer — What is a good Jina Reader alternative?**

Jina Reader charges for output tokens: $50 for 1 billion, $500 for 11 billion, with 10 million free tokens per new key for non-commercial use (read 22 October 2026). **WebReaderAPI** charges per page instead, from $0.07/1K pages, so a long page costs the same as a short one. It checks robots.txt on every read, sells credits that never expire, and takes crypto with no KYC.

## Jina Reader and WebReaderAPI at a glance

|  | WebReaderAPI (ours) | Jina Reader |
| --- | --- | --- |
| How you call it | `GET https://webreaderapi.com/api/v1/read?url=…` with an API key | Prefix the link: `https://r.jina.ai/` + URL; key optional |
| Billing unit | Pages: 1 credit, 2 with a browser | Output tokens |
| Price | $3.75 for 10,000 pages; from $0.07/1K pages | $50 per 1B tokens; $500 per 11B tokens |
| Free use | None | Keyless at 20 requests a minute; 10M tokens per new key, non-commercial only |
| Rate limits | Concurrency limit shown in the dashboard | 500 requests a minute with a key; 5,000 on premium |
| robots.txt | Checked on every read | Opt-in `X-Robots-Txt` header; default not stated |
| Crawl a whole site | `POST /crawl`, up to 10,000 pages | No crawl endpoint stated |
| PDF | Yes, up to 100 pages | Yes |
| Payment | BTC, USDT, USDC, ETH, SOL, LTC | Cards, Google Pay and PayPal through Stripe |
| Owner | SerpGoat LLC | Jina AI, part of Elastic since October 2025 |

*Prices checked on October 22, 2026.*

Jina facts from jina.ai/reader and its pricing dashboard, read on 2026-10-22.

## How does Jina Reader charge, and what does one page cost?

Jina counts the tokens in the response. Its packages are $50 for 1 billion tokens, about $0.05 per million, and $500 for 11 billion, about $0.045 per million. Failed requests are not deducted, and a page requested twice within 5 minutes comes from a cache.

The cost of a page therefore depends on its length, and Jina publishes no average. As an **estimate, assuming 5,000 tokens per page**, 1,000 pages cost about $0.25 on the first package and $0.225 on the second. A 2,000-token news brief costs less than that; a 20,000-token documentation page costs four times more. OCR through jina-ocr-v1 costs 40 times more tokens.

## When are per-page credits easier to plan with?

When you know how many pages you will read but not how long they are. A crawl of a documentation site, a list of competitor pages to watch, or an agent that reads five links per task all have a page count, not a token count.

With WebReaderAPI, 100,000 pages cost $21.75, whatever the length of each page, as of 22 October 2026. Pages that need a browser use two credits, and the `rendered` field says when that happened. Use `max_chars` to cap the size of what comes back; it protects your model's context window but does not change the price.

## When is Jina Reader the better choice?

Choose Jina Reader when setup time matters more than anything else, or when your pages are short:

- **No setup.** A URL prefix works without a key at 20 requests a minute, which is enough for tests and small scripts.
- **Short pages.** With token billing, a short page costs less than a per-page price; at the 5,000-token estimate above, Jina costs less per page than our 10,000 pages pack.
- **Fine control through headers.** `X-Target-Selector`, `X-Remove-Selector`, `X-Token-Budget`, `X-Engine` and others shape each read.
- **Models and search.** ReaderLM-v2 output and `s.jina.ai` search come from the same account.
- **An official MCP server** whose `read_url` tool reads up to five URLs per call.
- **Open source.** The Reader branch on GitHub is Apache-2.0, without the hosted storage layer.

Jina AI is now part of Elastic, which completed the acquisition on 9 October 2025.

## How do Jina Reader headers map to WebReaderAPI parameters?

Most reads move over by changing the URL and adding a key.

| Jina Reader | WebReaderAPI | Note |
|---|---|---|
| `https://r.jina.ai/https://example.com` | `GET https://webreaderapi.com/api/v1/read?url=https://example.com` | Key in the `Authorization` header |
| Default Markdown output | `format=markdown` (default) | Main content by default |
| `X-Engine: direct` | `render=false` | Plain HTTP read |
| Default headless browser | `render=auto` or `render=true` | 2 credits when the browser runs |
| `X-Token-Budget` | `max_chars` | Characters, not tokens |
| `X-Target-Selector`, `X-Remove-Selector` | — | Main-content detection instead |
| `X-Proxy` (country) | `country` | +10 credits, residential connection |
| `X-No-Cache` | — | We keep no cache |
| `X-Robots-Txt` (opt-in) | — | robots.txt is always checked |
| `X-User-Agent` override | — | Our User-Agent is fixed and published |

*Python: from the r.jina.ai prefix to the read endpoint*

```python
import os

import requests

# Before: requests.get("https://r.jina.ai/" + url)
url = "https://example.com/guide/install"
resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": url, "render": "auto", "max_chars": 30000},
    timeout=90,
)
resp.raise_for_status()
page = resp.json()
print(page["word_count"], "words, rendered:", page["rendered"], "credits:", page["credits_used"])
print(page["markdown"][:400])

```

## What changes for the sites you read?

With Jina, robots.txt is checked only when you send the `X-Robots-Txt` header, and you can override the browser User-Agent; its pages do not state the default for either. With WebReaderAPI, both are fixed: every read checks robots.txt for `WebReaderAPI` and for all robots, and every request carries `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`.

That means some pages Jina can read will be refused here, at no cost to you. In exchange, site owners can see who reads their pages and block or allow us in one line, as our [crawler page](https://webreaderapi.com/bot/) explains.

## What does WebReaderAPI cost instead of tokens?

A flat price per page: 10,000 pages for $3.75 up to 5,000,000 pages for $350, as of 22 October 2026. Credits never expire.

| Plan | Quantity | Price | Price per unit |
| --- | --- | --- | --- |
| Test | 10,000 pages | $3.75 | $0.38/1K pages |
| Build | 100,000 pages | $21.75 | $0.22/1K pages |
| Volume | 1,000,000 pages | $74.25 | $0.07/1K pages |
| Bulk | 5,000,000 pages | $350 | $0.07/1K pages |

In every plan: Main-content extraction · JavaScript rendering when needed · Failed and refused pages not charged · Credits never expire

**Before you pay**

- Minimum top-up $25. Top up once in crypto, then buy any plan from your balance.
- Your balance has no end date and can buy page credits at any time. If a pack costs less than the minimum top-up, the amount you added only to reach that minimum can be sent back on request within 30 days of the payment, in USDT or USDC, as long as you have not spent it. Any other balance is not refunded unless the law says otherwise.
- Credited once your payment is checked on the blockchain. Typical network confirmation time: BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Jina Reader alternative: common questions

### Is Jina Reader free?

Partly. Without a key, r.jina.ai is free for basic use at 20 requests a minute. Each new key also gets 10 million free tokens, which Jina's pricing page limits to non-commercial use. Paid packages start at $50 for 1 billion tokens.

### Why does a Jina Reader page cost more when the page is long?

Because Jina bills the tokens in its response. A long article returns more tokens than a short one. WebReaderAPI bills one credit per page, two with a browser, whatever the length.

### Can I pay Jina Reader in crypto?

Jina's pages name Stripe with cards, Google Pay and PayPal, and no crypto option. WebReaderAPI takes BTC, USDT, USDC, ETH, SOL, LTC, with no KYC.

### Does WebReaderAPI have a free keyless mode like r.jina.ai?

No. Every read needs a key, and keys come with a paid pack. The smallest pack is 10,000 pages for $3.75.

### Who owns Jina Reader now?

Elastic. It completed its acquisition of Jina AI on 9 October 2025, and Jina's legal page says Elastic's data processing terms now apply.

## Sources

1. [Reader](https://jina.ai/reader/) — Jina AI (read 2026-10-22)
2. [API dashboard: pricing](https://jina.ai/api-dashboard/pricing/) — Jina AI (read 2026-10-22)
3. [Legal](https://jina.ai/legal/) — Jina AI (read 2026-10-22)
4. [jina-ai/reader repository](https://github.com/jina-ai/reader) — GitHub (read 2026-10-22)
5. [jina-ai/MCP repository](https://github.com/jina-ai/MCP) — GitHub (read 2026-10-22)
6. [Elastic completes acquisition of Jina AI](https://ir.elastic.co/News--Events/news/news-details/2025/Elastic-Completes-Acquisition-of-Jina-AI-a-Leader-in-Frontier-Models-for-Multimodal-and-Multilingual-Search/default.aspx) — Elastic (2025-10-09, read 2026-10-22)

---

WebReaderAPI: WebReaderAPI is a web reader API for AI agents that turns any public web page into clean Markdown, paid in crypto with no ID upload. Prepaid credits from $0.07/1K pages never expire, and robots.txt is respected. No KYC — no ID, no selfie, no documents. Pay in crypto.