Ratenbegrenzungen
API-Rate-Limits, Gleichzeitigkeit und den Umgang damit verstehen
Übersicht
Rate-Limits schützen die API vor Missbrauch und gewährleisten eine faire Nutzung für alle Benutzer. Moknah setzt Limits für die Anfragehäufigkeit, den Credit-Verbrauch und gleichzeitige Verbindungen sowohl für unsere HTTP- als auch für WebSocket-Endpunkte durch.
Moknah verarbeitet genau eine Aktion pro Benutzer gleichzeitig.
• HTTP: Warten Sie, bis die aktuelle Anfrage abgeschlossen ist, bevor Sie eine weitere senden. Gleichzeitige Anfragen erhalten den Fehler 409 Conflict oder 429 Too Many Requests.
• WebSocket: Sie dürfen jeweils nur 1 aktive WebSocket-Verbindung geöffnet haben. Das Öffnen einer zweiten Verbindung führt zum sofortigen Schließen mit dem Code 4290.
Standardlimits
| Limittyp | Wert | Gilt für | Beschreibung |
|---|---|---|---|
| Anfragen pro Minute (RPM) | 60 |
Nur HTTP | Maximale Anzahl von Standard-API-POST-Anfragen pro Minute. |
| Credits pro Minute (CPM) | 10,000 |
HTTP & WebSocket | Maximale pro Minute verbrauchte Credits. |
| Aktive Verbindungen | 1 |
Nur WebSocket | Maximale Anzahl gleichzeitiger WSS-Streams pro Benutzer. |
WebSocket-Limits & Schließcodes
Da WebSockets eine dauerhafte Verbindung aufrechterhalten, verwenden sie keine HTTP-Header für das Rate Limiting. Stattdessen werden Limits über Verbindungsabbrüche und JSON-Steuernachrichten durchgesetzt:
| Erreichtes Limit | Verhalten / Ausgabe |
|---|---|
| Parallelitätslimit | Verbindung wird sofort mit Code 4290 geschlossen. |
| Credits aufgebraucht | Empfängt einen JSON-Fehler und wird geschlossen. |
| Chunk-Größenlimit | Empfängt einen JSON-Fehler, wenn ein einzelner Text-Chunk 2.000 Zeichen überschreitet. |
| Nachrichten-Ratenlimit | Empfängt einen JSON-Fehler, wenn Sie Text-Chunks schneller senden, als die Warteschlange sie verarbeiten kann. |
Hinweis: Wenn Ihre WebSocket-Verbindung unerwartet getrennt wird, warten Sie mindestens 15 Sekunden, bevor Sie sich erneut verbinden, um sicherzustellen, dass die serverseitige Sperre vollständig aufgehoben wurde.
HTTP-Rate-Limit-Header
Bei Standard-REST-Endpunkten enthält jede API-Antwort Header, mit denen Sie Ihren Status verfolgen können:
| Header | Beschreibung | Beispiel |
|---|---|---|
RateLimit-Limit |
Ihr RPM-Limit (Anfragen pro Minute) | 60 |
RateLimit-Remaining |
Verbleibende Anfragen in dieser Minute | 45 |
RateLimit-Reset |
Unix-Zeitstempel für das Zurücksetzen der Limits | 1699574460 |
Moknah-Credits-Remaining |
Verbleibende Credits in dieser Minute | 10000 |
Moknah-Credits-Used |
Verbrauchte Credits in dieser Minute | 5000 |
Bei Erreichen des HTTP-Rate-Limits
Wenn Sie das HTTP-Rate-Limit überschreiten, erhalten Sie eine Antwort vom Typ 429 Too Many Requests mit diesen zusätzlichen Headern:
| Header | Beschreibung | Beispiel |
|---|---|---|
Retry-After |
Wartezeit in Sekunden vor einem erneuten Versuch | 45 |
RateLimit-Reset |
Unix-Zeitstempel für den frühesten erneuten Versuch | 1699574460 |
Credit-Berechnung
Credits werden basierend auf der Textlänge und den Verarbeitungsoptionen berechnet. Bei WebSockets werden Credits während des Streamings dynamisch pro Chunk abgezogen.
| Faktor | Multiplikator | Beschreibung |
|---|---|---|
| Basiskosten | 1x |
1 Credits pro Zeichen |
| KI-gestützte Normalisierung | 2x |
Erweiterte Verarbeitung von Arabisch mit diakritischen Zeichen |
| Premium-Stimme | +% |
Zusätzlicher Prozentsatz für Premium-Stimmen |
Beispiel: Ein 500 Zeichen langer Text mit KI-gestützter Normalisierung:
500 characters × 2 (AI-Enhanced) = 1,000 credits
Best Practices
1. WebSockets für umfangreichen sequenziellen Text verwenden
Wenn Sie konversationelle KI-Antworten generieren oder lange Dokumente verarbeiten, senden Sie keine 50 schnellen HTTP-POST-Anfragen. Öffnen Sie stattdessen eine einzelne WebSocket-Verbindung und streamen Sie die Abschnitte über die bestehende Verbindung. Dadurch wird das HTTP-Limit von 60 RPM vollständig umgangen (Credit-Limits gelten jedoch weiterhin).
2. Anfragen-Warteschlange implementieren (HTTP)
Da Moknah keine gleichzeitigen Anfragen unterstützt, reihen Sie Ihre HTTP-Anfragen in eine Warteschlange ein und verarbeiten Sie sie nacheinander:
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. Anfragen-Warteschlange implementieren (HTTP)
Da Moknah keine gleichzeitigen Anfragen unterstützt, reihen Sie Ihre HTTP-Anfragen in eine Warteschlange ein und verarbeiten Sie sie nacheinander:
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. Exponentielles Backoff implementieren
Wenn Sie das Ratenlimit (HTTP 429) oder das Verbindungslimit (WebSocket 4290) erreichen, nutzen Sie exponentielles Backoff, um Anfragen sicher zu wiederholen, ohne den Server zu überlasten:
Zusammenfassung
HTTP-Limits: 60 RPM, 1 gleichzeitige Anfrage.
WebSocket-Limits: 1 gleichzeitige Verbindung, 2.000 Zeichen pro Abschnitt.
Globale Limits: 10.000 CPM (Credits pro Minute).
Benötigen Sie mehr Kapazität? E-Mail sales@moknah.io
Bei Fragen oder Problemen rund um die API kontaktieren Sie uns unter api@moknah.io.