New: Monitors. Watch any website for changes
Context.dev
Backed byY CombinatorCombinator

Data Extraction {API}

Describe the data you want as a JSON Schema. Get typed JSON back from any website, in one API call.

No CSS selectors to maintain, no scraper-plus-LLM pipeline to operate. The API crawls, renders, and extracts against your schema, then tells you exactly which pages it used.

Free tier included. No credit card, no proxy configuration, no prompt engineering.

No card required
View Documentation
Daydream logo
Kovai logo
Passionfroot logo
Orange logo
SendX logo
Klarna logo
Super.com logo
Daydream logo
Kovai logo
Passionfroot logo
Orange logo
SendX logo
Klarna logo
Super.com logo
Daydream logo
Kovai logo
Passionfroot logo
Orange logo
SendX logo
Klarna logo
Super.com logo
Daydream logo
Kovai logo
Passionfroot logo
Orange logo
SendX logo
Klarna logo
Super.com logo

What is a data extraction API?

A data extraction API turns unstructured websites into structured, typed data through a single HTTP request. You describe the fields you want as a JSON Schema, point the API at a URL, and get back JSON that matches the schema: right names, right types, required fields enforced. The hard parts of reading the web (crawling, JavaScript rendering, bot protection, and the extraction itself) happen on the API side.

The traditional alternatives both age badly. Selector-based scrapers break every time a target site ships a redesign, and the do-it-yourself stack (fetch the page, clean the HTML, prompt an LLM for JSON, validate, retry) turns into a pipeline you operate forever: two vendors, prompt drift, token budgeting, and hand-written crawl logic the moment an answer spans more than one page.

Context.dev's extract endpoint replaces both. One call crawls up to 50 pages of a site, reads them together, and returns data matching your schema plus urls_analyzed, the list of pages used to produce the answer. A factCheck mode restricts output to values actually stated on the pages, so nothing is inferred when correctness matters.

What You Get

A complete extraction pipeline, exposed as one clean API.

Schema in, typed JSON out

Send a JSON Schema describing the data you want. The response matches it: right field names, right types, required fields present. Generate the schema from Zod or Pydantic if you already have one.

Whole-site answers, not one page

One request crawls up to 50 pages of a site to assemble the answer: pricing from one page, founding year from another. The response lists every URL analyzed, so results stay auditable.

No selectors to maintain

Extraction reads rendered pages the way a person does, so a site redesign does not break your integration. There are no XPath or CSS selectors to write, monitor, or patch.

Fact-check mode

Pass factCheck: true and only values actually stated on the crawled pages come back. Fields the site does not answer stay empty instead of being inferred, which matters for compliance and finance workloads.

Rendering and anti-bot included

Every page renders in a stealth headless browser with automatic proxy escalation and bot-challenge handling, on every plan. JavaScript-heavy sites return real content, not empty shells.

One call replaces a pipeline

Fetching, cleaning, crawling, prompting, schema validation, and retries collapse into a single request. No second LLM vendor, no prompt drift, no glue code between a scraper and a model.

How It Works

Four things happen between your request and your data. You only write the first one.

— step 01 —

Describe the data

Send a starting URL and a JSON Schema for the shape you want back, with field descriptions to steer the extraction

— step 02 —

We crawl and render

The crawler follows relevant links up to your maxPages and maxDepth, rendering each page in a stealth headless browser

— step 03 —

AI extracts against your schema

Content from every analyzed page is read together and mapped onto your schema, with optional fact-checking

— step 04 —

Typed JSON comes back

response.data matches your schema and urls_analyzed lists every page used, so you can validate and audit the answer

API Response

One POST request returns typed JSON matching your schema, plus the pages used to answer it.

POST /v1/web/extract
Try in API Playground
{
  "status": "ok",
  "url": "https://stripe.com",
  "urls_analyzed": [
    "https://stripe.com",
    "https://stripe.com/pricing",
    "https://stripe.com/about"
  ],
  "data": {
    "founded_year": 2010,
    "has_free_trial": true
  },
  "metadata": {
    "numUrls": 3,
    "maxCrawlDepth": 1,
    "numSucceeded": 3,
    "numFailed": 0,
    "numSkipped": 0,
    "numBlocked": 0
  }
}

Extract structured data in one call

The same call works from JavaScript, Python, Ruby, Go, PHP, or plain curl. SDKs are typed, versioned, and published to npm, PyPI, and friends.

TypeScriptextract.ts
import ContextDev from 'context.dev';

const client = new ContextDev({ apiKey: process.env.CONTEXT_DEV_API_KEY });

const { data } = await client.web.extract({
  url: 'https://stripe.com',
  schema: {
    type: 'object',
    properties: {
      founded_year: { type: 'number' },
      has_free_trial: { type: 'boolean' },
    },
    required: ['founded_year'],
  },
});
Pythonextract.py
from context.dev import ContextDev

client = ContextDev(api_key="YOUR_API_KEY")

response = client.web.extract(
    url="https://stripe.com",
    schema={
        "type": "object",
        "properties": {
            "founded_year": {"type": "number"},
            "has_free_trial": {"type": "boolean"},
        },
        "required": ["founded_year"],
    },
)
print(response.data)
curlterminal
curl -X POST "https://api.context.dev/v1/web/extract" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://stripe.com",
    "schema": {
      "type": "object",
      "properties": {
        "founded_year": { "type": "number" }
      },
      "required": ["founded_year"]
    }
  }'

What teams extract with it

Lead and account enrichment

Turn a prospect's domain into the fields your CRM actually needs: employee count, pricing model, tech stack, hiring signals. Pair the answer with company profile data (logos, socials, address, industry codes) from the same API key.

Pricing and competitor matrices

Define one schema (plans, prices, limits, trial availability) and run it across every competitor domain. Because the schema stays fixed, results land in your database as comparable rows, not as prose to parse.

Compliance and finance snapshots

Extract structured summaries of privacy policies, terms, or disclosures with factCheck: true, so only statements actually on the page come back. Re-run on a schedule with extraction monitors and diff the results.

Agent tools

Agents work better with typed answers than with raw pages. Expose extract as a tool and the model gets exactly the fields it asked for, with live web context and provenance it can cite.

Catalogs and marketplaces

Ingest supplier or merchant sites into a normalized product or listing shape. For product pages specifically, the dedicated product extraction endpoint returns a pre-built record with price, billing frequency, images, and SKU.

Why not a scraper plus an LLM?

The do-it-yourself version is genuinely tempting: fetch the page, strip the markup, hand the text to a model with a JSON output format, validate the result. For one page on one friendly site, that is an afternoon of work, and it is the default answer most teams (and most coding agents) reach for.

Production is where it inverts. The site that needs JavaScript rendering, the one behind bot protection, the answer spread across a pricing page and an about page, the model that quietly invents a value for a field the site never states: each becomes its own subsystem. You end up operating a scraper, a crawler, and an LLM integration, paying two vendors, and re-validating output shapes on every model upgrade.

The extract endpoint is that entire stack as one request: stealth rendering and proxy escalation from the scraping infrastructure, crawl logic bounded by maxPages and maxDepth, schema enforcement on the way out, factCheck when inference is unacceptable, and urls_analyzed so every answer is auditable. If you are comparing providers, see the Firecrawl comparison for a feature-by-feature breakdown.

Simple, success-based pricing

An extraction costs 10 credits and covers the whole crawl. Failed requests are never billed.

One extract call costs 10 credits on success, whether it analyzed one page or fifty. Sign up with a work email and get 500 free API credits, enough for 50 extractions; free-email signups get 250 credits. Paid plans scale linearly per credit with no annual contract and no surcharges for rendering or stealth. Full details are on the pricing page.

Frequently asked questions

Common questions about the Context.dev data extraction API.

What is a data extraction API?
A data extraction API turns unstructured web content into structured, machine-readable data through a single HTTP request. You describe the fields you want (for example founded_year, pricing_tiers, or has_free_trial) as a JSON Schema, point the API at a website, and get back typed JSON that matches the schema. The API handles crawling, JavaScript rendering, bot protection, and the extraction itself, so there are no selectors to write and no scraping infrastructure to run.
How is a data extraction API different from a web scraping API?
A web scraping API returns page content (Markdown, HTML, or images) and leaves interpretation to you. A data extraction API returns answers: you define the output shape and the API reads the site and fills it in. Use scraping when you want the document; use extraction when you want specific fields as typed JSON. Context.dev offers both behind the same API key.
How do I define what data to extract?
With standard JSON Schema. Each property gets a type and a description telling the extractor what to look for, and required fields are enforced. If your codebase already defines shapes in Zod or Pydantic, generate the JSON Schema from them (z.toJSONSchema() in TypeScript, model_json_schema() in Python) and pass it straight through.
Can it pull data spread across multiple pages?
Yes. One request crawls up to 50 pages (maxPages, default 5) with a configurable maxDepth, following the links most likely to answer your schema. The response includes urls_analyzed, the list of every page used to produce the answer, so multi-page answers stay auditable.
Does it work on JavaScript-heavy or bot-protected sites?
Yes. Every page renders in a stealth headless Chromium browser, and requests escalate through datacenter and residential proxy pools when blocked. Bot-protection challenges are detected and handled automatically on every plan, at no extra cost.
How do I stop the model from making things up?
Pass factCheck: true. In fact-check mode only values actually stated on the crawled pages are returned, and fields the site does not answer stay empty instead of being inferred. For extra safety, validate response.data against the same JSON Schema you sent before using it downstream.
Which languages and SDKs are supported?
Official SDKs ship for TypeScript/JavaScript, Python, Ruby, Go, and PHP, and the REST endpoint (POST /v1/web/extract) works from any language that can send an HTTP request. In every SDK the call is one method: client.web.extract with a url and a schema.
How much does data extraction cost?
An extract call costs 10 credits on success, and covers the entire crawl (up to 50 pages) within that one call. Failed requests are never billed. Signing up with a work email gets you 500 free credits, enough for 50 extractions; free-email signups get 250 credits. Paid plans scale per credit with no annual contract.
Why not build this with a scraper and an LLM?
You can: fetch pages, clean the HTML, prompt a model with a JSON output format, validate, retry. That stack works, but you now operate a scraper and an LLM integration, pay two vendors, and own prompt drift, token budgeting, schema enforcement, and crawl logic for answers that span multiple pages. The extract endpoint is that whole pipeline as one request, with rendering, anti-bot handling, fact-checking, and provenance built in.
How does Context.dev compare to Firecrawl for structured extraction?
Both offer schema-based extraction. Context.dev extraction crawls up to 50 pages in a single call to answer schemas that span a site, includes fact-check mode and per-answer provenance (urls_analyzed), and includes stealth rendering and proxy escalation on every plan with no surcharges. See the Firecrawl comparison page for a feature-by-feature breakdown.

Ship an agent that actually knows things.

Free tier, 10-minute integration, and the same API powering agents at Mintlify, daily.dev, and Propane. No credit card to start.

Get API Access
Book a call