Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Limity rychlosti, kvóty a úrovně

Lekce 13 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Limity rychlosti, kvóty a úrovně
  2. Systém úrovní
  3. Typy limitů rychlosti
  4. Čtení hlaviček limitů rychlosti
  5. Omezování rychlosti na straně klienta
  6. Strategie pro vysoké objemy
  7. Klíčové poznatky

Limity rychlosti, kvóty a úrovně

Limity rychlosti definují, kolik požadavků můžeš za minutu odeslat do API. Pochopení a správa těchto limitů jsou klíčové pro předcházení výpadkům služby v produkci. Noční můra vypadá vždy stejně: integrace, která bezchybně fungovala ve vývoji, kde jsi posílal tři požadavky za minutu, jde do ostrého provozu a najednou zpracovává frontu několika tisíc dokumentů. Chyby 429 přicházejí v lavině a polovina zpracování se ztratí, protože nebyla anticipována propustnost.

Systém úrovní

OpenAI organizuje limity do úrovní (tierů) na základě historie tvého fakturace. Úroveň si nevybíráš; odemykáš ji akumulací útrat a čekáním na uplynutí časového okna. Tento postup má důležitý praktický důsledek: účet vytvořený pouze pro demo klientovi nebude mít stejnou kapacitu jako tvůj produkční účet, i když je kód identický.

# 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

Typy limitů rychlosti

Současně platí tři čítače a ten první, který dosáhneš, tě zablokuje. Zpracování krátkých textů nasytí RPM dlouho před TPM; naopak analýza dlouhých dokumentů vyčerpá TPM, i když jsi odeslal jen několik desítek požadavků. Před nastavením paralelismu si vždy ověř řádovou velikost svých promptů.

# 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

Čtení hlaviček limitů rychlosti

Nemusíš svou spotřebu odhadovat: každá odpověď ji nese ve svých HTTP hlavičkách. SDK je ve výchozím nastavení skrývá, aby vracelo pouze parsovaný objekt, ale with_raw_response ti poskytne přístup k surové odpovědi a parse() zrekonstruuje obvyklý objekt. Dashboard napájený těmito hodnotami tě upozorní, jak se blížíš ke stropu, místo abys to zjistil až prostřednictvím chyby.

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}")

Omezování rychlosti na straně klienta

Je lepší se sám zpomalit, než být odmítnut. Dvě implementace pokrývají většinu potřeb.

Omezení propustnosti pomocí semaforu

První kombinuje semafor, který omezuje počet současných volání, se zpožděním vypočítaným z cílové propustnosti. V příkladu je spuštěno padesát shrnutí najednou, ale pouze pět probíhá paralelně, oddělených zpožděním odpovídajícím 100 požadavkům za minutu. Volající kód zůstává jednoduchý asyncio.gather: veškerá disciplína je zapouzdřena ve třídě.

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())

Jednoduchý token bucket

Token bucket je flexibilnější, protože umožňuje nárazové špičky. Kbelík se plní konstantní rychlostí a s každým voláním se vyprazdňuje: pokud byla tvoje aplikace minutu nečinná, může restartovat plnou rychlostí pro padesát požadavků a poté přirozeně klesnout na rychlost plnění. To je přesně chování, které chceš u služby, která střídá špičky a klidová období, a díky zámku funguje i ve vícevláknových prostředích.

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

Strategie pro vysoké objemy

1. Distribuce napříč více projekty

Každý projekt má své vlastní limity rychlosti. Pokud narazíš na strop, i když již jsi na vysoké úrovni, distribuce volání napříč více projekty mechanicky znásobí dostupnou kapacitu. Níže uvedený round-robin ilustruje princip; v produkci přesuň cyklus mimo funkci, aby přetrvával mezi voláními.

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. Použití správného modelu pro správný objem

Výběr modelu je také rozhodnutím o kapacitě, nejen o kvalitě. Vyhrazení nejnáročnějších modelů pro kritické úkoly a směrování objemu na model s vyššími limity uvolní propustnost tam, kde ji skutečně potřebuješ.

# 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. Fronty

Nakonec fronty oddělují produkci požadavků od jejich spotřeby. Jediné vlákno dequeueuje pevným tempem, zatímco zbytek aplikace odesílá volně; volající blokuje na události, dokud nedorazí výsledek. Tento vzor absorbuje špičky, aniž by kdy překročil nakonfigurovanou propustnost.

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"]

Klíčové poznatky

  • Limity rychlosti platí současně pro RPM, TPM a RPD
  • Tvá úroveň určuje tvé limity – zvyšuje se s kumulativní útratou
  • Čti hlavičky x-ratelimit-*, abys znal svou spotřebu v reálném čase
  • Implementuj omezovač rychlosti na straně klienta, abys předešel chybám 429
  • Pro vysoké objemy distribuuj zátěž napříč projekty
  • Luna nabízí nejvyšší limity rychlosti pro hromadné zpracování