Limity rychlosti, kvóty a úrovně
Na této stránce
Limity rychlosti, kvóty a úrovně
Limity rychlosti definují, kolik požadavků můžeš za minutu odeslat do API. Pochopení a správa těchto limitů jsou klíčové pro předcházení výpadkům služby v produkci. Noční můra vypadá vždy stejně: integrace, která bezchybně fungovala ve vývoji, kde jsi posílal tři požadavky za minutu, jde do ostrého provozu a najednou zpracovává frontu několika tisíc dokumentů. Chyby 429 přicházejí v lavině a polovina zpracování se ztratí, protože nebyla anticipována propustnost.
Systém úrovní
OpenAI organizuje limity do úrovní (tierů) na základě historie tvého fakturace. Úroveň si nevybíráš; odemykáš ji akumulací útrat a čekáním na uplynutí časového okna. Tento postup má důležitý praktický důsledek: účet vytvořený pouze pro demo klientovi nebude mít stejnou kapacitu jako tvůj produkční účet, i když je kód identický.
# Tiers determine your limits
# Tier 1: After first successful payment
# Tier 2: After $50 cumulative spend + 7 days
# Tier 3: After $100 cumulative spend + 7 days
# Tier 4: After $250 cumulative spend + 14 days
# Tier 5: After $1000 cumulative spend + 30 days
# Limits increase significantly with each tier
Typy limitů rychlosti
Současně platí tři čítače a ten první, který dosáhneš, tě zablokuje. Zpracování krátkých textů nasytí RPM dlouho před TPM; naopak analýza dlouhých dokumentů vyčerpá TPM, i když jsi odeslal jen několik desítek požadavků. Před nastavením paralelismu si vždy ověř řádovou velikost svých promptů.
# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day
# Order of magnitude for Tier 3 (check your actual limits
# at platform.openai.com > Settings > Limits):
# RPM: 5,000 requests/minute
# TPM: 2,000,000 tokens/minute
# RPD: 10,000 requests/day
Čtení hlaviček limitů rychlosti
Nemusíš svou spotřebu odhadovat: každá odpověď ji nese ve svých HTTP hlavičkách. SDK je ve výchozím nastavení skrývá, aby vracelo pouze parsovaný objekt, ale with_raw_response ti poskytne přístup k surové odpovědi a parse() zrekonstruuje obvyklý objekt. Dashboard napájený těmito hodnotami tě upozorní, jak se blížíš ke stropu, místo abys to zjistil až prostřednictvím chyby.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Access headers via the raw HTTP response
# Using with_raw_response mode
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM limit: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM remaining: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM remaining: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Response: {response.output_text}")
Omezování rychlosti na straně klienta
Je lepší se sám zpomalit, než být odmítnut. Dvě implementace pokrývají většinu potřeb.
Omezení propustnosti pomocí semaforu
První kombinuje semafor, který omezuje počet současných volání, se zpožděním vypočítaným z cílové propustnosti. V příkladu je spuštěno padesát shrnutí najednou, ale pouze pět probíhá paralelně, oddělených zpožděním odpovídajícím 100 požadavkům za minutu. Volající kód zůstává jednoduchý asyncio.gather: veškerá disciplína je zapouzdřena ve třídě.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Limits the number of simultaneous requests."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Delay between each request
async def call(self, prompt: str) -> str:
async with self.semaphore:
await asyncio.sleep(self.delay)
response = await async_client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
async def batch_processing():
limiter = RateLimiter(max_concurrent=5, rpm=100)
prompts = [f"Summarize concept {i}" for i in range(50)]
tasks = [limiter.call(p) for p in prompts]
results = await asyncio.gather(*tasks)
for i, r in enumerate(results):
print(f"Result {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Jednoduchý token bucket
Token bucket je flexibilnější, protože umožňuje nárazové špičky. Kbelík se plní konstantní rychlostí a s každým voláním se vyprazdňuje: pokud byla tvoje aplikace minutu nečinná, může restartovat plnou rychlostí pro padesát požadavků a poté přirozeně klesnout na rychlost plnění. To je přesně chování, které chceš u služby, která střídá špičky a klidová období, a díky zámku funguje i ve vícevláknových prostředích.
import time
import threading
class TokenBucket:
"""Rate limiter based on the token bucket algorithm."""
def __init__(self, tokens_per_second: float, max_capacity: int):
self.tokens_per_second = tokens_per_second
self.max_capacity = max_capacity
self.tokens = max_capacity
self.last_refill = time.monotonic()
self.lock = threading.Lock()
def wait(self, tokens_needed: int = 1):
"""Waits until enough tokens are available."""
while True:
with self.lock:
now = time.monotonic()
elapsed = now - self.last_refill
self.tokens = min(
self.max_capacity,
self.tokens + elapsed * self.tokens_per_second
)
self.last_refill = now
if self.tokens >= tokens_needed:
self.tokens -= tokens_needed
return
time.sleep(0.1)
# Usage: max 50 requests per minute
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)
def limited_call(prompt: str) -> str:
bucket.wait(1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
return response.output_text
Strategie pro vysoké objemy
1. Distribuce napříč více projekty
Každý projekt má své vlastní limity rychlosti. Pokud narazíš na strop, i když již jsi na vysoké úrovni, distribuce volání napříč více projekty mechanicky znásobí dostupnou kapacitu. Níže uvedený round-robin ilustruje princip; v produkci přesuň cyklus mimo funkci, aby přetrvával mezi voláními.
from openai import OpenAI
# Each project has its own rate limits
clients = [
OpenAI(project="proj-aaaa"), # Project 1
OpenAI(project="proj-bbbb"), # Project 2
OpenAI(project="proj-cccc"), # Project 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Distributes calls across multiple projects."""
import itertools
client_cycle = itertools.cycle(clients)
client = next(client_cycle)
return client.responses.create(
model="gpt-5.6-terra",
input=prompt
).output_text
2. Použití správného modelu pro správný objem
Výběr modelu je také rozhodnutím o kapacitě, nejen o kvalitě. Vyhrazení nejnáročnějších modelů pro kritické úkoly a směrování objemu na model s vyššími limity uvolní propustnost tam, kde ji skutečně potřebuješ.
# Economy models (gpt-5.6-luna) have the highest limits
# Use them for high-volume tasks
# The flagship model (gpt-5.6-sol) has the lowest limits
# Reserve it for critical tasks
3. Fronty
Nakonec fronty oddělují produkci požadavků od jejich spotřeby. Jediné vlákno dequeueuje pevným tempem, zatímco zbytek aplikace odesílá volně; volající blokuje na události, dokud nedorazí výsledek. Tento vzor absorbuje špičky, aniž by kdy překročil nakonfigurovanou propustnost.
import queue
import threading
class APIQueue:
"""Queue for API calls."""
def __init__(self, rpm: int = 100):
self.queue = queue.Queue()
self.delay = 60.0 / rpm
self.running = True
self.worker = threading.Thread(target=self._process, daemon=True)
self.worker.start()
def _process(self):
while self.running:
try:
prompt, future = self.queue.get(timeout=1)
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
future["result"] = response.output_text
future["event"].set()
time.sleep(self.delay)
except queue.Empty:
continue
def submit(self, prompt: str) -> str:
future = {"result": None, "event": threading.Event()}
self.queue.put((prompt, future))
future["event"].wait()
return future["result"]
Klíčové poznatky
- Limity rychlosti platí současně pro RPM, TPM a RPD
- Tvá úroveň určuje tvé limity – zvyšuje se s kumulativní útratou
- Čti hlavičky
x-ratelimit-*, abys znal svou spotřebu v reálném čase - Implementuj omezovač rychlosti na straně klienta, abys předešel chybám 429
- Pro vysoké objemy distribuuj zátěž napříč projekty
- Luna nabízí nejvyšší limity rychlosti pro hromadné zpracování