Champs de coût dans les réponses

Suivre les coûts en temps réel

Chaque réponse de l’API Grok contient des informations détaillées sur la consommation de tokens et le coût de la requête. Ces champs sont essentiels pour construire un suivi financier de votre utilisation et détecter les anomalies de coût avant qu’elles n’impactent votre budget.

L’objet usage

Chaque réponse de l’API inclut un objet usage qui détaille la consommation de tokens :

{
  "usage": {
    "prompt_tokens": 1250,
    "completion_tokens": 340,
    "total_tokens": 1590,
    "cached_tokens": 800,
    "cost_in_usd_ticks": 5000000000,
    "cost_in_nano_usd": 500000000
  }
}

Champs de comptage

• prompt_tokens : nombre de tokens en entrée (votre prompt complet)
• completion_tokens : nombre de tokens en sortie (la réponse du modèle)
• total_tokens : somme des tokens en entrée et en sortie
• cached_tokens : nombre de tokens d’entrée servis depuis le cache (inclus dans prompt_tokens)

Champs de coût

L’API Grok fournit le coût de chaque requête dans deux formats différents, offrant une précision maximale sans erreurs d’arrondi.

cost_in_usd_ticks

Ce champ exprime le coût en “ticks” où 10 milliards de ticks équivalent à 1 dollar USD :

• 10 000 000 000 ticks = $1.00 USD
• 5 000 000 000 ticks = $0.50 USD
• 1 000 000 ticks = $0.0001 USD

Pour convertir en dollars :

cout_usd = cost_in_usd_ticks / 10_000_000_000

cost_in_nano_usd

Ce champ exprime le coût en nano-dollars où 1 milliard de nano-dollars équivaut à 1 dollar USD :

• 1 000 000 000 nano-USD = $1.00 USD
• 500 000 000 nano-USD = $0.50 USD
• 1 000 nano-USD = $0.000001 USD

Pour convertir en dollars :

cout_usd = cost_in_nano_usd / 1_000_000_000

Pourquoi deux formats ?

Les deux champs représentent le même coût avec des échelles différentes. cost_in_nano_usd est plus intuitif (1 milliard = 1 dollar), tandis que cost_in_usd_ticks offre une précision légèrement supérieure (10 milliards = 1 dollar). En pratique, utilisez celui qui vous convient le mieux.

Construire un suivi de coûts

En production, agrégez ces champs pour construire un tableau de bord de suivi :

class SuiviCouts:
    def __init__(self):
        self.total_nano_usd = 0
        self.requetes = 0
        self.tokens_entree = 0
        self.tokens_sortie = 0
        self.tokens_caches = 0

    def enregistrer(self, usage):
        self.total_nano_usd += usage.get("cost_in_nano_usd", 0)
        self.requetes += 1
        self.tokens_entree += usage.get("prompt_tokens", 0)
        self.tokens_sortie += usage.get("completion_tokens", 0)
        self.tokens_caches += usage.get("cached_tokens", 0)

    @property
    def cout_total_usd(self):
        return self.total_nano_usd / 1_000_000_000

    @property
    def taux_cache(self):
        if self.tokens_entree == 0:
            return 0
        return self.tokens_caches / self.tokens_entree

Alertes budgétaires

Implémentez des alertes pour prévenir les dépassements :

• Alerte jaune : 80 % du budget quotidien atteint
• Alerte rouge : 95 % du budget quotidien atteint
• Coupure automatique : 100 % du budget atteint, arrêt des requêtes non critiques

Analyser le taux de cache

Le champ cached_tokens vous permet de mesurer l’efficacité de votre stratégie de cache. Un taux de cache élevé réduit significativement vos coûts :

• 0-20 % : pas de cache effectif, optimisez la structure de vos prompts
• 20-50 % : cache partiel, vérifiez que vos system prompts sont stables
• 50-80 % : bon taux de cache pour des conversations
• 80 %+ : excellent, typique des applications avec des prompts longs et stables

Points clés à retenir

• Chaque réponse API contient un objet usage avec le détail des tokens et le coût
• cost_in_usd_ticks : 10 milliards de ticks = $1 USD
• cost_in_nano_usd : 1 milliard de nano-USD = $1 USD
• Le champ cached_tokens permet de mesurer l’efficacité du cache
• Construisez un suivi de coûts en production avec des alertes budgétaires