BroadRouter
Commencer

Maîtriser les dépenses d’API LLM : budgets, limites de clés, boucles

Par l’équipe BroadNet Inference · 5 min de lecture · Publié · Mis à jour

Maîtrisez les dépenses d’API LLM par couches : un solde prépayé comme plafond du compte, une clé par application limitée aux IP de vos serveurs, max_tokens et plafonds d’étapes sur chaque requête, et un budget en code qui arrête une tâche avant qu’elle dépense trop. Journalisez les tokens par clé et déclenchez des alertes sur vos propres chiffres. Les forfaits et les clés horaires plafonnent le pire des cas.

La plupart des mauvaises surprises sur une facture LLM ont la même cause : quelque chose a continué d’appeler l’API sans que personne ne surveille. Une boucle de nouvelles tentatives, un agent incapable de terminer, une clé divulguée dans un dépôt public. Les alertes de budget vous préviennent après coup. Cet article construit la maîtrise des dépenses par couches, du compte jusqu’à la requête individuelle, et montre ce que BroadNet Inference prend en charge et ce que vous ajoutez dans votre code.

Pourquoi les alertes ne suffisent-elles pas ?

Une alerte compare la dépense à un seuil une fois l’usage enregistré. Une boucle d’agent peut envoyer des dizaines de requêtes par minute. Quand l’e-mail arrive, l’argent est parti. Utilisez les alertes comme filet de sécurité et placez l’arrêt strict là où la requête est émise.

Quelles sont les couches de la maîtrise des dépenses LLM ?

Couche Contrôle Empêche Où le régler
Compte Solde prépayé Les dépenses au-delà de ce que vous avez provisionné Compte du fournisseur
Clé Une clé par application ou agent Qu’une seule fuite emporte tout Portail du fournisseur
Clé Liste d’IP autorisées L’usage d’une clé volée ailleurs Portail du fournisseur
Requête max_tokens, reasoning_effort Une réponse énorme Votre code
Tâche Plafond d’étapes, plafond de nouvelles tentatives, détection de boucle Les agents incontrôlés Votre code
Tâche Budget cumulé par tâche et par jour Les fuites lentes sur de nombreux appels Votre code ou proxy
Suivi Journalisation des tokens et alertes Les dérives que vous ne remarqueriez pas Vos journaux
Tarification Forfait ou clé horaire Le compteur de tokens lui-même Choix du forfait

Niveau compte : comment un solde prépayé plafonne-t-il la dépense ?

Les clés BroadNet Inference en paiement à l’usage puisent dans un solde de compte prépayé ; les nouveaux comptes démarrent avec $5 de crédit et sans carte. Quand l’allocation en paiement à l’usage est épuisée, les requêtes renvoient 401, et un achat que le solde ne couvre pas (comme une clé horaire) renvoie 402 insufficient_balance. Traitez les deux comme un panneau stop, pas comme quelque chose à réessayer. La référence des erreurs de BroadNet cite aussi une limite de dépenses parmi les causes d’un 429 : lisez donc le corps de l’erreur avant de réessayer un 429. Tous les codes d’erreur et comment gérer les 429 avec backoff.

Le solde est votre plafond extérieur. Provisionnez ce que vous êtes prêt à perdre ce mois-ci, pas une année entière. Pour dimensionner ce montant, faites d’abord passer votre trafic prévu dans le calculateur de coût d’API LLM.

Niveau clé : comment limiter les dégâts d’une clé divulguée ?

Une clé d’API est un pouvoir de dépense : quiconque la détient peut utiliser votre solde. Limitez le rayon d’action de chaque clé :

  1. Une clé par application, agent ou environnement. BroadNet autorise jusqu’à 10 clés actives par compte, chacune valable jusqu’à un an. Nommez-les pour que les journaux vous disent laquelle a dépensé.
  2. Verrouillez les clés sur vos serveurs. Ajoutez vos IP sortantes ou plages CIDR à la liste d’IP autorisées, jusqu’à 32 entrées. Les requêtes venant d’autres adresses reçoivent un 403.
  3. Révoquez vite. Les révocations et modifications de la liste s’appliquent aux nouvelles requêtes en moins de cinq secondes.
  4. Gardez les identifiants du portail hors des serveurs. Ils permettent de créer des clés et d’effectuer des achats. Les clés d’inférence ne font qu’appeler des modèles.

Verrouiller les clés d’API avec des listes d’IP autorisées.

Niveau requête : comment borner chaque réponse ?

Fixez max_tokens à chaque appel. Sur les modèles de raisonnement (DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B), gardez-le à 1 000 ou plus, car la réflexion partage le budget et une valeur trop basse renvoie une réponse vide que vous payez quand même. Baissez reasoning_effort pour les tâches simples. Comment les tokens de raisonnement sont facturés.

Niveau tâche : comment arrêter une boucle d’agent incontrôlée ?

Les boucles incontrôlées ont des signes reconnaissables : le même appel d’outil qui se répète, un contexte qui grossit à chaque tour et des erreurs réessayées sans limite. Placez un garde-fou autour du client :

import json, os, urllib.request
from openai import OpenAI

# Per-1M prices from BroadNet's machine-readable rate card
card = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in card["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
PRICE = {"in": m["input_per_m"], "cached": m["cached_input_per_m"], "out": m["output_per_m"]}
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=3)

class BudgetExceeded(Exception): pass

class Guard:
    def __init__(self, budget_usd, max_steps=40):
        self.budget, self.max_steps, self.spent, self.steps, self.last = budget_usd, max_steps, 0.0, 0, []

    def call(self, **kw):
        self.steps += 1
        if self.steps > self.max_steps: raise BudgetExceeded("step cap")
        if self.spent >= self.budget: raise BudgetExceeded("budget")
        r = client.chat.completions.create(max_tokens=kw.pop("max_tokens", 4000), **kw)
        u = r.usage
        cached = (u.prompt_tokens_details.cached_tokens or 0) if u.prompt_tokens_details else 0
        self.spent += ((u.prompt_tokens - cached) * PRICE["in"] + cached * PRICE["cached"]
                       + u.completion_tokens * PRICE["out"]) / 1e6
        calls = [(t.function.name, t.function.arguments) for t in (r.choices[0].message.tool_calls or [])]
        self.last = (self.last + [calls])[-3:]
        if calls and len(self.last) == 3 and all(c == calls for c in self.last):
            raise BudgetExceeded("same tool call three times")
        return r

Le garde-fou lit les prix dans la grille tarifaire au lieu de les coder en dur : il reste donc juste quand les prix changent. Passez à call() le même modèle que celui que vous avez chiffré. Gardez max_retries petit : les SDK OpenAI réessaient déjà les 429 et 5xx, et chaque nouvelle tentative est facturée à nouveau.

En équipe, exécutez la même vérification dans un proxy partagé pour que chaque service puise dans un même budget quotidien. Les nouvelles tentatives se heurtent aussi aux limites de débit : le calculateur de limites de débit montre combien d’appels par minute votre clé autorise réellement.

Suivi : que journaliser et sur quoi alerter ?

Journalisez, pour chaque requête : alias de la clé, nom de la fonctionnalité ou de l’agent, modèle, prompt_tokens, prompt_tokens_details.cached_tokens, completion_tokens, statut et X-Request-ID. En streaming, réglez stream_options: {"include_usage": true}, sinon l’usage n’arrive jamais (guide du streaming).

À partir de ces journaux, déclenchez des alertes sur :

  • un coût quotidien par clé supérieur au chiffre attendu dans votre estimation de coût ;
  • des tokens par tâche plus de trois fois supérieurs à la médiane ;
  • une part de cache en baisse, qui fait monter le coût sans plus de trafic ;
  • un taux croissant de réponses 429 ou 5xx, synonyme de nouvelles tentatives.

BroadNet conserve des enregistrements sans contenu, comme les durées, le nombre de tokens et le coût, pas les prompts : c’est donc dans vos propres journaux que se trouve le détail par fonctionnalité. Évitez de journaliser le contenu des prompts si votre politique de données l’interdit. Mettre en place une journalisation de l’usage avec coût par utilisateur et par fonctionnalité.

Niveau tarification : quand un prix fixe vaut-il mieux qu’un budget ?

La maîtrise des dépenses la plus fiable, c’est un prix qui ne bouge pas :

  • Session de forfait : $60 par mois (Full Moon), $15 par semaine (Orbit) ou $1 de l’heure (Meteor) pour DeepSeek V4.1 Flash illimité, une requête à la fois. Les requêtes faites avec une clé de forfait ne puisent jamais dans votre solde.
  • Clé horaire : $0.50 pour une heure de Gemma 4 VL 26B sur un flux. Idéal pour les clés qui quittent vos serveurs. Les clés horaires expliquées.

Une boucle sur un forfait gaspille du temps, pas de l’argent. Les plafonds d’étapes restent utiles, car un agent bloqué monopolise la session au détriment d’autres travaux. Qu’un forfait coûte moins que votre facture au compteur dépend du volume ; le calculateur forfait ou paiement au token donne le point mort pour votre mix de tokens.

Les tarifs au token peuvent aussi augmenter sans prévenir. 52 hausses de prix d’API LLM archivées montrent à quelle fréquence c’est arrivé, chez quels fournisseurs et de combien.

Une courte checklist

  1. Un solde prépayé dimensionné sur votre limite mensuelle.
  2. Une clé nommée par application, avec une liste d’IP autorisées.
  3. max_tokens sur chaque requête.
  4. Plafond d’étapes, plafond de nouvelles tentatives et détection des appels répétés sur chaque agent.
  5. Coût cumulé par tâche, vérifié avant chaque appel.
  6. Journalisation des tokens par requête, avec alertes sur vos seuils.
  7. Un forfait ou une clé horaire partout où l’usage est continu ou la clé exposée.

La place de BroadNet Inference

BroadNet vous fournit les couches compte et clé : solde prépayé, clés séparées, listes d’IP autorisées avec révocation en quelques secondes, ainsi que forfaits et clés horaires à prix fixe. Il ne fournit pas les budgets au niveau des tâches décrits ici ; ceux-ci relèvent de votre code ou de votre proxy. Si vous avez besoin de budgets par équipe sur de nombreux fournisseurs, une passerelle placée devant eux tous est le bon outil. Consulter les prix.

Questions fréquentes

Comment fixer une limite de dépenses sur une API LLM ?

Utilisez le solde prépayé ou le plafond de dépenses du fournisseur comme limite extérieure, puis appliquez dans votre code votre propre budget par tâche et par jour avant chaque requête, car les limites et alertes du fournisseur peuvent être en retard sur une boucle rapide.

Comment empêcher un agent IA de faire exploser la facture ?

Plafonnez les étapes par tâche et les nouvelles tentatives, fixez max_tokens sur chaque requête, détectez les appels d’outils identiques répétés et arrêtez la tâche quand son coût cumulé dépasse un budget.

Faut-il réessayer une erreur 401 ou 402 quand mon solde est épuisé ?

Non. Chez BroadNet, une allocation en paiement à l’usage épuisée renvoie 401, et 402 insufficient_balance signifie que le compte ne peut pas couvrir un achat, par exemple une clé horaire. Rechargez d’abord le compte. Réessayez plutôt les 429 et 5xx avec backoff.

Que faut-il journaliser pour suivre les dépenses LLM ?

Pour chaque requête, journalisez l’alias de la clé, le nom de la fonctionnalité ou de l’agent, le modèle, prompt_tokens, cached_tokens, completion_tokens, le code de statut et l’ID de requête. Multipliez par les valeurs du fichier de prix pour obtenir le coût.

Un forfait est-il une forme de maîtrise des dépenses ?

Oui. Une session de forfait ou une clé horaire coûte la même chose quel que soit le nombre de tokens utilisés : une boucle coûte donc du temps, pas de l’argent.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity