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.
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
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
Voor vragen of problemen met betrekking tot de API kun je contact met ons opnemen via api@moknah.io.