Moknah Dokumen
Mulai gratis
Referensi API

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.

Kebijakan Ketat Tanpa Konkurensi

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

Referensi Cepat

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

Dukungan API

Untuk pertanyaan atau masalah terkait API, hubungi kami di api@moknah.io.