Batas Laju
Memahami batas laju API, konkurensi, dan cara bekerja di dalamnya
Ringkasan
Batas laju melindungi API dari penyalahgunaan dan memastikan penggunaan yang adil bagi semua pengguna. Moknah menerapkan batas pada frekuensi permintaan, konsumsi kredit, dan koneksi bersamaan di endpoint HTTP maupun WebSocket kami.
Moknah memproses tepat satu tindakan per pengguna pada satu waktu.
• HTTP: Tunggu hingga permintaan saat ini selesai sebelum mengirim permintaan lain. Permintaan bersamaan akan menerima respons 409 Conflict atau 429 Too Many Requests.
• WebSocket: Anda hanya dapat memiliki 1 koneksi WebSocket aktif pada satu waktu. Membuka koneksi kedua akan langsung menutupnya dengan kode 4290.
Batas Default
| Jenis Batas | Nilai | Berlaku Untuk | Deskripsi |
|---|---|---|---|
| Permintaan per Menit (RPM) | 60 |
Hanya HTTP | Jumlah maksimum permintaan POST API standar per menit. |
| Kredit per Menit (CPM) | 10,000 |
HTTP & WebSocket | Kredit maksimum yang digunakan per menit. |
| Koneksi Aktif | 1 |
Khusus WebSocket | Jumlah maksimum stream WSS simultan per pengguna. |
Batas & Kode Penutupan WebSocket
Karena WebSocket mempertahankan koneksi persisten, WebSocket tidak menggunakan header HTTP untuk pembatasan laju. Sebagai gantinya, batas diterapkan melalui pemutusan koneksi dan pesan kontrol JSON:
| Batas Tercapai | Perilaku / Output |
|---|---|
| Batas Konkurensi | Koneksi langsung ditutup dengan kode 4290. |
| Kredit Habis | Menerima error JSON lalu ditutup. |
| Batas Ukuran Potongan | Menerima error JSON jika satu potongan teks melebihi 2.000 karakter. |
| Batas Laju Pesan | Menerima error JSON jika Anda mengirim potongan teks lebih cepat daripada yang dapat diproses antrean. |
Catatan: Jika WebSocket Anda terputus secara tidak terduga, tunggu setidaknya 15 detik sebelum menyambungkan kembali untuk memastikan kunci di sisi server telah sepenuhnya dilepaskan.
Header Batas Laju HTTP
Untuk endpoint REST standar, setiap respons API menyertakan header untuk membantu Anda memantau status Anda:
| Header | Deskripsi | Contoh |
|---|---|---|
RateLimit-Limit |
Batas RPM (permintaan per menit) Anda | 60 |
RateLimit-Remaining |
Sisa permintaan pada menit ini | 45 |
RateLimit-Reset |
Stempel waktu Unix saat batas direset | 1699574460 |
Moknah-Credits-Remaining |
Sisa kredit pada menit ini | 10000 |
Moknah-Credits-Used |
Kredit yang digunakan pada menit ini | 5000 |
Saat Terkena Batas Laju HTTP
Jika Anda melebihi batas laju HTTP, Anda akan menerima respons 429 Too Many Requests dengan header tambahan berikut:
| Header | Deskripsi | Contoh |
|---|---|---|
Retry-After |
Detik untuk menunggu sebelum mencoba lagi | 45 |
RateLimit-Reset |
Stempel waktu Unix saat Anda dapat mencoba lagi | 1699574460 |
Perhitungan Kredit
Kredit dihitung berdasarkan panjang teks dan opsi pemrosesan. Untuk WebSocket, kredit dipotong secara dinamis per potongan saat di-stream.
| Faktor | Pengali | Deskripsi |
|---|---|---|
| Biaya dasar | 1x |
1 kredit per karakter |
| Normalisasi Berbasis AI | 2x |
Pemrosesan bahasa Arab tingkat lanjut dengan diakritik |
| Suara Premium | +% |
Persentase tambahan untuk suara premium |
Contoh: Teks 500 karakter dengan normalisasi yang disempurnakan AI:
500 characters × 2 (AI-Enhanced) = 1,000 credits
Praktik Terbaik
1. Gunakan WebSocket untuk Teks Berurutan Bervolume Tinggi
Jika Anda menghasilkan respons AI percakapan atau mengurai dokumen panjang, jangan membuat 50 permintaan HTTP POST secara cepat. Buka satu koneksi WebSocket dan alirkan potongan teks melalui koneksi persisten tersebut. Cara ini sepenuhnya melewati batas HTTP 60 RPM (meskipun batas kredit tetap berlaku).
2. Terapkan Antrean Permintaan (HTTP)
Karena Moknah tidak mendukung permintaan bersamaan, masukkan permintaan HTTP Anda ke dalam antrean dan proses secara berurutan:
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. Terapkan Antrean Permintaan (HTTP)
Karena Moknah tidak mendukung permintaan bersamaan, masukkan permintaan HTTP Anda ke dalam antrean dan proses secara berurutan:
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. Terapkan Exponential Backoff
Saat terkena batas laju (HTTP 429) atau batas koneksi (WebSocket 4290), gunakan exponential backoff untuk mencoba kembali dengan aman tanpa membebani server:
Ringkasan
Batas HTTP: 60 RPM, 1 permintaan bersamaan.
Batas WebSocket: 1 koneksi bersamaan, 2.000 karakter per potongan.
Batas global: 10.000 CPM (Kredit Per Menit).
Butuh kapasitas lebih besar? E-mail sales@moknah.io
Untuk pertanyaan atau masalah terkait API, hubungi kami di api@moknah.io.