Ir al contenido principal
Español— Elegir un idioma
Menú

Campos de coste en las respuestas

Lección 8 de 14 Actualizado el 29 de julio de 2026 Avanzado
En esta página
  1. Seguimiento de costes en tiempo real
  2. El objeto usage
  3. Dos escalas para el mismo coste
  4. Construcción de un rastreador de costes
  5. Análisis de la tasa de caché
  6. Puntos clave

Seguimiento de costes en tiempo real

Cada respuesta de la API de Grok incluye los detalles de lo que acaba de costar. Muchos equipos descubren esta información demasiado tarde, cuando llega la factura mensual, a pesar de estar disponible solicitud por solicitud. Si aprovechas estos datos desde el inicio de la integración, detectarás desviaciones en menos de una hora desde que aparecen: un prompt de sistema que ha duplicado su tamaño tras un despliegue, un bucle de reintentos mal calibrado que repite las mismas llamadas o un contexto que cruza un umbral de facturación. Sin este seguimiento, estos incidentes permanecen invisibles hasta la recepción del extracto.

El objeto usage

Cada respuesta incluye un objeto usage que detalla el consumo de tokens y el coste asociado:

{
  "usage": {
    "prompt_tokens": 1250,
    "completion_tokens": 340,
    "total_tokens": 1590,
    "cached_tokens": 800,
    "cost_in_usd_ticks": 5000000000,
    "cost_in_nano_usd": 500000000
  }
}

Los cuatro campos de recuento se interpretan de la siguiente manera.

CampoSignificado
prompt_tokensnúmero de tokens de entrada (tu prompt completo)
completion_tokensnúmero de tokens de salida (la respuesta del modelo)
total_tokenssuma de los tokens de entrada y salida
cached_tokenstokens de entrada servidos desde la caché

Un detalle evita un error común: cached_tokens está incluido en prompt_tokens, no se suma a este. En el ejemplo anterior, 1.250 tokens entraron en el modelo, 800 provinieron de la caché y solo 450 se facturaron a tarifa completa. Si tu agregador suma ambos campos, contará dos veces la parte en caché e inflará artificialmente tus estadísticas de volumen.

Dos escalas para el mismo coste

El coste de la solicitud se proporciona en dos unidades enteras. Esta elección no es arbitraria: expresar fracciones de céntimo en números de punto flotante introduce errores de redondeo que se hacen visibles al agregar millones de llamadas. Los enteros evitan este problema por completo.

El campo cost_in_usd_ticks cuenta en «ticks», con 10.000 millones de ticks por dólar. El valor 5.000.000.000 del ejemplo corresponde por tanto a 0,50 $, y un millón de ticks equivale a 0,0001 $. La conversión cabe en una línea:

cost_usd = cost_in_usd_ticks / 10_000_000_000

El campo cost_in_nano_usd cuenta en nanodólares, con mil millones de nanodólares por dólar. Los 500.000.000 del ejemplo representan la misma cantidad, 0,50 $, y mil nanodólares equivalen a 0,000001 $. La conversión sigue la misma lógica:

cost_usd = cost_in_nano_usd / 1_000_000_000

Ambos campos describen la misma cantidad a diferentes escalas. cost_in_nano_usd es más intuitivo de manejar, mientras que cost_in_usd_ticks ofrece una precisión ligeramente superior. Elige uno y manténlo en toda tu cadena de medición: mezclar ambos en el mismo agregado es la mejor forma de obtener totales inconsistentes.

Construcción de un rastreador de costes

En producción, un único acumulador basta para convertir estos campos en un cuadro de mandos. La clase siguiente registra cada objeto usage y expone el coste acumulado junto con la tasa de caché:

class CostTracker:
    def __init__(self):
        self.total_nano_usd = 0
        self.requests = 0
        self.input_tokens = 0
        self.output_tokens = 0
        self.cached_tokens = 0

    def record(self, usage):
        self.total_nano_usd += usage.get("cost_in_nano_usd", 0)
        self.requests += 1
        self.input_tokens += usage.get("prompt_tokens", 0)
        self.output_tokens += usage.get("completion_tokens", 0)
        self.cached_tokens += usage.get("cached_tokens", 0)

    @property
    def total_cost_usd(self):
        return self.total_nano_usd / 1_000_000_000

    @property
    def cache_rate(self):
        if self.input_tokens == 0:
            return 0
        return self.cached_tokens / self.input_tokens

A continuación, asigna umbrales a total_cost_usd. Un primer umbral al 80 % del presupuesto diario activa una alerta informativa para el equipo técnico; un segundo al 95 % se convierte en una alerta crítica que requiere decisión humana; al 100 %, la aplicación corta automáticamente las solicitudes no críticas (trabajos por lotes, precomputaciones, enriquecimientos diferidos) y permite solo el tráfico directo de usuarios. Esta degradación elegante es preferible a una parada repentina del servicio en un día de máxima actividad.

Análisis de la tasa de caché

La propiedad cache_rate merece un cuadro de mandos propio, ya que refleja directamente la calidad de la estructura de tu prompt.

Tasa de cachéInterpretación
0 a 20 %caché ineficaz, revisa la estructura del prompt
20 a 50 %caché parcial, comprueba la estabilidad de tus prompts de sistema
50 a 80 %buena tasa para conversaciones
80 % y superiorexcelente, típico en prompts largos y estables

Una tasa que cae bruscamente de una semana a otra es casi siempre señal de un despliegue que ha introducido una variable al inicio del prompt. La siguiente lección detalla el mecanismo; por ahora, recuerda que esta cifra es un indicador de regresión tan valioso como una tasa de error.

Precios a 5 de agosto de 2026: los precios evolucionan con regularidad; antes de cualquier cálculo presupuestario, consulta la tarifa actual en la página oficial de modelos y precios de xAI.

Puntos clave

  • Cada respuesta de la API contiene un objeto usage con detalles de tokens y coste
  • cost_in_usd_ticks: 10.000 millones de ticks = 1 USD
  • cost_in_nano_usd: 1.000 millones de nano-USD = 1 USD
  • El campo cached_tokens mide la eficiencia de la caché
  • Implementa un rastreador de costes en producción con alertas de presupuesto