Moknah Docs
Gratis starten
API-referentie

Rate-limieten

Inzicht in API-rate-limits, gelijktijdigheid en hoe je hiermee werkt

Overzicht

Rate limits beschermen de API tegen misbruik en zorgen voor eerlijk gebruik voor alle gebruikers. Moknah hanteert limieten voor de verzoekfrequentie, het creditverbruik en gelijktijdige verbindingen voor zowel onze HTTP- als WebSocket-endpoints.

Strikt beleid tegen gelijktijdigheid

Moknah verwerkt precies één actie per gebruiker tegelijk.
• HTTP: Wacht tot het huidige verzoek is voltooid voordat je een nieuw verzoek stuurt. Gelijktijdige verzoeken krijgen een 409 Conflict of 429 Too Many Requests.
• WebSocket: Je mag slechts 1 actieve WebSocket-verbinding tegelijk open hebben. Als je een tweede verbinding opent, wordt deze direct gesloten met code 4290.

Standaardlimieten

Limiettype Waarde Van toepassing op Beschrijving
Verzoeken per minuut (RPM) 60 Alleen HTTP Maximumaantal standaard API POST-verzoeken per minuut.
Credits per minuut (CPM) 10,000 HTTP & WebSocket Maximum aantal verbruikte credits per minuut.
Actieve verbindingen 1 Alleen WebSocket Maximum aantal gelijktijdige WSS-streams per gebruiker.

WebSocket-limieten & sluitingscodes

Omdat WebSockets een blijvende verbinding onderhouden, gebruiken ze geen HTTP-headers voor rate limiting. In plaats daarvan worden limieten afgedwongen via verbindingsonderbrekingen en JSON-controleberichten:

Limiet bereikt Gedrag / Uitvoer
Gelijktijdigheidslimiet Verbinding wordt direct gesloten met code 4290.
Credits opgebruikt Ontvangt JSON-fout en sluit.
Limiet voor blokgrootte Ontvangt een JSON-fout als één tekstblok langer is dan 2.000 tekens.
Limiet voor berichtfrequentie Ontvangt een JSON-fout als je tekstblokken sneller verstuurt dan de wachtrij ze kan verwerken.

Opmerking: als je WebSocket-verbinding onverwacht wordt verbroken, wacht dan minstens 15 seconden voordat je opnieuw verbinding maakt om zeker te zijn dat de vergrendeling op de server volledig is opgeheven.

HTTP-headers voor rate limits

Voor standaard REST-endpoints bevat elke API-respons headers waarmee je je status kunt volgen:

Header Beschrijving Voorbeeld
RateLimit-Limit Je RPM-limiet (verzoeken per minuut) 60
RateLimit-Remaining Resterende verzoeken in deze minuut 45
RateLimit-Reset Unix-tijdstempel waarop limieten worden gereset 1699574460
Moknah-Credits-Remaining Resterende credits in deze minuut 10000
Moknah-Credits-Used Gebruikte credits in deze minuut 5000

Bij overschrijding van de HTTP-rate limit

Als je de HTTP-rate limit overschrijdt, ontvang je een 429 Too Many Requests-respons met deze extra headers:

Header Beschrijving Voorbeeld
Retry-After Seconden wachten voordat je opnieuw probeert 45
RateLimit-Reset Unix-tijdstempel waarop je opnieuw kunt proberen 1699574460

Creditberekening

Credits worden berekend op basis van tekstlengte en verwerkingsopties. Voor WebSockets worden credits dynamisch per blok afgeschreven tijdens het streamen.

Factor Vermenigvuldiger Beschrijving
Basiskosten 1x 1 credits per teken
AI-verbeterde normalisatie 2x Geavanceerde Arabische verwerking met diakritische tekens
Premium-stem +% Extra percentage voor premium-stemmen

Voorbeeld: Een tekst van 500 tekens met AI-verbeterde normalisatie:

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

Best practices

1. Gebruik WebSockets voor grote hoeveelheden opeenvolgende tekst

Als je conversationele AI-antwoorden genereert of lange documenten verwerkt, stuur dan geen 50 snelle HTTP POST-verzoeken. Open één WebSocket-verbinding en stream de fragmenten via de blijvende verbinding. Hiermee omzeil je de HTTP-limiet van 60 RPM volledig (hoewel creditlimieten wel van kracht blijven).

2. Implementeer een wachtrij voor verzoeken (HTTP)

Omdat Moknah geen gelijktijdige verzoeken ondersteunt, plaats je je HTTP-verzoeken in een wachtrij en verwerk je ze achter elkaar:

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. Implementeer een wachtrij voor verzoeken (HTTP)

Omdat Moknah geen gelijktijdige verzoeken ondersteunt, plaats je je HTTP-verzoeken in een wachtrij en verwerk je ze achter elkaar:

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. Implementeer exponential backoff

Wanneer je tegen een snelheidslimiet (HTTP 429) of verbindingslimiet (WebSocket 4290) aanloopt, gebruik dan exponential backoff om het veilig opnieuw te proberen zonder de server te overbelasten:


Samenvatting

Snel overzicht

HTTP-limieten: 60 RPM, 1 gelijktijdig verzoek.
WebSocket-limieten: 1 gelijktijdige verbinding, 2.000 tekens per fragment.
Algemene limieten: 10.000 CPM (credits per minuut).
Meer capaciteit nodig? E-mail sales@moknah.io

API-ondersteuning

Voor vragen of problemen met betrekking tot de API kun je contact met ons opnemen via api@moknah.io.