Codestin Search App

Scrape content, retrieve brand and design data, or start a background job. Choose an API below and try it with cURL or the TypeScript, Python, Ruby, Go, or PHP SDK. Prefer to have an agent set this up? Copy the setup prompt in Agent Quickstart.

1. Get an API key

Create an account, then copy a secret API key from API Keys in the dashboard. Set the key in the shell where you’ll run your request:

export CONTEXT_DEV_API_KEY="ctxt_secret_..."

Keep this key on your server. Do not commit it or include it in browser code.

2. Choose your client

cURL needs no package installation. Choose your language below; the SDK setup guides cover runtime requirements. These shell commands work on macOS, Linux, or WSL.

curl --version

npm install context.dev
npm install --save-dev tsx

python3 -m venv .venv
source .venv/bin/activate
python -m pip install context.dev

gem install context.dev

go mod init example.com/context-quickstart
go get github.com/context-dot-dev/context-go-sdk/v2

composer require context-dev/context-dev-php guzzlehttp/guzzle

Skip go mod init if your project already has a go.mod. Save the SDK example in a file and run it with the matching command:

Client	File	Run
cURL	No file needed	Paste the command into your terminal.
TypeScript	`example.mts`	`npx tsx example.mts`
Python	`example.py`	`python example.py`
Ruby	`example.rb`	`ruby example.rb`
Go	`main.go`	`go run main.go`
PHP	`example.php`, beside `vendor`	`php example.php`

3. Make a request

Choose an API, then your language.

Read example.com and keep its main content. A successful request costs 1 credit.

curl --get https://api.context.dev/v1/web/scrape/markdown \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "useMainContentOnly=true"

import ContextDev from "context.dev";

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

const response = await client.web.webScrapeMd({
  url: "https://example.com",
  useMainContentOnly: true,
});

console.log(response.markdown);

import os
from context.dev import ContextDev

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

response = client.web.web_scrape_md(
    url="https://example.com",
    use_main_content_only=True,
)

print(response.markdown)

require "cgi/core"
require "context_dev"

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

response = client.web.web_scrape_md(
  url: "https://example.com",
  use_main_content_only: true,
)

puts response.markdown

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.WebScrapeMd(context.Background(), contextdev.WebWebScrapeMdParams{
        URL:                "https://example.com",
        UseMainContentOnly: param.NewOpt(true),
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Markdown)
}

<?php

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

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

$response = $client->web->webScrapeMd(
    url: "https://example.com",
    useMainContentOnly: true,
);

echo $response->markdown, PHP_EOL;

The SDK examples print the page’s Markdown, beginning with the heading Example Domain. The cURL request returns JSON; this excerpt shows the fields to check:

Response excerpt

{
  "success": true,
  "url": "https://example.com",
  "markdown": "# Example Domain\n\nThis domain is for use in documentation examples without needing permission."
}

Page text can change. The full response also includes content length, page metadata, cache information, and credit usage.Markdown requests may return cached results up to one day old by default. Set maxAgeMs=0 when you need a new fetch. See Scrape for content selection and freshness options.

Ask for one field from stripe.com using a JSON Schema. This request can analyze up to 5 relevant pages and combines them into one result. A successful extraction costs 10 credits total, not 10 per page.

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
    },
    "maxPages": 5,
    "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,
  },
  maxPages: 5,
  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,
    },
    max_pages=5,
    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,
  },
  max_pages: 5,
  fact_check: true,
)

pp response.data, 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,
        },
        MaxPages:  param.NewOpt(int64(5)),
        FactCheck: param.NewOpt(true),
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Data, response.URLsAnalyzed)
}

<?php

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

$client = new ContextDev\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,
    ],
    maxPages: 5,
    factCheck: true,
);

print_r([$response->data, $response->urlsAnalyzed]);

The SDK examples print the extracted object and source pages. This illustrative response shows the fields to inspect; values and URLs depend on the available website content:

Response excerpt

{
  "status": "ok",
  "data": { "founded_year": 2010 },
  "urls_analyzed": ["https://stripe.com/about"]
}

factCheck asks the model to use stated facts; a missing year can be null. Validate data with your schema and keep urls_analyzed for source review. These URLs identify analyzed pages, not a citation for each field.See Extract for single-page extraction, coverage, and freshness controls.

Find image sources referenced by a webpage. This request costs 1 credit.

curl --get https://api.context.dev/v1/web/scrape/images \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --data-urlencode "url=https://stripe.com"

import ContextDev from "context.dev";

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

const page = await client.web.webScrapeImages({
  url: "https://stripe.com",
});

console.log(page.images);

import os
from context.dev import ContextDev

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

page = client.web.web_scrape_images(url="https://stripe.com")
print(page.images)

require "cgi/core"
require "context_dev"

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

page = client.web.web_scrape_images(url: "https://stripe.com")
puts page.images

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"
)

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

    page, err := client.Web.WebScrapeImages(context.Background(), contextdev.WebWebScrapeImagesParams{
        URL: "https://stripe.com",
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(page.Images)
}

<?php

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

use ContextDev\Client;

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

$page = $client->web->webScrapeImages(url: 'https://stripe.com');
print_r($page->images);

The images array contains the discovered assets; it may be empty. See the image guide for dimensions, hosted copies, and visual classification.

List up to 50 customer-page URLs from Stripe’s public sitemaps without rendering each page. This request costs 1 credit.

curl --get https://api.context.dev/v1/web/scrape/sitemap \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --data-urlencode "domain=stripe.com" \
  --data-urlencode "maxLinks=50" \
  --data-urlencode "urlRegex=/customers/"

import ContextDev from "context.dev";

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

const sitemap = await client.web.webScrapeSitemap({
  domain: "stripe.com",
  maxLinks: 50,
  urlRegex: "/customers/",
});

console.log(sitemap.urls);

import os
from context.dev import ContextDev

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

sitemap = client.web.web_scrape_sitemap(
    domain="stripe.com",
    max_links=50,
    url_regex="/customers/",
)

print(sitemap.urls)

require "cgi/core"
require "context_dev"

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

sitemap = client.web.web_scrape_sitemap(
  domain: "stripe.com",
  max_links: 50,
  url_regex: "/customers/",
)

puts sitemap.urls

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")),
    )

    sitemap, err := client.Web.WebScrapeSitemap(context.Background(), contextdev.WebWebScrapeSitemapParams{
        Domain: "stripe.com",
        MaxLinks: param.NewOpt[int64](50),
        URLRegex: param.NewOpt("/customers/"),
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(sitemap.URLs)
}

<?php

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

use ContextDev\Client;

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

$sitemap = $client->web->webScrapeSitemap(
    domain: 'stripe.com',
    maxLinks: 50,
    urlRegex: '/customers/',
);

print_r($sitemap->urls);

Read the URL list from urls and check meta for sitemap fetches and errors. The sitemap guide covers filtering and discovery limits.

Look up stripe.com and read the company’s name. A successful request costs 10 credits.

curl https://api.context.dev/v1/brand/retrieve \
  --request POST \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "type": "by_domain",
    "domain": "stripe.com"
  }'

import ContextDev from "context.dev";

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

const response = await client.brand.retrieve({
  type: "by_domain",
  domain: "stripe.com",
});

console.log(response.brand?.title);

import os
from context.dev import ContextDev

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

response = client.brand.retrieve(
    type="by_domain",
    domain="stripe.com",
)

print(response.brand.title if response.brand else None)

require "cgi/core"
require "context_dev"

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

response = client.brand.retrieve(
  body: {
    "type" => "by_domain",
    "domain" => "stripe.com",
  }
)

puts response.brand&.title

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"
)

func main() {
    client := contextdev.NewClient(option.WithAPIKey(os.Getenv("CONTEXT_DEV_API_KEY")))
    response, err := client.Brand.Get(context.Background(), contextdev.BrandGetParams{
        OfByDomain: &contextdev.BrandGetParamsBodyByDomain{
            Domain: "stripe.com",
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Brand.Title)
}

<?php

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

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

// Use the SDK's low-level request: its generated Brand helper cannot express this lookup.
$response = $client->request(
    method: 'post',
    path: 'brand/retrieve',
    body: [
      "type" => "by_domain",
      "domain" => "stripe.com",
    ],
);
$data = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
echo $data['brand']['title'] ?? 'No match', PHP_EOL;

PHP SDK 2.14.0 uses its low-level request method because its generated Brand helper cannot express this lookup. Authentication and retries are still handled by the SDK.The SDK examples print Stripe. The cURL request returns JSON; this illustrative excerpt shows the matched company and a discovered brand color:

Response excerpt

{
  "status": "ok",
  "brand": {
    "domain": "stripe.com",
    "title": "Stripe",
    "colors": [{ "hex": "#635BFF", "name": "Indigo" }]
  }
}

Use brand.colors to personalize an interface and brand.logos to find image assets. The full response can also include descriptions, social links, cache information, and credit usage. Values can change, and optional fields or arrays may be empty.See Brand lookup for other identifiers, response fields, and refresh rules.

Extract observed colors, typography, and component styles. This request costs 10 credits.

curl --get https://api.context.dev/v1/web/styleguide \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --data-urlencode "domain=stripe.com" \
  --data-urlencode "colorScheme=light"

import ContextDev from "context.dev";

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

const response = await client.web.extractStyleguide({
  domain: "stripe.com",
  colorScheme: "light",
});

console.log(response.styleguide?.colors);
console.log(response.styleguide?.typography.headings.h1);

import os
from context.dev import ContextDev

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

response = client.web.extract_styleguide(
    domain="stripe.com",
    color_scheme="light",
)

print(response.styleguide.colors)
print(response.styleguide.typography.headings.h1)

require "cgi/core"
require "context_dev"

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

response = client.web.extract_styleguide(
  domain: "stripe.com",
  color_scheme: :light
)

puts response.styleguide.colors.inspect
puts response.styleguide.typography.headings.h1.inspect

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"
)

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

    response, err := client.Web.ExtractStyleguide(
        context.Background(),
        contextdev.WebExtractStyleguideParams{
            Domain: contextdev.String("stripe.com"),
            ColorScheme: contextdev.WebExtractStyleguideParamsColorSchemeLight,
        },
    )
    if err != nil {
        panic(err)
    }

    fmt.Println(response.Styleguide.Colors)
    fmt.Println(response.Styleguide.Typography.Headings.H1)
}

<?php

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

use ContextDev\Client;

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

$response = $client->web->extractStyleguide(
    domain: 'stripe.com',
    colorScheme: 'light',
);

var_dump($response->styleguide->colors);
var_dump($response->styleguide->typography->headings->h1);

Inspect styleguide.colors and styleguide.typography. These are observations of the rendered page, not an official design-system specification. See the styleguide guide for the full result.

Submit two URLs for background scraping. Each successful page costs 1 credit.

curl https://api.context.dev/v1/batch/submit \
  --request POST \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "input": {
    "mode": "scrape",
    "data": {
      "format": "markdown",
      "urls": [
        {
          "url": "https://docs.context.dev/introduction"
        },
        {
          "url": "https://docs.context.dev/quickstart"
        }
      ]
    }
  }
}'

import ContextDev from "context.dev";

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

const response = await client.batch.submit({
  input: {
    mode: "scrape",
    data: {
      format: "markdown",
      urls: [
        {
          url: "https://docs.context.dev/introduction",
        },
        {
          url: "https://docs.context.dev/quickstart",
        },
      ],
    },
  },
});
console.log(response.id);

import os
from context.dev import ContextDev

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

response = client.batch.submit(
    input={
        "mode": "scrape",
        "data": {
            "format": "markdown",
            "urls": [
                {
                    "url": "https://docs.context.dev/introduction",
                },
                {
                    "url": "https://docs.context.dev/quickstart",
                },
            ],
        },
    },
)
print(response.id)

require "cgi/core"
require "context_dev"

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

response = client.batch.submit(
  input: {
    mode: "scrape",
    data: {
      format: "markdown",
      urls: [
        {
          url: "https://docs.context.dev/introduction",
        },
        {
          url: "https://docs.context.dev/quickstart",
        },
      ],
    },
  },
)
puts response.id

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"
)

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

    response, err := client.Batch.Submit(context.Background(), contextdev.BatchSubmitParams{
        Input: contextdev.BatchSubmitParamsInputUnion{
            OfScrape: &contextdev.BatchSubmitParamsInputScrape{
                Mode: "scrape",
                Data: contextdev.BatchSubmitParamsInputScrapeDataUnion{
                    OfMarkdown: &contextdev.BatchSubmitParamsInputScrapeDataMarkdown{
                        Format: "markdown",
                        URLs: []contextdev.BatchSubmitParamsInputScrapeDataMarkdownURL{
                            contextdev.BatchSubmitParamsInputScrapeDataMarkdownURL{
                                URL: "https://docs.context.dev/introduction",
                            },
                            contextdev.BatchSubmitParamsInputScrapeDataMarkdownURL{
                                URL: "https://docs.context.dev/quickstart",
                            },
                        },
                    },
                },
            },
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.ID)
}

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

use ContextDev\Client;

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

$response = $client->batch->submit(
    input: [
        "mode" => "scrape",
        "data" => [
            "format" => "markdown",
            "urls" => [
                [
                    "url" => "https://docs.context.dev/introduction",
                ],
                [
                    "url" => "https://docs.context.dev/quickstart",
                ],
            ],
        ],
    ],
);
echo $response->id, PHP_EOL;

The response contains a job id, not completed page content. Save it, then poll for completion and read the results.

Check a pricing page for text changes every day. No webhook is required.

This creates an ongoing monitor. Its initial and scheduled runs consume credits. Pause or delete it when you finish testing.

curl https://api.context.dev/v1/monitors \
  --request POST \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "name": "Pricing changes",
  "target": {
    "type": "page",
    "url": "https://stripe.com/pricing",
    "normalize_whitespace": true
  },
  "change_detection": {
    "type": "exact"
  },
  "schedule": {
    "type": "interval",
    "frequency": 1,
    "unit": "days"
  }
}'

import ContextDev from "context.dev";

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

const response = await client.monitors.create({
  name: "Pricing changes",
  target: {
    type: "page",
    url: "https://stripe.com/pricing",
    normalize_whitespace: true,
  },
  change_detection: {
    type: "exact",
  },
  schedule: {
    type: "interval",
    frequency: 1,
    unit: "days",
  },
});
console.log(response.id, response.initial_run_id);

import os
from context.dev import ContextDev

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

response = client.monitors.create(
    name="Pricing changes",
    target={
        "type": "page",
        "url": "https://stripe.com/pricing",
        "normalize_whitespace": True,
    },
    change_detection={
        "type": "exact",
    },
    schedule={
        "type": "interval",
        "frequency": 1,
        "unit": "days",
    },
)
print(response.id, response.initial_run_id)

require "cgi/core"
require "context_dev"

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

response = client.monitors.create(
  name: "Pricing changes",
  target: {
    type: "page",
    url: "https://stripe.com/pricing",
    normalize_whitespace: true,
  },
  change_detection: {
    type: "exact",
  },
  schedule: {
    type: "interval",
    frequency: 1,
    unit: "days",
  },
)
puts response.id, response.initial_run_id

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"
)

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

    response, err := client.Monitors.New(context.Background(), contextdev.MonitorNewParams{
        Name: "Pricing changes",
        Target: contextdev.MonitorNewParamsTargetUnion{
            OfPage: &contextdev.MonitorNewParamsTargetPage{
                Type:                "page",
                URL:                 "https://stripe.com/pricing",
                NormalizeWhitespace: contextdev.Bool(true),
            },
        },
        ChangeDetection: contextdev.MonitorNewParamsChangeDetectionUnion{
            OfExact: &contextdev.MonitorNewParamsChangeDetectionExact{
                Type: "exact",
            },
        },
        Schedule: contextdev.MonitorNewParamsSchedule{
            Type:      "interval",
            Frequency: 1,
            Unit:      "days",
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.ID, response.InitialRunID)
}

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

use ContextDev\Client;

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

$response = $client->monitors->create(
    name: "Pricing changes",
    target: [
        "type" => "page",
        "url" => "https://stripe.com/pricing",
        "normalizeWhitespace" => true,
    ],
    changeDetection: [
        "type" => "exact",
    ],
    schedule: [
        "type" => "interval",
        "frequency" => 1,
        "unit" => "days",
    ],
);
echo $response->id, " ", $response->initialRunID, PHP_EOL;

Save id and initial_run_id. The first run establishes a baseline. Use the monitoring guide to read later runs and changes.

If the request fails

For 401, check that the key is set in the same shell or process as your request. For 400 or 422, read the response message and error_code, when present, before retrying. For 429, wait for the Retry-After window. Troubleshooting covers other errors, including blocked websites, missing brands, and timeouts.

Keep building

Extract structured data

Extract fields from a website into your JSON Schema.

Crawl a website

Follow links and collect content from multiple pages.

Retrieve brand data

Look up company logos, colors, and profile details.

Production checklist

Prepare your integration for retries, missing data, and usage limits.

API reference

Check all request parameters and response fields.

Get started

Web data

Brand data

Automation

Production

Human Quickstart

1. Get an API key

2. Choose your client

3. Make a request

If the request fails

Keep building

Extract structured data

Crawl a website

Retrieve brand data

Production checklist

API reference

​1. Get an API key

​2. Choose your client

​3. Make a request

​If the request fails

​Keep building

Extract structured data

Crawl a website

Retrieve brand data

Production checklist

API reference

1. Get an API key

2. Choose your client

3. Make a request

If the request fails

Keep building