Extract structured data

Use POST /web/extract when you know the fields you need but not which page contains them. Context.dev selects relevant pages from a starting URL, combines their content, and returns one data object shaped by your JSON Schema. The response includes urls_analyzed so you can trace the source pages.

If you need the page content itself, scrape Markdown. If the data is a product or brand profile, use the purpose-built Product or Brand API first.

Prerequisites

Create an API key in the dashboard and keep it in a server-side environment variable:

export CONTEXT_DEV_API_KEY="ctxt_secret_..."

Make an extraction request

Describe each field precisely. Use nullable types when the website may not state a value.

curl https://api.context.dev/v1/web/extract \
  --request POST \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "url": "https://stripe.com",
    "schema": {
      "type": "object",
      "properties": {
        "founded_year": {
          "type": ["integer", "null"],
          "description": "The year the company says it was founded. Return null if not stated."
        }
      },
      "required": ["founded_year"],
      "additionalProperties": false
    },
    "factCheck": true
  }'

import ContextDev from "context.dev";

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

const response = await client.web.extract({
  url: "https://stripe.com",
  schema: {
    type: "object",
    properties: {
      founded_year: {
        type: ["integer", "null"],
        description: "The year the company says it was founded. Return null if not stated.",
      },
    },
    required: ["founded_year"],
    additionalProperties: false,
  },
  factCheck: true,
});

console.log(response.data, response.urls_analyzed);

import os
from context.dev import ContextDev

client = ContextDev(api_key=os.environ["CONTEXT_DEV_API_KEY"])

response = client.web.extract(
    url="https://stripe.com",
    schema={
        "type": "object",
        "properties": {
            "founded_year": {
                "type": ["integer", "null"],
                "description": "The year the company says it was founded. Return null if not stated.",
            }
        },
        "required": ["founded_year"],
        "additionalProperties": False,
    },
    fact_check=True,
)

print(response.data, response.urls_analyzed)

require "cgi/core"
require "context_dev"

client = ContextDev::Client.new(api_key: ENV.fetch("CONTEXT_DEV_API_KEY"))

response = client.web.extract(
  url: "https://stripe.com",
  schema: {
    type: "object",
    properties: {
      founded_year: {
        type: ["integer", "null"],
        description: "The year the company says it was founded. Return null if not stated.",
      },
    },
    required: ["founded_year"],
    additionalProperties: false,
  },
  fact_check: true,
)

puts response.data
puts response.urls_analyzed

package main

import (
    "context"
    "fmt"
    "os"

    contextdev "github.com/context-dot-dev/context-go-sdk/v2"
    "github.com/context-dot-dev/context-go-sdk/v2/option"
    "github.com/context-dot-dev/context-go-sdk/v2/packages/param"
)

func main() {
    client := contextdev.NewClient(
        option.WithAPIKey(os.Getenv("CONTEXT_DEV_API_KEY")),
    )

    response, err := client.Web.Extract(context.Background(), contextdev.WebExtractParams{
        URL: "https://stripe.com",
        Schema: map[string]any{
            "type": "object",
            "properties": map[string]any{
                "founded_year": map[string]any{
                    "type": []string{"integer", "null"},
                    "description": "The year the company says it was founded. Return null if not stated.",
                },
            },
            "required": []string{"founded_year"},
            "additionalProperties": false,
        },
        FactCheck: param.NewOpt(true),
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.Data, response.URLsAnalyzed)
}

<?php

require __DIR__.'/vendor/autoload.php';

use ContextDev\Client;

$client = new Client(apiKey: getenv('CONTEXT_DEV_API_KEY'));

$response = $client->web->extract(
    url: 'https://stripe.com',
    schema: [
        'type' => 'object',
        'properties' => [
            'founded_year' => [
                'type' => ['integer', 'null'],
                'description' => 'The year the company says it was founded. Return null if not stated.',
            ],
        ],
        'required' => ['founded_year'],
        'additionalProperties' => false,
    ],
    factCheck: true,
);

print_r($response->data);
print_r($response->urlsAnalyzed);

Each successful extraction request costs 10 credits, including the pages it analyzes. This is a per-request charge, not a per-page charge. maxPages defaults to 5 and accepts 1 to 50; it caps coverage rather than guaranteeing a page count.

Define the schema

The schema controls both extraction and output validation. A good schema makes missing evidence representable.

{
  "type": "object",
  "properties": {
    "pricing_model": {
      "type": ["string", "null"],
      "description": "How the company charges customers, using wording supported by the site. Return null if unclear."
    },
    "has_free_trial": {
      "type": ["boolean", "null"],
      "description": "Whether the site explicitly offers a free trial. Return null if not stated."
    },
    "source_url": {
      "type": ["string", "null"],
      "format": "uri",
      "description": "The page URL that best supports the pricing fields."
    }
  },
  "required": ["pricing_model", "has_free_trial", "source_url"],
  "additionalProperties": false
}

Use these rules:

Put the semantic requirement in description, including what to return when evidence is absent.
Use integer for whole numbers and number only when decimals are valid.
Make uncertain fields nullable instead of asking the model to invent a placeholder.
Keep additionalProperties: false when downstream code expects a fixed contract.
Validate response.data again in your application with the same schema or source model.

Control evidence and coverage

Decision	Parameter	Behavior
Request page-supported values	`factCheck=true`	Asks the extractor to use stated facts and return null or empty values when evidence is missing. Make those values valid in your schema.
Allow derived analysis	`factCheck=false`	The model may make reasonable inferences while keeping specific facts faithful to source content. This is the default.
Point toward likely pages	`instructions`	Adds up to 2,000 characters of crawl and extraction guidance.
Cap the analyzed pages	`maxPages`	Defaults to 5; accepted range is 1 to 50.
Limit link distance	`maxDepth`	`0` uses only the starting page; omitted means no depth cap within other limits.
Include child hosts	`followSubdomains=true`	Allows relevant pages on subdomains.

Use factCheck=true for database enrichment and facts shown to users, then validate consequential results against their sources. This setting asks the model to use stated evidence; it does not independently verify the website’s claims.

Read the result

{
  "status": "ok",
  "url": "https://stripe.com",
  "urls_analyzed": [
    "https://stripe.com/about"
  ],
  "data": {
    "founded_year": 2010
  },
  "metadata": {
    "numUrls": 1,
    "maxCrawlDepth": 1,
    "numSucceeded": 1,
    "numFailed": 0,
    "numSkipped": 1,
    "numBlocked": 0
  },
  "cache_metadata": {
    "status": "miss",
    "age_ms": 0
  }
}

urls_analyzed tells you which pages contributed content. metadata distinguishes successful, failed, skipped, and blocked pages. Keep this evidence with high-impact extracted values when auditability matters. If every usable page is blocked or inaccessible, the request returns 400 WEBSITE_ACCESS_ERROR. If some pages are usable, extraction can succeed and metadata.numBlocked records the pages that were excluded.

Handle dynamic content

maxAgeMs defaults to seven days and accepts values from 0 to 30 days.
waitForMs and settleAnimations help with content that appears shortly after page load.
actions can run up to five browser actions on the starting page. Actions require a paid plan.
stopAfterMs is a soft crawl budget. timeoutOpts.milliseconds bounds the whole request; behavior: "return-partial" can return schema-valid data collected before the deadline with partial: true. Incomplete JSON that fails your schema is never returned as a success. See Timeouts and partial results.
PDF links are parsed by default. Use pdf.shouldParse=false to skip them or provide a page range.

Reuse application types

When your project already uses Zod, Pydantic, or another schema library, generate JSON Schema from that source and validate the result with the same model.

import { z } from "zod";

const Pricing = z.object({
  pricing_model: z.string().nullable(),
  has_free_trial: z.boolean().nullable(),
});

const response = await client.web.extract({
  url: "https://example.com/pricing",
  schema: z.toJSONSchema(Pricing),
  factCheck: true,
});

const pricing = Pricing.parse(response.data);

from pydantic import BaseModel, Field

class Pricing(BaseModel):
    pricing_model: str | None = Field(description="How the company charges customers.")
    has_free_trial: bool | None = Field(description="Whether the page states that a free trial exists.")

response = client.web.extract(
    url="https://example.com/pricing",
    schema=Pricing.model_json_schema(),
    fact_check=True,
)

pricing = Pricing.model_validate(response.data)

Next steps

Refreshable web datasets

Validate and save records with source history and resumable processing.

Competitor comparisons

Compare compatible facts while keeping unknown values visible.

Extract API reference

Review the complete request schema and error responses.

Scrape websites in batches

Collect raw content from many known URLs.

Monitor website changes

Check the same structured facts on a recurring schedule.

Get started

Web data

Brand data

Automation

Account and billing

Production

Extract structured data

Prerequisites

Make an extraction request

Define the schema

Control evidence and coverage

Read the result

Handle dynamic content

Reuse application types

Next steps

Refreshable web datasets

Competitor comparisons

Extract API reference

Scrape websites in batches

Monitor website changes

​Prerequisites

​Make an extraction request

​Define the schema

​Control evidence and coverage

​Read the result

​Handle dynamic content

​Reuse application types

​Next steps

Refreshable web datasets

Competitor comparisons

Extract API reference

Scrape websites in batches

Monitor website changes

Prerequisites

Make an extraction request

Define the schema

Control evidence and coverage

Read the result

Handle dynamic content

Reuse application types

Next steps