Ratenlimits, Kontingente und Stufen
Auf dieser Seite
Ratenlimits, Kontingente und Stufen
Ratenlimits definieren, wie viele Anfragen Sie pro Minute an die API senden können. Das Verständnis und die Verwaltung dieser Limits sind entscheidend, um Produktionsausfälle zu vermeiden. Das Albtraumszenario ist immer dasselbe: Eine Integration, die in der Entwicklung einwandfrei funktionierte, wo Sie drei Anfragen pro Minute sendeten, geht live und verarbeitet plötzlich eine Warteschlange mit mehreren tausend Dokumenten. 429-Fehler strömen in Flut herein, und die Hälfte der Verarbeitung geht verloren, weil die Durchsatzkapazität nicht antizipiert wurde.
Das Stufensystem
OpenAI organisiert Limits in Stufen (Levels) basierend auf Ihrer Abrechnungshistorie. Sie wählen Ihre Stufe nicht aus; Sie entsperren sie durch die Ansammlung von Ausgaben und das Abwarten eines Zeitfensters. Diese Progression hat eine wichtige praktische Konsequenz: Ein Konto, das ausschließlich für eine Kundendemo erstellt wurde, verfügt nicht über die gleiche Kapazität wie Ihr Produktionskonto, selbst wenn der Code identisch ist.
# Stufen bestimmen Ihre Limits
# Stufe 1: Nach erster erfolgreicher Zahlung
# Stufe 2: Nach 50 USD kumulierten Ausgaben + 7 Tage
# Stufe 3: Nach 100 USD kumulierten Ausgaben + 7 Tage
# Stufe 4: Nach 250 USD kumulierten Ausgaben + 14 Tage
# Stufe 5: Nach 1.000 USD kumulierten Ausgaben + 30 Tage
# Die Limits steigen mit jeder Stufe signifikant an
Arten von Ratenlimits
Drei Zähler greifen gleichzeitig zu, und der erste, den Sie erreichen, blockiert Sie. Die Verarbeitung kurzer Texte sättigt das RPM (Anfragen pro Minute) lange vor dem TPM (Tokens pro Minute); umgekehrt wird das TPM durch die Analyse langer Dokumente erschöpft, selbst wenn Sie nur ein paar Dutzend Anfragen gesendet haben. Prüfen Sie stets die Größenordnung Ihrer Prompts, bevor Sie Ihre Parallelität dimensionieren.
# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day
# Größenordnung für Stufe 3 (prüfen Sie Ihre tatsächlichen Limits
# unter platform.openai.com > Einstellungen > Limits):
# RPM: 5.000 Anfragen/Minute
# TPM: 2.000.000 Tokens/Minute
# RPD: 10.000 Anfragen/Tag
Lesen von Ratenlimit-Headern
Sie müssen Ihren Verbrauch nicht raten: Jede Antwort enthält ihn in ihren HTTP-Headern. Die SDKs verstecken diese standardmäßig, um nur das parse-Objekt zurückzugeben, aber with_raw_response gibt Ihnen Zugriff auf die rohe Antwort, und parse() rekonstruiert das übliche Objekt. Ein Dashboard, das von diesen Werten gespeist wird, warnt Sie, wenn Sie sich dem Deckel nähern, anstatt dass Sie ihn erst über einen Fehler entdecken.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Zugriff auf Header über die rohe HTTP-Antwort
# Nutzung des with_raw_response-Modus
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-Verbleib: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM-Limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM-Verbleib: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Antwort: {response.output_text}")
Clientseitige Ratenbegrenzung
Es ist besser, sich selbst zu verlangsamen, als abgelehnt zu werden. Zwei Implementierungen decken die meisten Bedürfnisse ab.
Begrenzung des Durchsatzes mit einem Semaphore
Die erste Variante kombiniert ein Semaphore, das die Anzahl der gleichzeitigen Aufrufe begrenzt, mit einer Verzögerung, die aus dem Ziel-Durchsatz berechnet wird. Im Beispiel werden fünfzig Zusammenfassungen gleichzeitig gestartet, aber nur fünf laufen parallel, mit der Verzögerung entsprechend 100 Anfragen pro Minute getrennt. Der aufrufende Code bleibt ein einfaches asyncio.gather: Alle Disziplin ist in der Klasse verkapselt.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Begrenzt die Anzahl der gleichzeitigen Anfragen."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Verzögerung zwischen jeder Anfrage
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"Zusammenfassen des Konzepts {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"Ergebnis {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Einfacher Token-Bucket
Der Token-Bucket ist flexibler, da er Bursts erlaubt. Der Bucket füllt sich mit einer konstanten Rate und leert sich bei jedem Aufruf: Wenn Ihre Anwendung eine Minute lang inaktiv war, kann sie mit voller Geschwindigkeit für fünfzig Anfragen neu starten, fällt dann aber natürlich auf die Füllrate zurück. Dies ist genau das Verhalten, das Sie für einen Service wollen, der zwischen Spitzen und Flaute wechselt, und es funktioniert in mehrfädigen Umgebungen dank des Sperrmechanismus.
import time
import threading
class TokenBucket:
"""Ratenlimiter basierend auf dem Token-Bucket-Algorithmus."""
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):
"""Wartet, bis genügend Tokens verfügbar sind."""
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)
# Nutzung: maximal 50 Anfragen pro 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
Strategien für hohe Volumina
1. Verteilung über mehrere Projekte
Jedes Projekt verfügt über eigene Ratenlimits. Wenn Sie Ihr Limit erreichen, während Sie bereits in einer hohen Stufe sind, vervielfacht die Verteilung der Aufrufe über mehrere Projekte mechanisch die verfügbare Kapazität. Das untenstehende Round-Robin-Verfahren illustriert das Prinzip; in der Produktion verschieben Sie den Zyklus außerhalb der Funktion, damit er zwischen Aufrufen bestehen bleibt.
from openai import OpenAI
# Jedes Projekt hat eigene Ratenlimits
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:
"""Verteilt Aufrufe über mehrere Projekte."""
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. Das richtige Modell für das richtige Volumen wählen
Die Modellwahl ist auch eine Kapazitätsentscheidung, nicht nur eine Qualitätsentscheidung. Die Reservierung der schwersten Modelle für kritische Aufgaben und die Weiterleitung des Volumens an ein Modell mit höheren Limits setzt Durchsatz frei, wo Sie ihn tatsächlich benötigen.
# Wirtschaftliche Modelle (gpt-5.6-luna) haben die höchsten Limits
# Nutzen Sie sie für Aufgaben mit hohem Volumen
# Das Flaggschiff-Modell (gpt-5.6-sol) hat die niedrigsten Limits
# Reservieren Sie es für kritische Aufgaben
3. Warteschlangen
Schließlich entkoppelt eine Warteschlange die Anforderungserstellung vom Verbrauch. Ein einzelner Faden entnimmt mit festem Takt, während der Rest der Anwendung frei einreicht; der Aufrufende blockiert auf einem Event, bis sein Ergebnis eingetroffen ist. Dieses Muster absorbiert Spitzen, ohne jemals den konfigurierten Durchsatz zu überschreiten.
import queue
import threading
class APIQueue:
"""Warteschlange für API-Aufrufe."""
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"]
Kernaussagen
- Ratenlimits gelten gleichzeitig für RPM, TPM und RPD
- Ihre Stufe bestimmt Ihre Limits – sie steigt mit Ihren kumulierten Ausgaben
- Lesen Sie die
x-ratelimit-*-Header, um Ihren Verbrauch in Echtzeit zu kennen - Implementieren Sie einen clientseitigen Ratenlimiter, um 429-Fehler zu vermeiden
- Verteilen Sie die Last über Projekte für hohe Volumina
- Luna bietet die höchsten Ratenlimits für die Massenverarbeitung