# Onto — AI is reading your website wrong.
> Onto serves clean Markdown to AI agents instead of HTML noise. Same content, right format. One line of code. No changes to your site.

**Source:** /read-api
**Extracted:** 2026-05-20T20:59:17.388Z

---
LiveProduct · Read API

## Read any URL.  
_Get clean, agent-ready content._

The Read API takes a URL and returns clean Markdown plus a 0–100 AIO accuracy score and hallucination-risk flags. Sub-100 ms cache hits at the edge. Roughly 10× smaller payloads than raw HTML. Built for AI developers who can't afford to feed their model noise.

[Get an API key](https://app.buildonto.dev/signup)[Read the docs](https://docs.buildonto.dev/read-api)

<100 ms

Cache-hit latency

10×

Smaller payloads

8+

AI clients supported

01 // Integration

### One endpoint. Any URL. Clean output.

A single POST with the URL you want. Bearer-token auth. JSON back. No SDK required to start, no rate-limit gymnastics, no browser-automation glue.

curl

\# Read any public URL
curl https://api.buildonto.dev/v1/read \\
  \-H "Authorization: Bearer $ONTO\_API\_KEY" \\
  \-H "Content-Type: application/json" \\
  \-d '{ "url": "https://stripe.com/pricing" }'
\# Response (truncated)
{
  "markdown": "# Stripe pricing\\\\n\\\\n…",
  "score": 87,
  "insights": \["schema\_present", "clean\_headings"\],
  "hallucination\_risk": "low",
  "hash": "sha256:9f3b…"
}

01**One POST** with the URL you want. Bearer-token auth, no SDK required to start.

02**JSON response** with clean Markdown, a 0–100 AIO accuracy score, and hallucination-risk flags.

03**Idempotent** — same URL returns the same content hash. Cached 10 min at the edge.

02 // Capabilities

### More than a scraper. A scoring layer.

Anyone can clean up HTML. The Read API is the only managed endpoint that returns clean content _plus_ the metadata your agent needs to decide whether to trust it.

Scoring01

AIO accuracy score, 0–100

Every response is graded on semantic clarity, structural richness, and agent-readiness. Identify which pages are AI-ready and which are noise.

Safety02

Hallucination-risk flags

We surface fields the page describes ambiguously or contradicts itself on, so your agent knows when to ground vs guess.

Latency03

Sub-100 ms cache hits

Edge-cached responses across every Vercel POP. Cold fetches resolve in single-digit seconds even for JS-heavy SPAs.

Structure04

Schema & JSON-LD preserved

We don't strip semantic markup — Schema.org, OpenGraph, and JSON-LD blocks survive the cleaning step intact.

Economy05

10× smaller payloads

Typical token reduction vs raw HTML. Your agent burns less context, your customers burn less budget.

Determinism06

Content-hashed responses

Same URL, same response, same hash — until the source actually changes. Cache freely, audit confidently.

03 // Request lifecycle

### From URL to scored Markdown.

Every call passes through the same four stages. Most resolve in under 100 ms because of edge caching; cold fetches resolve in single-digit seconds even for JS-heavy SPAs.

Step 01

You POST a URL

Bearer-token auth, one body field. No SDK needed to start.

POST /v1/read

Step 02

We fetch & resolve

Resolve redirects, render JS when needed, dedupe via content hash. Hot URLs skip the fetch entirely.

edge resolver

Step 03

Clean & score

Strip nav/footer/chrome, extract semantic Markdown, run the AIO scorer over the result.

AIO scorer

Step 04

Return & cache

JSON response with Markdown + score + flags. Cached 10 min at the edge — adjustable per workspace.

Vercel edge

04 // Compared

### Read API vs the alternatives.

Firecrawl is the closest comparison — both are managed services for turning the public web into LLM-ready text. Here's where Onto adds the scoring + safety layer the alternatives don't.

Onto Read API

Firecrawl

Pricing model

✓Subscriptions + credit packs

Subscription tiers

AIO accuracy scoring

✓0–100 score + insights

—

Hallucination flags

✓Per-field risk labels

—

Official MCP server

✓Yes · @ontosdk/mcp

—

Edge-cache latency

✓Sub-100 ms hit

Origin-side cache

Free tier

✓1,000 reqs / month, forever

500 / month

Response determinism

✓Content-hashed

Best-effort

05 // Pricing

### Pay for requests, not seats.

Subscription tiers cover predictable usage; credit packs cover spikes. Free forever for 1,000 requests / month.

Free

$0forever

1,000 req/mo

2 concurrent · hard cap

Starter

$9/ month

10,000 req/mo

5 concurrent · credit overage

GrowthMost picked

$49/ month

100,000 req/mo

Priority queue · 20 concurrent

Scale

$250/ month

500,000 req/mo

Shared Slack · 50 concurrent

Credit packs from $5 (500 credits) to $200 (28,000 credits · +40% bonus). Stack with any subscription.

[Full pricing breakdown](/pricing)

06 // Common questions

### Things developers ask before signing up.

01How is this different from running my own scraper?

A scraper gives you HTML. The Read API gives you Markdown that an LLM can use directly, plus an accuracy score telling you whether the page is even worth feeding to your model. We also dedupe across the edge so you stop paying for the same URL twice.

02How accurate is the AIO score?

The score is subtractive — every penalty is traceable to a specific structural issue (missing headings, content-negotiation absent, schema not parseable, etc.). We expose insights so you can see why a page scored what it scored, not just the number.

03What happens when I exhaust my monthly requests?

On paid tiers you can top up with credit packs ($5 / $20 / $50 / $200) without changing plans. On Free, we soft-cap and surface a header indicating remaining quota — no surprise charges.

04Is there an official MCP server?

Yes — `@ontosdk/mcp` ships an official Model Context Protocol server. Drop it into Claude Code, Cursor, Cline, Zed, or Continue with three lines of config. [Read more](/mcp-server).

05Can I cache responses myself?

Yes. Every response includes a content hash — store it client-side and revalidate when source changes. We also expose ETag/If-None-Match headers for HTTP-native caching.

06Do you store the pages I read?

We cache responses for 10 minutes by default for performance; cache TTL is configurable per workspace. Source pages are never retained as crawl artifacts beyond the cache window.

Ready to build

### Start reading the web like an agent.

1,000 requests free forever. No card required. Upgrade only when your usage actually justifies it.

[Get an API key](https://app.buildonto.dev/signup)// No card. Cancel anytime.