---
title: "Log de uso de LLM: custo por usuário e recurso, sem PII"
description: "Registre cada chamada de API de LLM com tokens, custo, latência e request ID, atribua o gasto a usuários e recursos e mascare PII antes de gravar. Código em Python."
url: https://broadrouter.com/pt/blog/llm-api-usage-logging/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/llm-api-usage-logging/) (atualizado em 2026-11-14).

# Log de uso de API de LLM: custo por usuário e recurso, sem PII

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em 2026-11-14

Envolva toda chamada de LLM em uma única função que registra modelo, recurso, ID de usuário com hash, tokens de prompt, em cache, de raciocínio e de saída, custo, latência, status e o request ID do provedor. Calcule o custo a partir de uma tabela de preços, não da fatura. Registre metadados por padrão; se precisar guardar o texto do prompt, mascare-o antes de gravar e defina uma retenção curta.

## Pontos principais

-   Um wrapper, uma linha de log por chamada: modelo, recurso, usuário com hash, contagens de tokens, custo, latência, status, request ID.
-   Calcule o custo por chamada a partir do bloco usage e de uma tabela de preços: entrada nova, entrada em cache e saída têm preços diferentes.
-   Aplique hash com HMAC com chave aos IDs de usuário, para agrupar por usuário sem guardar quem ele é.
-   Registre metadados por padrão. O texto do prompt é o principal risco de PII; mascare antes de gravar, nunca depois.
-   Mascaramento por regex e por NER deixam passar coisas. Trate-os como uma camada, não como garantia.

**Nesta página**

1.  O que registrar em cada chamada de LLM?
2.  Como calcular o custo por chamada?
3.  Como fica o wrapper de logging?
4.  Como atribuir custo a usuários e recursos?
5.  Como manter PII fora dos logs de LLM?
6.  Onde a BroadNet Inference se encaixa

Os painéis dos provedores dizem quanto você gastou. Raramente dizem **qual recurso** ou **qual cliente** gastou, e não conseguem dizer por que a conta disparou na terça-feira. O seu próprio log de uso consegue. Este post mostra o esquema do log, um wrapper que o preenche, como calcular o custo por chamada e como deixar dados pessoais de fora. O que fazer com os números está em outros posts: [custo por usuário e precificação de SaaS](https://broadrouter.com/pt/blog/llm-cost-per-user-saas/) e [orçamentos e proteções contra loops](https://broadrouter.com/pt/blog/llm-api-spend-control/).

## O que registrar em cada chamada de LLM?

Uma linha por tentativa, novas tentativas incluídas:

| Campo | Exemplo | Por quê |
| --- | --- | --- |
| `ts` | 2026-11-14T09:12:03Z | Séries temporais, linha do tempo de incidentes |
| `feature` | `support_reply` | Custo por recurso |
| `user_hash` | `hmac:4f1c…` | Custo por usuário sem guardar a identidade |
| `tenant` | `acme` | Custo por cliente em apps B2B |
| `model` | broadnet/deepseek-v4.1-flash | Consulta de preço, comparação entre modelos |
| `prompt_tokens` | 18.240 | Custo de entrada |
| `cached_tokens` | 16.384 | Entrada em cache é mais barata; acompanhe a [taxa de cache](https://broadrouter.com/pt/blog/cached-input-tokens-explained/) |
| `reasoning_tokens` | 612 | Custo oculto de saída em modelos de raciocínio |
| `completion_tokens` | 1.104 | Custo de saída (inclui raciocínio) |
| `cost_usd` | calculado | O número que o financeiro pede |
| `latency_ms`, `ttft_ms` | 4.210 / 690 | Regressões de desempenho |
| `status` | 200, 429, 503 | Taxas de erro e de novas tentativas |
| `request_id` | valor de `X-Request-ID` | Chamados de suporte e contestação de faturas |
| `prompt_version` | `support-v14` | Liga mudanças de custo a mudanças de prompt |

Nada de texto do prompt, nada de texto da resposta. Eles vêm depois, e só com mascaramento.

## Como calcular o custo por chamada?

Leia o bloco usage e precifique cada tipo de [token](https://broadrouter.com/pt/glossary/input-and-output-tokens/) separadamente. A BroadNet publica preços em formato legível por máquina no [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-api-usage-logging&utm_content=body), com preços por 1M para entrada, entrada em cache e saída 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 o arquivo de preços em cache e atualize-o uma vez por dia em vez de baixá-lo a cada chamada. Dois erros fáceis: precificar tokens em cache como entrada nova (superestima o custo) e esquecer que os tokens de raciocínio já estão dentro de `completion_tokens` (não some duas vezes).

## Como fica o wrapper de logging?

```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` dá acesso aos cabeçalhos, então você pode guardar o `X-Request-ID`. Para chamadas em streaming, adicione `stream_options={"include_usage": True}` e preencha a linha a partir do último chunk, como mostra o [post sobre streaming com SSE](https://broadrouter.com/pt/blog/llm-streaming-sse-explained/). Mantenha a `HASH_KEY` secreta e estável: o mesmo usuário sempre gera o mesmo hash, mas o hash não pode ser revertido sem a chave.

## Como atribuir custo a usuários e recursos?

Com as linhas acima em qualquer banco SQL, a atribuição é uma 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;
```

Troque `feature` por `user_hash` ou `tenant` para ver o custo por cliente. Três desdobramentos compensam rápido:

1.  **O 1% de usuários mais caros.** Muitas vezes é um único loop ou um bot. Uma `cache_rate` em queda é o outro sinal de alerta precoce; a [calculadora de cache de prompt](https://broadrouter.com/tools/prompt-caching-calculator/) mostra quanto vale cada ponto de taxa de cache.
2.  **Custo por resultado bem-sucedido**, não por chamada: cruze com os seus próprios eventos de sucesso.
3.  **Fatia de novas tentativas.** Linhas com status 429 ou 5xx mostram quanto você gasta com falhas; veja [como lidar com erros 429](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/).

## Como manter PII fora dos logs de LLM?

O log mais seguro não tem texto de prompt nenhum. Quando você precisar do texto, para depuração ou avaliações, siga estes passos na ordem:

1.  **Amostre.** Guarde texto de uma pequena fração das chamadas e das falhas, não de tudo.
2.  **Mascare antes de gravar.** Rode o mascaramento no processo que grava o log. Mascarar depois significa que o texto bruto já está no disco e nos backups.
3.  **Combine detectores.** Regex para dados estruturados, uma ferramenta de NER para nomes e endereços.
4.  **Guarde separado.** Coloque o texto em outra tabela ou bucket, com acesso mais restrito e retenção curta, ligado pelo `request_id`.
5.  **Nunca registre segredos.** O cheat sheet de logging da OWASP inclui tokens de acesso, senhas e chaves de criptografia entre os dados a excluir; a [chave de API](https://broadrouter.com/pt/glossary/api-key/) entra nessa lista.

Uma camada 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
```

Isso pega os casos óbvios e deixa passar nomes, endereços e qualquer coisa fora do comum. O [Microsoft Presidio](https://github.com/microsoft/presidio) acrescenta reconhecimento de entidades para esses casos, e o README dele diz com todas as letras que não há garantia de que ele encontre todas as informações sensíveis. Conte com falhas: retenção curta e acesso restrito limitam o estrago quando algo escapa.

## Onde a BroadNet Inference se encaixa

A BroadNet Inference devolve o bloco usage com tokens em cache e de raciocínio quando o modelo os informa, um `X-Request-ID` em toda resposta e um arquivo público de preços que você pode carregar para calcular custos. Do lado dela, prompts e respostas são processados para a requisição e não são retidos; ela guarda só registros sem conteúdo, como tempos, contagens de tokens e custo ([como funciona a retenção zero de dados](https://broadrouter.com/pt/privacy/)). Isso faz dos seus próprios logs a única cópia de qualquer texto de prompt, então as regras de mascaramento acima definem a sua retenção real. As requisições de chat da BroadNet não têm campo de metadados por usuário, então a atribuição fica no seu wrapper. Para orçamentos separados por equipe, use chaves separadas; o [guia de chaves](https://broadrouter.com/pt/guides/api-keys-ip-allow-lists/) explica rótulos e allow-lists.

Ferramentas gratuitas sobre o tema (em 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.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Tokens de entrada em cache (cached input)](https://broadrouter.com/pt/glossary/cached-input-tokens/)

Tokens de entrada em cache são tokens do prompt que um provedor de LLM processou há pouco e pode reaproveitar de um cache em vez de calcular de novo, normalmente um prefixo repetido, como um system prompt ou um documento. Os provedores os cobram com uma tarifa menor que a dos tokens de entrada novos.

[Streaming](https://broadrouter.com/pt/glossary/streaming/)

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

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

Uma chave de API é uma string secreta que identifica e autoriza um cliente que chama uma API. As APIs de LLM normalmente a esperam em um cabeçalho Authorization: Bearer, e qualquer pessoa que tenha a chave pode fazer requisições cobradas da conta dona dela.

[PII (informações pessoais identificáveis)](https://broadrouter.com/pt/glossary/pii/)

PII (personally identifiable information) é a informação que permite distinguir ou rastrear a identidade de uma pessoa, como nome, número de documento ou registro biométrico, mais outras informações ligadas ou vinculáveis a ela. O termo mais amplo do GDPR é dados pessoais. Com LLMs, a anonimização de PII remove esses dados dos prompts antes que saiam dos seus sistemas.

[Reconhecimento de entidades nomeadas (NER)](https://broadrouter.com/pt/glossary/named-entity-recognition/)

Reconhecimento de entidades nomeadas (NER) é a tarefa de encontrar nomes em um texto e rotular cada um com um tipo, como pessoa, organização ou local. Sistemas clássicos rotulam cada token; já aos LLMs costuma-se pedir uma lista de entidades em JSON, que depois é conferida contra o texto original.

[Retenção zero de dados (zero data retention)](https://broadrouter.com/pt/glossary/zero-data-retention/)

Retenção zero de dados (ZDR) é uma política de tratamento de dados em que um provedor de IA processa prompts e saídas só para atender uma requisição e não guarda esse conteúdo depois, nem em logs, nem em caches, nem em dados de treinamento. Registros sem conteúdo, como contagens de tokens e tempos, costumam continuar sendo guardados.

[Server-sent events (SSE)](https://broadrouter.com/pt/glossary/sse/)

Server-sent events (SSE) é um padrão web para um servidor enviar a um cliente um fluxo de eventos de texto por uma única resposta HTTP de longa duração, com content type text/event-stream. Cada evento tem uma ou mais linhas de campo, como data:, e termina com uma linha em branco.

## Perguntas frequentes

### Como acompanhar o custo de API de LLM por usuário?

Marque cada chamada com um identificador de usuário, leia o bloco usage da resposta, multiplique as contagens de tokens pela sua tabela de preços e grave uma linha de log por chamada. Agrupe pela marca de usuário. Use um ID com hash em vez de um e-mail.

### Devo registrar prompts e respostas completos?

Não por padrão. É neles que ficam os dados pessoais. Registre contagens de tokens e metadados de toda chamada e guarde o texto completo só de chamadas amostradas ou com falha, depois do mascaramento, com um período de retenção curto.

### Por que meu custo calculado difere da fatura do provedor?

Geralmente porque tokens em cache foram precificados como entrada nova, tokens de raciocínio ficaram de fora da saída ou novas tentativas não foram registradas. Registre todas as tentativas, inclusive as que falharam e devolveram usage.

### Como obter o uso de tokens de uma resposta em streaming?

Defina include\_usage como true em stream\_options. O último chunk passa a trazer o bloco usage com uma lista choices vazia.

### Que ferramenta de mascaramento de PII usar em logs de LLM?

Comece com regex para dados estruturados, como e-mails, telefones e números de cartão, e adicione uma ferramenta baseada em NER, como o Microsoft Presidio, para nomes e endereços. O próprio README do Presidio diz que ele não garante encontrar tudo.

## Continue lendo

-   [API de LLM com retenção zero de dados: checklist de 10 perguntas](https://broadrouter.com/pt/blog/zero-data-retention-llm-api-checklist/)
-   [Tokens de entrada em cache: como reduzir a conta de API de LLM](https://broadrouter.com/pt/blog/cached-input-tokens-explained/)
-   [Erro 429 em API de LLM: backoff, jitter e limitadores](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/)
-   [Streaming de LLM explicado: chunks SSE, deltas, usage e cancelamento](https://broadrouter.com/pt/blog/llm-streaming-sse-explained/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Revisão humana no seu fluxo de IA para documentos](https://broadrouter.com/pt/blog/document-review-queues/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Streaming de chat completions e conexões que caem](https://broadrouter.com/pt/guides/streaming-chat-completions/)
-   [Guia: Restrinja chaves de API aos seus servidores com lista de IPs](https://broadrouter.com/pt/guides/api-keys-ip-allow-lists/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

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

**Fontes**

-   [Referência da API da BroadNet Inference, campos de usage, request IDs e retenção (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-api-usage-logging&utm_content=sources)
-   [Preços da BroadNet Inference em formato legível por máquina (pricing.json) (em inglês)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, dados que devem ficar fora dos logs](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README do Microsoft Presidio, detecção de PII e seus limites (consultado em 2026-11-14)](https://github.com/microsoft/presidio)
-   [README do openai-python, leitura de cabeçalhos de resposta com with\_raw\_response](https://github.com/openai/openai-python)
