Limity rýchlosti, kvóty a úrovne
Na tejto strane
Limity rýchlosti, kvóty a úrovne
Limity rýchlosti definujú, koľko požiadaviek môžeš odoslať do API za minútu. Pochopenie a správa týchto limitov sú kľúčové pre predchádzanie výpadkom služby v produkcii. Nočná mora vyzerá vždy rovnako: integrácia, ktorá bezchybne fungovala vo vývoji, kde si odosielal tri požiadavky za minútu, ide do ostrej prevádzky a zrazu spracováva front niekoľkých tisíc dokumentov. Chyby 429 prichádzajú v záplave a polovica spracovania sa stratí, pretože sa nepočítalo s priepustnosťou.
Systém úrovní
OpenAI organizuje limity do úrovní na základe tvojej histórie fakturácie. Úroveň si nevyberáš; odomkneš ju nahromadením útrat a vyčkaním určitého časového okna. Tento postup má dôležitý praktický dôsledok: účet vytvorený len pre demo klientovi nebude mať rovnakú kapacitu ako tvoj produkčný účet, aj keď je kód identický.
# Úrovne určujú tvoje limity
# Úroveň 1: Po prvej úspešnej platbe
# Úroveň 2: Po kumulatívnej útrate 50 $ + 7 dňoch
# Úroveň 3: Po kumulatívnej útrate 100 $ + 7 dňoch
# Úroveň 4: Po kumulatívnej útrate 250 $ + 14 dňoch
# Úroveň 5: Po kumulatívnej útrate 1000 $ + 30 dňoch
# Limity sa s každou úrovňou výrazne zvyšujú
Typy limitov rýchlosti
Súčasne platia tri počítadlá a prvé, ktoré dosiahneš, ťa zablokuje. Spracovanie krátkych textov nasýti RPM (požiadavky za minútu) dlho pred TPM (tokeny za minútu); naopak, analýza dlhých dokumentov vyčerpá TPM, aj keď si odoslal len niekoľko desiatok požiadaviek. Pred nastavením paralelizmu si vždy over rádové veľkosti svojich promptov.
# 1. RPM — Požiadavky za minútu (Requests Per Minute)
# 2. TPM — Tokeny za minútu (Tokens Per Minute)
# 3. RPD — Požiadavky za deň (Requests Per Day)
# Rádové veľkosti pre Úroveň 3 (skutočné limity si over
# na platform.openai.com > Settings > Limits):
# RPM: 5 000 požiadaviek/minútu
# TPM: 2 000 000 tokenov/minútu
# RPD: 10 000 požiadaviek/deň
Čítanie hlavičiek limitov rýchlosti
Netreba hádať tvoju spotrebu: každá odpoveď ju nesie vo svojich HTTP hlavičkách. SDK ich štandardne skrýva, aby vrátilo iba analyzovaný objekt, ale with_raw_response ti dá prístup k surovej odpovedi a parse() zrekonštruuje bežný objekt. Dashboard napájaný týmito hodnotami ťa upozorní, keď sa blížiš k stropu, namiesto toho, aby si to zistil až cez chybu.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Prístup k hlavičkám cez surovú HTTP odpoveď
# Použitie režimu with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"Limit RPM: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"Zostávajúce RPM: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Limit TPM: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"Zostávajúce TPM: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset za: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Odpoveď: {response.output_text}")
Obmedzovanie rýchlosti na strane klienta
Je lepšie sa sám spomaliť, než byť odmietnutý. Dve implementácie pokrývajú väčšinu potrieb.
Obmedzenie priepustnosti pomocou semafóru
Prvá kombinuje semafor, ktorý obmedzuje počet súbežných volaní, s oneskorením vypočítaným z cieľovej priepustnosti. V príklade sa spustí päťdesiat zhrnutí naraz, ale paralelne prebiehajú iba päť, oddelené oneskorením zodpovedajúcim 100 požiadavkám za minútu. Volajúci kód zostáva jednoduchý asyncio.gather: celá disciplína je zapuzdrená v triede.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Obmedzuje počet súbežných požiadaviek."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Onesorenie medzi každou požiadavkou
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"Zhrň koncept {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"Výsledok {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Jednoduchý token bucket
Token bucket je flexibilnejší, pretože umožňuje nárazové špičky. Vedro sa plní konštantnou rýchlosťou a s každým volaním sa vyprázdňuje: ak tvoja aplikácia bola minútu nečinná, môže reštartovať plnou rýchlosťou na päťdesiat požiadaviek a potom prirodzene klesnúť na rýchlosť plnenia. Presne takéto správanie chceš pre službu, ktorá strieda špičky a poklesy, a vďaka zámku funguje aj v multivláknových prostrediach.
import time
import threading
class TokenBucket:
"""Obmedzovač rýchlosti založený na algoritme token bucket."""
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):
"""Čaká, kým nie je k dispozícii dostatok tokenov."""
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)
# Použitie: max 50 požiadaviek za minútu
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
Stratégie pre vysoké objemy
1. Distribúcia medzi viaceré projekty
Každý projekt má svoje vlastné limity rýchlosti. Ak dosiahneš strop, keď už si na vysokej úrovni, distribúcia volaní medzi viaceré projekty mechanicky znásobí dostupnú kapacitu. Nižšie uvedený round-robin ilustruje princíp; v produkcii presuň cyklus mimo funkcie, aby pretrvával medzi volaniami.
from openai import OpenAI
# Každý projekt má svoje vlastné limity rýchlosti
clients = [
OpenAI(project="proj-aaaa"), # Projekt 1
OpenAI(project="proj-bbbb"), # Projekt 2
OpenAI(project="proj-cccc"), # Projekt 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Distribuuje volania medzi viaceré projekty."""
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žitie správneho modelu pre správny objem
Výber modelu je tiež rozhodnutím o kapacite, nielen o kvalite. Vyhradenie najnáročnejších modelov pre kritické úlohy a smerovanie objemu na model s vyššími limitmi uvoľní priepustnosť tam, kde ju skutočne potrebuješ.
# Ekonomické modely (gpt-5.6-luna) majú najvyššie limity
# Použi ich pre úlohy s vysokým objemom
# Vlajkový model (gpt-5.6-sol) má najnižšie limity
# Vyhraď ho pre kritické úlohy
3. Fronty (Queuing)
Nakoniec, fronty oddeľujú produkciu požiadaviek od ich spotreby. Jediné vlákno vyberá položky frontu pevným tempom, zatiaľ čo zvyšok aplikácie odosiela voľne; volateľ blokuje na udalosti, kým nepríde jeho výsledok. Tento vzor absorbuje špičky bez toho, aby niekedy prekročil nastavenú priepustnosť.
import queue
import threading
class APIQueue:
"""Fronta pre volania API."""
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"]
Kľúčové poznatky
- Limity rýchlosti platia súčasne pre RPM, TPM a RPD
- Tvoja úroveň určuje tvoje limity – zvyšuje sa s tvojou kumulatívnou útratou
- Čítaj hlavičky
x-ratelimit-*, aby si poznal svoju spotrebu v reálnom čase - Implementuj obmedzovač rýchlosti na strane klienta, aby si sa vyhol chybám 429
- Pre vysoké objemy rozdeľ záťaž medzi projekty
- Luna ponúka najvyššie limity rýchlosti pre hromadné spracovanie