Rate limits

Batas belanja Anda adalah token cap per pelanggan berdasarkan model tier class (mingguan + bulanan). RPM/TPM berperan sebagai burst guard anti-flood, dan token pack menambah headroom untuk lonjakan terencana.

Token cap berdasarkan model tier class

Batas belanja pada flat tier adalah batas token per kelas tier model yang keras, ditegakkan per pelanggan pada jendela mingguan dan bulanan. Tier class sebuah model (budget / mid / premium / ultra) ditentukan oleh harganya. Cap dibagi di seluruh key pada satu akun — N key mengambil dari satu bucket, menutup eksploit gaming multi-key yang dimiliki gateway lama. Lewati cap mingguan atau bulanan sebuah class dan request mengembalikan 402 token_quota_exceeded. Sebuah class tanpa baris untuk suatu tier tidak tersedia pada tier itu.

Token menghitung input + output. Starter hanya menjalankan model budget. Pro menambahkan mid + premium. Ultra-class adalah wilayah Enterprise / PAYG. PAYG dan Enterprise tidak memiliki token cap keras — penggunaan diatur oleh alert cost-velocity internal yang halus ditambah ketentuan komersial Anda.

Sebuah reserved Free tier (budget saja, 1M wk / 3M mo) ada dalam skema tetapi belum memiliki pendaftaran aktif hari ini.

Override kustom per-pelanggan tersedia — hubungi [email protected].

Burst guard RPM / TPM + inflight cap

Terpisah dari token cap (batas belanja Anda), setiap tier memiliki burst guard RPM dan TPM plus sebuah inflight cap per key. Ini adalah limit anti-flood — mereka melindungi provider upstream dan tail latency Anda sendiri, bukan budget bulanan Anda. Memicu salah satunya mengembalikan 429 rate_limit_exceeded (atau concurrent_limit_exceeded untuk inflight cap).

RPM = request / menit (laju). TPM = total token / menit (input + output). Max concurrent = request in-flight bersamaan per key — ruang untuk konkurensi, bukan batas throughput.

Dua batas yang berbeda

• 402 token_quota_exceeded — Anda menghabiskan token cap mingguan atau bulanan untuk sebuah model tier class. Response membawa model_tier_class dan window (weekly | monthly). Retry tidak akan membantu sampai jendela bergulir — beli token pack, upgrade tier Anda, atau pindahkan workload ke class yang masih memiliki budget.
• 429 rate_limit_exceeded — Anda memicu burst guard RPM/TPM. Transien: back off dan retry, dengan menghormati Retry-After.

Baca ini alih-alih menabrak limit

Setiap response yang berhasil melaporkan budget burst-guard RPM/TPM Anda saat ini. Gunakan untuk melakukan throttle di sisi client sebelum guard memicu. Habisnya token cap muncul sebagai 402 token_quota_exceeded, berbeda dari flood guard 429 rate_limit_exceeded.

200 — header burst-guard di setiap response

HTTP/1.1 200 OK
x-anoman-rate-limit-rpm:    120
x-anoman-rate-remaining-rpm: 86
x-anoman-rate-limit-tpm:    500000
x-anoman-rate-remaining-tpm: 491200
x-anoman-tier:              pro
content-type:               application/json

402 — kuota token terlampaui (batas belanja)

HTTP/1.1 402 Payment Required
x-anoman-tier:              pro
content-type:               application/json

{
  "error": {
    "type": "billing_error",
    "code": "token_quota_exceeded",
    "message": "Monthly token cap reached for the 'premium' model tier class.",
    "model_tier_class": "premium",
    "window": "monthly"
  }
}

429 — burst guard terpicu (flood RPM/TPM)

HTTP/1.1 429 Too Many Requests
x-anoman-rate-limit-rpm:    120
x-anoman-rate-remaining-rpm: 0
retry-after:                24
x-anoman-tier:              pro
content-type:               application/json

{
  "error": {
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded",
    "message": "120 RPM limit exceeded. Retry after 24s."
  }
}

429 — cap concurrent (inflight)

HTTP/1.1 429 Too Many Requests
x-anoman-inflight-cap:     150
x-anoman-inflight-current: 150
x-anoman-tier:             pro
content-type:              application/json

{
  "error": {
    "type": "rate_limit_error",
    "code": "concurrent_limit_exceeded",
    "message": "Per-key inflight cap (150) reached. Drop concurrency or upgrade tier."
  }
}

Hormati Retry-After

SDK OpenAI / Anthropic retry secara otomatis secara default, tetapi mereka mengabaikan Retry-After di beberapa versi. Berikut pola eksplisit yang memilih waktu tunggu yang disarankan server jika ada, jika tidak exponential backoff:

Python — hormati Retry-After

import time
from openai import OpenAI
from openai import RateLimitError, APIStatusError
 
client = OpenAI(base_url="https://api.anoman.io/v1", api_key="anm-sk-...")
 
def call_with_backoff(messages, model="gpt-4o-mini", max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return client.chat.completions.create(model=model, messages=messages)
        except (RateLimitError, APIStatusError) as e:
            if attempt == max_attempts - 1:
                raise
            # Retry-After in seconds (server-suggested wait)
            retry_after = float(e.response.headers.get("retry-after", 0))
            # Fall back to exponential backoff with jitter
            sleep = retry_after or min(2 ** attempt, 30)
            time.sleep(sleep)

TypeScript — pola yang sama

import OpenAI, { APIError } from "openai";
 
const client = new OpenAI({
  baseURL: "https://api.anoman.io/v1",
  apiKey: process.env.ANOMAN_API_KEY,
});
 
async function callWithBackoff<T>(fn: () => Promise<T>, max = 5): Promise<T> {
  for (let i = 0; i < max; i++) {
    try {
      return await fn();
    } catch (err) {
      if (!(err instanceof APIError) || err.status !== 429) throw err;
      if (i === max - 1) throw err;
      const retryAfter = Number(err.headers?.["retry-after"] ?? 0);
      const sleep = retryAfter || Math.min(2 ** i, 30);
      await new Promise(r => setTimeout(r, sleep * 1000));
    }
  }
  throw new Error("unreachable");
}

Concurrent vs rate

Kedua kode 429 memiliki arti yang berbeda:

• rate_limit_exceeded — Anda memicu burst guard RPM/TPM. Retry setelah jendela bergulir.
• concurrent_limit_exceeded — terlalu banyak in-flight pada saat bersamaan. Kurangi konkurensi atau tunggu satu selesai.

Inflight cap independen terhadap RPM/TPM. Akun Pro pada 120 RPM dengan inflight cap 150 dapat menembakkan 120 request sekuensial per menit atau hingga 150 bersamaan — tetapi tidak 150 bersamaan untuk panggilan 5 detik (itu akan membuat RPM melonjak jauh di atas 120).

Kenapa keduanya? RPM melindungi layanan upstream dari volume total. Inflight cap melindungi budget latensi Anda sendiri — terlalu banyak request in-flight yang menunggu di antrean upstream membuat semua orang lebih lambat. Inflight lebih rendah = tail latency yang dapat diprediksi.

Beli token ekstra saat Anda butuh headroom

Pada flat tier, ketika sebuah model tier class mendekati token cap-nya, beli token pack untuk menambah headroom sementara ke class itu selama durasi tetap. Ini adalah tambahan aditif ke cap class tersebut — bukan perubahan pada burst guard RPM/TPM Anda. Biaya dipotong dari saldo prabayar Anda.

Python — beli token pack

import requests
 
# Token packs add temporary headroom to a model tier class's token cap.
# Cost is deducted from prepaid balance. Pricing varies per tier — see the
# token-pack pricing table in your dashboard.
response = requests.post(
    "https://api.anoman.io/anoman/v1/burst/activate",
    headers={"Authorization": "Bearer anm-sk-..."},
    json={"model_tier_class": "premium", "extra_tokens": 5_000_000, "duration_hours": 24},
)
response.raise_for_status()
print(response.json())
# {
#   "active": true,
#   "model_tier_class": "premium",
#   "extra_tokens": 5000000,
#   "expires_at": 1740086400,
#   "cost_usd": "7.00",
#   "balance_remaining_usd": "23.00"
# }

PAYG dan Enterprise tidak butuh token pack — mereka memang tidak memiliki token cap keras sejak awal.

Pantau token cap Anda secara real time

Dashboard Rate Limits menampilkan penggunaan token per-class dan burst guard RPM/TPM dengan sparkline.

• Buka dashboard
• Kembali ke docs