AI API Rate Limits Compared: Every Major Provider in 2026

import openai
import time
import random

client = openai.OpenAI(
    api_key="your-crazyrouter-key",
    base_url="https://api.crazyrouter.com/v1"
)

def call_with_backoff(messages, model="gpt-5-mini", max_retries=5):
    """Call API with exponential backoff on rate limits"""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                max_tokens=1000
            )
            return response
        except openai.RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            
            # Parse retry-after header if available
            retry_after = getattr(e, 'retry_after', None)
            if retry_after:
                wait_time = retry_after
            else:
                # Exponential backoff with jitter
                wait_time = (2 ** attempt) + random.uniform(0, 1)
            
            print(f"Rate limited. Retrying in {wait_time:.1f}s (attempt {attempt + 1})")
            time.sleep(wait_time)
    
    return None

import asyncio
import time
from collections import deque

class TokenBucket:
    """Token bucket rate limiter"""
    
    def __init__(self, rpm=500, tpm=100000):
        self.rpm = rpm
        self.tpm = tpm
        self.request_times = deque()
        self.token_usage = deque()  # (timestamp, tokens)
    
    async def acquire(self, estimated_tokens=500):
        """Wait until we can make a request"""
        while True:
            now = time.time()
            
            # Clean old entries (older than 60s)
            while self.request_times and now - self.request_times[0] > 60:
                self.request_times.popleft()
            while self.token_usage and now - self.token_usage[0][0] > 60:
                self.token_usage.popleft()
            
            # Check RPM
            if len(self.request_times) >= self.rpm:
                wait = 60 - (now - self.request_times[0])
                await asyncio.sleep(max(0.1, wait))
                continue
            
            # Check TPM
            current_tokens = sum(t for _, t in self.token_usage)
            if current_tokens + estimated_tokens > self.tpm:
                wait = 60 - (now - self.token_usage[0][0])
                await asyncio.sleep(max(0.1, wait))
                continue
            
            # Record usage
            self.request_times.append(now)
            self.token_usage.append((now, estimated_tokens))
            return

# Usage
limiter = TokenBucket(rpm=500, tpm=100000)

async def rate_limited_call(messages, model="gpt-5-mini"):
    await limiter.acquire(estimated_tokens=500)
    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response

import openai

# Crazyrouter handles this automatically, but here's manual approach:
providers = [
    {
        "name": "primary",
        "client": openai.OpenAI(
            api_key="your-crazyrouter-key",
            base_url="https://api.crazyrouter.com/v1"
        ),
        "model": "gpt-5-mini"
    },
    {
        "name": "fallback_1",
        "client": openai.OpenAI(
            api_key="your-openai-key",
            base_url="https://api.openai.com/v1"
        ),
        "model": "gpt-5-mini"
    },
    {
        "name": "fallback_2",
        "client": openai.OpenAI(
            api_key="your-anthropic-key",
            base_url="https://api.anthropic.com/v1"
        ),
        "model": "claude-sonnet-4-5"
    }
]

def call_with_failover(messages, max_tokens=1000):
    """Try each provider in order"""
    for provider in providers:
        try:
            response = provider["client"].chat.completions.create(
                model=provider["model"],
                messages=messages,
                max_tokens=max_tokens
            )
            return response
        except openai.RateLimitError:
            print(f"Rate limited on {provider['name']}, trying next...")
            continue
    
    raise Exception("All providers rate limited")

import asyncio
from asyncio import Queue

class RequestQueue:
    """Queue-based rate limiter"""
    
    def __init__(self, rpm=500):
        self.queue = Queue()
        self.rpm = rpm
        self.interval = 60.0 / rpm  # seconds between requests
    
    async def worker(self):
        """Process requests from queue"""
        while True:
            func, args, kwargs, future = await self.queue.get()
            try:
                result = await asyncio.to_thread(func, *args, **kwargs)
                future.set_result(result)
            except Exception as e:
                future.set_exception(e)
            
            await asyncio.sleep(self.interval)
    
    async def submit(self, func, *args, **kwargs):
        """Submit request to queue"""
        future = asyncio.get_event_loop().create_future()
        await self.queue.put((func, args, kwargs, future))
        return await future

# Usage
queue = RequestQueue(rpm=450)  # Leave 10% headroom
asyncio.create_task(queue.worker())

# Submit requests
result = await queue.submit(
    client.chat.completions.create,
    model="gpt-5-mini",
    messages=[{"role": "user", "content": "Hello"}]
)

import openai

# Single client, automatic rate limit handling
client = openai.OpenAI(
    api_key="your-crazyrouter-key",
    base_url="https://api.crazyrouter.com/v1"
)

# Crazyrouter automatically:
# - Routes to available providers
# - Handles 429 errors with retry
# - Load balances across multiple keys
# - Provides higher effective rate limits

response = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[{"role": "user", "content": "Hello"}]
)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your-crazyrouter-key',
  baseURL: 'https://api.crazyrouter.com/v1'
});

async function callWithBackoff(messages, model = 'gpt-5-mini', maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await client.chat.completions.create({
        model,
        messages,
        max_tokens: 1000
      });
      return response;
    } catch (error) {
      if (error.status === 429 && attempt < maxRetries - 1) {
        const waitTime = Math.pow(2, attempt) + Math.random();
        console.log(`Rate limited. Retrying in ${waitTime.toFixed(1)}s`);
        await new Promise(r => setTimeout(r, waitTime * 1000));
      } else {
        throw error;
      }
    }
  }
}

#!/bin/bash
# Rate-limit-aware API call with retry

MAX_RETRIES=5
RETRY_DELAY=2

for i in $(seq 1 $MAX_RETRIES); do
  RESPONSE=$(curl -s -w "\n%{http_code}" \
    -X POST https://api.crazyrouter.com/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer your-crazyrouter-key" \
    -d '{
      "model": "gpt-5-mini",
      "messages": [{"role": "user", "content": "Hello"}]
    }')
  
  HTTP_CODE=$(echo "$RESPONSE" | tail -1)
  BODY=$(echo "$RESPONSE" | head -n -1)
  
  if [ "$HTTP_CODE" = "200" ]; then
    echo "$BODY"
    exit 0
  elif [ "$HTTP_CODE" = "429" ]; then
    echo "Rate limited. Retry $i/$MAX_RETRIES in ${RETRY_DELAY}s..."
    sleep $RETRY_DELAY
    RETRY_DELAY=$((RETRY_DELAY * 2))
  else
    echo "Error: HTTP $HTTP_CODE"
    echo "$BODY"
    exit 1
  fi
done

echo "Max retries exceeded"
exit 1

x-ratelimit-limit-requests: 500
x-ratelimit-remaining-requests: 499
x-ratelimit-reset-requests: 60s
x-ratelimit-limit-tokens: 100000
x-ratelimit-remaining-tokens: 99500