Rate Limiting

Oversigt

Rate limits beskytter API'en mod misbrug og sikrer stabil performance for alle brugere. Hver API-nøgle har specifikke grænser baseret på din plan.

Hvorfor Rate Limits?

• Stabilitet: Forhindrer overbelastning af API servere
• Fair brug: Sikrer lige adgang for alle brugere
• Omkostningskontrol: Beskytter mod utilsigtet høje omkostninger
• Fejlbeskyttelse: Fanger runaway processer eller bugs

Rate Limit Niveauer

Forskellige planer har forskellige rate limits:

Rate Limit Headers

Hver API response inkluderer headers der viser din aktuelle rate limit status:

• X-RateLimit-Limit - Maksimale anmodninger pr. vindue
• X-RateLimit-Remaining - Resterende anmodninger i dette vindue
• X-RateLimit-Reset - Unix timestamp når limit nulstilles

Eksempel Headers

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1704297600

Beregn tid til reset

// PHP
$reset = $headers['X-RateLimit-Reset'];
$secondsUntilReset = $reset - time();
echo "Rate limit resets in {$secondsUntilReset} seconds";

// JavaScript
const reset = parseInt(headers['x-ratelimit-reset']);
const secondsUntilReset = reset - Math.floor(Date.now() / 1000);
console.log(`Rate limit resets in ${secondsUntilReset} seconds`);

Håndtering af 429 Too Many Requests

Når du overskrider rate limit, får du en 429 respons:

429 Response Format

HTTP/1.1 429 Too Many Requests
Retry-After: 60
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1704297660

{
  "success": false,
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Try again in 60 seconds."
  }
}

Retry-After Header

429 responses inkluderer en Retry-After header der fortæller dig hvor mange sekunder du skal vente før du prøver igen.

Retry Strategier

Best Practices

Følg disse best practices for at holde dig inden for rate limits:

Kodeeksempler

Eksempler på hvordan du håndterer rate limiting i forskellige sprog:

PHP med Retry Logic

function makeApiRequest($url, $apiKey, $maxRetries = 3) {
    $attempt = 0;

    while ($attempt < $maxRetries) {
        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => ["Authorization: Bearer {$apiKey}"],
            CURLOPT_HEADER => true,
        ]);

        $response = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
        $headers = substr($response, 0, $headerSize);
        $body = substr($response, $headerSize);

        curl_close($ch);

        if ($statusCode === 429) {
            // Extract Retry-After header
            preg_match('/Retry-After:\s*(\d+)/i', $headers, $matches);
            $retryAfter = $matches[1] ?? pow(2, $attempt);

            error_log("Rate limited. Retrying after {$retryAfter}s");
            sleep($retryAfter);
            $attempt++;
            continue;
        }

        return json_decode($body, true);
    }

    throw new Exception('Max retries exceeded');
}

Node.js med Exponential Backoff

async function makeApiRequest(url, apiKey, maxRetries = 3) {
  let attempt = 0;

  while (attempt < maxRetries) {
    try {
      const response = await fetch(url, {
        headers: { 'Authorization': `Bearer ${apiKey}` }
      });

      if (response.status === 429) {
        const retryAfter = parseInt(
          response.headers.get('retry-after') || Math.pow(2, attempt)
        );

        console.log(`Rate limited. Retrying after ${retryAfter}s`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        attempt++;
        continue;
      }

      return await response.json();
    } catch (error) {
      console.error('Request failed:', error);
      attempt++;
    }
  }

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

Python med Rate Limit Tracking

import requests
import time

def make_api_request(url, api_key, max_retries=3):
    attempt = 0
    headers = {'Authorization': f'Bearer {api_key}'}

    while attempt < max_retries:
        response = requests.get(url, headers=headers)

        if response.status_code == 429:
            retry_after = int(
                response.headers.get('retry-after', 2 ** attempt)
            )

            print(f'Rate limited. Retrying after {retry_after}s')
            time.sleep(retry_after)
            attempt += 1
            continue

        response.raise_for_status()
        return response.json()

    raise Exception('Max retries exceeded')

Overvågning af API Forbrug

Hold styr på dit API forbrug:

Fejlfinding

Almindelige rate limit problemer og løsninger:

Næste Trin

Udforsk relaterede emner: