Limites de débit, quotas et niveaux
Šiame puslapyje
Limites de débit, quotas et niveaux
Les limites de débit définissent le nombre de requêtes que tu peux envoyer à l’API par minute. Comprendre et gérer ces limites est crucial pour éviter les interruptions de service en production. Le scénario catastrophe est toujours le même : une intégration qui fonctionnait parfaitement en développement, où tu envoyais trois requêtes par minute, passe en production et se retrouve soudainement à traiter une file d’attente de plusieurs milliers de documents. Les erreurs 429 arrivent en cascade, et la moitié du traitement est perdue car le débit n’avait pas été anticipé.
Le système de niveaux
OpenAI organise les limites en niveaux (paliers) basés sur ton historique de facturation. Tu ne choisis pas ton niveau ; tu le débloques en accumulant des dépenses et en attendant une fenêtre de temps donnée. Cette progression a une conséquence pratique importante : un compte créé juste pour une démo client n’aura pas la même capacité que ton compte de production, même si le code est identique.
# Les niveaux déterminent tes limites
# Niveau 1 : Après le premier paiement réussi
# Niveau 2 : Après 50 $ de dépenses cumulées + 7 jours
# Niveau 3 : Après 100 $ de dépenses cumulées + 7 jours
# Niveau 4 : Après 250 $ de dépenses cumulées + 14 jours
# Niveau 5 : Après 1000 $ de dépenses cumulées + 30 jours
# Les limites augmentent considérablement à chaque niveau
Types de limites de débit
Trois compteurs s’appliquent simultanément, et le premier que tu atteins te bloque. Le traitement de textes courts saturera le RPM (requêtes par minute) bien avant le TPM (jetons par minute) ; à l’inverse, l’analyse de longs documents épuisera le TPM même si tu n’as envoyé que quelques dizaines de requêtes. Vérifie toujours l’ordre de grandeur de tes invites avant de dimensionner ton parallélisme.
# 1. RPM — Requêtes par minute
# 2. TPM — Jetons par minute
# 3. RPD — Requêtes par jour
# Ordre de grandeur pour le Niveau 3 (vérifie tes limites réelles
# sur platform.openai.com > Settings > Limits) :
# RPM : 5 000 requêtes/minute
# TPM : 2 000 000 jetons/minute
# RPD : 10 000 requêtes/jour
Lecture des en-têtes de limite de débit
Tu n’as pas besoin de deviner ta consommation : chaque réponse la transporte dans ses en-têtes HTTP. Le SDK les masque par défaut pour ne renvoyer que l’objet analysé, mais with_raw_response te donne accès à la réponse brute, et parse() reconstruit l’objet habituel. Un tableau de bord alimenté par ces valeurs t’avertit lorsque tu approches du plafond au lieu de te laisser le découvrir via une erreur.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Accès aux en-têtes via la réponse HTTP brute
# Utilisation du mode with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"Limite RPM : {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM restants : {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Limite TPM : {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM restants : {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Réinitialisation dans : {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Réponse : {response.output_text}")
Limitation de débit côté client
Il vaut mieux se ralentir soi-même que d’être rejeté. Deux implémentations couvrent la plupart des besoins.
Limitation du débit avec un sémaphore
La première combine un sémaphore, qui plafonne le nombre d’appels simultanés, avec un délai calculé à partir du débit cible. Dans l’exemple, cinquante résumés sont lancés d’un coup, mais seulement cinq progressent en parallèle, espacés par le délai correspondant à 100 requêtes par minute. Le code appelant reste un simple asyncio.gather : toute la discipline est encapsulée dans la classe.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Limite le nombre de requêtes simultanées."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Délai entre chaque requête
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"Résumer le concept {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"Résultat {i} : {r[:50]}...")
# asyncio.run(batch_processing())
Simple seau de jetons
Le seau de jetons est plus flexible car il permet des pics de trafic. Le seau se remplit à un rythme constant et se vide à chaque appel : si ton application est restée inactive pendant une minute, elle peut redémarrer à pleine vitesse pour cinquante requêtes, puis revenir naturellement au rythme de remplissage. C’est exactement le comportement souhaité pour un service qui alterne entre pics et creux, et cela fonctionne dans des environnements multithread grâce au verrou.
import time
import threading
class TokenBucket:
"""Limiteur de débit basé sur l'algorithme du seau de jetons."""
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):
"""Attend jusqu'à ce que suffisamment de jetons soient disponibles."""
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)
# Utilisation : max 50 requêtes par 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
Stratégies pour les volumes élevés
1. Répartir sur plusieurs projets
Chaque projet possède ses propres limites de débit. Si tu atteins ton plafond alors que tu es déjà sur un niveau élevé, la répartition des appels sur plusieurs projets multiplie mécaniquement la capacité disponible. Le round-robin ci-dessous illustre le principe ; en production, déplace le cycle hors de la fonction pour qu’il persiste entre les appels.
from openai import OpenAI
# Chaque projet a ses propres limites de débit
clients = [
OpenAI(project="proj-aaaa"), # Projet 1
OpenAI(project="proj-bbbb"), # Projet 2
OpenAI(project="proj-cccc"), # Projet 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Répartit les appels sur plusieurs projets."""
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. Utiliser le bon modèle pour le bon volume
Le choix du modèle est aussi une décision de capacité, pas seulement de qualité. Réserver les modèles les plus lourds pour les tâches critiques et router le volume vers un modèle avec des limites plus élevées libère du débit là où tu en as réellement besoin.
# Les modèles économiques (gpt-5.6-luna) ont les limites les plus élevées
# Utilise-les pour les tâches à fort volume
# Le modèle phare (gpt-5.6-sol) a les limites les plus basses
# Réserve-le pour les tâches critiques
3. Mise en file d’attente
Enfin, la mise en file d’attente découple la production de requêtes de leur consommation. Un seul thread retire les éléments de la file à un rythme fixe tandis que le reste de l’application soumet librement ; l’appelant se bloque sur un événement jusqu’à l’arrivée de son résultat. Ce schéma absorbe les pics sans jamais dépasser le débit configuré.
import queue
import threading
class APIQueue:
"""File d'attente pour les appels API."""
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"]
Svarbiausi punktai
- Les limites de débit s’appliquent simultanément en RPM, TPM et RPD
- Ton niveau détermine tes limites : il augmente avec tes dépenses cumulées
- Lis les en-têtes
x-ratelimit-*pour connaître ta consommation en temps réel - Implémente un limiteur de débit côté client pour éviter les erreurs 429
- Répartis la charge sur plusieurs projets pour les volumes élevés
- Luna offre les limites de débit les plus élevées pour le traitement en masse