Token Claude: costi delle sessioni in Claude Code

Cosa sono i token in Claude?

Un token è l'unità di testo che Claude legge e scrive: un frammento di parola, composto da circa 3.5 caratteri inglesi. Questa stima proviene dal glossario ufficiale di Anthropic e, considerando spazi e punteggiatura, corrisponde a ben più di un token per parola. Di conseguenza, mille parole di prosa superano agevolmente 1,300 token. Il codice ha un'incidenza maggiore per riga: parentesi graffe, operatori, caratteri di sottolineatura e indentazione vengono suddivisi in più token per carattere rispetto all'inglese. Un file sorgente di alcune centinaia di righe contiene in genere diverse migliaia di token. Un file di 2,000 righe che l'agente decide di leggere comporta un consumo di token a cinque cifre prima ancora che venga scritta una riga di nuovo codice.

Due aspetti dei tokenizer causano spesso confusione. Primo, sono specifici del modello. A luglio 2026, Opus 4.7 e versioni successive, Sonnet 5 e Fable 5 usano un tokenizer più recente che produce circa il 30% di token in più per lo stesso testo rispetto ai modelli Claude precedenti. L'incremento esatto varia in base al contenuto. Questo modifica qualsiasi stima basata sui token, anche se i prezzi per token non sono aumentati insieme a tale variazione. Secondo, tiktoken, la libreria utilizzata dalla maggior parte dei post di blog, è il tokenizer di OpenAI e sottostima Claude di circa il 15–20% sul testo comune, con una differenza maggiore per il codice. L'unico conteggio attendibile è l'endpoint count_tokens, descritto di seguito.

Quanto costa una sessione di coding

Ogni addebito di Claude, sia una fattura API sia un limite di abbonamento, dipende da un unico contatore: token in ingresso e token in uscita. La pagina dei prezzi lo fa sembrare semplice: un certo numero di dollari per milione di token in ingresso e un certo numero per milione di token in uscita. Tuttavia, non spiega che in una sessione di coding agentico il contatore dei token in ingresso aumenta molto più rapidamente di quanto suggerisca l'intuizione, perché l'intera conversazione viene reinviata a ogni singolo turno. Da quindici anni vendo infrastrutture con tariffazione a consumo e i token sono il primo contatore che incontro il cui funzionamento resta realmente oscuro alla maggior parte dei clienti. Questa è la lezione su come leggere il contatore: che cosa viene conteggiato come input e output in una sessione agentica, perché il ciclo di reinvio è così costoso, perché il prompt caching modifica completamente il calcolo e quali leve incidono davvero sul valore finale.

Tutto è input: che cosa conta effettivamente il contatore

Si tende a pensare di pagare per il codice scritto da Claude. In una sessione agentica, questa è la voce di costo minore. I token di input, che hanno una tariffa più bassa ma un volume molto maggiore, includono:

• Il prompt di sistema. Le istruzioni dell'harness di Claude Code, oltre a CLAUDE.md e ai file di memoria, caricati all'avvio della sessione e presenti in ogni richiesta successiva.
• Le definizioni degli strumenti. Ogni schema degli strumenti che l'agente potrebbe chiamare. Ogni server MCP a cui ci si connette aumenta questo overhead fisso, anche se ora Claude Code rinvia per impostazione predefinita le definizioni complete degli strumenti MCP: nel contesto restano soltanto i nomi degli strumenti finché uno di essi non viene utilizzato. Questo riduce il costo, ma non lo elimina.
• Ogni file letto dall'agente. Una Read di un file sorgente inserisce nel contesto l'intero file, che vi rimane.
• Ogni risultato di uno strumento. Esecuzioni dei test, output di grep, output del terminale, log di compilazione: tutto torna come token di input. Una suite di test non riuscita che stampa 8,000 righe ti ha appena addebitato l'equivalente di un piccolo libro.
• L'intera conversazione fino a quel momento, reinviata a ogni turno. Questo aspetto merita una sezione dedicata.

Il reinvio che nessuno considera nel prezzo

L'API di Claude è stateless. Non conserva la sessione tra una richiesta e l'altra: non lo fa nessun componente. Al turno 2, quindi, il client invia il turno 1, la relativa risposta e il nuovo messaggio. Al turno 50 reinvia i turni da 1 a 49, ogni file letto, ogni risultato degli strumenti, ogni diff e il turno 50. Il modello rilegge l'intera trascrizione ogni volta, e ogni token riletto viene fatturato come input.

La conseguenza è che il costo per turno cresce in modo approssimativamente lineare con la durata della sessione, mentre il costo totale della sessione cresce in modo approssimativamente quadratico. Un messaggio che al turno 3 costava mezzo centesimo può costare venti volte tanto al turno 60, pur contenendo la stessa domanda di una riga, perché si porta dietro sessanta turni di contesto. Questo è il singolo fatto che spiega la maggior parte delle richieste relative a fatture insolitamente elevate. Non è una peculiarità di Claude: ogni prodotto LLM che dà l'impressione di mantenere lo stato usa sotto il cofano un'API stateless con un ciclo di reinvio.

Output: ciò che vedi e ciò che non vedi del ragionamento

I token di output sono la voce più costosa: nella gamma attuale hanno un costo cinque volte superiore a quello dell’input ($5/$25 su Opus 4.8, $3/$15 indicati per Sonnet 5, $1/$5 su Haiku 4.5, a luglio 2026). L’output comprende il testo e il codice generati da Claude, oltre ai token di ragionamento: il ragionamento interno che il modello esegue prima di rispondere. Qui contano due aspetti. Il ragionamento viene fatturato alle tariffe dell’output e incide sul limite max_tokens: una risposta API che termina con stop_reason: "max_tokens" e una risposta troncata indicano spesso che il ragionamento ha esaurito il budget prima della generazione della risposta. Inoltre, nei modelli attuali il riepilogo del ragionamento potrebbe non essere visualizzato: Opus 4.8, Sonnet 5 e Fable 5 lo omettono per impostazione predefinita, ma il ragionamento viene comunque eseguito e fatturato. Invisibile non significa gratuito.

Claude Code abilita il ragionamento esteso per impostazione predefinita perché migliora in modo misurabile le attività composte da più passaggi; il budget predefinito può arrivare a decine di migliaia di token per richiesta. Per le attività più semplici puoi ridurlo: diminuisci il livello di effort con /effort o in /model, oppure modifica le impostazioni del ragionamento in /config. È un controllo effettivo dei costi, non una semplice superstizione.

Il caching dei prompt cambia la matematica

Il caching dei prompt è il motivo per cui il ciclo di reinvio non porta tutti alla bancarotta. L'API può memorizzare in cache un prefisso stabile del prompt, del system prompt, delle definizioni degli strumenti e della cronologia della conversazione, quindi utilizzare questo contenuto nella richiesta successiva a una frazione del prezzo. A luglio 2026 i moltiplicatori sono i seguenti: una scrittura nella cache costa 1.25× la tariffa base degli input (2× per la variante di 1 ora), mentre una lettura dalla cache costa 0.1×. Le scritture hanno un sovrapprezzo; le letture offrono uno sconto del 90%. Una sola lettura ripaga già ampiamente il sovrapprezzo della scrittura con validità di 5 minuti.

Claude Code gestisce il caching per te e, in una sessione in condizioni normali, quasi tutto quel grande reinvio viene servito dalla cache. Tuttavia, per impostazione predefinita, la cache resta valida per cinque minuti dall'ultimo utilizzo. Se ti allontani per un caffè che si prolunga, torni, invii un messaggio, la cache è scaduta e l'intero prefisso accumulato viene riscritto a 1.25× invece di essere letto a 0.1×. In una sessione da 150K token, quel singolo turno a cache fredda costa più di una dozzina di turni a cache calda. Questo è il risultato controintuitivo da tenere a mente: un ritmo di pausa e ripresa può costare più del lavoro continuo, perché ogni intervallo di inattività oltre il TTL trasforma il turno successivo da una lettura economica in una costosa riscrittura. Lavora per sessioni concentrate; non alimentare una sessione enorme con un messaggio ogni dieci minuti.

Se chiami l'API da una tua applicazione su un VPS, non ottieni nulla di tutto questo automaticamente. L'errore tipico causato dall'utente è interpolare un timestamp o un ID di richiesta nel system prompt, modificando i byte del prefisso a ogni richiesta e disabilitando il caching senza alcun avviso. L'indicatore è usage.cache_read_input_tokens che resta a zero in chiamate apparentemente identiche.

La formula, con un esempio pratico

Ignorate chi indica un valore fisso del tipo «una sessione costa $X». Il costo delle sessioni può variare di due ordini di grandezza. La formula valida è:

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 con Claude Opus 4.8, che a luglio 2026 costa $5 per milione di token di input e $25 per milione di token di output. Consideriamo un turno a metà sessione con 80,000 token di contesto accumulato: 75,000 letti dalla cache, 3,000 scritti per la prima volta, 2,000 token di input nuovi non memorizzati nella cache e 1,500 token di output, incluso il thinking.

• Letture dalla cache: 75,000 × $0.50/M = $0.0375
• Scritture nella cache: 3,000 × $6.25/M = $0.019
• Input non memorizzato nella cache: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

Circa $0.10 per il turno; cinquanta turni di questo tipo costano circa $5. Consideriamo ora lo stesso turno dopo la scadenza della cache: riscrivere tutti gli 80,000 token a $6.25/M costa $0.50 prima dell'output, cioè circa cinque volte l'intero turno con cache attiva, a parità di lavoro. Questa differenza riassume l'intero impatto della cache in un solo numero. Le stesse quattro righe sono anche l'unico modo corretto per confrontare i provider, perché i prezzi pubblicizzati ignorano completamente le letture dalla cache e il thinking; applicandole a tre job reali si vede dove il costo di Claude è superiore o inferiore a quello di OpenAI.

Se volete capire meglio l'unità di fatturazione in sé, anziché un singolo turno, quanto corrisponde un milione di token in pagine, file e dollari ripete lo stesso calcolo a un livello più generale. Si tratta di un riferimento, non di una previsione: secondo i dati pubblicati da Anthropic sulle distribuzioni enterprise di Claude Code, a luglio 2026 il costo medio è di circa $13 per sviluppatore per giorno di attività e di $150–250 al mese; il 90% degli utenti rimane sotto $30 al giorno. Il costo effettivo dipende dal modello scelto, dalla gestione delle sessioni e dalle dimensioni della codebase. È esattamente per questo che le leve descritte di seguito sono importanti.

Visualizzare il proprio utilizzo

In Claude Code, il comando è /usage (/cost continua a funzionare perché è un alias). Il blocco Session nella parte superiore mostra le statistiche sui token e una stima dei costi calcolata localmente per la sessione corrente; nei piani in abbonamento, la stessa schermata mostra le barre dei limiti del piano e una ripartizione che attribuisce l'utilizzo recente a skill, subagent, plugin e singoli server MCP. Per i costi effettivi degli account API, la pagina dell'utilizzo nella Claude Console è la fonte autorevole; il valore mostrato dalla CLI è una stima. /context visualizza una griglia colorata di ciò che occupa la finestra di contesto, inclusi prompt di sistema, strumenti, definizioni MCP, file e cronologia. È il modo più rapido per individuare un CLAUDE.md sovradimensionato o un server MCP troppo loquace; passa all per espandere la ripartizione completa per elemento.

Dall'API, ogni risposta indica esattamente che cosa è successo:

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}")

Tieni presente che input_tokens rappresenta soltanto la parte non recuperata dalla cache; la dimensione effettiva del prompt è la somma di tutti e tre i campi di input. Un agent che ha funzionato per un'ora e mostra input_tokens: 4000 non è economico: gli altri 200,000 token sono stati forniti dalla cache. Per effettuare una stima prima dell'invio, usa l'endpoint per il conteggio dei token. La chiamata è gratuita, utilizza un limite di velocità dedicato e conta i token con il tokenizer del modello specificato (considera il risultato una stima approssimativa; la fatturazione riflette la richiesta effettiva):

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

Non tiktoken mai, per il motivo indicato sopra.

Piani in abbonamento e pagamento a consumo

Il funzionamento descritto in questa guida è identico in ogni caso; cambia soltanto il metodo di addebito. Con una chiave API, Anthropic applica un pagamento a consumo, calcolato per token alle tariffe pubblicate: ogni cifra riportata sopra corrisponde a denaro reale. Il consumo addebitabile inizia prima di quanto molti si aspettino, perché non esiste un piano gratuito su cui ripiegare. Sono disponibili soltanto un piccolo credito alla registrazione e alcuni endpoint che non generano addebiti. Questo è ciò che un nuovo account API ottiene effettivamente prima di registrare una carta. Con un abbonamento Claude (Pro, Max, Team, Enterprise), invece, l'utilizzo di Claude Code viene scalato dalla quota inclusa nel piano: a luglio 2026 si tratta di una finestra mobile di cinque ore e di una finestra settimanale, condivise tra i modelli e con la chat di claude.ai. La cifra in dollari /usage è quindi indicativa e non rappresenta un addebito. Quando una finestra si esaurisce, viene visualizzato "You've hit your session limit" oppure "You've hit your weekly limit", insieme all'orario di ripristino. Cambiare modello con /model non ripristina l'accesso, perché le finestre sono condivise tra i modelli. Le finestre dipendono dall'account e non dal client in uso. Questo è importante se stai ancora verificando quali componenti funzionano nativamente su Linux e quale piano copre ciascuna superficie. La finestra effettivamente esaurita determina la durata dell'attesa e le operazioni utili da svolgere nel frattempo. Conviene quindi conoscere le opzioni disponibili quando raggiungi un limite durante un'attività. I piani possono abilitare facoltativamente crediti per l'utilizzo, gestiti con /usage-credits, per acquistare ulteriore utilizzo oltre il limite. Non riporto volutamente le quote dei piani: sono i valori più soggetti a variazioni in questo argomento. Consulta invece claude.com/pricing e le barre /usage del tuo account. La gestione dei token resta importante anche con un abbonamento: una sessione inefficiente consuma la finestra esattamente come consumerebbe denaro. Per gli abbonamenti, consulta quale piano Claude è adatto al tuo utilizzo.

Le leve che funzionano davvero

• Limita ciò che l'agente legge. "Correggi il bug di validazione in auth.py" richiede la lettura di un file; "migliora questa codebase" ne richiede quaranta. Mantieni CLAUDE.md essenziale: viene caricato in ogni sessione. Inserisci invece le istruzioni specifiche del flusso di lavoro nelle skill, che vengono caricate quando servono.
• Mantieni il contesto chiaro e compatto. /clear tra attività non correlate: il contesto obsoleto viene reinviato e fatturato nuovamente a ogni messaggio successivo. In un'attività lunga, /compact Focus on the failing tests and the diff riassume la cronologia e impedisce che i costi seguano una crescita quadratica.
• Scegli un modello adeguato. Sonnet gestisce la maggior parte delle attività di coding a $2/$10 per milione di token con i prezzi introduttivi in vigore a luglio 2026 ($3/$15 a prezzo pieno, rispetto a Opus a $5/$25); Haiku, a $1/$5, è adatto alle attività meccaniche dei subagent, come il triage dei log. Fable 5 si colloca all'estremo opposto, a $10/$50, il doppio di Opus su entrambe le componenti del prezzo. Prima di lasciarlo selezionato per le attività ordinarie, conviene quindi sapere quali attività giustificano davvero questa tariffa. /model consente di cambiare modello durante la sessione.
• Pre-filtra l'output dettagliato. Un hook che usa grep per ridurre l'output di un test ai soli errori prima che Claude lo veda trasforma 20.000 token di risultato dello strumento in 300. Lo fa anche a ogni reinvio futuro di quel turno.
• Raggruppa le attività non interattive. Per le pipeline API, la classificazione, le revisioni in blocco e i processi notturni, la Batches API esegue gli stessi modelli con uno sconto del 50% in cambio della consegna asincrona.
• Considera la scadenza della cache. Lavora in sessioni continue. Una sessione di Claude Code scollegata in tmux su un VPS non costa nulla mentre è inattiva: i token vengono consumati solo quando viene eseguito un turno. Tuttavia, il tempo di inattività fa perdere la cache attiva e il turno successivo deve riscrivere il contesto.

FAQ

Quanti token utilizza una sessione di coding in Claude Code?

Non esiste un numero fisso. Un singolo turno a metà sessione include comunemente decine di migliaia di token di prompt, quando file e cronologia si sono accumulati, mentre una sessione operativa arriva a milioni di token, in gran parte serviti dalla cache a un decimo della tariffa di base. Come riferimento, secondo i dati enterprise pubblicati da Anthropic a luglio 2026, la media è di circa $13 per sviluppatore al giorno di attività e il 90% degli utenti spende meno di $30. Esegui /usage nella tua sessione; monitorarlo per cinque minuti è più utile di qualsiasi media pubblicata.

I token di ragionamento vengono addebitati anche quando non posso visualizzarli?

Sì. I token di ragionamento vengono fatturati come token di output, alla tariffa più elevata, e rientrano in max_tokens. I modelli attuali li fatturano anche quando l'interfaccia non mostra il riepilogo del ragionamento. Se una risposta si interrompe con stop_reason: "max_tokens" prima che termini la parte visibile, è probabile che il ragionamento abbia consumato il budget. In Claude Code, riduci il livello di impegno con /effort per le attività che non richiedono un ragionamento approfondito.

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

Perché l'API è stateless: a ogni turno reinvia l'intera conversazione, ogni file letto, ogni risultato degli strumenti e ogni scambio precedente come input fatturato. Di conseguenza, il turno 50 include i turni da 1 a 49. La cache dei prompt serve il prefisso ripetuto a circa un decimo del prezzo di base dell'input, ma il prefisso continua a crescere. Inoltre, un intervallo di inattività superiore al TTL della cache trasforma il turno successivo in una nuova elaborazione a prezzo pieno. /compact riduce la cronologia; /clear la reimposta.

Come posso controllare il consumo di token e i costi di Claude?

In Claude Code, /usage mostra le statistiche sui token della sessione, una stima locale dei costi e le barre dei limiti del piano negli abbonamenti (/cost è un alias); /context mostra quali elementi stanno occupando la finestra di contesto. Per i dati ufficiali sulla fatturazione dell'API, usa la pagina dei consumi nella Claude Console. Nel tuo codice, leggi response.usage: la somma di input_tokens, cache_creation_input_tokens e cache_read_input_tokens restituisce la dimensione effettiva del prompt. Per una stima preventiva, usa l'endpoint count_tokens, mai tiktoken.