Moknah Doku
Kostenlos starten
API-Referenz

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.

Strikte Richtlinie gegen Gleichzeitigkeit

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

Kurzübersicht

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

API-Support

Bei Fragen oder Problemen rund um die API kontaktieren Sie uns unter api@moknah.io.