Prefetch for Faster Response

A Brand lookup for a domain Context.dev hasn’t seen before can trigger a full crawl of the website and socials. Cold work can be materially slower than a warm response and is bounded by the five-minute platform timeout. Prefetching lets you move that work ahead of a user-facing request. Prefetching warms a cache ahead of time. Call POST /utility/prefetch as soon as you know the domain or email, then set type to "brand" before /brand/retrieve or "styleguide" before /web/styleguide. The identifier object takes exactly one of domain or email:

{ "type": "brand", "identifier": { "domain": "stripe.com" } }
{ "type": "brand", "identifier": { "email": "founder@stripe.com" } }
{ "type": "styleguide", "identifier": { "domain": "stripe.com" } }

The canonical case is a signup or onboarding form: fire a prefetch the moment the email field validates, and by the time the user submits, /brand/retrieve returns instantly. 0 Credits. Ordinary API rate limit applies. Subscriber-only.

# 1. As soon as the email field validates, fire a prefetch.
curl -X POST https://api.context.dev/v1/utility/prefetch \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "brand",
    "identifier": { "email": "founder@acme.com" }
  }'

# 2. On submit, the real call hits a warm cache.
curl -X POST https://api.context.dev/v1/brand/retrieve \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"type":"by_domain","domain":"acme.com"}'

import ContextDev from "context.dev";

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

// 1. As soon as the email field validates, fire a prefetch.
async function onEmailEntered(email: string) {
  // Fire-and-forget. Ignore errors (disposable email, etc.).
  client.utility
    .prefetch({ type: "brand", identifier: { email } })
    .catch(() => {});
}

// 2. On submit, the real call hits a warm cache.
async function onSignupComplete(email: string) {
  const domain = email.split("@")[1];
  const { brand } = await client.brand.retrieve({ type: "by_domain", domain });
  return brand;
}

import os
from context.dev import ContextDev

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

# 1. As soon as the email field validates, fire a prefetch.
def on_email_entered(email: str) -> None:
    try:
        client.utility.prefetch(type="brand", identifier={"email": email})
    except Exception:
        pass  # disposable / personal email; safe to ignore

# 2. On submit, the real call hits a warm cache.
def on_signup_complete(email: str):
    domain = email.split("@", 1)[1]
    return client.brand.retrieve(type="by_domain", domain=domain).brand

require "context_dev"

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

# 1. Fire a prefetch the moment the email validates.
def on_email_entered(client, email)
  client.utility.prefetch(type: "brand", identifier: { email: email })
rescue StandardError
  # disposable / personal email; safe to ignore
end

# 2. On submit, the real call hits a warm cache.
def on_signup_complete(client, email)
  domain = email.split("@", 2).last
  client.brand.retrieve(body: { type: :by_domain, domain: domain }).brand
end

package main

import (
    "context"
    "os"
    "strings"

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

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

    // 1. Fire a prefetch on email entry. Ignore errors.
    _, _ = client.Utility.Prefetch(ctx, contextdev.UtilityPrefetchParams{
        Type: "brand",
        Identifier: contextdev.UtilityPrefetchParamsIdentifier{
            Email: "founder@acme.com",
        },
    })

    // 2. On submit, the user-facing call lands warm.
    domain := strings.Split("founder@acme.com", "@")[1]
    _, _ = client.Brand.Get(ctx, contextdev.BrandGetParams{
        OfByDomain: &contextdev.BrandGetParamsBodyByDomain{Domain: domain},
    })
}

<?php

use ContextDev\Client;

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

// 1. As soon as the email field validates, fire a prefetch.
function onEmailEntered(string $email): void
{
    global $client;
    try {
        $client->utility->prefetch(type: 'brand', identifier: ['email' => $email]);
    } catch (Throwable) {
        // disposable / personal email; safe to ignore
    }
}

// 2. On submit, the real call hits a warm cache.
function onSignupComplete(string $email)
{
    global $client;
    $domain = explode('@', $email, 2)[1];
    return $client->brand->retrieve(type: 'by_domain', domain: $domain)->brand;
}

How the cache works

Cache TTL is up to 3 months. After that, the next call triggers a refresh in the background.
The cache is shared across the account. A prefetch from a backend job warms the cache for a user-facing call seconds later.
Prefetch is fire-and-forget. The endpoint returns immediately after queuing the work. You do not wait for the prefetch before calling /brand/retrieve or /web/styleguide.
Low timeouts fail fast on cold domains. A /brand/retrieve with timeoutMS below 10,000 ms on a domain that isn’t cached yet returns an immediate 422 (COLD_DOMAIN_TIMEOUT_TOO_LOW) instead of a guaranteed 408 — a cold crawl can never finish that fast. Prefetching is the fix: once the cache is warm, low-timeout lookups succeed.
Prefetch by email skips known free/disposable providers. Calls against gmail.com, yahoo.com, outlook.com, and the 10,000+ disposable services return a 422 (FREE_EMAIL_DETECTED or DISPOSABLE_EMAIL_DETECTED) that you can safely ignore.
Provide exactly one identifier. Sending both domain and email (or neither) returns a 400.

Latency

Prefetch moves cold crawl work ahead of the user-facing lookup. Warm-cache responses are generally faster, but exact latency depends on the target site, cache state, region, and requested work. Set timeoutMS for your application budget; the platform maximum is five minutes.

What prefetch does not do

It does not speed up general scraping endpoints. type: "styleguide" specifically warms /web/styleguide; /web/scrape/*, /web/crawl, /web/screenshot, and /brand/ai/* still fetch the target URL.
It does not preempt rate limits. Prefetch costs 0 API credits but still counts against your ordinary per-minute API limit, as does the eventual /brand/retrieve call.
It does not return brand or styleguide data. The endpoint queues the work and returns { status, message, type, domain, key_metadata }. Read the result later from /brand/retrieve or /web/styleguide.

Rate limits

How the per-plan per-minute limits interact with cached and prefetched calls.

Best practices

Where prefetching fits in the broader integration pattern.

Troubleshooting

Cold-hit timeouts and how to handle them.

Get brand data

The endpoint prefetching warms.

Get Started

Give it to your Agent

What can Context.dev do

Optimizations

Integrations

Prefetch for Faster Response

How the cache works

Latency

What prefetch does not do

Rate limits

Best practices

Troubleshooting

Get brand data

​How the cache works

​Latency

​What prefetch does not do

​Related resources

Rate limits

Best practices

Troubleshooting

Get brand data

How the cache works

Latency

What prefetch does not do

Related resources