Begränsningar, kvoter och nivåer
På denna sida
Begränsningar, kvoter och nivåer
Begränsningar (rate limits) definierar hur många förfrågningar du kan skicka till API:t per minut. Att förstå och hantera dessa gränser är avgörande för att undvika driftstopp i produktion. Mardrömsscenariot är alltid detsamma: en integration som fungerade felfritt under utveckling, där du skickade tre förfrågningar per minut, går live och börjar plötsligt bearbeta en kö på flera tusen dokument. 429-fel strömmar in och hälften av bearbetningen går förlorad eftersom genomströmningen inte hade beräknats i förväg.
Nivåsystemet
OpenAI organiserar begränsningar i nivåer baserat på din faktureringshistorik. Du väljer inte din nivå själv; du låser upp den genom att ackumulera kostnader och vänta ut ett tidsfönster. Denna progression har en viktig praktisk konsekvens: ett konto som skapats enbart för en kunddemo kommer inte att ha samma kapacitet som ditt produktionskonto, även om koden är identisk.
# Nivåer bestämmer dina begränsningar
# Nivå 1: Efter första lyckade betalningen
# Nivå 2: Efter $50 ackumulerad kostnad + 7 dagar
# Nivå 3: Efter $100 ackumulerad kostnad + 7 dagar
# Nivå 4: Efter $250 ackumulerad kostnad + 14 dagar
# Nivå 5: Efter $1000 ackumulerad kostnad + 30 dagar
# Begränsningarna ökar avsevärt med varje nivå
Typer av begränsningar
Tre räknare gäller samtidigt, och den första du når blockerar dig. Bearbetning av korta texter mättar RPM (förfrågningar per minut) långt innan TPM (tokens per minut); omvänt kommer analys av långa dokument att tömma TPM-kvoten även om du bara har skickat några dussin förfrågningar. Kontrollera alltid storleksordningen på dina prompts innan du dimensionerar din parallellisering.
# 1. RPM — Förfrågningar per minut (Requests Per Minute)
# 2. TPM — Tokens per minut (Tokens Per Minute)
# 3. RPD — Förfrågningar per dag (Requests Per Day)
# Storleksordning för Nivå 3 (kontrollera dina faktiska gränser
# på platform.openai.com > Settings > Limits):
# RPM: 5 000 förfrågningar/minut
# TPM: 2 000 000 tokens/minut
# RPD: 10 000 förfrågningar/dag
Läsa huvuden för begränsningar
Du behöver inte gissa din förbrukning: varje svar bär på denna information i sina HTTP-huvuden. SDK:döljer dem som standard för att endast returnera det parsade objektet, men with_raw_response ger dig tillgång till det råa svaret, och parse() återskapar det vanliga objektet. En dashboard matad med dessa värden varnar dig när du närmar dig taket istället för att låta dig upptäcka det via ett felmeddelande.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Kom åt huvuden via det råa HTTP-svaret
# Använd läget with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"RPM-gräns: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM kvarvarande: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM-gräns: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM kvarvarande: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Återställning om: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Svar: {response.output_text}")
Klientbaserad hastighetsbegränsning
Det är bättre att drossla sig själv än att bli avvisad. Två implementationer täcker de flesta behov.
Begränsa genomströmning med en semafor
Den första kombinerar en semafor, som begränsar antalet samtidiga anrop, med en fördröjning beräknad utifrån målgenomströmningen. I exemplet startas femtio sammanfattningar samtidigt men endast fem körs parallellt, utspridda med den fördröjning som motsvarar 100 förfrågningar per minut. Den anropande koden förblir en enkel asyncio.gather: all disciplin är kapslad i klassen.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Begränsar antalet samtidiga förfrågningar."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Fördröjning mellan varje förfrågan
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"Sammanfatta koncept {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"Resultat {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Enkel token-hink
Token-hinken är mer flexibel eftersom den tillåter burstar. Hinken fylls med en konstant hastighet och töms vid varje anrop: om din applikation har varit inaktiv i en minut kan den starta om i full hastighet för femtio förfrågningar, för att sedan naturligt falla tillbaka till påfyllningshastigheten. Detta är exakt det beteende du vill ha för en tjänst som växlar mellan toppar och lugnare perioder, och det fungerar i flåtrådade miljöer tack vare låset.
import time
import threading
class TokenBucket:
"""Hastighetsbegränsare baserad på token-hink-algoritmen."""
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):
"""Väntar tills tillräckligt många tokens är tillgängliga."""
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)
# Användning: max 50 förfrågningar per 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
Strategier för höga volymer
1. Distribuera över flera projekt
Varje projekt har sina egna hastighetsbegränsningar. Om du når taket medan du redan befinner dig på en hög nivå, multiplicerar distribution av anrop över flera projekt mekaniskt den tillgängliga kapaciteten. Round-robin-exemplet nedan illustrerar principen; i produktion bör du flytta cykeln utanför funktionen så att den persistenter mellan anrop.
from openai import OpenAI
# Varje projekt har sina egna hastighetsbegränsningar
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:
"""Distribuerar anrop över flera projekt."""
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. Använd rätt modell för rätt volym
Valet av modell är också ett kapacitetsbeslut, inte bara ett kvalitetsbeslut. Att reservera de tyngsta modellerna för kritiska uppgifter och dirigera volymen till en modell med högre gränser frigör genomströmning där du faktiskt behöver den.
# Ekonomimodeller (gpt-5.6-luna) har de högsta gränserna
# Använd dem för uppgifter med hög volym
# Flaggskeppsmodellen (gpt-5.6-sol) har de lägsta gränserna
# Reservera den för kritiska uppgifter
3. Kösystem
Slutligen kopplar kösystem bort produktionen av förfrågningar från konsumtionen. En enda tråd tar bort objekt från kön i ett fast tempo medan resten av applikationen skickar fritt; den anropande blockeras på en händelse tills resultatet anländer. Detta mönster absorberar toppar utan att någonsin överskrida den konfigurerade genomströmningen.
import queue
import threading
class APIQueue:
"""Kö för API-anrop."""
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"]
Viktiga punkter
- Begränsningar gäller samtidigt för RPM, TPM och RPD
- Din nivå bestämmer dina gränser – den ökar med din ackumulerade kostnad
- Läs
x-ratelimit-*-huvuden för att känna till din förbrukning i realtid - Implementera en klientbaserad hastighetsbegränsare för att undvika 429-fel
- Distribuera lasten över projekt för höga volymer
- Luna erbjuder de högsta hastighetsbegränsningarna för bulkbearbetning