Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Limites de débit, quotas et niveaux

Paskaita 13 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Limites de débit, quotas et niveaux
  2. Le système de niveaux
  3. Types de limites de débit
  4. Lecture des en-têtes de limite de débit
  5. Limitation de débit côté client
  6. Stratégies pour les volumes élevés
  7. Svarbiausi punktai

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