Unlimited AI API-aanroepen: uitleg over rate limits
Kun je ongelimiteerde ai api-verzoeken doen? Er is geen maandelijkse quota voor deze API, maar wel twee rate limits: verzoeken per minuut en gelijktijdig. Lees wat dit betekent en hoe je code schrijft die binnen deze limieten blijft.
Bijgewerkt
Belangrijkste punten
- Een volledige sleutel staat 300 verzoeken per minuut en 8 gelijktijdige verzoeken toe; een proefsleutel staat 60 en 2 toe.
- 429 met code rate_limited betekent te veel per minuut; code concurrency betekent te veel gelijktijdig.
- Een gestreamd verzoek houdt zijn concurrency-slot vast tot de stream eindigt.
- Gebruik een semaphore van 8 en probeer 429 opnieuw met backoff, respecteer Retry-After.


De twee limieten, naast elkaar
Voor ongelimiteerde ai api-verzoeken qua maandlimiet ben je verzekerd: prepaid en per token, zonder quota. De doorvoer wordt beperkt door twee rate limits die de gedeelde GPUs beschermen.
| Sleuteltype | Verzoeken per minuut | Gelijktijdige verzoeken |
|---|---|---|
| Volledige sleutel | 300 | 8 |
| Proefsleutel | 60 | 2 |
Andere vaste limieten: een request body tot 8 MB en een contextvenster van 100.000 tokens (prompt plus completion). Deze gelden per verzoek, niet per minuut.
De twee rate limits zijn onafhankelijk. Je kunt het concurrency-limiet overschrijden terwijl je slechts 20 verzoeken per minuut verstuurt als elk verzoek lang duurt, en je kunt het per-minuut limiet overschrijden met zeer snelle, korte aanroepen.
Wat de cijfers betekenen voor echte werklasten
Een snelle manier om je werklast te dimensioneren is de wet van Little: gelijktijdige verzoeken = aankomstfrequentie x gemiddelde duur.
- Chatbot, 100 actieve gebruikers. Als elk een bericht stuurt elke 60 seconden, is dat 100 verzoeken per minuut, ver onder de 300. Elke reactie duurt ongeveer 10 seconden, dus de gemiddelde concurrency is (100 / 60) x 10, ongeveer 17. Dat overschrijdt 8, dus je hebt wachtrijen nodig, niet alleen een retry-loop.
- Batch van 10.000 korte prompts. Bij 300 per minuut is de minimale looptijd 10.000 / 300 = 33,3 minuten. Om 300 per minuut te bereiken met 8 slots, moeten aanroepen gemiddeld 1,6 seconden duren (8 x 60 / 300). Langzamere aanroepen verschuiven de bottleneck naar concurrency: bij 8 seconden per aanroep geven 8 slots 60 aanroepen per minuut en duurt de taak ongeveer 167 minuten.
- Enkele ontwikkelaar die scriptt. Een of twee verzoeken tegelijk komen nooit in de buurt van een van beide limieten.
De les is dat voor lange generaties concurrency bijna altijd de limiet is die je eerst raakt. Korte outputs raken het per-minuut plafond.
De rate-limit headers lezen
Elk antwoord bevat headers die je kunt loggen of gebruiken om aan te passen:
X-RateLimit-Limit-Requests: je limiet per minuut.X-RateLimit-Limit-Concurrency: je concurrency limiet.X-Balance-USD: resterend tegoed.X-Request-Id: citeer dit bij support als er iets mis lijkt te zijn.
Met de OpenAI Python SDK gebruik je de raw response wrapper om ze te zien:
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)
Controleer deze eenmaal bij het opstarten en dimensioneer je worker pool op basis van de concurrency waarde in plaats van 8 hard te coderen. Zo werkt dezelfde code voor een proefsleutel en een volledige sleutel.
Wat een 429 je vertelt
Het overschrijden van een limiet retourneert HTTP 429 met een foutcode:
rate_limited: te veel verzoeken per minuut. Langzamer aan.concurrency: te veel verzoeken in uitvoering. Wacht tot er een klaar is.
De API retourneert ook 429 met een Retry-After: 5 header wanneer deze tijdelijk overbelast is. In elk geval is de juiste reactie hetzelfde: wacht en probeer het opnieuw, gebruik de header waarde indien aanwezig.
Een valkuil met streaming: een gestreamd verzoek bezet zijn concurrency slot tot de stream eindigt. Als een client een stream opent en stopt met lezen, of een UI verbindingen open laat staan, blijven die slots bezet. Sluit altijd streams die je verlaat.
Een batch-runner die beide limieten respecteert
Dit script houdt maximaal 8 verzoeken in uitvoering, verdeelt starts om onder de 300 per minuut te blijven, en probeert 429 opnieuw met backoff. Pas CONCURRENCY en RPM aan voor een proefsleutel.
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))
De semaphore wordt vrijgegeven tijdens het slapen op een 429, zodat andere taken door kunnen gaan. Het instellen van max_retries=0 op de client voorkomt dat de SDK zijn eigen verborgen retries uitvoert bovenop die van jou.
Ontwerptips voor hoog volume
- Wachtrij, geen fan-out. Een taakwachtrij met 8 workers is beter dan een thread per verzoek starten en opnieuw proberen.
- Jitter toevoegen. Als veel workers even lang backen, keren ze allemaal tegelijk terug en botsen ze weer.
- Output beperken. Het instellen van
max_tokensverlaagt de duur van een aanroep, wat de effectieve doorvoer verhoogt onder het concurrency limiet. - Geef de voorkeur aan minder, grotere prompts als de taak dat toelaat, bijvoorbeeld het classificeren van 20 items per verzoek in plaats van één. Dat vermindert het aantal verzoeken met een factor 20. Houd rekening met het venster van 100.000 tokens.
- Volg kosten naast snelheid. Bij $0,15 per 1M input en $0,50 per 1M output tokens kost een taak van 10.000 verzoeken met 2.000 tokens input en 300 output $4,50. Zie de prijzenpagina voor top-up bedragen en bonussen.
Als de limieten voor de volledige sleutel te laag zijn voor je product, geef dat dan door via de supportpagina met je verwachte verzoekfrequentie en gemiddelde outputlengte.
Veelgemaakte fouten die op limieten lijken
Sommige fouten lijken op rate limiting, maar hebben een andere oorzaak.
Retry-stormen
Een client die onmiddellijk retryt bij elke 429 maakt het probleem erger. Tien workers die retryen zonder vertraging houden de per-minuut teller op het plafond, dus geen van hen slaagt ooit. Backoff met jitter is niet optioneel bij volume.
Verzoeken tellen, geen pogingen
Je herhaalde oproepen tellen ook als verzoeken. Als je plan 300 per minuut is en 20% van de oproepen wordt herhaald, is je werkelijke vraag 360. Begroot dit door de startlus uit te voeren op ongeveer 80% van de limiet, bijvoorbeeld 240 per minuut.
Time-outs die werk annuleren
Als je client opgeeft na 30 seconden maar de server nog genereert, open je mogelijk een vervangend verzoek terwijl het eerste nog een slot bezet. Stel client time-outs hoger in dan je langst verwachte generatie, of verlaag max_tokens.
Snelle handmatige test
Om een limiet bewust te triggeren met een proefsleutel, stuur drie verzoeken tegelijk:
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
Met een proefsleutel (2 gelijktijdig) zou je twee 200-antwoorden en één 429 moeten zien.
Waar je nu naartoe kunt
Haal een sleutel op de API-sleutel-pagina; het één-klik proeftegoed is genoeg om je retry-logica te testen tegen echte 429-fouten, omdat de limieten van 60 per minuut en 2 gelijktijdige verbindingen van de proefsleutel makkelijk bewust worden overschreden. De documentatie somt alle endpoints op, en de notities over LangChain en agents tonen hoe je gelijktijdige verzoeken kunt beperken binnen agent-frameworks, waar één taak van een gebruiker meerdere gelijktijdige verzoeken kan genereren.
Meer handleidingen
Vragen en antwoorden
Is er een dagelijkse of maandelijkse limiet op API-aanroepen?
Nee. Facturatie is prepaid per token en er is geen quota voor verzoeken. Alleen de limieten per minuut en gelijktijdige verbindingen zijn van toepassing.
Wat gebeurt er als ik meer dan 300 verzoeken per minuut maak?
De API antwoordt met HTTP 429 en foutcode rate_limited. Wacht en probeer opnieuw, gebruik de Retry-After-header als die aanwezig is.
Waarom krijg ik een foutmelding over gelijktijdigheid bij weinig verkeer?
Lange generaties en open streams bezetten een slot tot ze klaar zijn. Acht trage verzoeken zijn genoeg om een volledige sleutel te vullen, dus beperk max_tokens en sluit ongebruikte streams.
Worden 429-responses gefactureerd?
Nee. Mislukte of geweigerde verzoeken worden niet aangerekend.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.