Rategrænser, kvoter og niveauer
På denne side
Rategrænser, kvoter og niveauer
Rategrænser definerer, hvor mange forespørgsler du kan sende til API’et pr. minut. Det er afgørende at forstå og håndtere disse grænser for at undgå afbrydelser i produktionen. Mareridtscenariet er altid det samme: En integration, der fungerede upåklageligt under udvikling, hvor du sendte tre forespørgsler i minuttet, går live og skal pludselig behandle en kø på flere tusinde dokumenter. 429-fejl strømmer ind, og halvdelen af behandlingen går tabt, fordi gennemstrømningen ikke var forudset.
Niveausystemet
OpenAI organiserer grænser i niveauer baseret på din betalingshistorik. Du vælger ikke dit niveau selv; du låser det op ved at akkumulere forbrug og vente på, at et bestemt tidsvindue udløber. Denne progression har en vigtig praktisk konsekvens: En konto, der kun er oprettet til en kundedemo, vil ikke have samme kapacitet som din produktionskonto, selvom koden er identisk.
# Niveauer bestemmer dine grænser
# Niveau 1: Efter første succesfulde betaling
# Niveau 2: Efter $50 samlet forbrug + 7 dage
# Niveau 3: Efter $100 samlet forbrug + 7 dage
# Niveau 4: Efter $250 samlet forbrug + 14 dage
# Niveau 5: Efter $1000 samlet forbrug + 30 dage
# Grænserne stiger markant med hvert niveau
Typer af rategrænser
Tre tællere gælder samtidigt, og den første, du rammer, blokerer dig. Behandling af korte tekster vil mætte RPM (forespørgsler pr. minut) længe før TPM (tokens pr. minut); omvendt vil analyse af lange dokumenter udtømme TPM, selvom du kun har sendt et par dusin forespørgsler. Tjek altid størrelsesordenen på dine prompts, før du dimensionerer din parallelisering.
# 1. RPM — Requests Per Minute (Forespørgsler pr. minut)
# 2. TPM — Tokens Per Minute (Tokens pr. minut)
# 3. RPD — Requests Per Day (Forespørgsler pr. dag)
# Størrelsesorden for Niveau 3 (tjek dine faktiske grænser
# på platform.openai.com > Settings > Limits):
# RPM: 5.000 forespørgsler/minut
# TPM: 2.000.000 tokens/minut
# RPD: 10.000 forespørgsler/dag
Læsning af rategrænse-headers
Du behøver ikke gætte på dit forbrug: Hvert svar bærer disse oplysninger i sine HTTP-headers. SDK’et skjuler dem som standard for kun at returnere det parsede objekt, men with_raw_response giver dig adgang til det rå svar, og parse() genopbygger det sædvanlige objekt. Et dashboard fodret med disse værdier advarer dig, når du nærmer dig loftet, i stedet for at lade dig opdage det via en fejl.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Få adgang til headers via det rå HTTP-svar
# Brug af with_raw_response-tilstand
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM-grænse: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM tilbageværende: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM-grænse: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM tilbageværende: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Nulstilling om: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Svar: {response.output_text}")
Ratebegrænsning på klientsiden
Det er bedre at drosle sig selv end at blive afvist. To implementeringer dækker de fleste behov.
Begrænsning af gennemstrømning med en semafør
Den første kombinerer en semafør, som begrænser antallet af samtidige kald, med en forsinkelse beregnet ud fra mål-gennemstrømningen. I eksemplet lanceres halvtreds summeringer på én gang, men kun fem kører parallelt, adskilt af den forsinkelse, der svarer til 100 forespørgsler pr. minut. Den kaldende kode forbliver et simpelt asyncio.gather: al disciplin er kapslet i klassen.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Begrænser antallet af samtidige forespørgsler."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Forsinkelse mellem hver forespørgsel
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"Opsummer koncept {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"Resultat {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Simpel token-spand
Token-spanden er mere fleksibel, fordi den tillader udsving (bursts). Spanden fyldes med en konstant hastighed og tømmes ved hvert kald: Hvis din applikation har været inaktiv i et minut, kan den genstarte med fuld hastighed i halvtreds forespørgsler og derefter naturligt falde tilbage til påfyldningshastigheden. Dette er præcis den adfærd, du ønsker for en tjeneste, der skifter mellem toppe og lavpunkter, og det fungerer i multitrådede miljøer takket være låsen.
import time
import threading
class TokenBucket:
"""Ratebegrænser baseret på token-spand-algoritmen."""
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):
"""Venter, indtil nok tokens er tilgængelige."""
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)
# Brug: maks. 50 forespørgsler pr. minut
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
Strategier for store volumener
1. Fordeling på flere projekter
Hvert projekt har sine egne rategrænser. Hvis du rammer dit loft, mens du allerede er på et højt niveau, vil fordeling af kald på tværs af flere projekter mekanisk gange den tilgængelige kapacitet. Round-robin-eksemplet nedenfor illustrerer princippet; i produktion bør du flytte cyklussen uden for funktionen, så den vedbliver mellem kald.
from openai import OpenAI
# Hvert projekt har sine egne rategrænser
clients = [
OpenAI(project="proj-aaaa"), # Projekt 1
OpenAI(project="proj-bbbb"), # Projekt 2
OpenAI(project="proj-cccc"), # Projekt 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Fordeler kald på tværs af flere projekter."""
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. Brug den rigtige model til det rigtige volumen
Valg af model er også en kapacitetsbeslutning, ikke kun en kvalitetsbeslutning. Ved at reservere de tungeste modeller til kritiske opgaver og lede volumen mod en model med højere grænser, frigør du gennemstrømning, hvor du faktisk har brug for den.
# Økonomimodeller (gpt-5.6-luna) har de højeste grænser
# Brug dem til opgaver med stort volumen
# Flagship-modellen (gpt-5.6-sol) har de laveste grænser
# Reserver den til kritiske opgaver
3. Køsystemer
Endelig afkobler køsystemer produktionen af forespørgsler fra forbruget. En enkelt tråd dequeuer med en fast hastighed, mens resten af applikationen indsender frit; den kaldende blokerer på en event, indtil resultatet ankommer. Dette mønster absorberer toppe uden nogensinde at overskride den konfigurerede gennemstrømning.
import queue
import threading
class APIQueue:
"""Kø til API-kald."""
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"]
Vigtige pointer
- Rategrænser gælder samtidigt for RPM, TPM og RPD
- Dit niveau bestemmer dine grænser – det stiger med dit samlede forbrug
- Læs
x-ratelimit-*-headers for at kende dit forbrug i realtid - Implementer en ratebegrænser på klientsiden for at undgå 429-fejl
- Fordel belastningen på tværs af projekter ved store volumener
- Luna tilbyder de højeste rategrænser til bulk-behandling