Appels API Unlimited AI : explication des limites de débit
Pouvez-vous effectuer des appels API illimités ? Il n'y a pas de quota mensuel sur cette API, mais il existe deux limites de débit : les requêtes par minute et les requêtes simultanées. Voici ce qu'elles signifient en pratique et comment écrire du code qui s'y conforme.
Mis à jour le
Points clés
- Une clé complète permet 300 requêtes par minute et 8 requêtes simultanées ; une clé d'essai permet 60 et 2.
- 429 avec le code rate_limited signifie trop de requêtes par minute ; le code concurrency signifie trop de requêtes simultanées.
- Une requête en streaming occupe son slot de concurrence jusqu'à la fin du flux.
- Utilisez un sémaphore de 8 et réessayez les 429 avec une temporisation, en respectant Retry-After.


Les deux limites, côte à côte
Pour des appels API sans quota mensuel, vous êtes couvert : la facturation est prépayée par token, sans quota d'appels. Ce qui limite le débit est une paire de limites de débit qui protègent les GPU partagés.
| Type de clé | Requêtes par minute | Requêtes simultanées |
|---|---|---|
| Clé complète | 300 | 8 |
| Clé d'essai | 60 | 2 |
Autres limites fixes : un corps de requête jusqu'à 8 Mo et une fenêtre de contexte de 100 000 tokens (prompt plus complétion). Cela s'applique par requête, pas par minute.
Les deux limites de débit sont indépendantes. Vous pouvez dépasser la limite de concurrence en envoyant seulement 20 requêtes par minute si chacune prend beaucoup de temps, et vous pouvez dépasser la limite par minute avec des appels très rapides et courts.
Ce que les chiffres signifient pour les charges réelles
Une méthode rapide pour dimensionner votre charge est la loi de Little : requêtes simultanées = taux d'arrivée x durée moyenne.
- Chatbot, 100 utilisateurs actifs. Si chacun envoie un message toutes les 60 secondes, cela fait 100 requêtes par minute, bien en dessous de 300. Chaque réponse prend environ 10 secondes, donc la concurrence moyenne est (100 / 60) x 10, soit environ 17. Cela dépasse 8, vous avez donc besoin de mise en file d'attente, pas seulement d'une boucle de réessai.
- Lot de 10 000 prompts courts. À 300 par minute, le temps d'exécution minimum est de 10 000 / 300 = 33,3 minutes. Pour atteindre 300 par minute avec 8 slots, les appels doivent durer en moyenne 1,6 seconde (8 x 60 / 300). Des appels plus longs déplacent le goulot d'étranglement vers la concurrence : à 8 secondes par appel, 8 slots donnent 60 appels par minute et la tâche prend environ 167 minutes.
- Développeur unique en scripting. Une ou deux requêtes à la fois ne frôlent aucune limite.
La leçon est que pour les générations longues, la concurrence est presque toujours la limite que vous atteignez en premier. Les sorties courtes atteignent plutôt le plafond par minute.
Lecture des en-têtes de limite de débit
Chaque réponse contient des en-têtes que vous pouvez enregistrer ou utiliser pour vous adapter :
X-RateLimit-Limit-Requests: votre limite par minute.X-RateLimit-Limit-Concurrency: votre limite de concurrence.X-Balance-USD: crédit restant.X-Request-Id: citez-le au support si quelque chose semble incorrect.
Avec le SDK Python OpenAI, utilisez le wrapper de réponse brute pour les voir :
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)
Vérifiez-les une fois au démarrage et dimensionnez votre pool de travailleurs à partir de la valeur de concurrence au lieu de coder en dur 8. Ainsi, le même code fonctionne pour une clé d'essai et une clé complète.
Ce qu'un 429 vous indique
Dépasser une limite renvoie HTTP 429 avec un code d'erreur :
rate_limited: trop de requêtes par minute. Ralentissez.concurrency: trop de requêtes en cours. Attendez qu'une se termine.
L'API renvoie également 429 avec un en-tête Retry-After: 5 lorsqu'elle est temporairement surchargée. Dans tous les cas, la bonne réponse est la même : attendez, puis réessayez, en utilisant la valeur de l'en-tête si elle est présente.
Un piège avec le streaming : une requête en streaming occupe son slot de concurrence jusqu'à la fin du flux. Si un client ouvre un flux puis arrête de lire, ou si une interface utilisateur laisse des connexions en attente, ces slots restent occupés. Fermez toujours les flux que vous abandonnez.
Un exécuteur par lots respectant les deux limites
Ce script maintient au maximum 8 requêtes en cours, espace les démarrages pour rester sous 300 par minute, et réessaie les 429 avec temporisation. Ajustez CONCURRENCY et RPM pour une clé d'essai.
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))
Le sémaphore est libéré pendant la pause sur un 429, afin que d'autres tâches continuent. Définir max_retries=0 sur le client empêche le SDK d'effectuer ses propres réessais cachés en plus des vôtres.
Conseils de conception pour les gros volumes
- File d'attente, pas d'envoi en rafale. Une file d'attente de tâches avec 8 travailleurs bat le fait de créer un thread par requête et de réessayer.
- Ajoutez du jitter. Si de nombreux travailleurs attendent le même temps, ils reviennent tous ensemble et entrent à nouveau en collision.
- Limitez la sortie. Définir
max_tokensréduit la durée des appels, ce qui augmente le débit effectif sous le plafond de concurrence. - Préférez moins de prompts plus gros lorsque la tâche le permet, par exemple classer 20 éléments par requête au lieu d'un. Cela réduit le nombre de requêtes de 20x. Attention à la fenêtre de 100 000 tokens.
- Suivez le coût en même temps que la vitesse. À $0,15 par 1M de tokens d'entrée et $0,50 par 1M de tokens de sortie, une tâche de 10 000 requêtes avec 2 000 tokens d'entrée et 300 de sortie coûte $4,50. Consultez la page des tarifs pour les montants de rechargement et les bonus.
Si les limites de clé complète sont trop faibles pour votre produit, faites-le savoir via la page de support avec votre taux de requêtes attendu et la longueur moyenne de sortie.
Erreurs courantes qui ressemblent à des limites
Certains échecs ressemblent à une limite de débit mais ont une autre cause.
Tempêtes de réessais
Un client qui réessaie instantanément à chaque 429 aggrave le problème. Dix travailleurs qui réessaient sans délai maintiennent le compteur par minute au plafond, donc aucun ne réussit. La temporisation avec jitter n'est pas une option à volume élevé.
Compter les requêtes, pas les tentatives
Vos réessais comptent aussi comme des requêtes. Si votre plan est de 300 par minute et que 20 % des appels sont réessayés, votre demande réelle est de 360. Budgétisez-le en exécutant la boucle de démarrage à environ 80 % de la limite, par exemple 240 par minute.
Timeouts qui annulent le travail
Si votre client abandonne après 30 secondes mais que le serveur génère encore, vous pouvez ouvrir une requête de remplacement tandis que la première occupe encore un slot. Définissez les timeouts client au-dessus de votre génération la plus longue attendue, ou réduisez max_tokens.
Test manuel rapide
Pour déclencher volontairement une limite avec une clé d'essai, lancez trois requêtes en même temps :
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
Avec une clé d’essai (2 simultanés), vous devriez voir deux réponses 200 et une 429.
Où aller ensuite
Obtenez une clé sur la page clé API ; le crédit d'essai en un clic suffit pour tester votre logique de nouvelle tentative face à de véritables erreurs 429, car les limites de 60 requêtes par minute et de 2 requêtes simultanées de la clé d'essai sont faciles à atteindre volontairement. La page documentation liste tous les endpoints, et les notes LangChain et agents montrent comment limiter le nombre de requêtes simultanées au sein des frameworks d'agents, où une seule tâche utilisateur peut générer plusieurs appels parallèles.
Plus de guides
Questions et réponses
Existe-t-il une limite quotidienne ou mensuelle sur les appels API ?
Non. La facturation est prépayée par token et il n'y a pas de quota d'appels. Seules les limites par minute et de concurrence s'appliquent.
Que se passe-t-il lorsque je dépasse 300 requêtes par minute ?
L'API répond avec un code HTTP 429 et le code d'erreur rate_limited. Attendez et réessayez, en utilisant l'en-tête Retry-After s'il est présent.
Pourquoi obtiens-je une erreur de concurrence avec un faible trafic ?
Les générations longues et les flux ouverts maintiennent un slot jusqu'à leur fin. Huit requêtes lentes suffisent à remplir une clé complète, donc limitez max_tokens et fermez les flux inutilisés.
Les réponses 429 sont-elles facturées ?
Non. Les requêtes échouées ou refusées ne sont pas facturées.
Votre clé n'est qu'à un formulaire d'ici
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.