Explorar guías rápidas · Ingeniería de IA para datos
Costo de LLM y presupuesto de tokens
Estima y controla el costo de una carga de trabajo con LLM con fórmulas simples por solicitud, por día y por mes, presupuestos de tokens, niveles de modelo, caché, procesamiento batch y monitorización.
En esta página
- Problema
- Respuesta rápida
- Fórmulas de costo
- Por qué cambian los precios
- Código / comandos
- 1. Estimar el costo de una solicitud
- 2. Proyectar el costo diario y mensual
- 3. Usar percentiles, no solo promedios
- 4. Incluir reintentos, escalados y tokens de razonamiento
- 5. Comparar el rendimiento con los límites
- 6. Fijar un presupuesto de tokens por solicitud
- 7. Limitar la salida
- 8. Añadir presupuestos por usuario y por sesión
- 9. Añadir presupuestos de workflow
- 10. Elegir el nivel de modelo según la tarea
- 11. Separar cargas batch e interactivas
- 12. Estimar el efecto de la caché
- 13. Monitorizar el costo de forma continua
- Qué significa el resultado
- Qué revisar
- Errores comunes
- 1. Escribir los precios en el código
- 2. Estimar solo con la solicitud promedio
- 3. Ignorar los tokens de salida
- 4. Olvidar reintentos y escalados
- 5. Presupuestar solo por mes
- 6. Suponer que la caché siempre ahorra
- 7. Elegir el modelo más barato sin medir la calidad
- Notas de producción
- Lista de comprobación
- Siguiente paso
- Para profundizar
Problema
Necesitas responder preguntas como:
- ¿Cuánto costará esta funcionalidad con LLM al mes?
- ¿Qué pasa con el costo si el uso se duplica?
- ¿Qué funcionalidad, usuario o pipeline impulsa el gasto?
- ¿Cómo evitar que un workflow consuma todo el presupuesto?
- ¿Vale la pena un modelo más barato, una caché o un procesamiento batch?
El costo de un LLM depende del uso: tokens, volumen de solicitudes, elección del modelo, reintentos y caché. Y los propios precios cambian con el tiempo.
Respuesta rápida
request_cost = (input_tokens × input_rate)
+ (output_tokens × output_rate)
monthly_cost = average_request_cost × requests_per_month
Las tarifas suelen expresarse por millón de tokens. Léelas de la configuración, no del código ni de la documentación, porque cambian.
Para controlar el costo:
- Registra los tokens y el costo estimado de cada solicitud.
- Fija un presupuesto de tokens por solicitud y un máximo de tokens de salida.
- Añade presupuestos por usuario, por sesión y por ejecución de workflow.
- Enruta el trabajo simple a modelos más baratos.
- Usa procesamiento batch para el trabajo no interactivo, cuando tu proveedor lo ofrezca.
- Usa caché solo donde las entradas se repiten.
- Alerta sobre el ritmo de consumo del presupuesto, no solo sobre la factura mensual.
Fórmulas de costo
| Magnitud | Fórmula |
|---|---|
| Tokens por solicitud | input_tokens + output_tokens |
| Costo por solicitud | input_tokens × input_rate + output_tokens × output_rate |
| Con entrada en caché | uncached_input × input_rate + cached_input × cached_input_rate + output_tokens × output_rate |
| Solicitudes por día | requests_per_minute × active_minutes_per_day (o según los registros) |
| Solicitudes efectivas | requests × (1 + retry_rate) |
| Costo por día | average_request_cost × effective_requests_per_day |
| Costo por mes | cost_per_day × days_in_month |
| Tokens por minuto | requests_per_minute × average_tokens_per_request |
Cómo se informan y se cobran los tokens en caché depende del proveedor: algunos los incluyen en los tokens de entrada, otros los informan aparte y algunos cobran por escribir en la caché. Revisa los campos de uso de la API que llamas.
Por qué cambian los precios
- Los proveedores publican modelos nuevos y cambian el precio de los anteriores.
- Los precios varían según el tamaño del modelo y entre entrada, salida y entrada en caché.
- Las ofertas batch, prioritarias o regionales pueden tener otras tarifas.
- Tu propio uso cambia: prompts más largos, nuevas funcionalidades, más usuarios.
Por eso:
- guarda las tarifas en una configuración versionada (una «tabla de tarifas»), no en el código
- almacena el costo estimado y la versión de la tabla de tarifas con cada solicitud registrada
- vuelve a estimar cuando cambies de modelo, de prompt o de tráfico
Código / comandos
1. Estimar el costo de una solicitud
from dataclasses import dataclass
@dataclass(frozen=True)
class Rates:
"""Precio por millón de tokens. Cárgalo desde la configuración: los precios de los proveedores cambian."""
input_per_m: float
output_per_m: float
cached_input_per_m: float | None = None
def request_cost(rates: Rates, input_tokens: int, output_tokens: int, cached_input_tokens: int = 0) -> float:
"""Costo de una solicitud. `input_tokens` incluye `cached_input_tokens`."""
uncached = input_tokens - cached_input_tokens
cached_rate = rates.cached_input_per_m if rates.cached_input_per_m is not None else rates.input_per_m
return (
uncached * rates.input_per_m
+ cached_input_tokens * cached_rate
+ output_tokens * rates.output_per_m
) / 1_000_000
2. Proyectar el costo diario y mensual
def monthly_cost(avg_request_cost: float, requests_per_day: float, days: int = 30, retry_rate: float = 0.0) -> float:
return avg_request_cost * requests_per_day * (1 + retry_rate) * days
example = Rates(input_per_m=1.00, output_per_m=4.00) # cifras ilustrativas, no precios reales
cost = request_cost(example, input_tokens=1_500, output_tokens=400)
print(round(cost, 6)) # 0.0031
print(round(monthly_cost(cost, requests_per_day=50_000))) # 4650
Ejemplo con esas tarifas ilustrativas:
| Paso | Valor |
|---|---|
| Entrada | 1.500 tokens × 1,00 / 1M = 0,0015 |
| Salida | 400 tokens × 4,00 / 1M = 0,0016 |
| Costo por solicitud | 0,0031 |
| 50.000 solicitudes/día | 155 por día |
| 30 días | 4.650 por mes |
Observa que 400 tokens de salida cuestan más que 1.500 de entrada cuando la tarifa de salida es mayor. La longitud de la salida importa.
3. Usar percentiles, no solo promedios
Unas pocas solicitudes muy largas (documentos grandes, conversaciones largas, bucles de agentes) pueden dominar el costo.
SELECT DISTINCT
feature,
PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p50_tokens,
PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p95_tokens,
MAX(input_tokens + output_tokens) OVER (PARTITION BY feature) AS max_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME());
Presupuesta para el p95, no para la solicitud promedio.
4. Incluir reintentos, escalados y tokens de razonamiento
El costo real por tarea completada es mayor que el costo por llamada cuando:
- se reintenta una salida no válida
- los casos fallidos se escalan a un modelo más grande
- el modelo cobra los tokens de razonamiento como salida
- un agente hace varias llamadas por cada petición del usuario
cost_per_successful_task = total_cost_of_all_calls / tasks_completed_successfully
5. Comparar el rendimiento con los límites
tokens_per_minute = requests_per_minute × average_tokens_per_request
requests_per_minute = tráfico pico, no el promedio diario
Compara ambos valores con los límites de solicitudes y de tokens de tu proveedor. Una carga histórica (backfill) en batch puede alcanzar el límite de tokens por minuto mucho antes que el presupuesto de costo.
6. Fijar un presupuesto de tokens por solicitud
Estima la entrada antes de llamar y reserva espacio para la salida máxima:
class BudgetExceeded(Exception):
pass
def check_request_budget(estimated_input: int, max_output: int, request_budget: int) -> None:
worst_case = estimated_input + max_output
if worst_case > request_budget:
raise BudgetExceeded(f"la solicitud puede usar {worst_case} tokens; el presupuesto es {request_budget}")
Si la comprobación falla, recorta el contexto (historial, recuperación) antes de llamar, o rechaza con un error claro.
7. Limitar la salida
- Fija un máximo de tokens de salida en cada llamada.
- Dimensiónalo según las longitudes observadas más un margen, no según el máximo del modelo.
- Trata una respuesta truncada como un fallo (JSON no válido, texto cortado) y regístrala.
8. Añadir presupuestos por usuario y por sesión
def remaining_tokens(daily_limit: int, used_today: int) -> int:
return max(daily_limit - used_today, 0)
Guarda el uso por usuario y por sesión (por ejemplo, en una tabla con clave de usuario y fecha), compruébalo antes de cada llamada y devuelve un mensaje claro cuando se agote el presupuesto. Esto también limita el abuso de endpoints públicos.
9. Añadir presupuestos de workflow
En pipelines y agentes, presupuesta la ejecución, no solo la llamada:
- número máximo de llamadas por ejecución
- número máximo de tokens por ejecución
- costo máximo por ejecución
- condición de parada al alcanzar el presupuesto, guardando los resultados parciales
class RunBudget:
def __init__(self, max_tokens: int, max_calls: int):
self.max_tokens, self.max_calls = max_tokens, max_calls
self.tokens = self.calls = 0
def charge(self, input_tokens: int, output_tokens: int) -> None:
self.calls += 1
self.tokens += input_tokens + output_tokens
if self.tokens > self.max_tokens or self.calls > self.max_calls:
raise BudgetExceeded(f"ejecución detenida tras {self.calls} llamadas y {self.tokens} tokens")
10. Elegir el nivel de modelo según la tarea
| Tarea | Nivel habitual |
|---|---|
| Clasificación, etiquetado, extracción corta | Modelo más pequeño y barato |
| Resúmenes de contenido con estructura conocida | Modelo pequeño o intermedio |
| Razonamiento en varios pasos, análisis ambiguo | Modelo más grande o de razonamiento |
| Parsing determinista, formato, cálculos | Sin modelo: código, SQL o reglas |
Mide la calidad en cada nivel: un modelo más barato que falla a menudo puede costar más por tarea completada.
11. Separar cargas batch e interactivas
| Interactiva | Batch | |
|---|---|---|
| Latencia | Importan los segundos | Minutos u horas aceptables |
| Volumen | Con picos | Grande, programable |
| Palancas de costo | Prompts más cortos, modelos más pequeños, caché | API batch donde existan, horarios de baja demanda, lotes más grandes por llamada |
| Presupuesto | Por usuario / sesión | Por ejecución / por día |
Ejecuta las cargas históricas y los trabajos de enriquecimiento como cargas batch, con su propio presupuesto.
12. Estimar el efecto de la caché
expected_input_cost = (1 - hit_rate) × uncached_cost + hit_rate × cached_cost
- La caché de resultados ahorra toda la solicitud en cada acierto, pero solo si se repiten entradas idénticas.
- La caché de prompts/prefijos, donde exista, reduce el costo de los prefijos repetidos; reglas y precios varían.
- Mide la tasa de aciertos real antes de contar el ahorro.
13. Monitorizar el costo de forma continua
Guarda el costo estimado con cada solicitud:
SELECT
CAST(requested_at AS date) AS usage_date,
feature,
SUM(input_tokens) AS input_tokens,
SUM(output_tokens) AS output_tokens,
SUM(estimated_cost) AS estimated_cost
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -30, SYSUTCDATETIME())
GROUP BY CAST(requested_at AS date), feature
ORDER BY usage_date, estimated_cost DESC;
Concilia regularmente con los datos de facturación del proveedor: tu estimación solo es tan buena como tu tabla de tarifas.
Qué significa el resultado
| Señal | Significado probable |
|---|---|
| El costo crece más rápido que las solicitudes | Los prompts, el historial o las salidas se alargan |
| Domina el costo de salida | Respuestas extensas o sin límite |
| Una funcionalidad domina | Optimízala o presupuéstala primero |
| p95 muy por encima del p50 | Unas pocas solicitudes largas impulsan el costo: limítalas |
| Costo por tarea completada muy superior al costo por llamada | Reintentos o escalados |
| La estimación no coincide con la factura | Tabla de tarifas desactualizada, llamadas no registradas o contabilidad de tokens en caché |
Qué revisar
- Solicitudes sin máximo de tokens de salida.
- Funcionalidades sin responsable ni presupuesto.
- Llamadas no registradas (scripts, notebooks, experimentos).
- Cargas históricas que consumen los límites del tráfico interactivo.
- Ráfagas de reintentos después de un despliegue.
- Una tabla de tarifas más antigua que la versión actual del modelo.
Errores comunes
1. Escribir los precios en el código
Los precios cambian. Guárdalos en la configuración, con una versión y una fecha de vigencia.
2. Estimar solo con la solicitud promedio
Las solicitudes de cola larga y los bucles de agentes dominan el gasto real.
3. Ignorar los tokens de salida
La salida suele ser más cara por token que la entrada.
4. Olvidar reintentos y escalados
El costo por llamada no es el costo por tarea completada.
5. Presupuestar solo por mes
Un trabajo desbocado puede gastar el presupuesto de un mes en horas. Usa límites por ejecución, por usuario y por día.
6. Suponer que la caché siempre ahorra
Solo ahorra cuando las entradas o los prefijos se repiten, y algunos proveedores cobran por escribir en caché.
7. Elegir el modelo más barato sin medir la calidad
Las respuestas incorrectas también cuestan: retrabajo, escalados y pérdida de confianza.
Notas de producción
- Mantén una tabla de tarifas versionada por modelo; registra su versión con cada solicitud.
- Aplica los presupuestos en el código antes de llamar al modelo, no después de la factura.
- Alerta sobre el ritmo de gasto diario y sobre picos inusuales por funcionalidad.
- Asigna a cada funcionalidad con LLM un responsable y un presupuesto.
- Separa experimentos y producción (claves o proyectos distintos) para ver sus costos por separado.
- Revisa el costo tras cada cambio de prompt, de modelo o de tráfico.
- Registra recuentos de tokens y costos, no prompts completos, cuando los prompts contengan datos sensibles.
Lista de comprobación
- Las tarifas vienen de una configuración versionada.
- Cada solicitud registra tokens de entrada, de salida y en caché, el modelo y el costo estimado.
- Cada llamada tiene un máximo de tokens de salida.
- Existen presupuestos por solicitud, por usuario/sesión y por ejecución.
- Los tokens por minuto en el pico caben en los límites del proveedor.
- El nivel de modelo se elige por tarea y se mide.
- El trabajo batch está separado del interactivo.
- La tasa de aciertos de la caché se mide antes de anunciar ahorros.
- Las estimaciones se concilian con la facturación.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.