Límites de tasa, cuotas y niveles
En esta página
Límites de tasa, cuotas y niveles
Los límites de tasa definen cuántas solicitudes puedes enviar a la API por minuto. Comprender y gestionar estos límites es fundamental para evitar interrupciones del servicio en producción. El escenario de pesadilla es siempre el mismo: una integración que funcionaba a la perfección en desarrollo, donde enviabas tres solicitudes por minuto, se pone en producción y de repente procesa una cola de varios miles de documentos. Los errores 429 llegan en avalancha y se pierde la mitad del procesamiento porque no se anticipó el rendimiento.
El sistema de niveles
OpenAI organiza los límites en niveles (tiers) basándose en tu historial de facturación. No eliges tu nivel; lo desbloqueas acumulando gasto y esperando que transcurra un intervalo de tiempo. Esta progresión tiene una consecuencia práctica importante: una cuenta creada únicamente para una demostración a un cliente no tendrá la misma capacidad que tu cuenta de producción, aunque el código sea idéntico.
# Los niveles determinan tus límites
# Nivel 1: Tras el primer pago correcto
# Nivel 2: Tras 50 $ de gasto acumulado + 7 días
# Nivel 3: Tras 100 $ de gasto acumulado + 7 días
# Nivel 4: Tras 250 $ de gasto acumulado + 14 días
# Nivel 5: Tras 1000 $ de gasto acumulado + 30 días
# Los límites aumentan significativamente con cada nivel
Tipos de límites de tasa
Se aplican tres contadores simultáneamente; el primero que alcances te bloqueará. Procesar textos cortos saturará las RPM (solicitudes por minuto) mucho antes que las TPM (tokens por minuto); por el contrario, analizar documentos largos agotará las TPM aunque solo hayas enviado unas pocas decenas de solicitudes. Comprueba siempre el orden de magnitud de tus prompts antes de dimensionar tu paralelismo.
# 1. RPM — Solicitudes por minuto
# 2. TPM — Tokens por minuto
# 3. RPD — Solicitudes por día
# Orden de magnitud para el Nivel 3 (comprueba tus límites reales
# en platform.openai.com > Settings > Limits):
# RPM: 5.000 solicitudes/minuto
# TPM: 2.000.000 tokens/minuto
# RPD: 10.000 solicitudes/día
Lectura de las cabeceras de límite de tasa
No necesitas adivinar tu consumo: cada respuesta lo incluye en sus cabeceras HTTP. El SDK las oculta por defecto para devolver solo el objeto analizado, pero with_raw_response te da acceso a la respuesta cruda y parse() reconstruye el objeto habitual. Un panel de control alimentado por estos valores te avisa cuando te acercas al techo, en lugar de dejarte descubrirlo mediante un error.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
# Acceso a las cabeceras mediante la respuesta HTTP cruda
# Uso del modo with_raw_response
raw = client.responses.with_raw_response.create(
model="gpt-5.6-terra",
input="Hello!"
)
print(f"Límite RPM: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM restantes: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"Límite TPM: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM restantes: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reinicio en: {raw.headers.get('x-ratelimit-reset-requests')}")
response = raw.parse()
print(f"Respuesta: {response.output_text}")
Limitación de tasa en el cliente
Es mejor ralentizarse uno mismo que ser rechazado. Dos implementaciones cubren la mayoría de las necesidades.
Limitación del rendimiento con un semáforo
La primera combina un semáforo, que limita el número de llamadas simultáneas, con un retraso calculado a partir del rendimiento objetivo. En el ejemplo, se lanzan cincuenta resúmenes a la vez, pero solo cinco avanzan en paralelo, espaciados por el retraso correspondiente a 100 solicitudes por minuto. El código de llamada sigue siendo un simple asyncio.gather: toda la disciplina está encapsulada en la clase.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
class RateLimiter:
"""Limita el número de solicitudes simultáneas."""
def __init__(self, max_concurrent: int = 10, rpm: int = 500):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.rpm = rpm
self.delay = 60.0 / rpm # Retraso entre cada solicitud
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"Resume el concepto {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"Resultado {i}: {r[:50]}...")
# asyncio.run(batch_processing())
Cubo de tokens simple
El cubo de tokens es más flexible porque permite ráfagas. El cubo se llena a una velocidad constante y se vacía con cada llamada: si tu aplicación ha estado inactiva durante un minuto, puede reiniciar a máxima velocidad durante cincuenta solicitudes y luego volver naturalmente a la velocidad de llenado. Este es exactamente el comportamiento que deseas para un servicio que alterna entre picos y valles, y funciona en entornos multihilo gracias al bloqueo (lock).
import time
import threading
class TokenBucket:
"""Limitador de tasa basado en el algoritmo del cubo de tokens."""
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):
"""Espera hasta que haya suficientes tokens disponibles."""
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)
# Uso: máximo 50 solicitudes por minuto
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
Estrategias para volúmenes elevados
1. Distribución entre varios proyectos
Cada proyecto tiene sus propios límites de tasa. Si alcanzas el techo estando ya en un nivel alto, distribuir las llamadas entre varios proyectos multiplica mecánicamente la capacidad disponible. El round-robin siguiente ilustra el principio; en producción, mueve el ciclo fuera de la función para que persista entre llamadas.
from openai import OpenAI
# Cada proyecto tiene sus propios límites de tasa
clients = [
OpenAI(project="proj-aaaa"), # Proyecto 1
OpenAI(project="proj-bbbb"), # Proyecto 2
OpenAI(project="proj-cccc"), # Proyecto 3
]
def round_robin_call(prompt: str, clients: list) -> str:
"""Distribuye las llamadas entre varios proyectos."""
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. Uso del modelo adecuado para el volumen adecuado
La elección del modelo también es una decisión de capacidad, no solo de calidad. Reservar los modelos más pesados para tareas críticas y dirigir el volumen a un modelo con límites más altos libera rendimiento donde realmente lo necesitas.
# Los modelos económicos (gpt-5.6-luna) tienen los límites más altos
# Úsalos para tareas de gran volumen
# El modelo insignia (gpt-5.6-sol) tiene los límites más bajos
# Resérvalo para tareas críticas
3. Colas
Por último, las colas desacoplan la producción de solicitudes de su consumo. Un único hilo extrae elementos de la cola a un ritmo fijo mientras el resto de la aplicación envía libremente; el llamador se bloquea en un evento hasta que llega su resultado. Este patrón absorbe picos sin superar nunca el rendimiento configurado.
import queue
import threading
class APIQueue:
"""Cola para llamadas a la 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"]
Puntos clave
- Los límites de tasa se aplican simultáneamente en RPM, TPM y RPD
- Tu nivel determina tus límites; aumenta con tu gasto acumulado
- Lee las cabeceras
x-ratelimit-*para conocer tu consumo en tiempo real - Implementa un limitador de tasa en el cliente para evitar errores 429
- Distribuye la carga entre proyectos para volúmenes elevados
- Luna ofrece los límites de tasa más altos para el procesamiento por lotes