Unlimited AI API-Aufrufe: Ratenlimits erklärt
Kannst du unbegrenzte AI-API-Aufrufe tätigen? Für diese API gibt es kein monatliches Kontingent, aber zwei Ratenlimits: Anfragen pro Minute und parallele Anfragen. Hier erfährst du, was das in der Praxis bedeutet und wie du Code schreibst, der sich daran hält.
Aktualisiert
Wichtige Punkte
- Ein voller Schlüssel erlaubt 300 Anfragen pro Minute und 8 parallele Anfragen; ein Trial-Schlüssel erlaubt 60 und 2.
- 429 mit dem Code rate_limited bedeutet zu viele pro Minute; der Code concurrency bedeutet zu viele parallele Anfragen.
- Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet.
- Verwende einen Semaphore mit 8 und wiederhole 429 mit Backoff, unter Beachtung von Retry-After.


Die beiden Limits im Vergleich
Für API-Aufrufe ohne monatliche Obergrenze bist du abgedeckt: Die Abrechnung erfolgt prepaid und pro Token, ohne Aufruf-Kontingent. Was den Durchsatz begrenzt, ist ein Paar von Ratenlimits, das die gemeinsam genutzten GPUs schützt.
| Schlüsseltyp | Anfragen pro Minute | Parallele Anfragen |
|---|---|---|
| Voller Schlüssel | 300 | 8 |
| Test-Schlüssel | 60 | 2 |
Weitere feste Limits: ein Anfrage-Body bis zu 8 MB und ein Kontextfenster mit 100.000 Token (Prompt plus Completion). Diese gelten pro Anfrage, nicht pro Minute.
Die beiden Ratenlimits sind unabhängig. Du kannst das Concurrency-Limit überschreiten, während du nur 20 Anfragen pro Minute sendest, wenn jede lange dauert. Du kannst das Ratenlimit pro Minute überschreiten, indem du sehr schnelle, kurze Aufrufe ausführst.
Was die Zahlen für reale Workloads bedeuten
Eine schnelle Methode zur Dimensionierung deines Workloads ist das Gesetz von Little: Parallele Anfragen = Ankunftsrate x durchschnittliche Dauer.
- Chatbot, 100 aktive Nutzer. Wenn jeder jede 60 Sekunden eine Nachricht sendet, sind das 100 Anfragen pro Minute, weit unter 300. Jede Antwort dauert etwa 10 Sekunden, die durchschnittliche Concurrency beträgt also (100 / 60) x 10, rund 17. Das überschreitet 8, daher benötigst du Warteschlangen, nicht nur eine Retry-Schleife.
- Batch von 10.000 kurzen Prompts. Bei 300 pro Minute beträgt die minimale Laufzeit 10.000 / 300 = 33,3 Minuten. Um 300 pro Minute mit 8 Slots zu erreichen, müssen Aufrufe durchschnittlich 1,6 Sekunden dauern (8 x 60 / 300). Längere Aufrufe verschieben den Flaschenhals zur Concurrency: Bei 8 Sekunden pro Aufruf und 8 Slots ergeben sich 60 Aufrufe pro Minute, und der Job dauert etwa 167 Minuten.
- Einzelner Entwickler beim Scripting. Ein oder zwei Aufrufe gleichzeitig liegen weit entfernt von beiden Limits.
Die Lehre daraus: Bei langen Generierungen ist die Concurrency fast immer das Limit, das du zuerst erreichst. Kurze Ausgaben treffen stattdessen die Obergrenze pro Minute.
Lesen der Ratenlimit-Header
Jede Antwort enthält Header, die du protokollieren oder zur Anpassung nutzen kannst:
X-RateLimit-Limit-Requests: dein Limit pro Minute.X-RateLimit-Limit-Concurrency: dein Limit für parallele Anfragen.X-Balance-USD: verbleibendes Guthaben.X-Request-Id: Gib dies im Support an, wenn etwas falsch aussieht.
Verwende mit dem OpenAI Python SDK den Raw-Response-Wrapper, um sie zu sehen:
from openai import OpenAI
client = OpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY")
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Reply with one word."}],
)
print(raw.headers.get("X-RateLimit-Limit-Requests"))
print(raw.headers.get("X-RateLimit-Limit-Concurrency"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)
Prüfe diese einmal beim Start und dimensioniere deinen Worker-Pool basierend auf dem Concurrency-Wert, statt 8 hart zu codieren. So funktioniert derselbe Code für einen Trial-Schlüssel und einen vollen Schlüssel.
Was ein 429 dir sagt
Das Überschreiten eines Limits liefert HTTP 429 mit einem Fehlercode:
rate_limited: zu viele Anfragen pro Minute. Verlangsame.concurrency: zu viele Anfragen gleichzeitig. Warte, bis eine fertig ist.
Die API gibt auch 429 mit einem Retry-After: 5-Header zurück, wenn sie vorübergehend überlastet ist. In jedem Fall ist die richtige Antwort gleich: Warte und versuche es erneut, nutze den Header-Wert, falls vorhanden.
Eine Falle beim Streaming: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn ein Client einen Stream öffnet und dann aufhört zu lesen, oder eine UI Verbindungen offen lässt, bleiben diese Slots belegt. Schließe immer Streams, die du verlässt.
Ein Batch-Runner, der beide Limits beachtet
Dieses Skript hält maximal 8 Anfragen gleichzeitig offen, startet sie so verteilt, um unter 300 pro Minute zu bleiben, und wiederholt 429 mit Backoff. Passe CONCURRENCY und RPM für einen Test-Schlüssel an.
import asyncio, random
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY", max_retries=0)
CONCURRENCY, RPM = 8, 300
sem = asyncio.Semaphore(CONCURRENCY)
interval = 60 / RPM # 0.2 s between starts
async def call(prompt, attempt=0):
async with sem:
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError as e:
if attempt >= 6:
raise
wait = float(e.response.headers.get("Retry-After", 5)) + random.random()
await asyncio.sleep(wait * (1.5 ** attempt))
return await call(prompt, attempt + 1)
async def main(prompts):
tasks = []
for p in prompts:
tasks.append(asyncio.create_task(call(p)))
await asyncio.sleep(interval)
return await asyncio.gather(*tasks)
results = asyncio.run(main(["Summarise: ..."] * 50))
Der Semaphore wird während des Wartens auf einen 429 freigegeben, sodass andere Aufgaben weiterlaufen. Setze max_retries=0 im Client, um zu verhindern, dass das SDK eigene versteckte Retries über deinen eigenen ausführt.
Design-Tipps für hohes Volumen
- Warteschlange, nicht Fan-Out. Eine Job-Warteschlange mit 8 Workern ist besser, als einen Thread pro Anfrage zu starten und zu wiederholen.
- Jitter hinzufügen. Wenn viele Worker für die gleiche Zeit warten, kehren sie alle gleichzeitig zurück und kollidieren erneut.
- Output begrenzen. Das Setzen von
max_tokensverkürzt die Aufrufdauer, was den effektiven Durchsatz unter dem Concurrency-Limit erhöht. - Weniger, größere Prompts bevorzugen, wenn die Aufgabe es erlaubt, z. B. 20 Elemente pro Anfrage klassifizieren statt eines. Das reduziert die Anzahl der Anfragen um das 20-fache. Beachte das 100.000-Token-Fenster.
- Kosten neben der Geschwindigkeit tracken. Bei $0,15 pro 1M Input- und $0,50 pro 1M Output-Token kostet ein Job mit 10.000 Anfragen, 2.000 Token Input und 300 Output, $4,50. Sieh dir die Preisseite für Aufladebeträge und Boni an.
Wenn die Limits des vollen Schlüssels für dein Produkt zu niedrig sind, gib dies über die Support-Seite bekannt, zusammen mit deiner erwarteten Anfragerate und der durchschnittlichen Output-Länge.
Häufige Fehler, die wie Limits aussehen
Einige Fehler fühlen sich wie Ratenlimiting an, haben aber eine andere Ursache.
Retry-Stürme
Ein Client, der bei jeder 429 sofort wiederholt, verschlimmert das Problem. Zehn Worker, die ohne Verzögerung wiederholen, halten den Zähler pro Minute an der Decke fest, sodass keiner von ihnen jemals erfolgreich ist. Backoff mit Jitter ist bei hohem Volumen nicht optional.
Anfragen zählen, nicht Versuche
Deine Wiederholungen zählen auch als Anfragen. Wenn dein Plan 300 pro Minute beträgt und 20 % der Aufrufe wiederholt werden, ist dein tatsächliches Volumen 360. Plane es ein, indem du die Start-Schleife bei etwa 80 % des Limits ausführst, zum Beispiel 240 pro Minute.
Timeouts, die Arbeit abbrechen
Wenn dein Client nach 30 Sekunden aufgibt, der Server aber noch generiert, kannst du eine Ersatzanfrage öffnen, während die erste noch einen Slot belegt. Setze Client-Timeouts über deine längste erwartete Generierungszeit hinaus oder reduziere max_tokens.
Schneller manueller Test
Um ein Limit mit einem Trial-Schlüssel absichtlich auszulösen, sende drei Anfragen gleichzeitig:
for i in 1 2 3; do
curl -s -o /dev/null -w "%{http_code}
" https://api.unlimitedaiapi.com/v1/chat/completions -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" -d '{"model":"uncensored","messages":[{"role":"user","content":"Write a 300 word story."}]}' &
done; wait
Bei einem Trial-Schlüssel (2 parallele Anfragen) solltest du zwei 200-Antworten und eine 429 sehen.
Nächste Schritte
Hole einen Schlüssel auf der API-Schlüssel-Seite; der One-Click-Testguthaben reicht aus, um deine Retry-Logik gegen echte 429-Fehler zu testen, da die Limits des Test-Schlüssels (60 pro Minute und 2 parallele Anfragen) leicht absichtlich erreicht werden können. Die Dokumentation listet jeden Endpunkt auf, und die LangChain- und Agent-Hinweise zeigen, wie du die Parallelität innerhalb von Agent-Frameworks begrenzt, wo eine Benutzeranfrage mehrere parallele Aufrufe auslösen kann.
Weitere Anleitungen
Fragen und Antworten
Gibt es ein tägliches oder monatliches Limit für API-Aufrufe?
Nein. Die Abrechnung erfolgt Prepaid pro Token und es gibt kein Aufrufkontingent. Es gelten nur die Limits pro Minute und die Parallelitätsbegrenzung.
Was passiert, wenn ich 300 Anfragen pro Minute überschreite?
Die API antwortet mit HTTP 429 und dem Fehlercode rate_limited. Warte und wiederhole, unter Verwendung der Retry-After-Antwortkopfzeile, falls vorhanden.
Warum erhalte ich einen Parallelitätsfehler bei geringem Traffic?
Lange Generierungen und offene Streams belegen einen Slot, bis sie abgeschlossen sind. Acht langsame Anfragen reichen aus, um einen vollständigen Schlüssel zu füllen, also begrenze max_tokens und schließe nicht genutzte Streams.
Werden 429-Antworten berechnet?
Nein. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.