# Onto vs context.dev · Trust-scored reads + a three-layer stack
> context.dev is a web-intelligence API — scrape, crawl, extract, and brand data, read into your agent. Onto adds a 0–100 accuracy score, keeps extraction deterministic (no LLM in the loop), and spans two layers context.dev doesn't: a site-side Serve SDK and Act.

**Source:** /compare/context-dev
**Extracted:** 2026-06-13T11:09:53.152Z

---
Compared · Onto vs context.dev

## context.dev reads the web.  
_Onto reads it, scores it, and serves it back._

Both turn URLs into clean Markdown and structured data. Onto adds a 0–100 accuracy score, keeps extraction deterministic — no LLM in the loop — and spans two layers context.dev's ingestion API doesn't: a site-side Serve SDK and Act.

[Try the scanner free](/scanner)[Read API docs](https://docs.buildonto.dev/api/read)

0–100

Accuracy score per read

<100 ms

Cache-hit latency

1,000

Free reqs / month, forever

01 // Shared ground

### What both products do well.

Before the differences, the overlap. context.dev is a strong web-intelligence API and gets a lot right. So does Onto. Here's the honest shared baseline — all of it at layer 1, reading the web.

Markdown01

HTML → clean Markdown

Both turn a URL into LLM-ready Markdown — nav, footer, and chrome stripped, semantic structure preserved. No further parsing before the model reads it.

Whole sites02

Crawl + sitemap discovery

Both go past a single URL. context.dev crawls a domain and lists its sitemap; Onto ships /v1/map for discovery and /v1/batch to read a list or a whole site in one call.

Extraction03

Structured data out of pages

Both pull structured data, not just prose. The difference is how — covered below — but if you need fields, not paragraphs, either product gives you a path.

Managed04

SDKs, MCP, auth, quotas

Both are managed APIs with official SDKs, an MCP server, bearer-token auth, and per-tier quotas. Neither asks you to run crawlers or proxies.

02 // Capability matrix

### Feature-by-feature.

Where each product is strong, where each is silent. Em-dashes mean "not a current capability," not "intentionally missing" — and brand intelligence is genuinely context.dev's, not ours.

Onto

context.dev

HTML → Markdown

✓Yes

Yes

AIO accuracy score (0–100)

✓Every response

—

Hallucination-risk flags

✓Per-field risk labels

—

Sitemap discovery + multi-page

✓/v1/map + /v1/batch (one call)

Crawl + sitemap

Structured extraction

✓Deterministic (JSON-LD / OG / meta)

LLM schema extract + aiQuery

Brand intelligence

—

Yes — domain → typed company profile

LLM in the pipeline

✓None — no inference cost or drift

Yes (extract, aiQuery)

Site-side SDK (Serve layer)

✓@ontosdk/next — serves crawlers Markdown

—

Official MCP server

✓@ontosdk/mcp

Yes

Free tier

✓1,000 reqs / month, forever

500 credits

Response determinism

✓Content-hashed

Best-effort

03 // Where Onto extends the layer

### A trust layer, a deterministic core, and two more layers.

context.dev is excellent at ingestion. The differences are what arrives with the content, how it's produced, and what Onto does that an ingestion API structurally can't.

01

0–100 accuracy score on every read

A subtractive score grading semantic clarity, structural richness, and content-negotiation health, with per-field hallucination flags. Your agent knows whether to trust a page before it spends a context token on it. context.dev returns content; it doesn't grade it.

02

Deterministic extraction — no model in the loop

Onto's /v1/extract returns the structured data a page already declares (JSON-LD, OpenGraph, meta) with a rule-based parser. No LLM means no inference cost passed to you and no invented fields. context.dev's extract and aiQuery run a model to infer fields — powerful, but you pay for that inference and inherit its drift.

03

A Serve layer, not just ingestion

context.dev reads the web INTO your agent. Onto also runs the other direction: @ontosdk/next is one line of middleware that serves AI crawlers a site's own pre-cleaned Markdown while humans still get the full page. There's no context.dev equivalent.

04

One engine across three layers

Read, Serve, and Act run on the same cleaning + scoring engine. context.dev is a layer-1 web-intelligence API; Onto spans layer 1 plus two more. Same primitive, larger surface.

04 // Which to pick

### The honest decision matrix.

A comparison that only says "pick us" isn't a comparison. Here's when each one is genuinely the right call.

Pick Onto if01

*   ✓You're building an agent that must decide whether to trust a page before grounding on it — you want the score, not just the content.
*   ✓You want extraction you can audit: only the structured data the page actually declares, produced deterministically, with no per-call model cost.
*   ✓You also own sites and want to serve AI crawlers clean Markdown — the Serve SDK is the same engine, one accuracy bar.
*   ✓You want predictable spend: 1,000 free reads/month, then subscriptions plus credit packs.

Pick context.dev if02

*   →You need brand intelligence — resolve a domain, email, or ticker into a typed company profile (logos, colors, fonts, firmographics), or embed a logo via their Logo Link CDN. Onto doesn't do this.
*   →You want LLM-inferred structured fields a page never explicitly states — context.dev's aiQuery and schema extract are built for exactly that.
*   →You need product-listing/detail extraction or image classification out of the box as first-class endpoints.

05 // Common questions

### What developers ask before choosing.

What does context.dev do that Onto doesn't?+

Brand intelligence is the honest answer. context.dev resolves a domain, email, merchant string, or ticker into a typed company profile — logos, colors, fonts, socials, firmographics — and offers a one-tag Logo Link CDN embed. That's a genuine niche Onto doesn't serve. It also offers LLM-based extraction (aiQuery, schema extract) that infers fields a page doesn't declare. If those are the job, context.dev is the better fit.

Is context.dev a "layer 1 only" tool?+

Yes, in Onto's framing. context.dev is a web-intelligence / ingestion API: scrape, crawl, extract, search, brand data — everything is read _into_ your agent. There's no site-side SDK that serves clean Markdown to incoming crawlers (Onto's Serve layer) and no agent-transaction layer (Onto's Act). Onto runs that same Read layer and the two above it on one engine.

Can I use both context.dev and Onto?+

Sure. Use context.dev where it's strongest — brand profiles, logos, firmographics. Use Onto's `/v1/read-and-score` (or `/v1/batch` for many URLs at once) for the reads your agent actually grounds on, where the trust score and deterministic output matter. Different jobs; they compose.

How does pricing compare?+

Onto: free 1,000 reqs/month forever, then $9 / $49 / $250 subscriptions plus credit packs ($5–$200). context.dev: free 500 credits, then roughly $49 / $149 / $949 tiers, where scrape calls cost ~1 credit and brand-data calls ~10. [See Onto pricing](/pricing); check context.dev's site for current numbers — both vendors adjust tiers often.

Is this comparison fair?+

We try. context.dev is a strong, YC-backed product with a real brand-intelligence wedge that we don't compete on. The honest overlap is layer 1 — reading and extracting the web. There, our differences are the trust score, deterministic (no-LLM) extraction, and the Serve layer. Run both on your real URLs and let your data decide.

Try it on your URLs

### Run both on the same page. Let the data decide.

The scanner is free. Drop any URL and get an AIO score in seconds — then run it through context.dev and compare the output side by side.

[Open the scanner](/scanner)[// Or get an API key](https://app.buildonto.dev/signup)