Handle Rate Limits

import ContextDev from "context.dev";

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

const CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
const cache = new Map<string, { data: unknown; at: number }>();

async function getBrand(domain: string) {
  const hit = cache.get(domain);
  if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.data;

  const { brand } = await client.brand.retrieve({ type: "by_domain", domain });
  cache.set(domain, { data: brand, at: Date.now() });
  return brand;
}

import os
import time
from context.dev import ContextDev

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

CACHE_TTL_S = 30 * 24 * 60 * 60
_cache: dict[str, tuple[float, dict]] = {}

def get_brand(domain: str):
    hit = _cache.get(domain)
    if hit and time.time() - hit[0] < CACHE_TTL_S:
        return hit[1]
    brand = client.brand.retrieve(type="by_domain", domain=domain).brand
    _cache[domain] = (time.time(), brand)
    return brand

require "context_dev"

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

CACHE_TTL_S = 30 * 24 * 60 * 60
@cache = {}

def get_brand(client, domain)
  hit = @cache[domain]
  return hit[:data] if hit && Time.now.to_i - hit[:at] < CACHE_TTL_S

  brand = client.brand.retrieve(body: { type: :by_domain, domain: domain }).brand
  @cache[domain] = { data: brand, at: Time.now.to_i }
  brand
end

get_brand(client, "acme.com")

package main

import (
    "context"
    "os"
    "sync"
    "time"

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

var (
    cacheMu sync.Mutex
    cache   = map[string]struct {
        data any
        at   time.Time
    }{}
    cacheTTL = 30 * 24 * time.Hour
    client   = contextdev.NewClient(option.WithAPIKey(os.Getenv("CONTEXT_DEV_API_KEY")))
)

func GetBrand(ctx context.Context, domain string) (any, error) {
    cacheMu.Lock()
    if hit, ok := cache[domain]; ok && time.Since(hit.at) < cacheTTL {
        cacheMu.Unlock()
        return hit.data, nil
    }
    cacheMu.Unlock()

    r, err := client.Brand.Get(ctx, contextdev.BrandGetParams{
        OfByDomain: &contextdev.BrandGetParamsBodyByDomain{Domain: domain},
    })
    if err != nil {
        return nil, err
    }
    cacheMu.Lock()
    cache[domain] = struct {
        data any
        at   time.Time
    }{r.Brand, time.Now()}
    cacheMu.Unlock()
    return r.Brand, nil
}

<?php

use ContextDev\Client;

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

const CACHE_TTL_S = 30 * 24 * 60 * 60;
$cache = [];

function getBrand(string $domain)
{
    global $client, $cache;

    if (isset($cache[$domain]) && time() - $cache[$domain]['at'] < CACHE_TTL_S) {
        return $cache[$domain]['data'];
    }

    $brand = $client->brand->retrieve(type: 'by_domain', domain: $domain)->brand;
    $cache[$domain] = ['data' => $brand, 'at' => time()];
    return $brand;
}

async function retrieveWithBackoff(domain: string, maxAttempts = 4) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await client.brand.retrieve({ type: "by_domain", domain });
    } catch (err: any) {
      if (err.status !== 429 || attempt === maxAttempts - 1) throw err;

      const retryAfter = Number(err.headers?.["retry-after"]);
      const delayMs = retryAfter > 0 ? retryAfter * 1000 : Math.pow(2, attempt) * 1000;
      await new Promise((r) => setTimeout(r, delayMs));
    }
  }
}

import time
from context.dev import APIStatusError

def retrieve_with_backoff(domain: str, max_attempts: int = 4):
    for attempt in range(max_attempts):
        try:
            return client.brand.retrieve(type="by_domain", domain=domain)
        except APIStatusError as e:
            if e.status_code != 429 or attempt == max_attempts - 1:
                raise
            retry_after = int(e.response.headers.get("Retry-After", 0))
            time.sleep(retry_after if retry_after > 0 else 2 ** attempt)

def retrieve_with_backoff(client, domain, max_attempts: 4)
  attempt = 0
  begin
    client.brand.retrieve(body: { type: :by_domain, domain: domain })
  rescue ContextDev::Errors::APIStatusError => e
    raise unless e.status == 429 && attempt < max_attempts - 1
    retry_after = e.headers["retry-after"].to_i
    sleep(retry_after.positive? ? retry_after : 2**attempt)
    attempt += 1
    retry
  end
end

import (
    "context"
    "errors"
    "fmt"
    "math"
    "strconv"
    "time"

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

func RetrieveWithBackoff(ctx context.Context, domain string) (*contextdev.BrandGetResponse, error) {
    const maxAttempts = 4
    for attempt := 0; attempt < maxAttempts; attempt++ {
        r, err := client.Brand.Get(ctx, contextdev.BrandGetParams{
            OfByDomain: &contextdev.BrandGetParamsBodyByDomain{Domain: domain},
        })
        if err == nil {
            return r, nil
        }
        var apiErr *contextdev.Error
        if !errors.As(err, &apiErr) || apiErr.StatusCode != 429 || attempt == maxAttempts-1 {
            return nil, err
        }
        delay := time.Duration(math.Pow(2, float64(attempt))) * time.Second
        if secs, parseErr := strconv.Atoi(apiErr.Response.Header.Get("Retry-After")); parseErr == nil && secs > 0 {
            delay = time.Duration(secs) * time.Second
        }
        time.Sleep(delay)
    }
    return nil, fmt.Errorf("unreachable")
}

<?php

use ContextDev\Client;
use ContextDev\Core\Exceptions\APIStatusException;

function retrieveWithBackoff(string $domain, int $maxAttempts = 4)
{
    global $client;

    for ($attempt = 0; $attempt < $maxAttempts; $attempt++) {
        try {
            return $client->brand->retrieve(
                type: 'by_domain',
                domain: $domain,
                requestOptions: ['maxRetries' => 0],
            );
        } catch (APIStatusException $e) {
            if ($e->status !== 429 || $attempt === $maxAttempts - 1) {
                throw $e;
            }
            $retryAfter = (int) ($e->response?->getHeaderLine('Retry-After') ?: 0);
            sleep($retryAfter > 0 ? $retryAfter : 2 ** $attempt);
        }
    }

    throw new RuntimeException('unreachable');
}