Sebességkorlátok, kvóták és szintek
Ezen az oldalon
Sebességkorlátok, kvóták és szintek
A sebességkorlátok határozzák meg, hány kérést küldhetsz az API-nak percenként. Ezen korlátok megértése és kezelése elengedhetetlen a szolgáltatás megszakadásának elkerüléséhez éles környezetben. A rémálom forgatókönyv mindig ugyanaz: egy integráció, amely hibátlanul működött fejlesztés közben, ahol percenként csak három kérést küldtél, élesbe kerül, és hirtelen több ezer dokumentumot tartalmazó sort kell feldolgoznia. A 429-es hibák özönlenek, és a feldolgozás fele elveszik, mert nem számoltál a szükséges átviteli sebességgel.
A szintrendszer
Az OpenAI a számlázási előzményeid alapján szintekre (szintekre) osztja a korlátokat. Nem te választod ki a szintedet; azt a felhalmozott költés és egy időablak kivárása után oldod fel. Ennek a fejlődésnek fontos gyakorlati következménye van: egy csak ügyféldemóhoz létrehozott fiók kapacitása nem lesz ugyanakkora, mint az éles környezeti fiókodé, még akkor sem, ha a kód azonos.
# A szintek határozzák meg a korlátaidat
# 1. szint: Az első sikeres fizetés után
# 2. szint: 50 $ kumulatív költés + 7 nap után
# 3. szint: 100 $ kumulatív költés + 7 nap után
# 4. szint: 250 $ kumulatív költés + 14 nap után
# 5. szint: 1000 $ kumulatív költés + 30 nap után
# A korlátok minden szinttel jelentősen nőnek
A sebességkorlátok típusai
Három számláló fut egyszerre, és az első, amelyet elérsz, letilt. A rövid szövegek feldolgozása sokkal hamarabb telíti az RPM-et (kérés/perc), mint a TPM-et (token/perc); ezzel szemben a hosszú dokumentumok elemzése kimeríti a TPM-et akkor is, ha csak néhány tucat kérést küldtél. A párhuzamosítás méretezése előtt mindig ellenőrizd a promptjaid nagyságrendjét.
# 1. RPM — Kérések percenként (Requests Per Minute)
# 2. TPM — Tokenek percenként (Tokens Per Minute)
# 3. RPD — Kérések naponta (Requests Per Day)
# Nagyságrend a 3. szinthez (a tényleges korlátokat
# a platform.openai.com > Settings > Limits oldalon ellenőrizd):
# RPM: 5000 kérés/perc
# TPM: 2 000 000 token/perc
# RPD: 10 000 kérés/nap
Sebességkorlát-fejlécek olvasása
Nem kell találgatnod a fogyasztásodat: minden válasz tartalmazza ezt a HTTP-fejléceiben. Az SDK alapértelmezetten elrejti ezeket, hogy csak a parszolt objektumot adja vissza, de a with_raw_response hozzáférést biztosít a nyers válaszhoz, a parse() pedig újjáépíti a szokásos objektumot. Egy ezeken az értékeken alapuló irányítópult figyelmeztet, ahogy közeledsz a plafonhoz, ahelyett, hogy hagyna egy hiba révén szembesülni vele.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Hozzáférés a fejlécekhez a nyers HTTP-válaszon keresztül
# A with_raw_response mód használata
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM korlát: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM maradék: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM korlát: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM maradék: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Visszaállítás: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Válasz: {response.output_text}")
Kliensoldali sebességkorlátozás
Jobb, ha te lassítasz, mint hogy elutasítsanak. Két megvalósítás lefedi a legtöbb igényt.
Átviteli sebesség korlátozása szemaforral
Az első egy szemafort kombinál, amely korlátozza az egyidejű hívások számát, egy, a célzott átviteli sebességből számított késleltetéssel. A példában ötven összefoglaló indul egyszerre, de csak öt fut párhuzamosan, eltolva azzal a késleltetéssel, amely 100 kérés/percnek felel meg. A hívó kód egy egyszerű asyncio.gather marad: minden fegyelem az osztályba van kapszulázva.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Korlátozza az egyidejű kérések számát."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Késleltetés minden kérés között
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())
Egyszerű token-vödör
A token-vödör rugalmasabb, mert lehetővé teszi a kitöréseket (burst). A vödör konstans sebességgel telik, és minden hívással ürül: ha az alkalmazásod egy percig tétlen volt, újraindulhat teljes sebességgel ötven kérés erejéig, majd természetesen visszaáll a töltési sebességre. Pontosan ez a viselkedés kell egy olyan szolgáltatáshoz, amely csúcsok és hullámvölgyek között váltakozik, és a zárnak köszönhetően több szálas környezetekben is működik.
import time
import threading
class TokenBucket:
"Sebességkorlátozó a token-vödör algoritmus alapján."
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):
"""Várakozás, amíg elegendő token rendelkezésre áll."""
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)
# Használat: maximum 50 kérés percenként
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égiák nagy volumenhez
1. Elosztás több projekt között
Minden projektnek megvannak a saját sebességkorlátai. Ha eléred a plafont, miközben már magas szinten vagy, a hívások több projekt közötti elosztása mechanikusan megszorozza a rendelkezésre álló kapacitást. Az alábbi round-robin illusztrálja az elvet; éles környezetben vidd ki a ciklust a függvényből, hogy a hívások között is megmaradjon.
from openai import OpenAI
# Minden projektnek megvannak a saját sebességkorlátai
clients = [
OpenAI(project="proj-aaaa"), # 1. projekt
OpenAI(project="proj-bbbb"), # 2. projekt
OpenAI(project="proj-cccc"), # 3. projekt
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Elosztja a hívásokat több projekt között."""
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. A megfelelő modell használata a megfelelő volumenhez
A modellválasztás nemcsak minőségi, hanem kapacitásbeli döntés is. A legnehezebb modellek fenntartása kritikus feladatokra, és a nagy volumenű forgalom irányítása egy magasabb korlátokkal rendelkező modellre, felszabadítja az átviteli sebességet ott, ahol valóban szükséged van rá.
# A gazdaságos modellek (gpt-5.6-luna) rendelkeznek a legmagasabb korlátokkal
# Használd őket nagy volumenű feladatokhoz
# A zászlóshajó modell (gpt-5.6-sol) rendelkezik a legalacsonyabb korlátokkal
# Tartogasd kritikus feladatokra
3. Sorba állítás (Queuing)
Végül a sorba állítás szétválasztja a kérések előállítását és fogyasztását. Egyetlen szál egy fix ütemben veszi ki a elemeket a sorból, míg az alkalmazás többi része szabadon küldhet; a hívó blokkol egy eseményen, amíg az eredmény meg nem érkezik. Ez a minta elnyeli a csúcsokat anélkül, hogy valaha is túllépné a konfigurált átviteli sebességet.
import queue
import threading
class APIQueue:
"""Sor az API-hívásokhoz."""
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"]
Főbb megállapítások
- A sebességkorlátok egyszerre vonatkoznak az RPM-re, TPM-re és RPD-re
- A szinted határozza meg a korlátaidat – ez a kumulatív költéssel nő
- Olvasd be az
x-ratelimit-*fejléceket, hogy valós időben tudd a fogyasztásodat - Implementálj kliensoldali sebességkorlátozót a 429-es hibák elkerülésére
- Nagy volumen esetén oszd el a terhelést a projektek között
- A Luna biztosítja a legmagasabb sebességkorlátokat a tömeges feldolgozáshoz