Ograničenja stope, kvote i razine
Na ovoj stranici
Ograničenja stope, kvote i razine
Ograničenja stope definiraju koliko zahtjeva možeš poslati API-ju u minuti. Razumijevanje i upravljanje tim ograničenjima ključno je za izbjegavanje prekida usluge u produkcijskom okruženju. Noćna mora je uvijek ista: integracija koja je besprijekorno radila u razvoju, gdje si slao tri zahtjeva u minuti, krene u proizvodnju i odjednom obrađuje red od nekoliko tisuća dokumenata. Greške 429 preplave sustav, a pola obrade se izgubi jer propusnost nije bila predviđena.
Sustav razina
OpenAI organizira ograničenja u razine temeljem tvoje povijesti naplate. Ne biraš svoju razinu; otključavaš je akumuliranjem troškova i čekanjem određenog vremenskog prozora. Taj napredak ima važnu praktičnu posljedicu: račun stvoren samo za demonstraciju klijentu neće imati isti kapacitet kao tvoj produkcijski račun, čak i ako je kod identičan.
# Razine određuju tvoja ograničenja
# Razina 1: Nakon prve uspješne uplate
# Razina 2: Nakon 50 USD ukupne potrošnje + 7 dana
# Razina 3: Nakon 100 USD ukupne potrošnje + 7 dana
# Razina 4: Nakon 250 USD ukupne potrošnje + 14 dana
# Razina 5: Nakon 1000 USD ukupne potrošnje + 30 dana
# Ograničenja se značajno povećavaju sa svakom razinom
Vrste ograničenja stope
Tri brojača vrijede istovremeno, a prvi koji dosegneš blokira te. Obrada kratkih tekstova zasitit će RPM (zahtjeva u minuti) puno prije nego TPM (tokena u minuti); suprotno tome, analiza dugih dokumenata iscrpit će TPM čak i ako si poslao samo nekoliko desetaka zahtjeva. Uvijek provjeri red veličine svojih promptova prije nego što odrediš razinu paralelizma.
# 1. RPM — Zahtjeva u minuti (Requests Per Minute)
# 2. TPM — Tokena u minuti (Tokens Per Minute)
# 3. RPD — Zahtjeva dnevno (Requests Per Day)
# Red veličine za Razinu 3 (provjeri svoja stvarna ograničenja
# na platform.openai.com > Settings > Limits):
# RPM: 5.000 zahtjeva/minuti
# TPM: 2.000.000 tokena/minuti
# RPD: 10.000 zahtjeva/dnevno
Čitanje zaglavlja ograničenja stope
Ne moraš nagađati svoju potrošnju: svaki odgovor nosi je u svojim HTTP zaglavljima. SDK ih prema zadanim postavkama skriva kako bi vratio samo parsirani objekt, ali with_raw_response ti daje pristup sirovom odgovoru, a parse() rekonstruira uobičajeni objekt. Nadzorna ploča napunjena tim vrijednostima upozorit će te dok se približavaš stropu, umjesto da to otkriješ putem greške.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Pristup zaglavljima putem sirovog HTTP odgovora
# Korištenje načina with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM ograničenje: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM preostalo: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM ograničenje: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM preostalo: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Ponovno postavljanje za: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Odgovor: {response.output_text}")
Ograničavanje stope na strani klijenta
Bolje je da se sam usporiš nego da budeš odbijen. Dvije implementacije pokrivaju većinu potreba.
Ograničavanje propusnosti semaforom
Prva kombinira semafor, koji ograničava broj istovremenih poziva, s kašnjenjem izračunatim iz ciljne propusnosti. U primjeru se pokreće pedeset sažetaka odjednom, ali samo pet teče paralelno, razmaknuto kašnjenjem koje odgovara 100 zahtjeva u minuti. Kod koji poziva ostaje jednostavan asyncio.gather: sva je disciplina encapsulirana u klasi.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Ograničava broj istovremenih zahtjeva."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Kašnjenje između svakog zahtjeva
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"Rezultat {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Jednostavna kanta s tokenima
Kanta s tokenima fleksibilnija je jer dopušta burstove (nagle skokove). Kanta se puni konstantnom brzinom i prazni sa svakim pozivom: ako je tvoja aplikacija mirovala minutu, može ponovno pokrenuti punom brzinom za pedeset zahtjeva, a zatim se prirodno vratiti na brzinu punjenja. To je točno ponašanje koje želiš za uslugu koja izmjenjuje vrhunce i zatišja, a funkcionira u višenitnim okruženjima zahvaljujući bravi.
import time
import threading
class TokenBucket:
"""Ograničivač stope temeljen na algoritmu kante s tokenima."""
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):
"""Čeka dok nije dostupno dovoljno tokena."""
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)
# Upotreba: maks. 50 zahtjeva u minuti
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
Strategije za velike volumene
1. Distribucija na više projekata
Svaki projekt ima svoja vlastita ograničenja stope. Ako dosegneš strop dok si već na visokoj razini, distribucija poziva na više projekata mehanički množi dostupni kapacitet. Donji round-robin ilustrira princip; u proizvodnji premjesti ciklus izvan funkcije kako bi trajao između poziva.
from openai import OpenAI
# Svaki projekt ima svoja vlastita ograničenja stope
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:
"""Distribuira pozive na više projekata."""
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. Korištenje ispravnog modela za ispravan volumen
Izbor modela također je odluka o kapacitetu, a ne samo o kvaliteti. Rezerviranje najtežih modela za kritične zadatke i usmjeravanje volumena na model s višim ograničenjima oslobađa propusnost tamo gdje ti je stvarno potrebna.
# Ekonomični modeli (gpt-5.6-luna) imaju najviša ograničenja
# Koristi ih za zadatke velikog volumena
# Vodeći model (gpt-5.6-sol) ima najniža ograničenja
# Rezerviraj ga za kritične zadatke
3. Stavljanje u red čekanja
Konačno, stavljanje u red čekanja odvaja proizvodnju zahtjeva od potrošnje. Jedna nit uklanja iz reda fiksnim tempom dok ostatak aplikacije slobodno podnosi zahtjeve; pozivatelj blokira na događaju dok ne stigne njegov rezultat. Ovaj obrazac apsorbira vrhunce bez ikakvog prekoračenja konfigurirane propusnosti.
import queue
import threading
class APIQueue:
"""Red čekanja za API pozive."""
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"]
Ključne točke
- Ograničenja stope vrijede istovremeno za RPM, TPM i RPD
- Tvoja razina određuje tvoja ograničenja — povećava se s tvojom ukupnom potrošnjom
- Čitaj zaglavlja
x-ratelimit-*kako bi znao svoju potrošnju u stvarnom vremenu - Implementiraj ograničivač stope na strani klijenta kako bi izbjegao greške 429
- Distribuiraj opterećenje na projekte za velike volumene
- Luna nudi najviša ograničenja stope za masovnu obradu