Rate limits, quota's en tiers
Op deze pagina
Rate limits, quota’s en tiers
Rate limits definiëren hoeveel verzoeken u per minuut naar de API kunt sturen. Het begrijpen en beheren van deze limieten is cruciaal om serviceonderbrekingen in productie te voorkomen. Het nachtmerriescenario is altijd hetzelfde: een integratie die vlekkeloos werkte tijdens de ontwikkeling, waarbij u drie verzoeken per minuut verstuurde, gaat live en verwerkt plotseling een wachtrij van enkele duizenden documenten. 429-fouten stromen binnen en de helft van de verwerking gaat verloren omdat de doorvoer niet was voorzien.
Het tier-systeem
OpenAI organiseert limieten in tiers (niveaus) op basis van uw factuurgeschiedenis. U kiest uw tier niet; u ontgrendelt deze door uitgaven te accumuleren en een tijdsvenster af te wachten. Deze progressie heeft een belangrijke praktische consequentie: een account dat alleen voor een klantendemo is aangemaakt, heeft niet dezelfde capaciteit als uw productieaccount, zelfs als de code identiek is.
# Tiers determine your limits
# Tier 1: After first successful payment
# Tier 2: After $50 cumulative spend + 7 days
# Tier 3: After $100 cumulative spend + 7 days
# Tier 4: After $250 cumulative spend + 14 days
# Tier 5: After $1000 cumulative spend + 30 days
# Limits increase significantly with each tier
Soorten rate limits
Drie tellers zijn gelijktijdig van toepassing en de eerste die u bereikt, blokkeert u. Het verwerken van korte teksten zal RPM verzadigen lang voordat TPM dat doet; omgekeerd zal het analyseren van lange documenten TPM uitputten, zelfs als u slechts enkele tientallen verzoeken hebt verzonden. Controleer altijd de orde van grootte van uw prompts voordat u uw parallelisme dimensioneert.
# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day
# Order of magnitude for Tier 3 (check your actual limits
# at platform.openai.com > Settings > Limits):
# RPM: 5,000 requests/minute
# TPM: 2,000,000 tokens/minute
# RPD: 10,000 requests/day
Rate limit-headers uitlezen
U hoeft uw verbruik niet te raden: elk antwoord bevat dit in zijn HTTP-headers. De SDK verbergt ze standaard om alleen het geparseerde object terug te geven, maar with_raw_response geeft u toegang tot het ruwe antwoord en parse() reconstrueert het gebruikelijke object. Een dashboard dat op deze waarden is gebaseerd, waarschuwt u terwijl u het plafond nadert, in plaats van dat u het via een fout ontdekt.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Access headers via the raw HTTP response
# Using with_raw_response mode
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM limit: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM remaining: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM remaining: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Response: {response.output_text}")
Client-side rate limiting
Het is beter om uzelf te vertragen dan om geweigerd te worden. Twee implementaties dekken de meeste behoeften.
Doorvoer beperken met een semafoor
De eerste combineert een semafoor, die het aantal gelijktijdige oproepen beperkt, met een vertraging die wordt berekend op basis van de gewenste doorvoer. In het voorbeeld worden vijftig samenvattingen tegelijk gestart, maar gaan er slechts vijf parallel verder, gescheiden door de vertraging die overeenkomt met 100 verzoeken per minuut. De aanroepende code blijft een eenvoudige asyncio.gather: alle discipline is ingekapseld in de klasse.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Limits the number of simultaneous requests."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Delay between each request
async def call(self, prompt: str) -> str:
async with self.semaphore:
await asyncio.sleep(self.delay)
response = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
async def batch_processing():
limiter = RateLimiter(max_concurrent=5, rpm=100)
prompts = [f"Summarize concept {i}" for i in range(50)]
tasks = [limiter.call(p) for p in prompts]
results = await asyncio.gather(*tasks)
for i, r in enumerate(results):
print(f"Result {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Eenvoudige token bucket
De token bucket is flexibeler omdat deze bursts toestaat. De bucket vult zich met een constante snelheid en leegt bij elke oproep: als uw applicatie een minuut inactief is geweest, kan deze vijftig verzoeken lang weer op volle snelheid herstarten, om daarna natuurlijk terug te vallen op de vulsnelheid. Dit is precies het gedrag dat u wilt voor een service die afwisselt tussen pieken en dalen, en het werkt in multithread-omgevingen dankzij de lock.
import time
import threading
class TokenBucket:
"""Rate limiter based on the token bucket algorithm."""
def __init__(self, tokens_per_second: float, max_capacity: int):
self.tokens_per_second = tokens_per_second
self.max_capacity = max_capacity
self.tokens = max_capacity
self.last_refill = time.monotonic()
self.lock = threading.Lock()
def wait(self, tokens_needed: int = 1):
"""Waits until enough tokens are available."""
while True:
with self.lock:
now = time.monotonic()
elapsed = now - self.last_refill
self.tokens = min(
self.max_capacity,
self.tokens + elapsed * self.tokens_per_second
)
self.last_refill = now
if self.tokens >= tokens_needed:
self.tokens -= tokens_needed
return
time.sleep(0.1)
# Usage: max 50 requests per minute
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)
def limited_call(prompt: str) -> str:
bucket.wait(1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
Strategieën voor hoge volumes
1. Verdelen over meerdere projecten
Elk project heeft zijn eigen rate limits. Als u uw plafond bereikt terwijl u zich al op een hoge tier bevindt, vermenigvuldigt het verdelen van oproepen over meerdere projecten mechanisch de beschikbare capaciteit. De onderstaande round-robin illustreert het principe; verplaats de cyclus in productie naar buiten de functie, zodat deze tussen oproepen door persisteert.
from openai import OpenAI
# Each project has its own rate limits
clients = [
OpenAI(project="proj-aaaa"), # Project 1
OpenAI(project="proj-bbbb"), # Project 2
OpenAI(project="proj-cccc"), # Project 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Distributes calls across multiple projects."""
import itertools
client_cycle = itertools.cycle(clients)
client = next(client_cycle)
return client.responses.create(
model="gpt-5.6-terra",
input=prompt
).output_text
2. Gebruik het juiste model voor het juiste volume
Modelkeuze is ook een capaciteitsbeslissing, niet alleen een kwaliteitsbeslissing. Door de zwaarste modellen te reserveren voor kritieke taken en volume door te sturen naar een model met hogere limieten, maakt u doorvoer vrij waar u deze echt nodig hebt.
# Economy models (gpt-5.6-luna) have the highest limits
# Use them for high-volume tasks
# The flagship model (gpt-5.6-sol) has the lowest limits
# Reserve it for critical tasks
3. Wachtrijen
Tot slot ontkoppelt een wachtrij de productie van verzoeken van de consumptie. Een enkele thread haalt items met een vast tempo uit de wachtrij, terwijl de rest van de applicatie vrij kan indienen; de aanroeper blokkeert op een event totdat het resultaat arriveert. Dit patroon absorbeert pieken zonder ooit de geconfigureerde doorvoer te overschrijden.
import queue
import threading
class APIQueue:
"""Queue for API calls."""
def __init__(self, rpm: int = 100):
self.queue = queue.Queue()
self.delay = 60.0 / rpm
self.running = True
self.worker = threading.Thread(target=self._process, daemon=True)
self.worker.start()
def _process(self):
while self.running:
try:
prompt, future = self.queue.get(timeout=1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
future["result"] = response.output_text
future["event"].set()
time.sleep(self.delay)
except queue.Empty:
continue
def submit(self, prompt: str) -> str:
future = {"result": None, "event": threading.Event()}
self.queue.put((prompt, future))
future["event"].wait()
return future["result"]
Belangrijkste punten
- Rate limits zijn gelijktijdig van toepassing op RPM, TPM en RPD
- Uw tier bepaalt uw limieten; deze stijgt met uw cumulatieve uitgaven
- Lees
x-ratelimit-*headers om uw verbruik in realtime te kennen - Implementeer een client-side rate limiter om 429-fouten te voorkomen
- Verdeel de belasting over projecten voor hoge volumes
- Luna biedt de hoogste rate limits voor bulkverwerking