Премини към основното съдържание
Български— Изберете език
Меню

Ограничения на честотата, квоти и нива

Урок 13 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Ограничения на честотата, квоти и нива
  2. Системата с нива
  3. Видове ограничения на честотата
  4. Четене на хедъри за ограничения на честотата
  5. Ограничаване на честотата от страна на клиента
  6. Стратегии за големи обеми
  7. Ключови изводи

Ограничения на честотата, квоти и нива

Ограниченията на честотата дефинират колко заявки можете да изпращате към 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 предлага най-високите ограничения на честотата за масова обработка