BroadRouter
Commencer

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

Par l’équipe BroadNet Inference · 4 min de lecture · Publié

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.

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 et budgets et garde-fous contre les boucles.

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
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 séparément. BroadNet publie des prix lisibles par machine dans pricing.json, avec des prix par million pour l’entrée, l’entrée en cache et la sortie de chaque modèle :

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 ?

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

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

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 a sa place sur cette liste.

Une couche de regex minimale :

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 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). 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 couvre les libellés et les listes d’IP autorisées.

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 en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity