# 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-09-04T20:32:43.659Z

---
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.

[Get started](https://app.buildonto.dev/signup) [Try the scanner free](/scanner)

[Read API docs](https://docs.buildonto.dev/api/read)

`context.dev`90their site

`Onto`80ours

Both scored 16 August 2026 with the engine behind [the scanner](/scanner).

0–100

Accuracy score per read

<100 ms

Cache-hit latency

1,000

Free reqs / month, forever

Shared ground

### What context.dev and Onto both do.

Starting anywhere else would be dishonest. These overlap substantially, and for a lot of jobs either one is a reasonable answer.

Markdown

#### 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 sites

#### 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.

Extraction

#### 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.

Managed

#### 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.

Capability matrix

### Line by line.

Where the two differ, and in which direction. A dash means the product doesn't do it — not that it does it badly.

| Capability | 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 — 1 credit, up to 50 URLs | 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 |
| Credits per call | Read 1 · Extract 1 — deterministic | Scrape ~1 · Brand ~10 |
| Free tier | 1,000 reqs / month, forever | 500 credits (one-time) |
| Response determinism | Content-hashed | Best-effort |

Where Onto extends the layer

### What you get that you wouldn't otherwise.

1.  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.
    
2.  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.
    
3.  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.
    
4.  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.
    

Which to pick

### When to choose context.dev instead.

Both columns are real. If the right-hand one describes you, use them — you'll get a better result than forcing our product at your problem.

#### Pick Onto if…

*   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 if…

*   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.

Common questions

### Details worth knowing.

01What 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.

02Is 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.

03Can 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.

04How 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 _one-time_ (a trial allotment, not a monthly refill), 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.

05Is 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.

Decide for yourself

### Run the same URL through both.

The scanner is free and needs no account. Compare the actual output rather than the marketing.

[Open the scanner](/scanner) [All comparisons](/compare)