FR ▾

Qu’est-ce qu’une limite de débit API ? Limits, retries, contexte

Une limite de débit plafonne le trafic qu’une clé peut envoyer à une API dans un temps donné. Cette page explique ce qu’est une limite de débit API en pratique, comment la gérer dans le code, et quelles sont les limites de cette API.

Mis à jour

Porte avec huit voies passant des paquets légers, illustrant les limites de débit API et la concurrence

Points clés

  • Une limite de débit restreint les requêtes par minute ou les requêtes en cours, afin qu’un client ne surcharge pas le service.
  • Les limites de débit ne sont pas identiques à la fenêtre de contexte : l’une limite le trafic, l’autre la taille d’une seule requête.
  • Clé complète : 8 requêtes simultanées et 300 par minute. Clé d’essai : 2 simultanées et 60 par minute.
  • Gérez les limites avec un cap de concurrence, des retries avec backoff et une inspection des en-têtes de réponse.

Ce qu’est une limite de débit

Alors, qu’est-ce qu’une limite de débit API ? C’est une règle qui indique combien d’appels un compte ou une clé peut effectuer dans une fenêtre de temps, ou combien peuvent s’exécuter simultanément. Si vous la dépassez, le serveur refuse les appels supplémentaires au lieu de les traiter. La plupart des APIs HTTP signalent cela avec le code de statut 429 (Too Many Requests), et beaucoup ajoutent un en-tête indiquant quand réessayer. Consultez la documentation de chaque service pour son comportement exact.

Les limites existent car un serveur de modèle dispose d’une quantité fixe de puissance de calcul. Sans elles, un script en boucle serrée pourrait ralentir tous les autres utilisateurs. Pour vous en tant que développeur, cela signifie deux choses : votre code doit s’attendre à des refus et s’en remettre, et votre architecture doit répartir la charge au lieu de tout envoyer d’un coup.

Les trois types de limites que vous rencontrerez

Les fournisseurs combinent ces limites, donc lisez attentivement celles qui s’appliquent à votre clé.

TypeCe qui est comptéEffet typique
Requêtes par minuteAppels démarrés dans une minute glissanteLes pics sont refusés même si chaque appel est petit
ConcurrenceAppels en cours simultanémentLes workers parallèles au-delà du cap sont refusés ou mis en file d’attente
Quota de tokens ou de dépensesTokens ou argent utilisé par minute, jour ou moisLes prompts volumineux atteignent le cap plus tôt que les petits

La concurrence est plus critique pour les modèles de langage que pour les APIs ordinaires, car une seule complétion peut prendre plusieurs secondes. Dix workers attendant chacun une longue réponse occupent dix créneaux pendant toute la durée.

Les limites de cette API

Cette API limite les requêtes par minute et la concurrence, par clé :

Type de cléRequêtes simultanéesRequêtes par minute
Clé complète (avec crédit)8300
Clé d'essai260

Deux autres chiffres méritent d’être connus. Le corps de la requête maximum est de 8 Mo, et chaque réponse contient des en-têtes que vous pouvez lire : X-Request-Id pour identifier un appel lors d’une demande d’assistance, X-Balance-USD pour votre crédit restant, et X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency pour les limites applicables à votre clé. Vous pouvez les voir avec curl :

curl -i https://api.abliteratedapi.com/v1/chat/completions   -H "Authorization: Bearer $ABLITERATED_API_KEY"   -H "Content-Type: application/json"   -d '{"model":"uncensored","max_tokens":5,"messages":[{"role":"user","content":"Hi"}]}'

Les limites sont identiques quel que soit le client que vous utilisez ; l’API est compatible OpenAI, donc n’importe quel SDK OpenAI fonctionne une fois que vous avez modifié l’URL de base vers https://api.abliteratedapi.com/v1.

Quelle limite allez-vous réellement atteindre ?

Divisez les deux nombres. Une clé complète peut exécuter 8 requêtes simultanément et 300 par minute, soit une moyenne de 5 par seconde. Pour atteindre 300 par minute avec seulement 8 en cours, chaque appel devrait se terminer en 1,6 seconde en moyenne (8 x 60 / 300). Les réponses d’un modèle de langage prennent généralement plus de temps que cela lorsqu’elles comportent plus de quelques phrases, donc sur une clé complète, le cap de concurrence se déclenche généralement en premier.

Prenons un cas hypothétique où l’appel moyen dure 10 secondes. Huit créneaux vous donnent alors 8 x 60 / 10 = 48 requêtes par minute, bien en dessous de 300. La même logique sur une clé d’essai : 2 créneaux et 60 par minute signifient que des appels de moins de 2 secondes sont nécessaires avant que le cap par minute ne devienne pertinent. Ces durées sont une illustration, pas une mesure. Chronométrez vos propres appels et insérez la valeur réelle.

Le conseil pratique : dimensionnez votre pool de workers à la limite de concurrence, pas à la limite de requêtes, et laissez la limite par minute agir comme filet de sécurité.

Comment gérer les limites dans le code

Trois habitudes couvrent presque tous les cas.

  1. Maîtrisez vous-même la parallélisation. Un sémaphore dimensionné selon votre limite de concurrence signifie que vous êtes rarement refusé.
  2. Réessayez avec un backoff exponentiel et un jitter. Attendez 1 seconde, puis 2, puis 4, en ajoutant une fraction aléatoire pour que de nombreux workers ne réessayent pas en synchronisation. Arrêtez après quelques tentatives.
  3. Ne réessayez pas aveuglément. Une requête malformée ou une clé invalide échouera toujours. Réessayez uniquement en cas de limite de débit et d’erreurs serveur temporaires.

Le SDK Python officiel d'OpenAI effectue déjà des tentatives en cas d'erreur 429 et d'erreurs serveur avec un backoff, et vous le contrôlez via max_retries. Combiné à un sémaphore, un lot de travail ressemble à ceci :

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.abliteratedapi.com/v1",
    api_key=os.environ["ABLITERATED_API_KEY"],
    max_retries=5,
)
sem = asyncio.Semaphore(8)   # use 2 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one short fact about the number {n}." for n in range(40)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

Quarante prompts passent, jamais plus de huit à la fois. Si vous construisez votre propre client, intégrez les mêmes deux idées : une limite sur les appels en cours, et un délai de retry qui augmente.

Les limites de débit ne sont pas la fenêtre de contexte

Les gens confondent souvent les deux, car les deux produisent des erreurs lorsque vous demandez trop. Une limite de débit contrôle le nombre de requêtes que vous effectuez. La fenêtre de contexte contrôle la taille d’une seule requête.

Sur cette API, la fenêtre de contexte est de 100 000 tokens, comptant le prompt et la complétion ensemble. Si votre prompt fait 95 000 tokens, il reste au maximum 5 000 tokens pour la réponse. Le paramètre max_tokens est optionnel : laissez-le absent et la complétion peut utiliser tout ce qui reste dans la fenêtre. Le définir reste une bonne habitude lorsque vous savez que la réponse devrait être courte, car les tokens de sortie coûtent 0,50 $ par 1M contre 0,15 $ par 1M pour l’entrée. Un prompt complet de 95 000 tokens coûte 95 000 x 0,15 / 1 000 000 = 0,01425 $ en entrée.

Une limite de débit ne réduit pas la fenêtre de contexte, et un grand contexte n’utilise pas plus de limite de débit. Chaque appel est une requête, quelle que soit sa taille, tant que le corps reste sous 8 Mo.

Streaming et limites de débit

Avec stream: true, la réponse revient via des événements envoyés par le serveur, token par token, et les données d’utilisation arrivent à la fin. Un appel en streaming occupe toujours un créneau de concurrence jusqu’à la fin du flux, donc un lecteur lent qui garde les connexions ouvertes occupe des créneaux plus longtemps que prévu. Fermez les flux dont vous n’avez plus besoin.

Erreurs courantes

  • Pas de limite de workers. Un pool de threads avec 50 workers face à une limite de 8 signifie que la plupart des appels seront refusés. Adaptez le pool à la limite de concurrence.
  • Relances immédiates. Relancer immédiatement après un refus ajoute de la charge au pire moment. Attendez, et augmentez le délai à chaque fois.
  • Considérer chaque erreur comme une limite de débit. Un timeout, une clé invalide et un corps de requête trop volumineux nécessitent chacun une correction différente. Journalisez le code de statut et l'en-tête X-Request-Id.
  • Partager une seule clé pour tout. Un job de nuit et une fonctionnalité de chat en direct sur la même clé se disputent les mêmes 8 emplacements. Utilisez des clés séparées, ou planifiez le job pour les heures creuses.
  • Ignorer les streams lents. Un client qui arrête de lire mais garde la connexion ouverte conserve toujours un emplacement.

Ajoutez un compteur d'appels refusés à vos logs. S'il reste à zéro, votre limite est bien réglée. S'il augmente, réduisez la taille du pool avant d'ajouter des relances.

Planification autour des limites

Les limites de débit et le budget sont liés. Huit emplacements à plein régime peuvent consommer du crédit rapidement, alors décidez de la quantité que vous êtes prêt à dépenser avant de lancer un traitement. Le prix est au paiement à l’usage, avec un crédit qui n’expire jamais et sans frais pour les requêtes échouées ou refusées. Consultez la page tarifaire pour les tarifs et les bonus de rechargement, et le guide de démarrage rapide pour les paramètres de requête. Pour tester votre logique de tentatives en toute sécurité, obtenez une clé API et utilisez le crédit d’essai, qui ne nécessite pas de carte. N’oubliez pas qu’il s’exécute avec les limites inférieures de l’essai.

Questions et réponses

Que se passe-t-il lorsque je dépasse une limite de débit ?

Le serveur refuse les requêtes supplémentaires, généralement avec un HTTP 429, et votre code doit attendre et relancer. Ralentissez ou réduisez votre parallélisme jusqu'à ce que les erreurs cessent.

Quelles sont les limites de cette API ?

Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 requêtes simultanées et 60 par minute.

Une limite de débit est-elle la même chose qu'une fenêtre de contexte ?

Non. Une limite de débit contrôle le nombre de requêtes que vous pouvez envoyer dans le temps. La fenêtre de contexte, 100 000 tokens ici, contrôle la taille d'une seule requête et de sa réponse.

Comment voir mes limites depuis une réponse ?

Lisez les en-têtes de réponse X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency. L'en-tête X-Balance-USD affiche votre crédit restant, et X-Request-Id identifie un appel spécifique.

Les requêtes refusées coûtent-elles de l'argent ?

Non. Les requêtes échouées ou refusées ne sont pas facturées sur cette API.

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.

Obtenir une clé API