---
title: "Log d’uso LLM: costo per utente e funzione, senza PII"
description: "Registra ogni chiamata API LLM con token, costo, latenza e request ID, attribuisci la spesa a utenti e funzioni e oscura le PII prima di scrivere. Codice Python."
url: https://broadrouter.com/it/blog/llm-api-usage-logging/
lang: it
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/llm-api-usage-logging/) (aggiornato il 2026-11-14).

# Log di utilizzo delle API LLM: costo per utente e funzione, senza PII

A cura del team di BroadNet Inference · 4 min di lettura · Pubblicato 2026-11-14

Avvolgi ogni chiamata LLM in un’unica funzione che registra modello, funzione, ID utente con hash, token di prompt, in cache, di ragionamento e di output, costo, latenza, stato e request ID del provider. Calcola il costo da una tabella prezzi, non dalla fattura. Di default registra solo i metadati; se devi conservare il testo dei prompt, oscuralo prima di scriverlo e imposta una conservazione breve.

## Punti chiave

-   Un wrapper, una riga di log per chiamata: modello, funzione, utente con hash, conteggi dei token, costo, latenza, stato, request ID.
-   Calcola il costo di ogni chiamata dal blocco usage e da una tabella prezzi: input nuovo, input in cache e output hanno prezzi diversi.
-   Applica agli ID utente un hash con HMAC a chiave, così puoi raggruppare per utente senza salvare chi è.
-   Di default registra i metadati. Il testo dei prompt è il rischio principale per i dati personali; oscuralo prima di scriverlo, mai dopo.
-   Sia l’oscuramento con regex sia quello con NER si lasciano sfuggire qualcosa. Trattali come un livello di protezione, non come una garanzia.

**In questa pagina**

1.  Che cosa registrare per ogni chiamata LLM?
2.  Come si calcola il costo di ogni chiamata?
3.  Com’è il wrapper di logging?
4.  Come si attribuiscono i costi a utenti e funzioni?
5.  Come si tengono le PII fuori dai log LLM?
6.  Dove si inserisce BroadNet Inference

Le dashboard dei provider ti dicono quanto hai speso. Raramente ti dicono **quale funzione** o **quale cliente** l’ha speso, e non possono dirti perché la fattura è schizzata martedì. Il tuo log di utilizzo può farlo. Questo articolo mostra lo schema del log, un wrapper che lo compila, come calcolare il costo di ogni chiamata e come tenere fuori i dati personali. Che cosa fare con i numeri è trattato altrove: [costo per utente e prezzi di un SaaS](https://broadrouter.com/it/blog/llm-cost-per-user-saas/) e [budget e protezioni contro i loop](https://broadrouter.com/it/blog/llm-api-spend-control/).

## Che cosa registrare per ogni chiamata LLM?

Una riga per tentativo, retry compresi:

| Campo | Esempio | Perché |
| --- | --- | --- |
| `ts` | 2026-11-14T09:12:03Z | Serie temporali, cronologia degli incidenti |
| `feature` | `support_reply` | Costo per funzione |
| `user_hash` | `hmac:4f1c…` | Costo per utente senza salvarne l’identità |
| `tenant` | `acme` | Costo per cliente nelle app B2B |
| `model` | broadnet/deepseek-v4.1-flash | Ricerca del prezzo, confronti tra modelli |
| `prompt_tokens` | 18.240 | Costo dell’input |
| `cached_tokens` | 16.384 | L’input in cache costa meno; monitora il [tasso di cache](https://broadrouter.com/it/blog/cached-input-tokens-explained/) |
| `reasoning_tokens` | 612 | Costo nascosto dell’output nei modelli di ragionamento |
| `completion_tokens` | 1.104 | Costo dell’output (ragionamento incluso) |
| `cost_usd` | calcolato | Il numero che chiede l’amministrazione |
| `latency_ms`, `ttft_ms` | 4.210 / 690 | Regressioni di prestazioni |
| `status` | 200, 429, 503 | Tassi di errore e di retry |
| `request_id` | valore di `X-Request-ID` | Ticket di supporto e contestazioni delle fatture |
| `prompt_version` | `support-v14` | Collega le variazioni di costo alle modifiche del prompt |

Niente testo del prompt, niente testo della risposta. Quelli vengono dopo, e solo con l’oscuramento.

## Come si calcola il costo di ogni chiamata?

Leggi il blocco usage e prezza separatamente ogni tipo di [token](https://broadrouter.com/it/glossary/input-and-output-tokens/). BroadNet pubblica i prezzi in formato leggibile dalle macchine in [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-usage-logging&utm_content=body), con i prezzi per 1M di input, input in cache e output per ogni modello:

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

Tieni in cache il file dei prezzi e aggiornalo ogni giorno invece di scaricarlo a ogni chiamata. Due errori facili: prezzare i token in cache come input nuovo (sovrastima il costo) e dimenticare che i token di ragionamento sono già dentro `completion_tokens` (non sommarli due volte).

## Com’è il wrapper di 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` ti dà gli header, così puoi conservare l’`X-Request-ID`. Per le chiamate in streaming, aggiungi `stream_options={"include_usage": True}` e compila la riga dall’ultimo chunk, come mostrato nell’[articolo sullo streaming SSE](https://broadrouter.com/it/blog/llm-streaming-sse-explained/). Tieni `HASH_KEY` segreta e stabile: lo stesso utente corrisponde sempre allo stesso hash, ma senza la chiave l’hash non si può invertire.

## Come si attribuiscono i costi a utenti e funzioni?

Con le righe qui sopra in un qualsiasi database SQL, l’attribuzione è una query:

```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;
```

Sostituisci `feature` con `user_hash` o `tenant` per il costo per cliente. Tre approfondimenti ripagano subito:

1.  **L’1% degli utenti che costa di più.** Spesso è un singolo loop o un bot. Un `cache_rate` in calo è l’altro segnale d’allarme precoce; il [calcolatore del prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) mostra quanto vale ogni punto di tasso di cache.
2.  **Costo per esito positivo**, non per chiamata: collega le righe ai tuoi eventi di successo.
3.  **Quota di retry.** Le righe con stato 429 o 5xx mostrano quanto spendi in fallimenti; vedi [gestire gli errori 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/).

## Come si tengono le PII fuori dai log LLM?

Il log più sicuro non contiene alcun testo dei prompt. Quando ti serve il testo, per il debug o per le valutazioni, segui questi passi nell’ordine:

1.  **Campiona.** Conserva il testo per una piccola parte delle chiamate e per i fallimenti, non per tutto.
2.  **Oscura prima di scrivere.** Esegui l’oscuramento nel processo che scrive il log. Oscurare dopo significa che il testo grezzo è già su disco e nei backup.
3.  **Combina i rilevatori.** Regex per i dati strutturati, uno strumento NER per nomi e indirizzi.
4.  **Salva separatamente.** Metti il testo in una tabella o in un bucket diverso con accessi più restrittivi e conservazione breve, collegato tramite `request_id`.
5.  **Non registrare mai segreti.** Il cheat sheet di OWASP sul logging include token di accesso, password e chiavi di cifratura tra i dati da escludere; la [chiave API](https://broadrouter.com/it/glossary/api-key/) va in quell’elenco.

Un livello minimo di 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
```

Questo intercetta i casi ovvi e si lascia sfuggire nomi, indirizzi e tutto ciò che è insolito. [Microsoft Presidio](https://github.com/microsoft/presidio) aggiunge il riconoscimento delle entità per questi casi, e il suo README dice chiaramente che non c’è garanzia che trovi tutte le informazioni sensibili. Metti in conto le mancate rilevazioni: conservazione breve e accessi ristretti limitano i danni quando qualcosa passa.

## Dove si inserisce BroadNet Inference

BroadNet Inference restituisce il blocco usage con token in cache e di ragionamento quando il modello li riporta, un `X-Request-ID` in ogni risposta e un file prezzi pubblico che puoi caricare per calcolare i costi. Dal suo lato, prompt e risposte vengono elaborati per la richiesta e non conservati; tiene solo registrazioni prive di contenuto come tempi, conteggi dei token e costi ([come funziona la zero data retention](https://broadrouter.com/it/privacy/)). Così i tuoi log sono l’unica copia di qualsiasi testo dei prompt, e le regole di oscuramento qui sopra decidono la tua conservazione effettiva. Le richieste chat di BroadNet non hanno un campo di metadati per utente, quindi l’attribuzione sta nel tuo wrapper. Per budget separati per team, usa chiavi separate; la [guida alle chiavi](https://broadrouter.com/it/guides/api-keys-ip-allow-lists/) spiega etichette e allow-list.

Strumenti gratuiti sul tema (in inglese)

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

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Token di input in cache (cached input)](https://broadrouter.com/it/glossary/cached-input-tokens/)

I token di input in cache sono token del prompt che un provider LLM ha elaborato da poco e può riusare da una cache invece di ricalcolarli, di solito un prefisso ripetuto come un system prompt o un documento. I provider li fatturano a una tariffa più bassa dei token di input nuovi.

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

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

[Riconoscimento di entità nominate (NER)](https://broadrouter.com/it/glossary/named-entity-recognition/)

La named entity recognition (NER) è il compito di trovare i nomi in un testo ed etichettare ciascuno con un tipo, come persona, organizzazione o luogo. I sistemi classici etichettano ogni token; agli LLM si chiede spesso invece di restituire una lista di entità in JSON, che poi si verifica sul testo originale.

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

I server-sent events (SSE) sono uno standard web con cui un server invia a un client un flusso di eventi testuali su un’unica risposta HTTP di lunga durata, con content type text/event-stream. Ogni evento è composto da una o più righe di campo, come data:, ed è chiuso da una riga vuota.

[Zero data retention (nessuna conservazione dei dati)](https://broadrouter.com/it/glossary/zero-data-retention/)

La zero data retention (ZDR) è una policy di gestione dei dati in cui un provider AI elabora prompt e output solo per servire una richiesta e poi non ne conserva il contenuto, né in log né in cache né in dati di addestramento. Di solito restano registri senza contenuti, come conteggi di token e tempi.

[Chiave API (API key)](https://broadrouter.com/it/glossary/api-key/)

Una chiave API è una stringa segreta che identifica e autorizza un client che chiama un’API. Le API LLM di solito la vogliono in un header Authorization: Bearer, e chiunque possieda la chiave può fare richieste fatturate all’account a cui appartiene.

[PII (informazioni personali identificabili)](https://broadrouter.com/it/glossary/pii/)

I PII (personally identifiable information) sono informazioni che permettono di distinguere o rintracciare l’identità di una persona, come nome, numero identificativo o dato biometrico, più altre informazioni collegate o collegabili a essa. Il GDPR usa il termine più ampio dati personali. Con gli LLM, l’oscuramento dei PII li toglie dai prompt prima che escano dai tuoi sistemi.

## Domande frequenti

### Come monitoro il costo delle API LLM per utente?

Etichetta ogni chiamata con un identificativo dell’utente, leggi il blocco usage dalla risposta, moltiplica i conteggi dei token per la tua tabella prezzi e scrivi una riga di log per chiamata. Raggruppa per etichetta utente. Usa un ID con hash invece di un’email.

### Devo registrare prompt e risposte completi?

Non di default. È lì che stanno i dati personali. Registra conteggi dei token e metadati per ogni chiamata, e conserva il testo completo solo per le chiamate campionate o fallite, dopo l’oscuramento, con un periodo di conservazione breve.

### Perché il costo che calcolo è diverso dalla fattura del provider?

Di solito perché i token in cache sono stati prezzati come input nuovo, i token di ragionamento sono stati esclusi dall’output o i retry non sono stati registrati. Registra ogni tentativo, compresi quelli falliti che hanno restituito usage.

### Come ottengo l’utilizzo dei token da una risposta in streaming?

Imposta include\_usage a true in stream\_options. L’ultimo chunk contiene allora il blocco usage con un elenco choices vuoto.

### Quale strumento usare per oscurare le PII nei log LLM?

Parti dalle regex per i dati strutturati come email, numeri di telefono e numeri di carta, e aggiungi uno strumento basato su NER come Microsoft Presidio per nomi e indirizzi. Lo stesso README di Presidio dice che non può garantire di trovare tutto.

## Continua a leggere

-   [API LLM con zero data retention: una checklist di 10 domande](https://broadrouter.com/it/blog/zero-data-retention-llm-api-checklist/)
-   [Token di input in cache: come ridurre la bolletta delle API LLM](https://broadrouter.com/it/blog/cached-input-tokens-explained/)
-   [Errore 429 nelle API LLM: backoff, jitter e limitatori](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/)
-   [Streaming degli LLM spiegato: chunk SSE, delta, usage e annullamento](https://broadrouter.com/it/blog/llm-streaming-sse-explained/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Revisione umana nel flusso di document AI: regole e code](https://broadrouter.com/it/blog/document-review-queues/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Streaming delle chat completions e connessioni interrotte](https://broadrouter.com/it/guides/streaming-chat-completions/)
-   [Guida: Limita le chiavi API ai tuoi server con le allowlist di IP](https://broadrouter.com/it/guides/api-keys-ip-allow-lists/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Riferimento API di BroadNet Inference, campi usage, request ID e conservazione dei dati (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-usage-logging&utm_content=sources)
-   [Prezzi di BroadNet Inference in formato leggibile dalle macchine (pricing.json) (in inglese)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, dati da escludere dai log](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README di Microsoft Presidio, rilevamento delle PII e suoi limiti (consultato il 2026-11-14)](https://github.com/microsoft/presidio)
-   [README di openai-python, lettura degli header di risposta con with\_raw\_response](https://github.com/openai/openai-python)
