---
title: "Registro de uso de LLM: costo por usuario y función, sin PII"
description: "Registre cada llamada a la API de LLM con tokens, costo, latencia e ID de solicitud, atribuya el gasto a usuarios y funciones y oculte la PII antes de escribir."
url: https://broadrouter.com/es/blog/llm-api-usage-logging/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/llm-api-usage-logging/) (actualizado el 2026-11-14).

# 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 2026-11-14

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.

## Puntos clave

-   Un envoltorio, una línea de registro por llamada: modelo, función, usuario con hash, cantidades de tokens, costo, latencia, estado e ID de solicitud.
-   Calcule el costo de cada llamada a partir del bloque usage y de una tabla de precios: la entrada nueva, la entrada en caché y la salida tienen precios distintos.
-   Aplique a los ID de usuario un HMAC con clave para poder agrupar por usuario sin guardar quién es.
-   Registre metadatos por defecto. El texto del prompt es el principal riesgo de PII; oculte los datos antes de escribir, nunca después.
-   Tanto el enmascaramiento con regex como con NER dejan cosas sin detectar. Trátelos como una capa, no como una garantía.

**En esta página**

1.  ¿Qué debe registrar de cada llamada al LLM?
2.  ¿Cómo se calcula el costo por llamada?
3.  ¿Cómo es el envoltorio de registro?
4.  ¿Cómo se atribuye el costo a usuarios y funciones?
5.  ¿Cómo se mantiene la PII fuera de los registros de LLM?
6.  Dónde encaja BroadNet Inference

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](https://broadrouter.com/es/blog/llm-cost-per-user-saas/) y [presupuestos y protecciones contra bucles](https://broadrouter.com/es/blog/llm-api-spend-control/).

## ¿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é](https://broadrouter.com/es/blog/cached-input-tokens-explained/) |
| `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](https://broadrouter.com/es/glossary/input-and-output-tokens/) por separado. BroadNet publica precios legibles por máquina en [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-api-usage-logging&utm_content=body), con precios por 1M para entrada, entrada en caché y salida de cada modelo:

```python
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?

```python
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](https://broadrouter.com/es/blog/llm-streaming-sse-explained/). 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:

```sql
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](https://broadrouter.com/tools/prompt-caching-calculator/) 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](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/).

## ¿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](https://broadrouter.com/es/glossary/api-key/) pertenece a esa lista.

Una capa mínima de regex:

```python
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](https://github.com/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](https://broadrouter.com/es/privacy/)). 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](https://broadrouter.com/es/guides/api-keys-ip-allow-lists/) explica las etiquetas y las listas de permitidos.

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Tokens de entrada en caché (cached input tokens)](https://broadrouter.com/es/glossary/cached-input-tokens/)

Los tokens de entrada en caché son tokens del prompt que un proveedor de LLM procesó recientemente y puede reutilizar desde un caché en lugar de calcularlos de nuevo; normalmente son un prefijo repetido, como un prompt de sistema o un documento. Los proveedores los cobran a una tarifa menor que los tokens de entrada nuevos.

[Streaming (respuestas en tiempo real)](https://broadrouter.com/es/glossary/streaming/)

El streaming es una forma de devolver la respuesta de un modelo de lenguaje en pequeños fragmentos mientras aún se genera, en lugar de una sola respuesta al final. Las APIs compatibles con OpenAI hacen streaming mediante server-sent events cuando la solicitud define stream como true.

[PII (información de identificación personal)](https://broadrouter.com/es/glossary/pii/)

La PII (información de identificación personal) es información que permite distinguir o rastrear la identidad de una persona, como su nombre, un número de identificación o un registro biométrico, más otra información vinculable a ella. El RGPD habla de datos personales, un término más amplio. Con LLMs, se anonimiza antes de que los prompts salgan de sus sistemas.

[Reconocimiento de entidades nombradas (NER)](https://broadrouter.com/es/glossary/named-entity-recognition/)

El reconocimiento de entidades nombradas (NER) es la tarea de encontrar nombres en un texto y etiquetar cada uno con un tipo, como persona, organización o lugar. Los sistemas clásicos etiquetan cada token; a los LLMs, en cambio, se les suele pedir una lista de entidades en JSON, que luego se contrasta con el texto original.

[Clave de API (API key)](https://broadrouter.com/es/glossary/api-key/)

Una clave de API es una cadena secreta que identifica y autoriza a un cliente que llama a una API. Las APIs de LLM suelen esperarla en un encabezado Authorization: Bearer, y cualquiera que tenga la clave puede hacer solicitudes que se facturan a la cuenta propietaria.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Retención cero de datos (zero data retention, ZDR)](https://broadrouter.com/es/glossary/zero-data-retention/)

La retención cero de datos (ZDR) es una política de manejo de datos en la que un proveedor de IA procesa los prompts y las salidas solo para atender una solicitud y después no guarda ese contenido en logs, cachés ni datos de entrenamiento. Los registros sin contenido, como conteos de tokens y tiempos, normalmente se conservan.

## 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.

## Siga leyendo

-   [API de LLM con retención cero de datos: lista de 10 preguntas](https://broadrouter.com/es/blog/zero-data-retention-llm-api-checklist/)
-   [Tokens de entrada en caché: cómo reducir la factura de una API de LLM](https://broadrouter.com/es/blog/cached-input-tokens-explained/)
-   [Cómo manejar el 429 de una API de LLM: backoff, jitter y limitadores](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/)
-   [Streaming de LLM explicado: chunks SSE, deltas, usage y cancelación](https://broadrouter.com/es/blog/llm-streaming-sse-explained/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Integre la revisión humana en su flujo de IA documental](https://broadrouter.com/es/blog/document-review-queues/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: Streaming de chat completions y conexiones interrumpidas](https://broadrouter.com/es/guides/streaming-chat-completions/)
-   [Guía: Limite sus claves de API a sus servidores con listas de IP permitidas](https://broadrouter.com/es/guides/api-keys-ip-allow-lists/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-api-usage-logging&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference: campos de usage, ID de solicitud y retención (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-api-usage-logging&utm_content=sources)
-   [Precios de BroadNet Inference en formato legible por máquina (pricing.json) (en inglés)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, datos que se deben excluir de los registros](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README de Microsoft Presidio, detección de PII y sus límites (consultado el 2026-11-14)](https://github.com/microsoft/presidio)
-   [README de openai-python, lectura de las cabeceras de respuesta con with\_raw\_response](https://github.com/openai/openai-python)
