# Web page to Markdown API: the main content of any URL, ready for a model

> Web page to Markdown API for LLMs and AI agents: any URL to clean Markdown with title, author and date, from $0.07/1K pages. No KYC, crypto.

- URL: https://webreaderapi.com/url-to-markdown-api/
- Last updated: 2026-10-22
- Publisher: WebReaderAPI (https://webreaderapi.com)

Pass a URL and get the article back as Markdown: headings, paragraphs, lists, tables and links kept; menus, cookie banners, ads and footers removed. With the page's title, author, date and language.

**Quick answer — Which API converts a web page into clean Markdown for an LLM?**

A web page to Markdown API fetches a page, keeps its main content and returns it as Markdown. **WebReaderAPI** does it in one request: `GET https://webreaderapi.com/api/v1/read?url=…` returns the article with its headings, lists, tables and links, plus title, author, date and word count, for one credit per page from $0.07/1K pages as of October 2026. robots.txt is respected. No KYC; pay in crypto.

## URL to Markdown API at a glance

| Attribute | Value |
| --- | --- |
| Endpoint | `GET https://webreaderapi.com/api/v1/read?url=…` (or `POST` with a JSON body) |
| Output | Clean Markdown of the page's main content (or plain text, or cleaned HTML), with title, description, author, publication date, language and word count; links and images on request |
| JavaScript | JavaScript rendering in a headless browser when the page needs it (render=auto), or always, or never |
| Billing | 1 credit = 1 page read without a browser; 2 credits when the page needs a browser to render JavaScript. A request that fails, or that a site's robots.txt refuses, is not charged |
| Token budget | `max_chars` cuts the Markdown to the length your model can take |
| robots.txt | We respect robots.txt: our crawler identifies itself as WebReaderAPI, follows the rules written for it or for all robots, and does not read a page that a site disallows. Refused pages are not charged |
| Price | $3.75 for 10,000 pages, $21.75 for 100,000 pages, from $0.07/1K pages at 5,000,000 pages |
| Payment | BTC, USDT, USDC, ETH, SOL, LTC, from a $25 top-up; no KYC |

## Why convert web pages to Markdown before giving them to a model?

Markdown keeps the structure a model needs and drops the markup it does not. A typical article page carries navigation, scripts, tracking tags, cookie notices and related-post widgets around a few hundred words of text. Sent as raw HTML, most of the tokens you pay for are markup.

Markdown keeps headings as `#`, lists as `-`, tables as pipes and links as `[text](url)`. A model can still see which sentence belongs to which section, quote the source link and split the text into chunks along its headings. The same text in plain prose loses that structure; the same text in HTML costs far more tokens.

## What does the API keep, and what does it remove?

With `main_content=true`, the default, the API keeps the part of the page that a reader came for and removes the rest.

| Kept | Removed |
|---|---|
| Title and headings | Site navigation and menus |
| Paragraphs, quotes and lists | Cookie and consent banners |
| Tables, as Markdown tables | Ads and promoted widgets |
| Code blocks, with their language when shown | Sidebars and related-post lists |
| Links inside the text | Footers and legal boilerplate |
| Images, only with `include_images=true` | Share buttons and comment forms |

Set `main_content=false` to convert the whole page instead, for example a home page or a product listing where everything matters. Set `format=text` for plain text without Markdown, or `format=html` for cleaned HTML of the main content.

*curl: one page as Markdown, cut to 20,000 characters*

```bash
curl -G "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/blog/pour-over-coffee" \
  -d format=markdown -d max_chars=20000
```

*Python: read a page and print its metadata and Markdown*

```python
import os

import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/blog/pour-over-coffee", "format": "markdown"},
    timeout=90,
)
resp.raise_for_status()
page = resp.json()
print(page["title"], "|", page.get("author"), "|", page.get("published_at"))
print(page["word_count"], "words,", page["credits_used"], "credit(s)")
print(page["markdown"][:500])

```

## What about pages built with JavaScript?

Many pages send almost no text in their first HTML and build the content in the browser. With `render=auto`, the default, the API first reads the raw HTML; if it holds too little text, it opens the page in a headless browser and reads the result. The response says which one happened in `rendered`.

A page that needed the browser costs two credits instead of one. If you know a site always needs it, set `render=true`; if you only want what the server sends, set `render=false` and never pay the second credit.

## What happens when a site does not want to be read?

We respect its choice and you are not charged. Our crawler identifies itself as `WebReaderAPI` and checks robots.txt before every read. A page disallowed for our token, or for all robots, returns `403 blocked_by_robots`. A site that declares `Content-Signal: ai-input=no` returns `403 blocked_by_site_policy`.

If the site refuses the request in another way, such as a 403 status, a challenge page or a login wall, you get `502 target_refused` with the site's own status. If a site refuses our request, we return its answer: we never solve CAPTCHAs, log in to accounts, or try to get around a block or a paywall. Our [crawler page](https://webreaderapi.com/bot/) explains all of this to site owners, with the exact User-Agent.

## How many pages will my project need?

Count one credit per page, two for pages that need the browser. Some typical volumes:

- **An AI agent** that reads 5 pages per task and runs 100 tasks a day reads about 15,000 pages a month: 50,000 pages ($14.25) last more than three months.
- **A RAG index** of three documentation sites with 2,000 pages each is 6,000 pages, then a weekly refresh of changed pages.
- **A research corpus** of 400,000 news and blog articles fits in 500,000 pages ($50).

Credits never expire, so a pack bought for a one-off crawl keeps its remaining value for later jobs.

## How much does the URL to Markdown API cost?

10,000 pages cost $3.75, 100,000 pages cost $21.75 and 1,000,000 pages cost $74.25, as of October 2026. Failed pages and pages refused by robots.txt are free. See [all packs](https://webreaderapi.com/pricing/).

| Plan | Quantity | Price | Price per unit |
| --- | --- | --- | --- |
| Test | 10,000 pages | $3.75 | $0.38/1K pages |
| Starter | 50,000 pages | $14.25 | $0.28/1K pages |
| Build | 100,000 pages | $21.75 | $0.22/1K pages |
| Volume | 1,000,000 pages | $74.25 | $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

## URL to Markdown API: common questions

### Does the Markdown keep tables and code blocks?

Yes. HTML tables become Markdown tables, and code blocks stay fenced, with their language when the page marks it. Very complex tables, such as ones with merged cells, are flattened row by row.

### Can I get the whole page instead of the article?

Yes. Set `main_content=false` and the API converts everything on the page, including navigation and footer. This suits home pages, category pages and product listings, where the main-content detector would drop useful parts.

### How do I keep pages within my model's context window?

Use `max_chars`, between 1,000 and 500,000 characters, to cut the Markdown at a set length. The `word_count` field tells you how long the full article was, so your agent can decide whether to read more.

### Can it read pages behind a login or a paywall?

No. WebReaderAPI reads public pages only. It never logs in to accounts and never tries to get around a paywall or a block; such pages return the site's refusal and are not charged.

### Do I need an ID or a card to get a key?

No. WebReaderAPI asks for no ID, no selfie, no company documents and no card. Account-number login; email is optional. You top up from $25 in BTC, USDT, USDC, ETH, SOL, LTC.

---

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.