Calculadora de costes de API: tokens, caché y volumen de solicitudes

¿Qué datos necesita la calculadora?

Para la API de texto prepara siete entradas:

input_tokens_per_call
output_tokens_per_call
cache_write_tokens_per_miss
cache_read_tokens_per_hit
calls
cache_hit_rate
prices_per_1m_tokens

¿Quieres contrastar la previsión con una llamada real? Crea una cuenta BetterToken y una API Key, toma las tarifas actuales de la página de precios y realiza una solicitud controlada. Después compara modelo, estado, input, output, cache tokens aplicables y consumo en el Dashboard para ver qué supuestos debes corregir.

El caching depende del modelo y del protocolo. Antes de rellenar los campos, consulta la referencia API de BetterToken, OpenAI Prompt Caching o Anthropic Prompt Caching.

Fórmula universal

Símbolos:

I  — tokens de input normales
O  — tokens de output
W  — tokens de cache write / creación
R  — tokens de cache read / almacenados en caché
Pi — precio de input por 1.000.000 de tokens
Po — precio de output por 1.000.000 de tokens
Pw — precio de cache write por 1.000.000 de tokens
Pr — precio de cache read por 1.000.000 de tokens

Coste de una llamada:

C = I / 1_000_000 × Pi
  + O / 1_000_000 × Po
  + W / 1_000_000 × Pw
  + R / 1_000_000 × Pr
  + Cextra

Cextra incluye unidades cobradas por separado: búsqueda web, imágenes, audio, almacenamiento, tools u otras operaciones. Si no las hay, el valor es cero. Si no sabes si hay un cargo adicional, deja el campo como desconocido y revisa la documentación; usar cero crearía una precisión falsa.

El error más habitual es olvidar dividir entre un millón. Si el precio es por 1.000.000 de tokens, divide primero los tokens entre 1_000_000 y después multiplica por la tarifa.

Calculadora Python para copiar

El script no contiene precios ni API Key. Pide los datos y calcula un escenario. El resultado usa la misma moneda que las tarifas introducidas.

from decimal import Decimal, InvalidOperation

MILLION = Decimal("1000000")

def read_decimal(label: str, *, allow_empty: bool = False) -> Decimal:
    raw = input(label).strip().replace(",", ".")
    if allow_empty and raw == "":
        return Decimal("0")
    try:
        value = Decimal(raw)
    except InvalidOperation as exc:
        raise SystemExit(f"Invalid number for {label!r}") from exc
    if value < 0:
        raise SystemExit(f"Negative value is not allowed for {label!r}")
    return value

input_tokens = read_decimal("Input tokens per call: ")
output_tokens = read_decimal("Output tokens per call: ")
cache_write_tokens = read_decimal("Cache write tokens per call: ")
cache_read_tokens = read_decimal("Cache read tokens per call: ")
calls = read_decimal("Number of calls: ")

price_input = read_decimal("Input price per 1M tokens: ")
price_output = read_decimal("Output price per 1M tokens: ")
price_cache_write = read_decimal("Cache write price per 1M tokens: ")
price_cache_read = read_decimal("Cache read price per 1M tokens: ")
extra_per_call = read_decimal("Extra cost per call (empty = 0): ", allow_empty=True)

per_call = (
    input_tokens / MILLION * price_input
    + output_tokens / MILLION * price_output
    + cache_write_tokens / MILLION * price_cache_write
    + cache_read_tokens / MILLION * price_cache_read
    + extra_per_call
)
total = per_call * calls

print(f"Cost per call: {per_call:.8f}")
print(f"Total cost:    {total:.8f}")
Mostrar más

Guarda el código como api_cost_calculator.py y ejecútalo:

python3 api_cost_calculator.py

No introduzcas tokens reales en los campos cache write/read si el endpoint actual no separa esas categorías. Convierte antes el uso en grupos mutuamente excluyentes para no contar el mismo token dos veces.

Cómo tener en cuenta la tasa de cache hit

Para una serie de consultas conviene separar cache hits y misses:

N     — número total de llamadas
h     — tasa de cache hit de 0 a 1
Nhits — N × h
Nmiss — N - Nhits
Chit  — coste de una llamada con cache read
Cmiss — coste de una llamada sin hit o con cache write

Resultado:

Ctotal = Nhits × Chit + Nmiss × Cmiss + Cextra_total

Para planificar, redondea Nhits hacia abajo y Nmiss hacia arriba. En un registro real usa el número efectivo de llamadas de cada tipo.

Tres escenarios en lugar de un número

Escenario base

Usa el input y output medianos de tareas recientes, el número esperado de llamadas y la tasa de cache hit observada. Si aún no hay historial, etiqueta los valores como supuestos.

Escenario favorable

Prefijo largo estable, alta tasa de cache hit, output limitado y sin errores repetidos. Muestra un límite inferior, pero no debe convertirse en una promesa de presupuesto.

Peor caso

Añade cache misses, output largo, un retry limitado y tools cobrados aparte. No aumentes todos los parámetros arbitrariamente: cada supuesto debe corresponder a un riesgo real del proceso.

Registra los resultados en una hoja sencilla:

scenario, calls, hit_rate, input, output, write, read, extra, total
base,     ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...
low,      ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...
high,     ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...

Cómo evaluar un workflow de agent

Una ejecución visible de un agent no siempre equivale a una llamada de modelo. Puede incluir planificación, tool call, tool result, retry y respuesta final. Por ello:

1. realiza una tarea de prueba segura;
2. cuenta las llamadas API reales;
3. agrúpalas por modelo y categoría de uso;
4. aplica la fórmula a cada grupo;
5. añade por separado las unidades de tool o búsqueda;
6. compara el importe con el Dashboard.

No multipliques el coste de una llamada cualquiera por el número de usuarios si la longitud de las solicitudes varía mucho. Es mejor usar varias clases de tarea: pregunta corta, revisión de archivo y tarea de agent.

Cómo contrastar una previsión con el hecho

Tras la llamada de prueba, compara:

• hora y request status;
• Model ID;
• tokens de input y output;
• categoría de caché;
• número de retries;
• consumo real;
• moneda y fecha del precio.

La diferencia suele indicar tarifa incorrecta, doble conteo de cached tokens, retry oculto o una transacción facturable adicional. Para BetterToken usa la página de precios actual y comprueba la entrada real del Dashboard; no copies precios de una captura o artículo antiguo.

Límites de la calculadora

La fórmula solo cubre categorías conocidas. No predice cambios de tarifa, precios futuros, routing dinámico ni el número de pasos de agent. Imágenes, audio, búsqueda web, almacenamiento y algunas tools pueden tener unidades propias.

Tampoco evalúa la calidad de la respuesta. Una llamada más barata que haya que repetir manualmente puede elevar el coste de la tarea completa; eso se mide con un experimento separado, no añadiendo un coeficiente inventado.

FAQ

¿Qué introduzco si no se usa caché?

Pon cache write y cache read a cero solo si el endpoint no usó realmente caché. Si el valor es desconocido, revisa primero el uso.

¿En qué moneda estará el resultado?

El resultado usa la moneda de las tarifas y de extra_per_call introducidas. No mezcles dólares y rublos sin un tipo de cambio explícito y una fecha.

¿Los cached tokens están incluidos en los input tokens?

Depende de la forma de uso de la API concreta. Consulta la documentación y convierte los campos en categorías mutuamente excluyentes para evitar el doble conteo.

¿Cómo calculo el coste de un mes?

Calcula primero el coste de una clase de tarea y multiplícalo después por el número real o previsto de llamadas. Crea líneas independientes para distintos modelos y tareas, y suma el total.

¿Por qué el cargo real es mayor que la estimación?

Comprueba output, retries, pasos de agent, cache misses y tools adicionales. Relaciona cada línea de uso con el Dashboard, no solo el total.