BroadRouter
Comenzar

Registro de uso de API de LLM: costo por usuario y función, sin PII

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado

Envuelva cada llamada al LLM en una función que registre modelo, función del producto, ID de usuario con hash, tokens de prompt, en caché, de razonamiento y de salida, costo, latencia, estado e ID de solicitud del proveedor. Calcule el costo con una tabla de precios, no con la factura. Registre metadatos por defecto; si debe guardar el prompt, oculte los datos personales antes de escribirlo y fije una retención corta.

Los paneles de los proveedores le dicen cuánto gastó. Rara vez le dicen qué función o qué cliente lo gastó, y no pueden decirle por qué la factura se disparó el martes. Su propio registro de uso sí puede. Este artículo muestra el esquema del registro, un envoltorio que lo rellena, cómo calcular el costo por llamada y cómo mantener fuera los datos personales. Qué hacer con las cifras se trata en otros artículos: costo por usuario y precios de SaaS y presupuestos y protecciones contra bucles.

¿Qué debe registrar de cada llamada al LLM?

Una fila por intento, reintentos incluidos:

Campo Ejemplo Por qué
ts 2026-11-14T09:12:03Z Series temporales, cronologías de incidentes
feature support_reply Costo por función
user_hash hmac:4f1c… Costo por usuario sin guardar su identidad
tenant acme Costo por cliente en aplicaciones B2B
model broadnet/deepseek-v4.1-flash Consulta de precios, comparación de modelos
prompt_tokens 18,240 Costo de entrada
cached_tokens 16,384 La entrada en caché es más barata; siga la tasa de caché
reasoning_tokens 612 Costo de salida oculto en los modelos de razonamiento
completion_tokens 1,104 Costo de salida (incluye el razonamiento)
cost_usd calculado La cifra que pide finanzas
latency_ms, ttft_ms 4,210 / 690 Regresiones de rendimiento
status 200, 429, 503 Tasas de error y de reintento
request_id valor de X-Request-ID Tickets de soporte y disputas de facturación
prompt_version support-v14 Vincula los cambios de costo con los cambios de prompt

Sin texto del prompt ni de la respuesta. Eso viene después, y solo con ocultación de datos.

¿Cómo se calcula el costo por llamada?

Lea el bloque usage y ponga precio a cada tipo de token por separado. BroadNet publica precios legibles por máquina en pricing.json, con precios por 1M para entrada, entrada en caché y salida de cada modelo:

import json, urllib.request

PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}

def call_cost(model: str, usage) -> float:
    p = PRICES[model]
    details = getattr(usage, "prompt_tokens_details", None)
    cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
    new_input = usage.prompt_tokens - cached
    return (
        new_input * (p.get("input_per_m") or 0)
        + cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
        + usage.completion_tokens * (p.get("output_per_m") or 0)
    ) / 1_000_000

Guarde en caché el archivo de precios y actualícelo a diario en lugar de descargarlo en cada llamada. Dos errores fáciles: cobrar los tokens en caché como entrada nueva (sobrestima el costo) y olvidar que los tokens de razonamiento ya están dentro de completion_tokens (no los sume dos veces).

¿Cómo es el envoltorio de registro?

import hashlib, hmac, os, time, logging
from openai import OpenAI

log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()

def user_hash(user_id: str) -> str:
    return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]

def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
    t0 = time.perf_counter()
    row = {"feature": feature, "user_hash": user_hash(user_id),
           "model": kwargs["model"], "prompt_version": prompt_version}
    try:
        raw = client.chat.completions.with_raw_response.create(**kwargs)
        resp = raw.parse()
        u = resp.usage
        d = getattr(u, "completion_tokens_details", None)
        row.update(
            status=200,
            request_id=raw.headers.get("x-request-id"),
            prompt_tokens=u.prompt_tokens,
            cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
            reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
            completion_tokens=u.completion_tokens,
            cost_usd=round(call_cost(kwargs["model"], u), 6),
        )
        return resp
    except Exception as e:
        row.update(status=getattr(e, "status_code", "error"),
                   request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
        raise
    finally:
        row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
        log.info("llm_call", extra={"llm": row})

with_raw_response le da las cabeceras, así que puede guardar el X-Request-ID. Para llamadas en streaming, añada stream_options={"include_usage": True} y rellene la fila a partir del último fragmento, como se muestra en el artículo sobre streaming SSE. Mantenga HASH_KEY en secreto y estable: el mismo usuario siempre produce el mismo hash, pero el hash no se puede revertir sin la clave.

¿Cómo se atribuye el costo a usuarios y funciones?

Con las filas anteriores en cualquier almacén SQL, la atribución es una sola consulta:

SELECT feature, model,
       count(*)                          AS calls,
       sum(cost_usd)                     AS cost,
       sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
       avg(completion_tokens)            AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;

Cambie feature por user_hash o tenant para obtener el costo por cliente. Tres comprobaciones posteriores rinden rápido:

  1. El 1 % de usuarios con más costo. A menudo es un solo bucle o un bot. Una cache_rate que baja es la otra alerta temprana; la calculadora de caché de prompts muestra cuánto vale cada punto de tasa de caché.
  2. Costo por resultado exitoso, no por llamada: crúcelo con sus propios eventos de éxito.
  3. Proporción de reintentos. Las filas con estado 429 o 5xx muestran cuánto gasta en fallos; vea cómo manejar los errores 429.

¿Cómo se mantiene la PII fuera de los registros de LLM?

El registro más seguro no tiene ningún texto de prompt. Cuando necesite el texto, para depurar o para evaluaciones, siga estos pasos en orden:

  1. Muestree. Guarde el texto de una pequeña parte de las llamadas y de los fallos, no de todo.
  2. Oculte antes de escribir. Ejecute la ocultación en el proceso que escribe el registro. Ocultar después significa que el texto sin procesar ya está en disco y en las copias de seguridad.
  3. Combine detectores por capas. Regex para datos estructurados, una herramienta de NER para nombres y direcciones.
  4. Almacene por separado. Ponga el texto en otra tabla o bucket con acceso más restringido y retención corta, vinculado por request_id.
  5. Nunca registre secretos. El OWASP Logging Cheat Sheet incluye los tokens de acceso, las contraseñas y las claves de cifrado entre los datos que se deben excluir; la clave de API pertenece a esa lista.

Una capa mínima de regex:

import re
PATTERNS = [
    (re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
    (re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
    (re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
    (re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
    for pat, label in PATTERNS:
        text = pat.sub(label, text)
    return text

Esto detecta los casos obvios y no detecta nombres, direcciones ni nada inusual. Microsoft Presidio añade reconocimiento de entidades para esos casos, y su README dice claramente que no hay garantía de que encuentre toda la información sensible. Cuente con que algo se escapará: una retención corta y un acceso restringido limitan el daño cuando ocurra.

Dónde encaja BroadNet Inference

BroadNet Inference devuelve el bloque usage con los tokens en caché y de razonamiento cuando el modelo los informa, un X-Request-ID en cada respuesta y un archivo de precios público que puede cargar para calcular costos. Por su parte, los prompts y las respuestas se procesan para la solicitud y no se conservan; solo guarda registros sin contenido, como tiempos, cantidades de tokens y costo (cómo funciona la retención cero de datos). Eso convierte sus propios registros en la única copia de cualquier texto de prompt, así que las reglas de ocultación anteriores determinan su retención real. Las solicitudes de chat de BroadNet no tienen un campo de metadatos por usuario, así que la atribución vive en su envoltorio. Para presupuestos separados por equipo, use claves separadas; la guía de claves explica las etiquetas y las listas de permitidos.

Preguntas frecuentes

¿Cómo hago el seguimiento del costo de la API de LLM por usuario?

Etiquete cada llamada con un identificador de usuario, lea el bloque usage de la respuesta, multiplique las cantidades de tokens por su tabla de precios y escriba una fila de registro por llamada. Agrupe por la etiqueta de usuario. Use un ID con hash en lugar de un correo electrónico.

¿Debo registrar los prompts y las respuestas completos?

No por defecto. Es ahí donde están los datos personales. Registre cantidades de tokens y metadatos de cada llamada, y guarde el texto completo solo de una muestra o de las llamadas fallidas, tras ocultar los datos, con un periodo de retención corto.

¿Por qué mi costo calculado no coincide con la factura del proveedor?

Normalmente porque los tokens en caché se cobraron como entrada nueva, los tokens de razonamiento quedaron fuera de la salida o los reintentos no se registraron. Registre cada intento, incluidos los fallidos que devolvieron usage.

¿Cómo obtengo el uso de tokens de una respuesta en streaming?

Configure include_usage en stream_options como true. El último fragmento traerá entonces el bloque usage con una lista choices vacía.

¿Qué herramienta de ocultación de PII uso para los registros de LLM?

Empiece con regex para datos estructurados como correos, teléfonos y números de tarjeta, y añada una herramienta basada en NER como Microsoft Presidio para nombres y direcciones. El propio README de Presidio dice que no puede garantizar que lo encuentre todo.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity