Cosa sono i token di Claude e costi sessione

Cosa sono i token in Claude?

Un token è l'unità di testo che Claude legge e scrive: un frammento di parola, corrispondente a circa 3.5 caratteri inglesi. Questo valore deriva dal glossario di Anthropic. Considerando spazi e punteggiatura, il numero di token è superiore a uno per parola; pertanto, mille parole di prosa superano agevolmente i 1.300 token. Il codice consuma più risorse per riga: parentesi graffe, operatori, underscore e indentazione generano più token per carattere rispetto all'inglese. Un file sorgente di poche centinaia di righe pesa tipicamente diverse migliaia di token. Se l'agente decide di leggere un file di 2.000 righe, l'impatto sarà di decine di migliaia di token prima ancora di scrivere una riga di nuovo codice.

Due aspetti relativi ai tokenizer possono confondere l'utente. Primo, sono specifici per ogni modello. A partire da luglio 2026, Opus 4.7 e versioni successive, Sonnet 5 e Fable 5 utilizzano un nuovo tokenizer che produce circa il 30% di token in più rispetto ai precedenti modelli Claude per lo stesso testo (l'incremento esatto varia in base al contenuto). Questo modifica il calcolo del budget in token, nonostante i prezzi per singolo token non siano aumentati. Secondo, tiktoken, la libreria utilizzata comunemente nei blog post, è il tokenizer di OpenAI e sottostima il consumo di Claude di circa il 15–20% su testo comune, e in misura maggiore su codice. L'unico conteggio affidabile è l'endpoint count_tokens, descritto di seguito.

Perché la tua sessione di coding ha quel costo

Ogni fattura di Claude, che si tratti di un conto API o di un limite di abbonamento, dipende da un unico parametro: i token in ingresso e i token in uscita. La pagina dei prezzi sembra semplice: un certo numero di dollari per un milione di token di input, un altro per un milione di output. Ciò che non viene spiegato è che, in una sessione di coding agentica, il consumo di input è molto più elevato di quanto si possa intuire, poiché l'intera conversazione viene inviata nuovamente ad ogni turno. Ho venduto infrastrutture a consumo per quindici anni, e i token sono il primo parametro in cui la maggior parte dei clienti non riesce a identificare la causa dell'aumento dei costi. Questa è la lezione sull'analisi dei consumi: cosa viene conteggiato come input e output in una sessione agentica, perché il ciclo di rispedizione è così costoso, come il prompt caching modifichi il calcolo e quali fattori influenzano effettivamente il totale.

Tutto è input: cosa viene effettivamente conteggiato

Si tende a pensare di pagare per il codice generato da Claude. In una sessione agentica, questa è solo una piccola parte della spesa. I token di input — con tariffa inferiore ma volume molto più elevato — includono:

• Il system prompt. Le istruzioni di sistema di Claude Code, insieme ai file CLAUDE.md e ai file di memoria, caricati all'inizio della sessione e presenti in ogni richiesta successiva.
• Tool definitions. Ogni schema dei tool che l'agent può chiamare. Ogni MCP server connesso aumenta questo overhead fisso — sebbene Claude Code ora posticipi le definizioni complete dei tool MCP di default; pertanto, solo i nomi dei tool sono nel contesto finché un tool non viene utilizzato, riducendo il costo senza eliminarlo.
• Ogni file letto dall'agent. Un Read di un file sorgente inserisce l'intero file nel contesto, che rimane attivo.
• Ogni risultato dei tool. Esecuzioni di test, output di grep, log del terminale, log di build — tutto viene restituito come token di input. Una suite di test fallita che stampa 8,000 righe può costare quanto un intero libro.
• L'intera conversazione precedente, inviata nuovamente ad ogni turno. Questo punto richiede una sezione dedicata.

Il problema del rinvio dei dati nelle sessioni

L'API di Claude è stateless. Non mantiene la memoria della sessione tra una richiesta e l'altra. Di conseguenza, al turn 2, il client invia il turn 1, la sua risposta e il nuovo messaggio. Al turn 50, il client invia nuovamente i turn da 1 a 49 — inclusi ogni file letto, ogni risultato degli tool e ogni diff — più il turn 50. Il modello rilegge l'intero transcript ad ogni iterazione; ogni token riletto viene fatturato come input.

La conseguenza: il costo per turn cresce in modo approssimativamente lineare rispetto alla lunghezza della sessione, mentre il costo totale della sessione cresce in modo approssimativamente quadratico. Un messaggio che costa mezzo centesimo al turn 3 può costarne venti volte tanto al turn 60, pur trattandosi della stessa domanda di una riga, poiché trasporta il carico di sessanta turn precedenti. Questo singolo fattore spiega la maggior parte dei ticket relativi a "fatture troppo elevate". Non è un'anomalia di Claude: ogni prodotto LLM che appare stateful è in realtà un'API stateless con un ciclo di rinvio dei dati sottostante.

Output: ciò che vedi, più il ragionamento interno

I token di output sono i più costosi: il tasso è cinque volte superiore a quello di input nell'attuale gamma ($5/$25 su Opus 4.8, $3/$15 su Sonnet 5, $1/$5 su Haiku 4.5, a partire da luglio 2026). L'output include il testo e il codice generati da Claude, e i thinking tokens: il ragionamento interno che il modello esegue prima di rispondere. In questo contesto contano due fatti. Il thinking viene fatturato alle tariffe di output e consuma max_tokens — una risposta API che termina con stop_reason: "max_tokens" e una risposta troncata spesso significano che il thinking ha esaurito il budget prima della risposta stessa. Inoltre, sui modelli attuali il riepilogo del ragionamento potrebbe non essere visualizzato affatto — Opus 4.8, Sonnet 5 e Fable 5 lo omettono di default — ma il thinking avviene comunque e viene fatturato. L'invisibilità non è gratuita.

Claude Code abilita il thinking esteso di default perché migliora misurabilmente il lavoro multi-step, e il budget predefinito può raggiungere decine di migliaia di token per richiesta. Su task più semplici è possibile ridurlo: abbassare il livello di sforzo con /effort o in /model, oppure regolare le impostazioni di thinking in /config. Si tratta di un reale parametro di costo, non di una superstizione.

Il prompt caching modifica il calcolo dei costi

Il prompt caching evita che i cicli di invio ripetuti causino costi eccessivi. L'API può memorizzare in cache un prefisso stabile del prompt — system prompt, definizioni dei tool, cronologia della conversazione — e servirlo alla prossima richiesta a una frazione del prezzo originale. A partire da luglio 2026, i moltiplicatori sono: una scrittura in cache (write) costa 1.25× la tariffa base di input (2× per la variante da 1 ora), mentre una lettura in cache (read) costa 0.1×. Le scritture hanno un costo premium; le letture hanno uno sconto del 90%. Una singola lettura compensa già ampiamente il sovrapprezzo della scrittura di 5 minuti.

Claude Code gestisce la cache automaticamente; in una sessione attiva, quasi tutti i dati inviati ripetutamente vengono serviti dalla cache. Tuttavia, la cache predefinita scade dopo cinque minuti dall'ultimo utilizzo. Se la sessione si interrompe per un tempo superiore, la cache scade: al ritorno, l'intero prefisso accumulato deve essere riscritto al costo di 1.25× invece di essere letto a 0.1×. In una sessione da 150K-token, un singolo turno a freddo costa più di una dozzina di turni a caldo. Il risultato controintuitivo da memorizzare è: un ritmo di lavoro interrotto può costare più di un lavoro continuo, poiché ogni pausa superiore al TTL trasforma il turno successivo da una lettura economica in una riscrittura costosa. Lavora per sessioni intensive; non inviare messaggi singoli ogni dieci minuti in una sessione molto lunga.

Se chiami l'API da la tua applicazione su un VPS, questi vantaggi non sono automatici. L'errore comune è inserire un timestamp o un ID di richiesta all'interno del system prompt; questo modifica i byte del prefisso ad ogni richiesta e disabilita silenziosamente la cache. Il segnale è usage.cache_read_input_tokens che rimane a zero nonostante le chiamate siano identiche.

La formula, con un esempio pratico

Ignora chiunque affermi che "una sessione costa $X". Il costo delle sessioni varia di due ordini di grandezza. L'unica costante è la formula:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

Esempio pratico su Claude Opus 4.8, che a luglio 2026 costa $5 per milione di input token e $25 per milione di output token. Un turno a metà sessione con 80.000 token di contesto accumulato: 75.000 letti dalla cache, 3.000 scritti di nuovo, 2.000 di input fresco non in cache, 1.500 token di output inclusi i processi di thinking.

• Letture cache: 75.000 × $0.50/M = $0.0375
• Scritture cache: 3.000 × $6.25/M = $0.019
• Input non in cache: 2.000 × $5/M = $0.010
• Output: 1.500 × $25/M = $0.0375

Circa $0.10 per il turno; cinquanta turni identici costano circa $5. Ora esegui lo stesso turno dopo la scadenza della cache: i restanti 80.000 token riscritti a $6.25/M costano $0.50 prima dell'output — circa cinque volte il costo del turno con cache attiva, a parità di lavoro. Questo divario rappresenta il valore del caching in un unico numero.

Per calibrazione invece che per previsione: i dati pubblicati da Anthropic per le implementazioni enterprise di Claude Code, a luglio 2026, indicano una media di circa $13 per sviluppatore al giorno attivo — $150–250 al mese — con il 90% degli utenti sotto i $30 al giorno. Il costo effettivo dipende dalla scelta del modello, dalla gestione della sessione e dalla dimensione del codebase; per questo i parametri riportati di seguito sono fondamentali.

Visualizzare il proprio utilizzo

In Claude Code, il comando è /usage (/cost funziona ancora — è un alias). Il blocco Session in alto mostra le statistiche dei token e una stima del costo calcolata localmente per la sessione corrente; nei piani in abbonamento, la stessa schermata mostra le barre dei limiti del piano e un dettaglio che attribuisce l'utilizzo recente a skill, subagent, plugin e singoli server MCP. Per la fatturazione ufficiale degli account API, la pagina di utilizzo nella Claude Console è l'unica fonte attendibile — il valore riportato dalla CLI è una stima. /context genera una griglia colorata di cosa occupa la context window — system prompt, tools, definizioni MCP, file, history — ed è il modo più rapido per individuare un CLAUDE.md eccessivo o un server MCP troppo prolisso; usa all per espandere il dettaglio completo per ogni elemento.

Dall'API, ogni risposta indica esattamente cosa è accaduto:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Nota che input_tokens rappresenta solo il residuo non memorizzato in cache — la dimensione reale del prompt è la somma di tutti e tre i campi di input. Un agent che lavora per un'ora mostrando input_tokens: 4000 non è economico; gli altri 200,000 token sono stati serviti dalla cache. Per stimare il costo prima dell'invio, usa l'endpoint di conteggio dei token — la chiamata è gratuita, ha un proprio limite di rate limit e conta i token utilizzando il tokenizer del modello specificato (considera il risultato come una stima approssimativa; la fatturazione riflette la richiesta reale):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Non usare mai tiktoken, per la ragione sopra indicata.

Piani di abbonamento rispetto al pay-as-you-go

Le meccaniche descritte in questa guida sono identiche ovunque; cambia solo il metodo di fatturazione. Con una API key, Anthropic fattura con modalità pay-as-you-go, per token, secondo le tariffe pubblicate — ogni cifra indicata sopra rappresenta denaro reale. Con un abbonamento Claude (Pro, Max, Team, Enterprise), l'utilizzo di Claude Code consuma invece la quota inclusa nel piano: a partire da luglio 2026, si tratta di una finestra di sessione rotante di cinque ore più una finestra settimanale, condivisa tra i modelli e con la chat di claude.ai; la cifra di /usage dollari è a scopo informativo e non rappresenta una fattura. Una volta esaurita una finestra, apparirà il messaggio "You've hit your session limit" o "You've hit your weekly limit" con l'indicazione dell'orario di reset — cambiare modello tramite /model non ripristinerà l'accesso, poiché le finestre sono condivise tra i modelli. I piani possono opzionalmente abilitare i crediti di utilizzo, gestiti tramite /usage-credits, per acquistare utilizzo oltre il limite massimo. Non riporto deliberatamente le quote dei piani: sono i valori più variabili di questo argomento, quindi consulta claude.com/pricing e le proprie barre /usage. La gestione dei token è rilevante anche con un abbonamento — una sessione inefficiente consuma la quota esattamente come consumerebbe denaro. Per i dettagli sull'abbonamento, consulta quale piano Claude si adatta al tuo utilizzo.

Le leve che funzionano davvero

• Definisci lo scope di lettura dell'agent. "Fix the validation bug in auth.py" legge un singolo file; "improve this codebase" ne legge quaranta. Mantieni CLAUDE.md snello — viene caricato in ogni sessione, quindi limitati agli elementi essenziali — e sposta le istruzioni specifiche del workflow in skills caricate on demand.
• Sii chiaro e compatto. /clear tra task non correlati — il contesto obsoleto viene inviato nuovamente e fatturato di nuovo ad ogni messaggio successivo. All'interno di un singolo task prolungato, /compact Focus on the failing tests and the diff riassume la cronologia per evitare un aumento quadratico dei costi.
• Scegli il modello dimensionato correttamente. Sonnet gestisce la maggior parte del coding a $2/$10 per milione di token con i prezzi introduttivi di luglio 2026 ($3/$15 standard, contro Opus a $5/$25), mentre Haiku a $1/$5 è lo strumento ideale per task meccanici di subagent come il triage dei log. /model permette il cambio di modello durante la sessione.
• Pre-filtra l'output verboso. Un hook che esegue un grep su un test run per isolare solo i fallimenti prima che Claude li riceva trasforma 20,000 token di risultati degli strumenti in 300; questo avviene ad ogni successivo invio di quel turno.
• Esegui in batch ciò che non è interattivo. Per le pipeline API personali — classificazione, revisione massiva, job notturni — la Batches API esegue gli stessi modelli con uno sconto del 50% in cambio di una consegna asincrona.
• Rispetta la cache clock. Lavora in sessioni continue. Una Claude Code session in tmux on a VPS separata non ha costi mentre è inattiva — i token vengono consumati solo durante l'esecuzione di un turno — ma l'inattività comporta la perdita della cache calda, e il turno successivo pagherà il ricalcolo.

FAQ

Quanti token consuma una sessione di coding in Claude Code?

Non esiste un numero fisso. Un singolo turno a metà sessione può contenere decine di migliaia di prompt token man mano che i file e la cronologia si accumulano. Una sessione di lavoro può raggiungere milioni di token, la maggior parte dei quali viene servita dalla cache a un decimo della tariffa base. Per riferimento, i dati aziendali pubblicati da Anthropic a luglio 2026 indicano una media di circa $13 per sviluppatore al giorno, con il 90% degli utenti sotto i $30. Esegui /usage nella tua sessione; cinque minuti di monitoraggio sono più accurati di qualsiasi media pubblicata.

I thinking tokens hanno un costo anche se non sono visibili?

Sì. I thinking tokens vengono fatturati come output tokens — con la tariffa più elevata — e contribuiscono al consumo di max_tokens. I modelli attuali li fatturano anche quando l'interfaccia omette il riepilogo del ragionamento dalla visualizzazione. Se una risposta viene troncata con stop_reason: "max_tokens" prima che la risposta visibile sia completata, è probabile che il ragionamento abbia esaurito il budget. In Claude Code, riduci il livello di sforzo con /effort per i task che non richiedono un ragionamento profondo.

Perché una sessione lunga di Claude Code diventa più costosa per ogni messaggio?

Perché l'API è stateless: ogni turno invia nuovamente l'intera conversazione — ogni file letto, risultato degli strumenti e scambio precedente — come input fatturabile. Di conseguenza, il turno 50 include i turni dall'1 al 49 come carico aggiuntivo. Il prompt caching serve il prefisso ripetuto a circa un decimo del prezzo di input base, ma il prefisso stesso continua a crescere. Inoltre, qualsiasi intervallo di inattività superiore al TTL della cache trasforma il turno successivo in una nuova scrittura a prezzo pieno. /compact riduce la cronologia; /clear la resetta.

Come posso controllare l'utilizzo dei token e i costi di Claude?

In Claude Code, /usage mostra le statistiche dei token della sessione, una stima locale dei costi e le barre dei limiti del piano per gli abbonamenti (/cost è un alias); /context mostra il contenuto della finestra. Per la fatturazione ufficiale delle API, utilizza la pagina usage nella Claude Console. Nel proprio codice, leggere response.usage — la somma di input_tokens, cache_creation_input_tokens e cache_read_input_tokens fornisce la dimensione reale del prompt — ed effettuare una stima preventiva con l'endpoint count_tokens, mai con tiktoken.