Capture Screenshot

Scrape Screenshot

curl --request GET \
  --url https://api.context.dev/v1/web/screenshot \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.context.dev/v1/web/screenshot', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.context.dev/v1/web/screenshot",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.context.dev/v1/web/screenshot"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.context.dev/v1/web/screenshot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "cache_metadata": {
    "status": "hit",
    "age_ms": 1
  },
  "status": "<string>",
  "domain": "<string>",
  "screenshot": "<string>",
  "screenshotType": "viewport",
  "width": 123,
  "height": 123,
  "code": 123,
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "RATE_LIMITED",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

GET

web

screenshot

Scrape Screenshot

curl --request GET \
  --url https://api.context.dev/v1/web/screenshot \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.context.dev/v1/web/screenshot', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.context.dev/v1/web/screenshot",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.context.dev/v1/web/screenshot"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.context.dev/v1/web/screenshot")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "cache_metadata": {
    "status": "hit",
    "age_ms": 1
  },
  "status": "<string>",
  "domain": "<string>",
  "screenshot": "<string>",
  "screenshotType": "viewport",
  "width": 123,
  "height": 123,
  "code": 123,
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "RATE_LIMITED",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

{
  "message": "<string>",
  "error_code": "INTERNAL_ERROR",
  "key_metadata": {
    "credits_consumed": 123,
    "credits_remaining": 123
  }
}

1 Credit

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <API_KEY>, where <API_KEY> is your api key.

Query Parameters

domain

string

Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The domain will be automatically normalized and validated. You must provide either 'domain' or 'directUrl', but not both.

Minimum string length: 3

directUrl

string<uri>

A specific URL to screenshot directly, bypassing domain resolution (e.g., 'https://example.com/pricing'). When provided, the screenshot is taken of this exact URL. You must provide either 'domain' or 'directUrl', but not both.

fullScreenshot

enum<string>

Optional parameter to determine screenshot type. If 'true', takes a full page screenshot capturing all content. If 'false' or not provided, takes a viewport screenshot (standard browser view).

Available options:

true,

false

page

enum<string>

Optional parameter to specify which page type to screenshot. If provided, the system will scrape the domain's links and use heuristics to find the most appropriate URL for the specified page type (30 supported languages). If not provided, screenshots the main domain landing page. Only applicable when using 'domain', not 'directUrl'.

Available options:

login,

signup,

blog,

careers,

pricing,

terms,

privacy,

contact

waitForMs

integer | null

default:3000

Optional browser wait time in milliseconds after initial page load before taking the screenshot. Min: 0. Max: 30000 (30 seconds). Defaults to 3000 ms when omitted.

Required range: 0 <= x <= 30000

viewport

object

Optional browser viewport dimensions for the screenshot. Defaults to 1920x1080.

Show child attributes

Optional parameter to control cookie/consent popup handling. If 'true', we dismiss cookie banner before capture. If 'false' or not provided, captures the page without that step.

clearPopups

boolean

default:false

Optional parameter for comprehensive popup cleanup. If 'true', the browser dismisses detected cookie/consent UI and clears other detected obstructive popups and overlays before capture. If 'false' or not provided, this parameter requests no cleanup; handleCookiePopup can still request cookie/consent handling independently.

colorScheme

enum<string>

Optional parameter to choose the site's visual theme in the screenshot. Use 'light' or 'dark' when the site offers both appearances.

Available options:

light,

dark

scrollOffset

integer | null

Optional vertical scroll offset in pixels for capturing a long page in viewport-sized chunks. When provided, the full page is captured once and the returned image is the viewport-sized slice that begins at this Y offset (e.g. request scrollOffset=0, then 1080, then 2160 to walk a 1920x1080 landing page top to bottom). The final slice may be shorter than the viewport height. Takes precedence over fullScreenshot. Max: 100000.

Required range: 0 <= x <= 100000

maxAgeMs

integer | null

default:86400000

Return a cached screenshot if a prior screenshot for the same parameters exists and is younger than this many milliseconds. Defaults to 1 day (86400000 ms) when omitted. Max is 30 days (2592000000 ms). Set to 0 to always capture fresh.

Required range: 0 <= x <= 2592000000

country

enum<string>

Fetch the target page through a residential proxy in this country (ISO 3166-1 alpha-2).

Available options:

ad,

ae,

af,

ag,

ai,

al,

am,

ao,

ar,

at,

au,

aw,

az,

ba,

bb,

bd,

be,

bf,

bg,

bh,

bi,

bj,

bm,

bn,

bo,

bq,

br,

bs,

bw,

by,

bz,

ca,

cd,

cf,

cg,

ch,

ci,

cl,

cm,

cn,

co,

cr,

cv,

cw,

cy,

cz,

de,

dj,

dk,

dm,

do,

dz,

ec,

ee,

eg,

es,

et,

fi,

fj,

fr,

ga,

gb,

gd,

ge,

gf,

gg,

gh,

gm,

gn,

gp,

gq,

gr,

gt,

gu,

gw,

gy,

hk,

hn,

hr,

ht,

hu,

id,

ie,

il,

im,

in,

iq,

ir,

is,

it,

je,

jm,

jo,

jp,

ke,

kg,

kh,

kn,

kr,

kw,

ky,

kz,

la,

lb,

lc,

lk,

lr,

ls,

lt,

lu,

lv,

ly,

ma,

mc,

md,

me,

mf,

mg,

mk,

ml,

mm,

mn,

mo,

mq,

mr,

mt,

mu,

mv,

mw,

mx,

my,

mz,

na,

nc,

ne,

ng,

ni,

nl,

no,

np,

nz,

om,

pa,

pe,

pf,

pg,

ph,

pk,

pl,

pr,

ps,

pt,

py,

qa,

re,

ro,

rs,

ru,

rw,

sa,

sc,

sd,

se,

sg,

si,

sk,

sl,

sm,

sn,

so,

sr,

ss,

st,

sv,

sx,

sy,

sz,

tc,

td,

tg,

th,

tj,

tl,

tm,

tn,

tr,

tt,

tw,

tz,

ua,

ug,

us,

uy,

uz,

vc,

ve,

vg,

vi,

vn,

ye,

yt,

za,

zm,

zw

Example:

"de"

timeoutMS

integer

Optional timeout in milliseconds for the request. If the request takes longer than this value, it will be aborted with a 408 status code. Maximum allowed value is 300000ms (5 minutes).

Required range: 1 <= x <= 300000

zdr

enum<string>

default:disabled

Set to enabled to bypass shared caches and omit request and response content from retained usage logs. Requires zero data retention to be enabled for your organization (contact [email protected]), otherwise the request fails with ZDR_NOT_ENABLED. Successful ZDR responses include X-Context-ZDR: true.

Available options:

enabled,

disabled

Response

Successful response

cache_metadata

object

required

Cache outcome for this response. Composite responses are hits only when every cache-controlled fetch contributing to the output was a hit; age_ms is the oldest contributing hit.

Show child attributes

status

string

Status of the response, e.g., 'ok'

domain

string

The normalized domain that was processed

screenshot

string

Public image URL for standard requests, or an in-memory data URL when ZDR is enabled.

screenshotType

enum<string>

Type of screenshot that was captured

Available options:

viewport,

fullPage

width

integer

Width in pixels of the returned screenshot image

height

integer

Height in pixels of the returned screenshot image

code

integer

HTTP status code

key_metadata

object

Credit usage, included whenever a valid API key is provided.

Show child attributes

Web Extraction

Batch Processing

Brand Intelligence

People

News

Entity Enrichment

Monitor Infrastructure

Webhook Deliveries

Authorizations

Query Parameters

Response