Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Campi di costo nelle risposte

Lezione 8 di 14 Aggiornata il 29 luglio 2026 Avanzato
In questa pagina
  1. Monitora i costi in tempo reale
  2. L’oggetto usage
  3. Due scale per lo stesso costo
  4. Costruisci un tracker dei costi
  5. Analizza il tasso di cache
  6. Punti chiave

Monitora i costi in tempo reale

Ogni risposta delle API di Grok include i dettagli del costo appena sostenuto. Molti team scoprono queste informazioni troppo tardi, all’arrivo della fattura mensile, sebbene siano disponibili richiesta per richiesta. Sfruttandole fin dall’inizio dell’integrazione, individui le anomalie entro un’ora dalla loro comparsa: un prompt di sistema raddoppiato dopo un deployment, un ciclo di retry mal calibrato che ripete le stesse chiamate o un contesto che supera una soglia di fatturazione. Senza questo monitoraggio, questi incidenti restano invisibili fino all’estrazione conto.

L’oggetto usage

Ogni risposta include un oggetto usage che dettaglia il consumo di token e il costo associato:

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

I quattro campi di conteggio si leggono come segue.

CampoSignificato
prompt_tokensnumero di token in input (il tuo prompt completo)
completion_tokensnumero di token in output (la risposta del modello)
total_tokenssomma dei token in input e output
cached_tokenstoken in input serviti dalla cache

Un dettaglio previene un errore comune: cached_tokens è incluso in prompt_tokens, non aggiunto ad esso. Nell’esempio sopra, 1.250 token sono entrati nel modello, 800 provenivano dalla cache e solo 450 sono stati fatturati alla tariffa piena. Se il tuo aggregatore somma entrambi i campi, conteggerà due volte la parte cached e gonfierà artificialmente le tue statistiche di volume.

Due scale per lo stesso costo

Il costo della richiesta è fornito in due unità intere. Questa scelta non è arbitraria: esprimere frazioni di centesimo con numeri in virgola mobile introduce errori di arrotondamento che diventano visibili aggregando milioni di chiamate. Gli interi evitano completamente questo problema.

Il campo cost_in_usd_ticks conta in “tick”, con 10 miliardi di tick per dollaro. Il valore 5.000.000.000 nell’esempio corrisponde quindi a 0,50 $, e un milione di tick equivale a 0,0001 $. La conversione sta in una riga:

cost_usd = cost_in_usd_ticks / 10_000_000_000

Il campo cost_in_nano_usd conta in nano-dollari, con un miliardo di nano-dollari per dollaro. I 500.000.000 nell’esempio rappresentano lo stesso importo, 0,50 $, e mille nano-dollari equivalgono a 0,000001 $. La conversione segue la stessa logica:

cost_usd = cost_in_nano_usd / 1_000_000_000

Entrambi i campi descrivono lo stesso importo a scale diverse. cost_in_nano_usd è più intuitivo da gestire, mentre cost_in_usd_ticks offre una precisione leggermente superiore. Scegline uno e mantienilo coerente in tutta la tua catena di misurazione: mescolarli nello stesso aggregato è il modo migliore per ottenere totali incoerenti.

Costruisci un tracker dei costi

In produzione, un singolo accumulatore basta a trasformare questi campi in una dashboard. La classe sottostante registra ogni oggetto usage ed espone il costo cumulativo insieme al tasso di cache:

class CostTracker:
    def __init__(self):
        self.total_nano_usd = 0
        self.requests = 0
        self.input_tokens = 0
        self.output_tokens = 0
        self.cached_tokens = 0

    def record(self, usage):
        self.total_nano_usd += usage.get("cost_in_nano_usd", 0)
        self.requests += 1
        self.input_tokens += usage.get("prompt_tokens", 0)
        self.output_tokens += usage.get("completion_tokens", 0)
        self.cached_tokens += usage.get("cached_tokens", 0)

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

    @property
    def cache_rate(self):
        if self.input_tokens == 0:
            return 0
        return self.cached_tokens / self.input_tokens

Collega poi delle soglie a total_cost_usd. Una prima soglia all’80% del budget giornaliero attiva un avviso informativo per il team tecnico; una seconda al 95% diventa un avviso critico che richiede una decisione umana; al 100%, l’applicazione interrompe automaticamente le richieste non critiche—job batch, pre-calcoli, arricchimenti differiti—e consente solo il traffico diretto degli utenti. Questo degrado graduale è preferibile a un arresto improvviso del servizio in un giorno di picco.

Analizza il tasso di cache

La proprietà cache_rate merita una dashboard dedicata, poiché riflette direttamente la qualità della struttura del tuo prompt.

Tasso di cacheInterpretazione
Da 0 a 20%nessuna cache efficace, rivedi la struttura del prompt
Da 20 a 50%cache parziale, verifica la stabilità dei tuoi prompt di sistema
Da 50 a 80%buon tasso per le conversazioni
80% e oltreeccellente, tipico per prompt lunghi e stabili

Un tasso che crolla bruscamente da una settimana all’altra è quasi sempre segno di un deployment che ha introdotto una variabile all’inizio del prompt. La prossima lezione dettaglia il meccanismo; per ora, ricorda che questa cifra è un indicatore di regressione prezioso quanto un tasso di errore.

Prezzi al 5 agosto 2026 — i prezzi evolvono regolarmente: prima di qualsiasi calcolo di budget, verifica la tariffa attuale sulla pagina ufficiale dei modelli e dei prezzi xAI.

Punti chiave

  • Ogni risposta API contiene un oggetto usage con dettagli sui token e sul costo
  • cost_in_usd_ticks: 10 miliardi di tick = 1 $ USD
  • cost_in_nano_usd: 1 miliardo di nano-USD = 1 $ USD
  • Il campo cached_tokens misura l’efficienza della cache
  • Costruisci un tracker dei costi in produzione con avvisi di budget