Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Fatturazione e ottimizzazione dei costi

Lezione 9 di 12 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Token di ragionamento in fattura
  2. Prezzi per modello (luglio 2026)
  3. Traccia il costo di ogni richiesta
  4. Strategie di ottimizzazione dei costi
  5. Tracciamento del budget in produzione
  6. Punti chiave

Aggiornato il 3 novembre 2026: Gli esempi precedenti accedevano a usage.prompt_tokens e usage.completion_tokens sulle risposte delle API Responses, che espongono invece input_tokens, output_tokens e i relativi dettagli (cached_tokens, reasoning_tokens): il codice generava un AttributeError. Il tracciamento dei costi ora tiene conto dell’input memorizzato nella cache e il consiglio di ridurre il limite di output per limitare il ragionamento è stato corretto, poiché questo limite non include i token di ragionamento. Fonti: Modelli e Prezzi · Migliori pratiche.

Token di ragionamento in fattura

La fatturazione dei token di ragionamento è un aspetto cruciale nell’utilizzo dei modelli xAI. Questi token vengono addebitati alla tariffa dei token di output, la più elevata, e un utilizzo non ottimizzato può far lievitare rapidamente i costi, specialmente con uno sforzo di ragionamento elevato su grok-4.5.

Novità del 2026 fondamentale da comprendere: la tariffazione è a scaglioni. Il prezzo per token dipende dalla dimensione del contesto della richiesta. Sotto i 200k token di prompt, paghi la tariffa standard; oltre tale soglia, la tariffa raddoppia.

Prezzi per modello (luglio 2026)

Prezzo per milione di token.

Modello Input < 200k Output < 200k Input ≥ 200k Output ≥ 200k
grok-4.5 $2.00 $6.00 $4.00 $12.00
grok-4.20-0309-reasoning $1.25 $2.50 $2.50 $5.00
grok-4.3 $1.25 $2.50 $2.50 $5.00
grok-build-0.1 $1.00 $2.00 $2.00 $4.00

I token di ragionamento sono fatturati alla tariffa della colonna “Output”. Con grok-4.5 sotto i 200k di contesto, ogni milione di token di ragionamento costa $6.00; con grok-4.20-0309-reasoning, $2.50. Se il tuo prompt supera i 200k token, questi importi raddoppiano: $12.00 e $5.00.

Traccia il costo di ogni richiesta

L’oggetto usage nella risposta contiene i contatori di token; alcune risposte delle API xAI possono includere anche campi diretti per il costo. Ispeziona l’oggetto usage restituito dal tuo modello e consulta la documentazione ufficiale per i campi disponibili. In alternativa, il calcolo manuale è semplice:

response = client.responses.create(
    model="grok-4.5",
    input="Solve this dynamic programming problem...",
    reasoning={"effort": "high"}
)

# Tariffe grok-4.5 sotto i 200k token di contesto (le API Responses contano in input/output)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000  # include il ragionamento
total_cost = input_cost + output_cost

print(f"Input cost: ${input_cost:.6f}")
print(f"Output cost: ${output_cost:.6f}")
print(f"Total cost: ${total_cost:.6f}")

Attenzione: questo calcolo presuppone un contesto inferiore a 200k token. In produzione, il tuo tracker deve rilevare lo scaglione applicabile (vedi sotto).

Strategie di ottimizzazione dei costi

1. Adatta lo sforzo al compito

La prima e più efficace ottimizzazione consiste nello scegliere il livello di sforzo di ragionamento corretto su grok-4.5. Uno sforzo basso può consumare significativamente meno token di ragionamento rispetto a uno sforzo elevato:

# Ordina le richieste per complessità
if complexity == "simple":
    effort = "low"      # ragionamento breve
elif complexity == "medium":
    effort = "medium"   # ragionamento intermedio
else:
    effort = "high"     # ragionamento profondo

Verifica i valori esatti accettati dal parametro nella pagina ufficiale dei modelli.

2. Usa il modello giusto

Per compiti di ragionamento comuni, grok-4.20-0309-reasoning a $2.50/M di output costa meno della metà di grok-4.5 a $6.00/M. Riserva il modello di punta ai compiti che lo richiedono davvero. Per il codice, grok-build-0.1 a $2.00/M di output è ancora più economico.

3. Rimani sotto lo scaglione dei 200k token

Lo scaglione di prezzo è una leva diretta: una richiesta con 250k token di contesto costa il doppio per token rispetto a una richiesta con 150k. Prima di inviare un contesto massiccio, chiediti se suddividerlo in diverse richieste più piccole (o un riepilogo intermedio) non sarebbe sia più economico che più efficace.

4. Sfrutta la cache dei prompt

xAI offre prezzi ridotti per i token di input già presenti in cache: i prefissi di prompt ripetuti (istruzioni di sistema, contesto condiviso) costano meno se riutilizzati da una richiesta all’altra. Sotto i 200k token, l’input in cache costa $0.30 per milione invece di $2.00 con grok-4.5, e $0.20 invece di $1.25 con grok-4.20-0309-reasoning (pagina Modelli e Prezzi, novembre 2026). Struttura i tuoi prompt con parti stabili all’inizio; la porzione servita dalla cache appare in usage.input_tokens_details.cached_tokens.

5. Dimensiona il limite di output

Il limite di output (max_output_tokens nelle API Responses, max_completion_tokens nelle Chat Completions) limita solo la risposta visibile: i token di ragionamento non contano verso di esso. Abbassarlo quindi non riduce il ragionamento; rischia solo di troncare la risposta. Le migliori pratiche xAI raccomandano di impostarlo al di sopra della risposta più lunga prevista o di lasciare il suo valore predefinito di 128.000 token. Per ridurre il ragionamento, abbassa lo sforzo sui modelli che lo accettano o scegli un modello più economico.

Tracciamento del budget in produzione

class CostTracker:
    # Tariffe per MTok: (input, input in cache, output) per scaglione di contesto
    RATES = {
        "grok-4.5": {"low": (2.00, 0.30, 6.00), "high": (4.00, 0.60, 12.00)},
        "grok-4.20-0309-reasoning": {"low": (1.25, 0.20, 2.50), "high": (2.50, 0.40, 5.00)},
        "grok-build-0.1": {"low": (1.00, 0.20, 2.00), "high": (2.00, 0.40, 4.00)},
    }
    TIER_THRESHOLD = 200_000  # token del prompt

    def __init__(self):
        self.total_cost = 0
        self.request_count = 0

    def track(self, response, model="grok-4.5"):
        usage = response.usage  # risposta API Responses
        details = usage.input_tokens_details
        cached = details.cached_tokens if details else 0
        tier = "high" if usage.input_tokens >= self.TIER_THRESHOLD else "low"
        rate_in, rate_cached, rate_out = self.RATES[model][tier]
        cost = (
            (usage.input_tokens - cached) * rate_in / 1e6
            + cached * rate_cached / 1e6
            + usage.output_tokens * rate_out / 1e6  # include il ragionamento
        )
        self.total_cost += cost
        self.request_count += 1
        return cost

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

Punti chiave

  • I token di ragionamento sono fatturati alla tariffa dei token di output
  • La tariffazione 2026 è a scaglioni: oltre i 200k token di contesto, il prezzo per token raddoppia
  • grok-4.5 costa $2/$6 per MTok sotto i 200k ($4/$12 sopra); grok-4.20-0309-reasoning costa $1.25/$2.50 ($2.50/$5 sopra)
  • Le tre leve principali: adatta lo sforzo di ragionamento, scegli il modello giusto, rimani sotto lo scaglione dei 200k
  • Traccia i tuoi costi richiesta per richiesta, tenendo conto dello scaglione applicabile