Explorar guías rápidas · Ingeniería de IA para datos

Tecnología: Ingeniería de IA para datosCategoría: Gestión de costosNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Fórmulas de costo
  4. Por qué cambian los precios
  5. Código / comandos
  6. 1. Estimar el costo de una solicitud
  7. 2. Proyectar el costo diario y mensual
  8. 3. Usar percentiles, no solo promedios
  9. 4. Incluir reintentos, escalados y tokens de razonamiento
  10. 5. Comparar el rendimiento con los límites
  11. 6. Fijar un presupuesto de tokens por solicitud
  12. 7. Limitar la salida
  13. 8. Añadir presupuestos por usuario y por sesión
  14. 9. Añadir presupuestos de workflow
  15. 10. Elegir el nivel de modelo según la tarea
  16. 11. Separar cargas batch e interactivas
  17. 12. Estimar el efecto de la caché
  18. 13. Monitorizar el costo de forma continua
  19. Qué significa el resultado
  20. Qué revisar
  21. Errores comunes
  22. 1. Escribir los precios en el código
  23. 2. Estimar solo con la solicitud promedio
  24. 3. Ignorar los tokens de salida
  25. 4. Olvidar reintentos y escalados
  26. 5. Presupuestar solo por mes
  27. 6. Suponer que la caché siempre ahorra
  28. 7. Elegir el modelo más barato sin medir la calidad
  29. Notas de producción
  30. Lista de comprobación
  31. Siguiente paso
  32. 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:

  1. Registra los tokens y el costo estimado de cada solicitud.
  2. Fija un presupuesto de tokens por solicitud y un máximo de tokens de salida.
  3. Añade presupuestos por usuario, por sesión y por ejecución de workflow.
  4. Enruta el trabajo simple a modelos más baratos.
  5. Usa procesamiento batch para el trabajo no interactivo, cuando tu proveedor lo ofrezca.
  6. Usa caché solo donde las entradas se repiten.
  7. 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.

Siguiente paso

  • Los prompts son demasiado grandes → Optimización de tokens en LLM.
  • No tienes claro qué nivel de modelo encaja → Elegir el modelo de IA adecuado.
  • El contexto crece en cada solicitud → Ingeniería de contexto para LLM.

← Todas las guías rápidas