Passer au contenu principal

​
Aperçu

LemonData implémente des limites de débit pour garantir une utilisation équitable et la stabilité de la plateforme. Les limites varient selon le niveau du compte.

​
Niveaux de limites de débit

NiveauRequêtes/minDescription
Utilisateur60Niveau par défaut pour tous les comptes
Partenaire300Pour les partenaires d’intégration
VIP1 000Utilisateurs à volume élevé
Les limites de débit sont sujettes à modification. Contactez [email protected] pour des limites personnalisées.

​
En-têtes de limite de débit

Chaque réponse API inclut des informations sur la limite de débit : 
X-RateLimit-Limit: 60          # Votre limite par minute
X-RateLimit-Remaining: 55      # Requêtes restantes
X-RateLimit-Reset: 1234567890  # Horodatage Unix lors de la réinitialisation de la limite

​
Limite de débit dépassée

Lorsque vous dépassez la limite, vous recevrez une réponse 429 : 
{
  "error": {
    "message": "Rate limit exceeded. Please slow down.",
    "type": "rate_limit_exceeded"
  }
}
Avec un en-tête supplémentaire : 
Retry-After: 60  # Secondes à attendre avant de réessayer

​
Gestion des limites de débit

​
Backoff exponentiel

Implémentez un backoff exponentiel pour les tentatives automatiques : 
import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    api_key="sk-your-api-key",
    base_url="https://api.lemondata.cc/v1"
)

def make_request_with_backoff(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            wait_time = 2 ** attempt  # 1, 2, 4, 8, 16 secondes
            print(f"Limite de débit atteinte. Attente de {wait_time}s...")
            time.sleep(wait_time)

​
Mise en file d’attente des requêtes

Pour les applications à volume élevé, implémentez une file d’attente de requêtes : 
import asyncio
from collections import deque

class RateLimitedClient:
    def __init__(self, requests_per_minute=60):
        self.rpm = requests_per_minute
        self.interval = 60 / requests_per_minute
        self.last_request = 0

    async def request(self, messages):
        # Attendre si nécessaire pour respecter la limite de débit
        now = asyncio.get_event_loop().time()
        wait_time = max(0, self.last_request + self.interval - now)
        if wait_time > 0:
            await asyncio.sleep(wait_time)

        self.last_request = asyncio.get_event_loop().time()
        return await self.client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )

​
Traitement par lots

Pour les opérations en masse, traitez par lots avec des délais : 
def process_batch(items, batch_size=50, delay=1):
    results = []
    for i in range(0, len(items), batch_size):
        batch = items[i:i + batch_size]
        for item in batch:
            result = client.chat.completions.create(
                model="gpt-4o",
                messages=[{"role": "user", "content": item}]
            )
            results.append(result)
        time.sleep(delay)  # Pause entre les lots
    return results

​
Bonnes pratiques

Suivez les en-têtes de limite de débit pour rester proactivement en dessous des limites.
Mettez en cache les réponses pour les requêtes identiques afin de réduire les appels API.
Les modèles plus rapides (comme gpt-4o-mini) permettent un débit plus élevé.
Si vous avez besoin de limites plus élevées, contactez [email protected].

​
Mise à niveau de votre niveau

Pour demander une mise à niveau de niveau :
  1. Connectez-vous à votre Tableau de bord
  2. Allez dans Paramètres → Compte
  3. Contactez le support avec votre cas d’utilisation
Ou envoyez un e-mail à [email protected] avec :
  • L’e-mail de votre compte
  • Le volume de requêtes attendu
  • La description du cas d’utilisation