Rate Limits

import time
import requests

def lookup_with_retry(email, api_key, max_retries=3):
    url = "https://encrata.com/api/agent/lookup"
    headers = {"Authorization": f"Bearer {api_key}"}

    for attempt in range(max_retries):
        resp = requests.post(url, headers=headers, json={"email": email})

        if resp.status_code == 429:
            retry_after = int(resp.headers.get("Retry-After", 2 ** attempt))
            time.sleep(retry_after)
            continue

        return resp.json()

    raise Exception("Max retries exceeded")

async function lookupWithRetry(email, apiKey, maxRetries = 3) {
  const url = "https://encrata.com/api/agent/lookup";

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const resp = await fetch(url, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ email: email }),
    });

    if (resp.status === 429) {
      const retryAfter = parseInt(resp.headers.get("Retry-After") || 2 ** attempt);
      await new Promise((r) => setTimeout(r, retryAfter * 1000));
      continue;
    }

    return resp.json();
  }

  throw new Error("Max retries exceeded");
}

func lookupWithRetry(email, apiKey string, maxRetries int) (map[string]interface{}, error) {
    url := "https://encrata.com/api/agent/lookup"

    for attempt := 0; attempt < maxRetries; attempt++ {
        body, _ := json.Marshal(map[string]string{"email": email})
        req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
        req.Header.Set("Authorization", "Bearer "+apiKey)
        req.Header.Set("Content-Type", "application/json")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()

        if resp.StatusCode == 429 {
            retryAfter, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
            if retryAfter == 0 {
                retryAfter = 1 << attempt
            }
            time.Sleep(time.Duration(retryAfter) * time.Second)
            continue
        }

        var result map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&result)
        return result, nil
    }

    return nil, fmt.Errorf("max retries exceeded")
}