Supervisión de costes y uso
En esta página
Supervisión de costes y uso
Los costes de la API pueden dispararse rápidamente si no los vigilas. Esta lección te enseña a rastrear, estimar y controlar tu gasto en producción. La historia se repite proyecto tras proyecto: una funcionalidad se publica un jueves, nadie revisa el panel durante el fin de semana y la factura del lunes por la mañana iguala todo el presupuesto mensual. Los pasos siguientes te ayudan a detectar la desviación de costes en el momento en que ocurre, no treinta días después.
Comprensión de la facturación
Los costes se calculan por millón de tokens, con precios distintos para entrada y salida. Esta asimetría tiene consecuencias directas en tus decisiones de diseño: enviar un documento largo como entrada cuesta significativamente menos que hacer que el modelo genere uno largo. Cada respuesta devuelve el recuento exacto para ambas direcciones, así que nunca tienes que estimar.
from openai import OpenAI
client = OpenAI()
# Cada respuesta incluye métricas de uso
response = client.responses.create(
model="gpt-5.6-terra",
input="Explica la facturación de la API de OpenAI."
)
usage = response.usage
print(f"Tokens de entrada: {usage.input_tokens}")
print(f"Tokens de salida: {usage.output_tokens}")
print(f"Total de tokens: {usage.total_tokens}")
# ¡La salida cuesta más que la entrada!
Calculadora de costes
Convertir estos contadores en dólares requiere una tabla de precios. Aíslala en una estructura dedicada en lugar de dispersar constantes por todo tu código: cuando cambien los precios o añadas un modelo, solo necesitas modificar una línea. Las tarifas siguientes son indicativas y deben verificarse en cada revisión presupuestaria.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Precios aproximados en USD por millón de tokens
# Verifica siempre los precios actuales en platform.openai.com/pricing
RATES = {
"gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
"gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
"gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}
def calculate_cost(model: str, input_tokens: int,
output_tokens: int) -> float:
"""Calcula el coste de una llamada en USD."""
rate = RATES.get(model)
if not rate:
raise ValueError(f"Modelo desconocido: {model}")
input_cost = (input_tokens / 1_000_000) * rate.input_per_million
output_cost = (output_tokens / 1_000_000) * rate.output_per_million
return input_cost + output_cost
# Ejemplo
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Coste: ${cost:.6f}")
# Resultado: Coste: $0.008000
Ocho décimas de centavo por llamada suena tranquilizador hasta que lo multiplicas por las cincuenta mil llamadas diarias de un chatbot en producción: eso son cuatrocientos dólares al día. Acostúmbrate siempre a pensar en volúmenes mensuales, nunca por llamada.
Rastreador de costes en tiempo real
Los cálculos unitarios son inútiles si no se agregan. Este rastreador agrega el gasto en tres ejes: por día, por modelo y por número de llamadas, y compara el total del día con un presupuesto que tú establezcas. Las alertas son graduales: una advertencia cuando queda menos del 20 % del presupuesto, seguida de una alerta firme al superar el límite. Este paso intermedio es valioso porque te da tiempo a intervenir antes de que se corte el servicio.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Seguimiento de costes de la API en tiempo real."""
def __init__(self, daily_budget_usd: float = 10.0):
self.daily_budget = daily_budget_usd
self.costs_per_day: dict[str, float] = defaultdict(float)
self.costs_per_model: dict[str, float] = defaultdict(float)
self.calls_per_day: dict[str, int] = defaultdict(int)
self.total_tokens = 0
def record(self, model: str, input_tokens: int,
output_tokens: int):
"""Registra los costes de una llamada."""
cost = calculate_cost(model, input_tokens, output_tokens)
today = date.today().isoformat()
self.costs_per_day[today] += cost
self.costs_per_model[model] += cost
self.calls_per_day[today] += 1
self.total_tokens += input_tokens + output_tokens
return cost
def remaining_budget(self) -> float:
"""Devuelve el presupuesto restante para hoy."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Comprueba si el presupuesto está cerca del límite."""
remaining = self.remaining_budget()
if remaining <= 0:
print("ALERTA: ¡Presupuesto diario superado!")
return True
elif remaining < self.daily_budget * 0.2:
print(f"AVISO: Quedan ${remaining:.2f} del presupuesto diario")
return True
return False
def report(self) -> dict:
"""Genera un informe de costes."""
return {
"total_cost_usd": sum(self.costs_per_day.values()),
"cost_today_usd": self.costs_per_day.get(
date.today().isoformat(), 0
),
"remaining_budget_usd": self.remaining_budget(),
"costs_per_model": dict(self.costs_per_model),
"total_tokens": self.total_tokens,
}
# Uso
tracker = CostTracker(daily_budget_usd=5.0)
response = client.responses.create(
model="gpt-5.6-terra",
input="¡Hola!"
)
cost = tracker.record(
model="gpt-5.6-terra",
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
print(f"Coste de esta llamada: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))
Cliente con control de presupuesto
La supervisión no siempre es suficiente: ante un bucle defectuoso que llama a la API continuamente, necesitas un disyuntor financiero. Este cliente comprueba el presupuesto restante antes de emitir la solicitud y rechaza rotundamente la llamada si el sobre está agotado. El servicio se degrada, pero de forma controlada y sin facturas sorpresa. La contabilidad de costes ocurre después, una vez conocido el uso real.
class BudgetControlledClient:
"""Cliente que rechaza llamadas si se supera el presupuesto."""
def __init__(self, daily_budget: float = 10.0):
self.client = OpenAI()
self.tracker = CostTracker(daily_budget_usd=daily_budget)
def create(self, model: str, input: str, **kwargs) -> object:
"""Llamada a la API con control de presupuesto."""
# Comprobar presupuesto antes de la llamada
if self.tracker.remaining_budget() <= 0:
raise RuntimeError(
"Presupuesto diario agotado. "
f"Gastado: ${self.tracker.report()['cost_today_usd']:.2f}"
)
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
cost = self.tracker.record(
model=model,
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
# Alertar si el presupuesto es bajo
self.tracker.budget_alert()
return response
# Uso
budget_client = BudgetControlledClient(daily_budget=2.0)
try:
response = budget_client.create("gpt-5.6-terra", "¡Hola!")
print(response.output_text)
except RuntimeError as e:
print(f"Bloqueado: {e}")
Optimización de costes
1. Elección del modelo adecuado
La palanca más potente sigue siendo el enrutamiento por complejidad. Una tarea de clasificación en tres categorías no necesita el modelo más caro: para esta tarea, la diferencia en la factura alcanza un factor de veinticinco con una calidad idéntica. Convierte la complejidad en un parámetro explícito de tu función en lugar de una decisión hardcodeada en la lógica.
# Coste relativo por tarea (aproximado, ~300 tokens de entrada / 20 de salida):
# Clasificación simple: gpt-5.6-luna ~0,0001 $ vs gpt-5.6-sol ~0,002 $
# ¡El modelo correcto marca una diferencia de 25 veces en los costes!
def optimized_call(prompt: str, complexity: str) -> str:
"""Elige el modelo más económico adecuado."""
model = {
"simple": "gpt-5.6-luna",
"standard": "gpt-5.6-terra",
"complex": "gpt-5.6-sol",
}.get(complexity, "gpt-5.6-terra")
response = client.responses.create(model=model, input=prompt)
return response.output_text
2. Caché de respuestas
La segunda palanca es evitar pagar dos veces por la misma respuesta. Una FAQ, un catálogo de productos o un formulario estándar generan docenas de veces al día prompts estrictamente idénticos. La clave de caché combina el modelo, la entrada y los parámetros; incluirlos todos es esencial, de lo contrario un cambio en la temperatura devolvería silenciosamente la respuesta antigua.
import hashlib
class CachedClient:
"""Cliente con caché para evitar llamadas redundantes."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Crear una clave de caché
cache_key = hashlib.md5(
f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
).hexdigest()
if cache_key in self.cache:
print("¡Acierto de caché!")
return self.cache[cache_key]
response = self.client.responses.create(
model=model, input=input, **kwargs
)
self.cache[cache_key] = response.output_text
return response.output_text
3. Limitación de tokens de salida
Por último, limita la salida siempre que su longitud sea predecible. Dado que la salida es la parte cara, pedir una sola palabra mientras autorizas dos mil tokens deja la puerta abierta a una respuesta verbosa que pagarás pero no usarás.
# Establece siempre max_output_tokens para tareas predecibles
response = client.responses.create(
model="gpt-5.6-terra",
input="Clasifica este texto: positivo, negativo o neutro.",
max_output_tokens=10 # Se espera una sola palabra
)
Tarifas a 5 de agosto de 2026: los precios cambian con regularidad; antes de cualquier cálculo presupuestario, verifica la tabla actual en la página oficial de precios de OpenAI.
Puntos clave
- Los costes dependen del modelo Y de la dirección (entrada frente a salida)
- Implementa un rastreador de costes con alertas de presupuesto
- Usa el modelo adecuado para cada tarea: Luna para volumen, Terra por defecto
- El caché puede reducir drásticamente los costes para solicitudes repetitivas
- Establece
max_output_tokenscuando la longitud de la respuesta sea predecible - Consulta el panel de OpenAI para el seguimiento oficial del consumo