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.
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é
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
Pour toute question ou tout problème concernant l’API, contactez-nous à l’adresse api@moknah.io.