Moknah Documents
Commencez gratuitement
Référence de l’API

Limites de débit

Comprendre les limites de débit et la concurrence des API, et savoir comment s’y adapter

Vue d’ensemble

Les limitations de débit protègent l’API contre les abus et garantissent une utilisation équitable pour tous les utilisateurs. Moknah applique des limites concernant la fréquence des requêtes, la consommation de crédits et les connexions simultanées, aussi bien pour nos points de terminaison HTTP que WebSocket.

Politique stricte d’interdiction de simultanéité

Moknah effectue des traitements précis. une action par utilisateur à la fois.
• HTTP : Attendez que la requête en cours se termine avant d’en envoyer une autre. Les requêtes simultanées reçoivent une réponse 409 Conflict ou 429 Too Many Requests.
• WebSocket : Vous ne pouvez avoir qu’une seule connexion WebSocket active à la fois. L’ouverture d’une seconde connexion entraînera sa fermeture immédiate avec le code 4290.

Limites par défaut

Type de limite Valeur S’applique à Description
Requêtes par minute (RPM) 60 HTTP uniquement Nombre maximal de requêtes API POST standard par minute.
Crédits par minute (CPM) 10,000 HTTP et WebSocket Nombre maximal de crédits consommés par minute.
Connexions actives 1 WebSocket uniquement Nombre maximal de flux WSS simultanés par utilisateur.

Limites et codes de fermeture WebSocket

Comme les WebSockets maintiennent une connexion persistante, ils n’utilisent pas d’en-têtes HTTP pour la limitation du débit. À la place, les limites sont appliquées par le biais de coupures de connexion et de messages de contrôle JSON :

Limite atteinte Comportement / Résultat
Limite de concurrence La connexion se ferme instantanément avec le code 4290.
Crédits épuisés Reçoit une erreur JSON et se ferme.
Limite de taille de segment Une erreur JSON survient si un seul bloc de texte dépasse 2 000 caractères.
Limite de débit des messages Vous recevez une erreur JSON si vous envoyez des segments de texte plus rapidement que la file d’attente ne peut les traiter.

Remarque : Si votre WebSocket se déconnecte de manière inattendue, attendez au moins 15 secondes avant de vous reconnecter afin de vous assurer que le verrou côté serveur a été entièrement levé.

En-têtes HTTP de limitation de débit

Pour les points de terminaison REST standard, chaque réponse de l’API inclut des en-têtes vous permettant de suivre votre statut :

En-tête Description Exemple
RateLimit-Limit Votre limite de régime moteur 60
RateLimit-Remaining Requêtes restantes pour cette minute 45
RateLimit-Reset Horodatage Unix de réinitialisation des limites 1699574460
Moknah-Credits-Remaining Crédits restants à l’heure actuelle 10000
Moknah-Credits-Used Crédits utilisés cette minute 5000

En cas de limitation du débit HTTP

Si vous dépassez la limite de débit HTTP, vous recevrez une réponse 429 Too Many Requests accompagnée des en-têtes supplémentaires suivants :

En-tête Description Exemple
Retry-After Secondes à attendre avant de réessayer 45
RateLimit-Reset Horodatage Unix indiquant quand vous pouvez réessayer 1699574460

Calcul du crédit

Les crédits sont calculés en fonction de la longueur du texte et des options de traitement. Dans le cas des WebSockets, les crédits sont déduits dynamiquement par segment à mesure que les données sont transmises en flux.

Facteur Multiplier Description
Coût de base 1x 1 crédits par caractère
Normalisation améliorée par l’IA 2x Traitement avancé de l’arabe avec diacritiques
Voix premium +% Pourcentage supplémentaire pour les voix premium

Exemple : Un texte de 500 caractères avec normalisation améliorée par IA :

500 characters × 2 (AI-Enhanced) = 1,000 credits

Meilleures pratiques

1. Utilisez des WebSockets pour les flux de texte séquentiels à haut volume.

Si vous générez des réponses d’IA conversationnelle ou analysez de longs documents, n’effectuez pas 50 requêtes HTTP POST successives et rapides. Ouvrez plutôt une connexion WebSocket unique et transmettez les segments en flux continu via cette connexion persistante. Cela permet de contourner totalement la limite HTTP de 60 requêtes par minute (bien que les limites de crédits restent applicables).

2. Mettre en œuvre la mise en file d’attente des requêtes (HTTP)

Comme Moknah ne prend pas en charge les requêtes simultanées, mettez vos requêtes HTTP en file d’attente et traitez-les séquentiellement :

import queue
import threading
import time

class TTSQueue:
    def __init__(self, api_key):
        self.api_key = api_key
        self.queue = queue.Queue()
        self.worker = threading.Thread(target=self._process_queue, daemon=True)
        self.worker.start()

    def _process_queue(self):
        while True:
            text, voice_id, callback = self.queue.get()
            try:
                result = self._generate(text, voice_id)
                callback(result, None)
            except Exception as e:
                callback(None, e)
            finally:
                self.queue.task_done()

    def _generate(self, text, voice_id):
        # Your API call here
        pass

    def add(self, text, voice_id, callback):
        self.queue.put((text, voice_id, callback))

# Usage
tts = TTSQueue("your_api_key")
tts.add("Hello world", "voice_123", lambda r, e: print(r or e))
class TTSQueue {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.queue = [];
    this.processing = false;
  }

  async add(text, voiceId) {
    return new Promise((resolve, reject) => {
      this.queue.push({ text, voiceId, resolve, reject });
      this.processNext();
    });
  }

  async processNext() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;
    const { text, voiceId, resolve, reject } = this.queue.shift();

    try {
      const result = await this.generate(text, voiceId);
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.processing = false;
      this.processNext(); // Process next in queue
    }
  }

  async generate(text, voiceId) {
    // Your API call here
  }
}

// Usage
const tts = new TTSQueue("your_api_key");
const audio = await tts.add("Hello world", "voice_123");

2. Mettre en œuvre la mise en file d’attente des requêtes (HTTP)

Comme Moknah ne prend pas en charge les requêtes simultanées, mettez vos requêtes HTTP en file d’attente et traitez-les séquentiellement :

import time
import random

def request_with_backoff(func, max_retries=5):
    retries = 0

    while retries < max_retries:
        try:
            response = func()

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                # Add jitter to prevent thundering herd
                wait_time = retry_after + random.uniform(0, 1)
                print(f"Rate limited. Waiting {wait_time:.1f}s...")
                time.sleep(wait_time)
                retries += 1
                continue

            return response

        except Exception as e:
            # Exponential backoff for other errors
            wait_time = (2 ** retries) + random.uniform(0, 1)
            print(f"Error: {e}. Retrying in {wait_time:.1f}s...")
            time.sleep(wait_time)
            retries += 1

    raise Exception("Max retries exceeded")
async function requestWithBackoff(func, maxRetries = 5) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      const response = await func();

      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("Retry-After") || 60);
        // Add jitter to prevent thundering herd
        const waitTime = retryAfter + Math.random();
        console.log(`Rate limited. Waiting ${waitTime.toFixed(1)}s...`);
        await new Promise(r => setTimeout(r, waitTime * 1000));
        retries++;
        continue;
      }

      return response;

    } catch (error) {
      // Exponential backoff for other errors
      const waitTime = Math.pow(2, retries) + Math.random();
      console.log(`Error: ${error.message}. Retrying in ${waitTime.toFixed(1)}s...`);
      await new Promise(r => setTimeout(r, waitTime * 1000));
      retries++;
    }
  }

  throw new Error("Max retries exceeded");
}

3. Implémenter le backoff exponentiel

En cas de limitation du débit (HTTP 429) ou du nombre de connexions (WebSocket 4290), utilisez une stratégie de temporisation exponentielle pour réessayer en toute sécurité sans surcharger le serveur :


Résumé

Référence rapide

Limites HTTP : 60 requêtes par minute, 1 requête simultanée.
Limites des WebSockets : 1 connexion simultanée, 2 000 caractères par segment.
Limites globales : 10 000 CPM (crédits par minute).
Besoin de plus de capacité ? E-mail sales@moknah.io

Support API

Pour toute question ou tout problème concernant l’API, contactez-nous à l’adresse api@moknah.io.