Limity częstotliwości, kwoty i poziomy
Na tej stronie
Limity częstotliwości, kwoty i poziomy
Limity częstotliwości określają, ile żądań możesz wysłać do API w ciągu minuty. Zrozumienie i zarządzanie tymi limitami jest kluczowe, aby uniknąć przerw w działaniu usługi w środowisku produkcyjnym. Koszmar wygląda zawsze tak samo: integracja, która działała bezbłędnie w fazie deweloperskiej, gdzie wysyłałeś trzy żądania na minutę, trafia do produkcji i nagle musi przetworzyć kolejkę kilku tysięcy dokumentów. Błędy 429 spadają lawinowo, a połowa przetwarzania przepada, ponieważ nie przewidziano odpowiedniej przepustowości.
System poziomów
OpenAI organizuje limity w poziomy w zależności od historii Twoich rozliczeń. Nie wybierasz poziomu samodzielnie – odblokowujesz go, accumulating wydatki i odczekując określony czas. Ta progresja ma istotną konsekwencję praktyczną: konto utworzone wyłącznie na potrzeby demonstracji dla klienta nie będzie miało tej samej wydajności co Twoje konto produkcyjne, nawet jeśli kod jest identyczny.
# Poziomy określają Twoje limity
# Poziom 1: Po pierwszej udanej płatności
# Poziom 2: Po 50 USD łącznych wydatków + 7 dni
# Poziom 3: Po 100 USD łącznych wydatków + 7 dni
# Poziom 4: Po 250 USD łącznych wydatków + 14 dni
# Poziom 5: Po 1000 USD łącznych wydatków + 30 dni
# Limity znacząco rosną z każdym poziomem
Rodzaje limitów częstotliwości
Działają jednocześnie trzy liczniki, a ten, który pierwszy osiągniesz, blokuje Cię. Przetwarzanie krótkich tekstów nasyci RPM (żądania na minutę) znacznie wcześniej niż TPM (tokeny na minutę); odwrotnie, analiza długich dokumentów wyczerpie TPM, nawet jeśli wysłałeś tylko kilkadziesiąt żądań. Zawsze sprawdzaj rzęd wielkości swoich promptów przed dobraniem poziomu równoległości.
# 1. RPM — Żądania na minutę (Requests Per Minute)
# 2. TPM — Tokeny na minutę (Tokens Per Minute)
# 3. RPD — Żądania na dzień (Requests Per Day)
# Rząd wielkości dla Poziomu 3 (sprawdź swoje rzeczywiste limity
# na platform.openai.com > Settings > Limits):
# RPM: 5000 żądań/minutę
# TPM: 2 000 000 tokenów/minutę
# RPD: 10 000 żądań/dzień
Odczytywanie nagłówków limitów częstotliwości
Nie musisz zgadywać swojego zużycia: każda odpowiedź zawiera je w nagłówkach HTTP. SDK domyślnie je ukrywa, zwracając tylko sparsowany obiekt, ale with_raw_response daje Ci dostęp do surowej odpowiedzi, a parse() odtwarza zwykły obiekt. Dashboard zasilany tymi wartościami ostrzeże Cię, gdy zbliżasz się do limitu, zamiast kazać Ci odkrywać to poprzez błąd.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Dostęp do nagłówków poprzez surową odpowiedź HTTP
# Użycie trybu 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"Pozostało RPM: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Limit TPM: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"Pozostało TPM: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset za: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Odpowiedź: {response.output_text}")
Ograniczanie częstotliwości po stronie klienta
Lepiej jest samemu zwolnić tempo, niż zostać odrzuconym. Dwie implementacje pokrywają większość potrzeb.
Ograniczanie przepustowości za pomocą semafora
Pierwsza łączy semafor, który ogranicza liczbę jednoczesnych wywołań, z opóźnieniem obliczanym na podstawie docelowej przepustowości. W przykładzie pięćdziesiąt podsumowań jest uruchamianych jednocześnie, ale tylko pięć przebiega równolegle, rozdzielonych opóźnieniem odpowiadającym 100 żądaniom na minutę. Kod wywołujący pozostaje prostym asyncio.gather: cała dyscyplina jest zamknięta w klasie.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Ogranicza liczbę jednoczesnych żądań."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Opóźnienie między każdym żądaniem
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"Podsumuj koncepcję {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"Wynik {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Proste wiadro tokenowe
Wiadro tokenowe jest bardziej elastyczne, ponieważ pozwala na skoki obciążenia. Wiadro wypełnia się ze stałą szybkością i opróżnia przy każdym wywołaniu: jeśli Twoja aplikacja była bezczynna przez minutę, może restartować z pełną prędkością przez pięćdziesiąt żądań, a następnie naturalnie wrócić do tempa wypełniania. To dokładnie zachowanie, którego oczekujesz od usługi alternującej między szczytami a okresami spokoju, i działa ono w środowiskach wielowątkowych dzięki blokadzie.
import time
import threading
class TokenBucket:
"""Ogranicznik częstotliwości oparty na algorytmie wiadra tokenowego."""
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):
"""Czeka, aż dostępna będzie wystarczająca liczba tokenów."""
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)
# Użycie: maks. 50 żądań na minutę
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
Strategie dla dużych wolumenów
1. Rozdzielenie na wiele projektów
Każdy projekt ma własne limity częstotliwości. Jeśli osiągniesz sufit, będąc już na wysokim poziomie, rozdzielenie wywołań na wiele projektów mechanicznie mnoży dostępną pojemność. Poniższy mechanizm round-robin ilustruje tę zasadę; w produkcji przenieś cykl poza funkcję, aby utrzymywał się między wywołaniami.
from openai import OpenAI
# Każdy projekt ma własne limity częstotliwości
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:
"""Rozdziela wywołania na wiele projektów."""
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. Użycie odpowiedniego modelu do odpowiedniego wolumenu
Wybór modelu to także decyzja dotycząca pojemności, a nie tylko jakości. Rezerwowanie najcięższych modeli dla zadań krytycznych i kierowanie dużego wolumenu do modelu z wyższymi limitami uwalnia przepustowość tam, gdzie naprawdę jej potrzebujesz.
# Modele ekonomiczne (gpt-5.6-luna) mają najwyższe limity
# Używaj ich do zadań o dużym wolumenie
# Model flagowy (gpt-5.6-sol) ma najniższe limity
# Rezerwuj go dla zadań krytycznych
3. Kolejkowanie
Na koniec kolejkowanie oddziela produkcję żądań od ich konsumpcji. Pojedynczy wątek pobiera elementy z kolejki w ustalonym tempie, podczas gdy reszta aplikacji submituje je swobodnie; wywołujący blokuje się na zdarzeniu, dopóki nie nadejdzie wynik. Ten wzorzec absorbuje skoki obciążenia, nigdy nie przekraczając skonfigurowanej przepustowości.
import queue
import threading
class APIQueue:
"""Kolejka dla wywołań 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"]
Kluczowe wnioski
- Limity częstotliwości działają jednocześnie dla RPM, TPM i RPD
- Twój poziom określa Twoje limity – rośnie on wraz z łącznymi wydatkami
- Odczytuj nagłówki
x-ratelimit-*, aby znać swoje zużycie w czasie rzeczywistym - Zaimplementuj ogranicznik częstotliwości po stronie klienta, aby uniknąć błędów 429
- Rozdziel obciążenie na wiele projektów przy dużych wolumenach
- Luna oferuje najwyższe limity częstotliwości do przetwarzania wsadowego