Limite de debit, cote și niveluri
Pe această pagină
Limite de debit, cote și niveluri
Limitele de debit definesc numărul de cereri pe care le puteți trimite către API pe minut. Înțelegerea și gestionarea acestor limite sunt esențiale pentru a evita întreruperile serviciului în producție. Scenariul coșmar este întotdeauna același: o integrare care a funcționat impecabil în dezvoltare, unde trimiteați trei cereri pe minut, intră în producție și procesează brusc o coadă de câteva mii de documente. Erorile 429 sosesc în avalanșă, iar jumătate din procesare se pierde deoarece throughput-ul nu a fost anticipat.
Sistemul de niveluri
OpenAI organizează limitele pe niveluri, în funcție de istoricul dvs. de facturare. Nu vă alegeți nivelul; îl deblocați acumulând cheltuieli și așteptând trecerea unei ferestre de timp. Această progresie are o consecință practică importantă: un cont creat special pentru o demonstrație client nu va avea aceeași capacitate ca contul dvs. de producție, chiar dacă codul este identic.
# 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
Tipuri de limite de debit
Trei contoare se aplică simultan, iar primul pe care îl atingeți vă blochează. Procesarea textelor scurte va satura RPM (cereri pe minut) mult înainte de TPM (tokeni pe minut); invers, analizarea documentelor lungi va epuiza TPM chiar dacă ați trimis doar câteva zeci de cereri. Verificați întotdeauna ordinul de mărime al prompturilor înainte de a dimensiona paralelismul.
# 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
Citirea antetelor de limitare a debitului
Nu trebuie să ghiciți consumul: fiecare răspuns îl conține în anteturile HTTP. SDK-ul le ascunde implicit pentru a returna doar obiectul analizat, dar with_raw_response vă oferă acces la răspunsul brut, iar parse() reconstruiește obiectul obișnuit. Un tablou de bord alimentat de aceste valori vă avertizează pe măsură ce vă apropiați de plafon, în loc să vă lase să-l descoperiți printr-o eroare.
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}")
Limitarea debitului la nivel de client
Este mai bine să vă autolimitați decât să fiți respins. Două implementări acoperă majoritatea nevoilor.
Limitarea throughput-ului cu un semafor
Prima combină un semafor, care limitează numărul de apeluri simultane, cu o întârziere calculată din throughput-ul țintă. În exemplu, cincizeci de rezumate sunt lansate simultan, dar doar cinci progresează în paralel, spațiate de întârzierea corespunzătoare a 100 de cereri pe minut. Codul apelant rămâne un simplu asyncio.gather: toată disciplina este encapsulată în clasă.
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())
Găleată simplă de tokeni (Token Bucket)
Găleata de tokeni este mai flexibilă deoarece permite vârfuri de activitate. Găleata se umple cu o rată constantă și se golește la fiecare apel: dacă aplicația dvs. a fost inactivă timp de un minut, poate reporni cu viteza maximă pentru cincizeci de cereri, apoi revine natural la rata de umplere. Acesta este exact comportamentul dorit pentru un serviciu care alternează între vârfuri și perioade de acalmie, și funcționează în medii multithread datorită mecanismului de lock.
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
Strategii pentru volume mari
1. Distribuirea pe mai multe proiecte
Fiecare proiect are propriile limite de debit. Dacă atingeți plafonul fiind deja într-un nivel ridicat, distribuirea apelurilor pe mai multe proiecte multiplică mecanic capacitatea disponibilă. Exemplul round-robin de mai jos ilustrează principiul; în producție, mutați ciclul în afara funcției pentru a persista între apeluri.
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. Utilizarea modelului potrivit pentru volumul potrivit
Alegerea modelului este, de asemenea, o decizie de capacitate, nu doar de calitate. Rezervarea modelelor cele mai grele pentru sarcini critice și direcționarea volumului către un model cu limite mai mari eliberează throughput acolo unde aveți nevoie de el.
# 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. Coada de așteptare (Queuing)
În final, coada de așteptare decuplează producția de cereri de consumul acestora. Un singur thread extrage elemente din coadă cu un ritm fix, în timp ce restul aplicației trimite liber; apelantul se blochează pe un eveniment până când rezultatul său sosește. Acest model absoarbe vârfurile fără a depăși vreodată throughput-ul configurat.
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"]
Puncte cheie
- Limitele de debit se aplică simultan pentru RPM, TPM și RPD
- Nivelul dvs. determină limitele – acesta crește odată cu cheltuielile cumulative
- Citiți anteturile
x-ratelimit-*pentru a vă cunoaște consumul în timp real - Implementați un limitator de debit la nivel de client pentru a evita erorile 429
- Distribuiți sarcina pe mai multe proiecte pentru volume mari
- Luna oferă cele mai mari limite de debit pentru procesarea în lot