Salt la conținutul principal
Română— Alege o limbă
Meniu

Limite de debit, cote și niveluri

Lecția 13 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Limite de debit, cote și niveluri
  2. Sistemul de niveluri
  3. Tipuri de limite de debit
  4. Citirea antetelor de limitare a debitului
  5. Limitarea debitului la nivel de client
  6. Strategii pentru volume mari
  7. Puncte cheie

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