Rate Limits

#!/usr/bin/env bash
# Retry with Retry-After backoff — handles both rate limit types

API_KEY="lg_live_xxxxxxxxxxxxxxxxxxxx"
MAX_ATTEMPTS=5

attempt=1
while [ $attempt -le $MAX_ATTEMPTS ]; do
  response=$(curl -s -w "\n%{http_code}" -X POST https://api.limitguard.ai/v1/entity/check \
    -H "X-API-Key: $API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"entity_name": "Acme Corp BV", "country": "NL"}')

  http_code=$(echo "$response" | tail -n1)
  body=$(echo "$response" | head -n-1)

  if [ "$http_code" -eq 200 ]; then
    echo "$body"
    exit 0
  elif [ "$http_code" -eq 429 ]; then
    retry_after=$(curl -s -I -X POST https://api.limitguard.ai/v1/entity/check \
      -H "X-API-Key: $API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"entity_name": "Acme Corp BV", "country": "NL"}' \
      | grep -i "retry-after" | awk '{print $2}' | tr -d '\r')
    retry_after=${retry_after:-60}
    echo "Rate limited. Waiting ${retry_after}s before retry ${attempt}/${MAX_ATTEMPTS}..." >&2
    sleep "$retry_after"
  else
    echo "Error $http_code: $body" >&2
    exit 1
  fi

  attempt=$((attempt + 1))
done

echo "Exhausted $MAX_ATTEMPTS attempts." >&2
exit 1

import time
import httpx

def check_entity(
    entity_name: str,
    country: str,
    api_key: str,
    max_attempts: int = 5,
) -> dict:
    """
    POST /v1/entity/check with automatic 429 retry.

    Respects Retry-After for rate limits.
    Uses exponential backoff for 5xx transient errors.
    """
    url = "https://api.limitguard.ai/v1/entity/check"
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json",
    }
    payload = {"entity_name": entity_name, "country": country}

    for attempt in range(1, max_attempts + 1):
        response = httpx.post(url, headers=headers, json=payload, timeout=30)

        if response.status_code == 200:
            return response.json()

        if response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 60))
            remaining = response.headers.get("X-RateLimit-Remaining", "0")
            reset_at = response.headers.get("X-RateLimit-Reset", "unknown")
            print(
                f"[attempt {attempt}/{max_attempts}] Rate limited. "
                f"Remaining: {remaining}. Reset at: {reset_at}. "
                f"Waiting {retry_after}s..."
            )
            time.sleep(retry_after)
            continue

        if response.status_code >= 500:
            # Exponential backoff for transient server errors
            wait = min(2 ** attempt, 60)
            print(
                f"[attempt {attempt}/{max_attempts}] Server error "
                f"{response.status_code}. Waiting {wait}s..."
            )
            time.sleep(wait)
            continue

        # Non-retryable error (4xx other than 429)
        response.raise_for_status()

    raise RuntimeError(f"Exhausted {max_attempts} attempts for entity check.")


# Usage
result = check_entity(
    entity_name="Acme Corp BV",
    country="NL",
    api_key="lg_live_xxxxxxxxxxxxxxxxxxxx",
)
print(result)

/**
 * POST /v1/entity/check with automatic 429 retry.
 * Respects Retry-After for rate limits.
 * Uses exponential backoff for 5xx transient errors.
 */
async function checkEntity(
  entityName,
  country,
  apiKey,
  { maxAttempts = 5 } = {}
) {
  const url = "https://api.limitguard.ai/v1/entity/check";
  const headers = {
    "X-API-Key": apiKey,
    "Content-Type": "application/json",
  };
  const body = JSON.stringify({ entity_name: entityName, country });

  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const response = await fetch(url, { method: "POST", headers, body });

    if (response.ok) {
      return response.json();
    }

    if (response.status === 429) {
      const retryAfter = parseInt(
        response.headers.get("Retry-After") ?? "60",
        10
      );
      const remaining = response.headers.get("X-RateLimit-Remaining") ?? "0";
      const resetAt = response.headers.get("X-RateLimit-Reset") ?? "unknown";
      console.warn(
        `[attempt ${attempt}/${maxAttempts}] Rate limited. ` +
          `Remaining: ${remaining}. Reset at: ${resetAt}. ` +
          `Waiting ${retryAfter}s...`
      );
      await sleep(retryAfter * 1000);
      continue;
    }

    if (response.status >= 500) {
      const wait = Math.min(2 ** attempt, 60);
      console.warn(
        `[attempt ${attempt}/${maxAttempts}] Server error ${response.status}. ` +
          `Waiting ${wait}s...`
      );
      await sleep(wait * 1000);
      continue;
    }

    // Non-retryable (4xx other than 429)
    const error = await response.json().catch(() => ({}));
    throw new Error(
      `Limitguard API error ${response.status}: ${error.error ?? response.statusText}`
    );
  }

  throw new Error(`Exhausted ${maxAttempts} attempts for entity check.`);
}

// Usage
const result = await checkEntity(
  "Acme Corp BV",
  "NL",
  "lg_live_xxxxxxxxxxxxxxxxxxxx"
);
console.log(result);