---
title: "Journaux d’usage LLM : coût par utilisateur, sans PII"
description: "Journalisez chaque appel d’API LLM avec tokens, coût, latence et ID de requête, attribuez la dépense par utilisateur et fonctionnalité, masquez les PII. Code Python."
url: https://broadrouter.com/fr/blog/llm-api-usage-logging/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/llm-api-usage-logging/) (mis à jour le 2026-11-14).

# Journaliser l’usage d’une API LLM : coût par utilisateur, sans PII

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14

Enveloppez chaque appel LLM dans une fonction qui enregistre modèle, fonctionnalité, ID utilisateur haché, tokens de prompt, en cache, de raisonnement et de sortie, coût, latence, statut et ID de requête du fournisseur. Calculez le coût avec une grille de prix, pas la facture. Journalisez les métadonnées par défaut ; si vous gardez le texte des prompts, masquez-le avant l’écriture et conservez-le peu de temps.

## À retenir

-   Une seule fonction d’enveloppe, une ligne de journal par appel : modèle, fonctionnalité, utilisateur haché, nombres de tokens, coût, latence, statut, ID de requête.
-   Calculez le coût de chaque appel à partir du bloc usage et d’une grille de prix : entrée nouvelle, entrée en cache et sortie ont des prix différents.
-   Hachez les ID utilisateur avec un HMAC à clé : vous pouvez regrouper par utilisateur sans stocker qui il est.
-   Journalisez les métadonnées par défaut. Le texte des prompts est le principal risque de PII ; masquez avant l’écriture, jamais après.
-   Le masquage par regex et par NER laisse tous deux passer des choses. Considérez-les comme une couche, pas comme une garantie.

**Sur cette page**

1.  Que journaliser pour chaque appel LLM ?
2.  Comment calculer le coût de chaque appel ?
3.  À quoi ressemble la fonction d’enveloppe de journalisation ?
4.  Comment attribuer le coût aux utilisateurs et aux fonctionnalités ?
5.  Comment tenir les PII à l’écart des journaux LLM ?
6.  La place de BroadNet Inference

Les tableaux de bord des fournisseurs vous disent ce que vous avez dépensé. Ils vous disent rarement **quelle fonctionnalité** ou **quel client** l’a dépensé, et ne peuvent pas expliquer pourquoi une facture a bondi mardi. Votre propre journal d’usage le peut. Cet article présente le schéma du journal, une fonction d’enveloppe qui le remplit, le calcul du coût par appel et la manière de tenir les données personnelles à l’écart. Ce qu’on fait des chiffres est traité ailleurs : [coût par utilisateur et tarification SaaS](https://broadrouter.com/fr/blog/llm-cost-per-user-saas/) et [budgets et garde-fous contre les boucles](https://broadrouter.com/fr/blog/llm-api-spend-control/).

## Que journaliser pour chaque appel LLM ?

Une ligne par tentative, relances comprises :

| Champ | Exemple | Pourquoi |
| --- | --- | --- |
| `ts` | 2026-11-14T09:12:03Z | Séries temporelles, chronologies d’incidents |
| `feature` | `support_reply` | Coût par fonctionnalité |
| `user_hash` | `hmac:4f1c…` | Coût par utilisateur sans stocker l’identité |
| `tenant` | `acme` | Coût par client dans les applications B2B |
| `model` | broadnet/deepseek-v4.1-flash | Recherche du prix, comparaisons de modèles |
| `prompt_tokens` | 18 240 | Coût d’entrée |
| `cached_tokens` | 16 384 | L’entrée en cache coûte moins cher ; suivez le [taux de cache](https://broadrouter.com/fr/blog/cached-input-tokens-explained/) |
| `reasoning_tokens` | 612 | Coût de sortie caché des modèles de raisonnement |
| `completion_tokens` | 1 104 | Coût de sortie (raisonnement inclus) |
| `cost_usd` | calculé | Le chiffre que demande la finance |
| `latency_ms`, `ttft_ms` | 4 210 / 690 | Régressions de performance |
| `status` | 200, 429, 503 | Taux d’erreurs et de relances |
| `request_id` | valeur de `X-Request-ID` | Tickets de support et contestations de facture |
| `prompt_version` | `support-v14` | Relie les variations de coût aux changements de prompt |

Pas de texte de prompt, pas de texte de réponse. Ils viennent plus tard, et seulement avec masquage.

## Comment calculer le coût de chaque appel ?

Lisez le bloc usage et tarifez chaque type de [token](https://broadrouter.com/fr/glossary/input-and-output-tokens/) séparément. BroadNet publie des prix lisibles par machine dans [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-api-usage-logging&utm_content=body), avec des prix par million pour l’entrée, l’entrée en cache et la sortie de chaque modèle :

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

Mettez le fichier de prix en cache et rafraîchissez-le chaque jour plutôt que de le télécharger à chaque appel. Deux erreurs faciles : compter les tokens en cache au prix d’une entrée nouvelle (ce qui surestime le coût), et oublier que les tokens de raisonnement sont déjà inclus dans `completion_tokens` (ne les ajoutez pas deux fois).

## À quoi ressemble la fonction d’enveloppe de journalisation ?

```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` vous donne les en-têtes, ce qui permet de garder le `X-Request-ID`. Pour les appels en streaming, ajoutez `stream_options={"include_usage": True}` et remplissez la ligne à partir du dernier chunk, comme le montre [l’article sur le streaming SSE](https://broadrouter.com/fr/blog/llm-streaming-sse-explained/). Gardez `HASH_KEY` secrète et stable : un même utilisateur donne toujours le même hachage, mais le hachage ne peut pas être inversé sans la clé.

## Comment attribuer le coût aux utilisateurs et aux fonctionnalités ?

Avec les lignes ci-dessus dans n’importe quelle base SQL, l’attribution tient en une requête :

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

Remplacez `feature` par `user_hash` ou `tenant` pour obtenir le coût par client. Trois analyses complémentaires rapportent vite :

1.  **Le 1 % d’utilisateurs le plus coûteux.** Souvent une seule boucle ou un bot. Un `cache_rate` en baisse est l’autre signal d’alerte précoce ; le [calculateur de prompt caching](https://broadrouter.com/tools/prompt-caching-calculator/) montre ce que vaut chaque point de taux de cache.
2.  **Le coût par résultat réussi**, et non par appel : faites une jointure avec vos propres événements de succès.
3.  **La part des relances.** Les lignes au statut 429 ou 5xx montrent combien vous dépensez en échecs ; voir [gérer les erreurs 429](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/).

## Comment tenir les PII à l’écart des journaux LLM ?

Le journal le plus sûr ne contient aucun texte de prompt. Quand vous avez besoin du texte, pour déboguer ou pour des évaluations, suivez ces étapes dans l’ordre :

1.  **Échantillonnez.** Gardez le texte pour une petite part des appels et pour les échecs, pas pour tout.
2.  **Masquez avant d’écrire.** Faites le masquage dans le processus qui écrit le journal. Masquer plus tard signifie que le texte brut est déjà sur le disque et dans les sauvegardes.
3.  **Combinez les détecteurs.** Des regex pour les données structurées, un outil de NER pour les noms et les adresses.
4.  **Stockez à part.** Placez le texte dans une autre table ou un autre bucket, avec un accès plus strict et une courte durée de conservation, relié par `request_id`.
5.  **Ne journalisez jamais de secrets.** L’OWASP Logging Cheat Sheet range les jetons d’accès, les mots de passe et les clés de chiffrement parmi les données à exclure ; la [clé d’API](https://broadrouter.com/fr/glossary/api-key/) a sa place sur cette liste.

Une couche de regex minimale :

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

Elle attrape les cas évidents et laisse passer les noms, les adresses et tout ce qui sort de l’ordinaire. [Microsoft Presidio](https://github.com/microsoft/presidio) ajoute la reconnaissance d’entités pour ces cas, et son README dit clairement qu’il n’y a aucune garantie qu’il trouve toutes les informations sensibles. Prévoyez des oublis : une courte conservation et un accès restreint limitent les dégâts quand quelque chose passe à travers.

## La place de BroadNet Inference

BroadNet Inference renvoie le bloc usage avec les tokens en cache et de raisonnement quand le modèle les indique, un `X-Request-ID` sur chaque réponse, et un fichier de prix public que vous pouvez charger pour calculer les coûts. De son côté, les prompts et les réponses sont traités pour la requête et ne sont pas conservés ; il ne garde que des enregistrements sans contenu, comme les durées, les nombres de tokens et le coût ([fonctionnement de la conservation zéro des données](https://broadrouter.com/fr/privacy/)). Vos propres journaux sont donc la seule copie de tout texte de prompt, et ce sont les règles de masquage ci-dessus qui déterminent votre conservation réelle. Les requêtes de chat de BroadNet n’ont pas de champ de métadonnées par utilisateur : l’attribution se fait dans votre fonction d’enveloppe. Pour des budgets séparés par équipe, utilisez des clés séparées ; le [guide des clés](https://broadrouter.com/fr/guides/api-keys-ip-allow-lists/) couvre les libellés et les listes d’IP autorisées.

Outils gratuits sur ce sujet (en anglais)

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

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

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

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Tokens d’entrée en cache (cached input tokens)](https://broadrouter.com/fr/glossary/cached-input-tokens/)

Les tokens d’entrée en cache sont des tokens de prompt qu’un fournisseur de LLM a traités récemment et peut réutiliser depuis un cache au lieu de les recalculer, en général un préfixe répété comme un prompt système ou un document. Les fournisseurs les facturent moins cher que les nouveaux tokens d’entrée.

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

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

[PII (données d’identification personnelle)](https://broadrouter.com/fr/glossary/pii/)

Les PII (personally identifiable information) sont les informations permettant de distinguer ou de retrouver l’identité d’une personne, comme un nom, un numéro d’identité ou des données biométriques, et toute information qui lui est liée ou rattachable. Le RGPD parle plus largement de données personnelles. Avec les LLM, le masquage des PII les retire des prompts avant qu’ils quittent vos systèmes.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Clé d’API (API key)](https://broadrouter.com/fr/glossary/api-key/)

Une clé d’API est une chaîne secrète qui identifie et autorise un client qui appelle une API. Les API LLM l’attendent généralement dans un en-tête Authorization: Bearer, et quiconque détient la clé peut envoyer des requêtes facturées au compte qui la possède.

[Guardrails (garde-fous pour LLM)](https://broadrouter.com/fr/glossary/guardrails/)

Les guardrails sont des contrôles qu’une application exécute autour d’un appel à un modèle de langage pour le maintenir dans des limites définies. Ceux d’entrée filtrent ce qui entre dans le modèle, ceux de sortie vérifient ce qui en sort, et ceux d’outils valident les actions avant leur exécution. Un contrôle échoué bloque, réécrit ou signale la requête.

[Liste d’IP autorisées (IP allow list)](https://broadrouter.com/fr/glossary/ip-allow-list/)

Une liste d’IP autorisées est un contrôle de sécurité qui n’accepte que les requêtes provenant d’adresses IP ou de plages CIDR listées et refuse toutes les autres. Sur une API, elle limite les dégâts d’une clé divulguée, car la clé ne fonctionne pas depuis des réseaux absents de la liste.

## Questions fréquentes

### Comment suivre le coût d’une API LLM par utilisateur ?

Marquez chaque appel avec un identifiant utilisateur, lisez le bloc usage de la réponse, multipliez les nombres de tokens par votre grille de prix et écrivez une ligne de journal par appel. Regroupez par identifiant utilisateur. Utilisez un ID haché plutôt qu’une adresse e-mail.

### Faut-il journaliser les prompts et les réponses complets ?

Pas par défaut. C’est là que se trouvent les données personnelles. Journalisez les nombres de tokens et les métadonnées de chaque appel, et ne gardez le texte complet que pour un échantillon ou les appels en échec, après masquage, avec une courte durée de conservation.

### Pourquoi mon coût calculé diffère-t-il de la facture du fournisseur ?

En général parce que les tokens en cache ont été comptés au prix d’une entrée nouvelle, que les tokens de raisonnement ont été oubliés dans la sortie, ou que les relances n’ont pas été journalisées. Journalisez chaque tentative, y compris les échecs qui ont renvoyé un bloc usage.

### Comment obtenir la consommation de tokens d’une réponse en streaming ?

Mettez include\_usage à true dans stream\_options. Le dernier chunk contient alors le bloc usage avec une liste choices vide.

### Quel outil de masquage des PII utiliser pour les journaux LLM ?

Commencez par des regex pour les données structurées comme les adresses e-mail, les numéros de téléphone et de carte, et ajoutez un outil fondé sur la NER comme Microsoft Presidio pour les noms et les adresses. Le README de Presidio dit lui-même qu’il ne peut pas garantir de tout trouver.

## À lire ensuite

-   [API LLM à conservation zéro des données : checklist en 10 questions](https://broadrouter.com/fr/blog/zero-data-retention-llm-api-checklist/)
-   [Tokens d’entrée en cache : réduire la facture d’une API LLM](https://broadrouter.com/fr/blog/cached-input-tokens-explained/)
-   [Gérer les erreurs 429 d’une API LLM : backoff, jitter et limiteurs](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/)
-   [Le streaming LLM expliqué : chunks SSE, deltas, usage et annulation](https://broadrouter.com/fr/blog/llm-streaming-sse-explained/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Intégrer la relecture humaine à votre workflow d’IA documentaire](https://broadrouter.com/fr/blog/document-review-queues/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Streamer des chat completions et gérer les connexions coupées](https://broadrouter.com/fr/guides/streaming-chat-completions/)
-   [Guide : Limiter vos clés API à vos serveurs avec une liste d’IP autorisées](https://broadrouter.com/fr/guides/api-keys-ip-allow-lists/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Référence de l’API BroadNet Inference, champs usage, ID de requête et conservation (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-api-usage-logging&utm_content=sources)
-   [Prix lisibles par machine de BroadNet Inference (pricing.json) (en anglais)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, données à exclure des journaux](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README de Microsoft Presidio, détection des PII et ses limites (consulté le 2026-11-14)](https://github.com/microsoft/presidio)
-   [README d’openai-python, lire les en-têtes de réponse avec with\_raw\_response](https://github.com/openai/openai-python)
