Przejdź do głównej treści
Polski— Wybierz język
Menu

Limity częstotliwości, kwoty i poziomy

Lekcja 13 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Limity częstotliwości, kwoty i poziomy
  2. System poziomów
  3. Rodzaje limitów częstotliwości
  4. Odczytywanie nagłówków limitów częstotliwości
  5. Ograniczanie częstotliwości po stronie klienta
  6. Strategie dla dużych wolumenów
  7. Kluczowe wnioski

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