Ограничения на честотата, квоти и нива
На тази страница
Ограничения на честотата, квоти и нива
Ограниченията на честотата дефинират колко заявки можете да изпращате към API за минута. Разбирането и управлението на тези лимити е от съществено значение за избягване на прекъсвания в работата на производствената среда. Най-лошият сценарий винаги е един и същ: интеграция, която е работила безупречно по време на разработка, където сте изпращали по три заявки в минута, преминава в експлоатация и изведнъж започва да обработва опашка от няколко хиляди документа. Грешки 429 заливат системата и половината обработка се губи, защото пропускателната способност не е била предвидена.
Системата с нива
OpenAI организира ограниченията в нива (нива на достъп) въз основа на историята на Вашите плащания. Вие не избирате своето ниво; го отключвате чрез натрупване на разходи и изчакване на определен времеви прозорец. Тази прогресия има важно практическо следствие: акаунт, създаден само за демо презентация пред клиент, няма да има същия капацитет като Вашия производствен акаунт, дори кодът да е идентичен.
# 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
Видове ограничения на честотата
Три брояча се прилагат едновременно и първият, който достигнете, Ви блокира. Обработката на кратки текстове ще насити RPM (заявки в минута) много преди TPM (токъни в минута); обратно, анализът на дълги документи ще изчерпи TPM, дори ако сте изпратили само няколко десетки заявки. Винаги проверявайте порядъка на величината на Вашите подкани, преди да оразмерите паралелизма си.
# 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
Четене на хедъри за ограничения на честотата
Не е необходимо да гадайте потреблението си: всеки отговор го носи в своите HTTP хедъри. SDK по подразбиране ги скрива, за да върне само парсирания обект, но with_raw_response Ви дава достъп до суровия отговор, а parse() реконструира обичайния обект. Табло, захранвано с тези стойности, Ви предупреждава, когато се приближавате до тавана, вместо да Ви остави да го откриете чрез грешка.
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}")
Ограничаване на честотата от страна на клиента
По-добре е сами да забавите темпото, отколкото да бъдете отхвърлени. Две реализации покриват повечето нужди.
Ограничаване на пропускателната способност със семафор
Първата комбинира семафор, който ограничава броя на едновременните извиквания, със забавяне, изчислено от целевата пропускателна способност. В примера петдесет обобщения се стартират едновременно, но само пет протичат паралелно, разпределени със забавяне, съответстващо на 100 заявки в минута. Извикващият код остава прост asyncio.gather: цялата дисциплина е капсулирана в класа.
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())
Просто кофа с токъни
Кофата с токъни е по-гъвкава, защото позволява всплескове. Кофата се пълни с постоянна скорост и се изпразва при всяко извикване: ако приложението Ви е било неактивно една минута, то може да рестартира с пълна скорост за петдесет заявки, след което естествено да се върне към скоростта на пълнене. Това е точно поведението, което искате за услуга, която редува пикове и затишия, и то работи в многонишкови среди благодарение на заключването.
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
Стратегии за големи обеми
1. Разпределение между множество проекти
Всеки проект има свои собствени ограничения на честотата. Ако достигнете тавана си, докато вече сте на високо ниво, разпределението на извикванията между множество проекти механично умножава наличния капацитет. Долният пример с цикличен превключвател (round-robin) илюстрира принципа; в производствена среда преместете цикъла извън функцията, за да се запази между извикванията.
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. Използване на правилния модел за правилния обем
Изборът на модел също е решение за капацитет, а не само за качество. Запазването на най-тежките модели за критични задачи и пренасочването на обема към модел с по-високи лимити освобождава пропускателна способност там, където наистина Ви е необходима.
# 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. Опашки
Накрая, опашките разделят производството на заявки от тяхното потребление. Една нишка извлича заявки с фиксиран темп, докато останалата част от приложението подава свободно; извикващият блокира на събитие, докато резултатът му пристигне. Този шаблон поглъща пикове, без никога да надвишава конфигурираната пропускателна способност.
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"]
Ключови изводи
- Ограниченията на честотата се прилагат едновременно за RPM, TPM и RPD
- Вашето ниво определя Вашите лимити – то се повишава с натрупаните Ви разходи
- Четете хедърите
x-ratelimit-*, за да знаете потреблението си в реално време - Внедрете ограничител на честотата от страна на клиента, за да избегнете грешки 429
- Разпределете натоварването между проектите за големи обеми
- Luna предлага най-високите ограничения на честотата за масова обработка