Cosa sono i token in Claude e come funzionano? Ne abbiamo contati 3,8 miliardi

La parola la trovi ovunque intorno a Claude: nel listino prezzi, nel messaggio di limite, in /usage, in ogni articolo su come risparmiare. Quasi nessuno dice cos'è un token, e il numero che la gente guarda è raramente quello che conta. Ciò che Claude scrive in risposta è una frazione di punto percentuale di quello che conta una sessione di programmazione.

Così abbiamo contato i nostri. Trenta giorni di sessioni di Claude Code su un Mac, dal 10 settembre al 9 ottobre 2026: 388 sessioni, 19.668 richieste al modello, 3,8 miliardi di token. Ecco cos'è un token, i quattro modi in cui Claude li conta e come appaiono questi numeri su lavoro reale.

Un token è un pezzo di testo, e la dimensione del pezzo cambia

Un modello non legge lettere né parole. Legge token: pezzi di testo presi da un vocabolario fisso, a volte una parola breve intera, spesso una parte di parola, a volte un singolo carattere o un byte per qualcosa che non ha mai visto. Tutto si conta in questi pezzi: quello che invii, quello che Claude scrive, quello che conserva da un turno all'altro.

Quanto testo sta in un token dipende dal modello e dalla lingua. Il glossario di Anthropic indica circa 3,5 caratteri inglesi per token sui modelli precedenti a Claude 4.7, e dice che Claude 4.7 e i successivi usano un nuovo tokenizer che produce circa il 30% di token in più per lo stesso testo. Il conteggio esatto arriva solo dall'endpoint di conteggio dei token, con il modello che intendi usare.

Abbiamo misurato il rapporto sul nostro testo. I nostri agenti rispondono in francese, quindi abbiamo preso le risposte di solo testo, senza ragionamento, senza chiamate a strumenti, senza blocchi di codice, di almeno 80 parole: 296 risposte distribuite tra Opus 5, Opus 5.5, Fable 5.1 e Sonnet 5.5. La mediana era di 2,3 caratteri per token, circa 2,6 token per parola. Il codice, il JSON e le scritture non latine danno altri rapporti. Il punto non è la cifra esatta: un token è più piccolo di una parola, e non li conti mai a mano.

Ogni richiesta viene contata su quattro contatori

Claude Code scrive ogni sessione in una trascrizione JSONL sotto ~/.claude/projects/. Ogni risposta del modello porta un blocco usage. Eccone uno reale dalle nostre trascrizioni, con i campi utili:

"usage": {
  "input_tokens": 2,
  "cache_creation_input_tokens": 51836,
  "cache_read_input_tokens": 24882,
  "output_tokens": 315,
  "output_tokens_details": { "thinking_tokens": 54 },
  "cache_creation": {
    "ephemeral_1h_input_tokens": 51836,
    "ephemeral_5m_input_tokens": 0
  }
}

Quattro contatori, e non costano allo stesso modo:

• input_tokens: la parte del prompt che non viene né scritta in cache né letta dalla cache, fatturata al prezzo base dell'input. In Claude Code è quasi sempre una manciata di token, perché quasi tutto passa dalla cache.
• cache_creation_input_tokens: la parte del prompt memorizzata nella cache perché la richiesta successiva possa riutilizzarla. Una scrittura in cache costa 1,25 volte il prezzo dell'input per una cache di 5 minuti e 2 volte per una cache di 1 ora. Nelle nostre trascrizioni, il 97% delle scritture era del tipo da 1 ora.
• cache_read_input_tokens: la parte del prompt riletta dalla cache. Una lettura dalla cache costa 0,1 volte il prezzo dell'input sulla maggior parte dei modelli, 0,05 volte su Opus 5.5 e Sonnet 5.5, e 0,025 volte su Fable 5.1 (pagina sul prompt caching di Anthropic, verificata il 10 ottobre 2026).
• output_tokens: ciò che Claude scrive, ragionamento incluso. L'output costa 5 volte il prezzo dell'input su tutti i modelli attuali: 20 dollari per milione su Opus 5.5, 25 su Opus 5, 50 su Fable 5.1, 10 su Sonnet 5.5.

I primi tre sommati danno il contesto che il modello ha letto per quella richiesta. Il quarto è la risposta.

Come appaiono 30 giorni delle nostre sessioni

Sulle 19.668 richieste, contate una volta per richiesta (una stessa chiamata all'API può occupare più righe di una trascrizione):

La colonna del costo valuta ogni richiesta con il suo modello e la sua durata di cache. Non paghiamo quella cifra: queste sessioni giravano su un abbonamento. È il peso di ogni contatore, la stessa ponderazione che AgentsRoom usa per ripartire la percentuale di un piano tra i progetti.

Tre letture.

Quasi ogni token è la conversazione riletta. Il 97,7% dei token sono letture dalla cache. Il 99,2% delle richieste legge qualcosa dalla cache. Quando qualcuno dice che una sessione "ha consumato 50 milioni di token", è questo che sta guardando.

Ciò che Claude scrive pesa poco in token e non poco in costo. Lo 0,34% dei token, il 16,8% della fattura, perché l'output è il token più caro che ci sia. Il ragionamento era il 29% di quell'output.

Le scritture in cache sono la sorpresa costosa. Il 2% dei token, il 37% del costo. Ci aspettavamo che venissero dalla scadenza della cache, ma solo 16 richieste su 19.668 hanno dovuto riscrivere un contesto a freddo, sette delle quali dopo più di un'ora di silenzio. Il 79% delle scritture è semplicemente ogni nuovo messaggio e ogni risultato di strumento memorizzato una volta, al doppio del prezzo dell'input, prima di essere riletto a ogni turno successivo. L'altro 20% è la prima richiesta di ogni sessione.

Perché una sessione si appesantisce a ogni turno

Il modello non conserva nulla tra due richieste. Claude Code rimanda tutto ogni volta: il prompt di sistema, le definizioni degli strumenti, CLAUDE.md, ogni messaggio, ogni file che ha letto, ogni output di comando. La cache rende la parte ripetuta economica per token, non gratuita, e non più piccola.

Contesto mediano letto per richiesta, in base alla posizione nella sessione:

La richiesta mediana ha letto 179.000 token di contesto per scrivere 290 token di risposta. Quel rapporto riassume tutta la storia dei token in un agente di programmazione: la risposta è breve, la lettura è lunga, e la lettura cresce con la sessione.

La nostra prima richiesta è pesante, 52.000 token prima che qualcuno abbia digitato qualcosa, perché i nostri agenti partono con un lungo brief di ruolo e quattro server MCP le cui definizioni degli strumenti stanno nel prompt. Una sessione di Claude Code spoglia in una cartella vuota parte molto più in basso. /context mostra cosa si porta dietro la tua prima del primo messaggio.

Quanto consuma una sessione

Sulle 380 sessioni con almeno tre richieste:

• 33 richieste di mediana, da 16 a 61 per la metà centrale.
• 27.000 token di output di mediana, da 12.000 a 48.000.
• 5,4 milioni di token elaborati di mediana, da 1,5 a 10,7 milioni per la metà centrale, di cui 5,1 milioni erano letture dalla cache.
• 181.000 token scritti in cache o inviati fuori cache di mediana: la parte davvero nuova.
• 4,55 dollari ai prezzi di listino dell'API di mediana, da 1,81 a 9,25 per la metà centrale.

Quindi la risposta onesta a "quanti token consuma una sessione di programmazione" è un intervallo da circa uno a dieci milioni, quasi tutto lo stesso contesto riletto. Una sessione che gira tutto il pomeriggio su un unico compito lungo sta in cima all'intervallo; una sessione che corregge un bug e si ferma sta in fondo.

Cosa contano davvero la finestra di 5 ore e la settimana

Con un piano Pro o Max non vedi mai un saldo di token. Il centro assistenza di Anthropic dice che entrambi i piani hanno un limite di sessione di cinque ore e un limite settimanale, che questi limiti sono condivisi tra Claude e Claude Code (IDE incluso), e che i piani Max hanno un limite settimanale separato per Fable. Non pubblica nessuna cifra in token per nessuno di essi. /usage mostra una percentuale di ogni finestra e l'ora in cui si azzera.

Cosa fa muovere quella percentuale, nell'elenco di Anthropic stessa: la lunghezza del messaggio, la dimensione degli allegati, la lunghezza della conversazione in corso, l'uso degli strumenti, la scelta del modello, il livello di sforzo e le attività in più passaggi. Letta insieme alle tabelle qui sopra, "la lunghezza della conversazione in corso" è quella che domina una sessione di programmazione: il contesto letto a ogni richiesta passa da 52.000 a 237.000 token in cinquanta richieste. Il centro assistenza dice anche che i contenuti in cache nei progetti pesano meno sui tuoi limiti quando vengono riutilizzati, che è la stessa idea del prezzo di una lettura dalla cache.

Non sappiamo come Anthropic converta i token in una percentuale di una finestra, e non inventeremo una conversione. Quello che i dati dicono è che una richiesta tardiva in una sessione lunga conta diverse volte quanto una richiesta iniziale, per la stessa domanda.

Cosa cambia il conteggio, in pratica

Quattro leve, nell'ordine in cui pesano sui nostri dati:

• /clear tra attività non correlate. Anthropic la definisce "la leva più efficace, sia per la qualità sia per il costo". Un'attività nuova in una sessione vecchia paga il contesto dell'attività precedente a ogni richiesta.
• /compact quando continui una sessione lunga. Sostituisce la cronologia con un breve riassunto, quindi le richieste successive leggono meno.
• Fai attenzione a cosa entra nel contesto. Una lettura di file o un output di comando da 20.000 token viene scritto una volta al doppio del prezzo dell'input, poi riletto a ogni richiesta successiva fino alla fine della sessione. Leggere le righe che ti servono invece del file intero ripaga due volte.
• Modello e sforzo. Il ragionamento era il 29% del nostro output, e l'output è il token più caro. Un livello di sforzo più basso sul lavoro di routine abbassa l'output, e un modello più economico abbassa tutti i prezzi in un colpo.

Cosa non ha pesato sui nostri dati: lasciare una sessione inattiva. Con la cache di 1 ora che Claude Code usa nelle nostre trascrizioni, una riscrittura a freddo è capitata 16 volte in 30 giorni.

Per altri modi di spendere meno, leggi come ridurre i costi dei token di Claude Code.

Conta i tuoi

La tabella qui sopra viene da uno script senza dipendenze. Legge tutte le trascrizioni di Claude Code sulla macchina, conta ogni richiesta una volta e stampa i quattro contatori e le mediane per sessione. Aggiungi un filtro su o["timestamp"] se vuoi una finestra temporale.

import json, glob, os, statistics as st
from collections import defaultdict

FIELDS = ("input_tokens", "cache_creation_input_tokens",
          "cache_read_input_tokens", "output_tokens")
totals, sessions = defaultdict(int), []
for path in glob.glob(os.path.expanduser("~/.claude/projects/*/*.jsonl")):
    seen, session = set(), defaultdict(int)
    with open(path, errors="ignore") as fh:
        for line in fh:
            try: o = json.loads(line)
            except ValueError: continue
            msg = o.get("message") or {}
            usage = msg.get("usage") if isinstance(msg, dict) else None
            if o.get("type") != "assistant" or not usage: continue
            rid = o.get("requestId") or o.get("uuid")
            if rid in seen: continue   # one API call can span several lines
            seen.add(rid)
            session["requests"] += 1
            for f in FIELDS:
                n = usage.get(f) or 0
                totals[f] += n
                session[f] += n
    if session["requests"] >= 3: sessions.append(session)

grand = sum(totals[f] for f in FIELDS)
for f in FIELDS:
    print(f"{f:30s} {totals[f]:>15,} {100 * totals[f] / grand:6.2f}%")
for key in ("requests", "output_tokens", "cache_read_input_tokens"):
    print(f"median per session, {key}: {st.median(s[key] for s in sessions):,.0f}")

Confronta le tue quote con le nostre. La riga delle letture dalla cache è la conversazione riletta, e la riga delle scritture in cache è ciò che era nuovo: queste due dicono più della tua fattura che la riga dell'output.

Dove lo mostra AgentsRoom

Lo script ti dà un mese. Mentre lavori, AgentsRoom mostra gli stessi contatori per agente: un badge dei token nel composer di ogni sessione che diventa rosso quando una sessione si appesantisce, un monitor di sessione con input, output, scritture in cache, letture dalla cache e la percentuale di hit della cache, e una traccia di sessione che riproduce la sessione turno per turno per mostrare quale lettura di file o quale risultato di strumento ha riempito il contesto. Il pannello Usage ripartisce la percentuale che il tuo piano riporta tra i tuoi progetti e i tuoi agenti, pesando ogni sessione in base a quanto costerebbe ai prezzi dell'API, la stessa ponderazione della tabella qui sopra.

Quello che niente di tutto questo ti dà è un saldo di token, perché il tuo piano non ce l'ha. Per questa domanda, leggi quanti token ti restano su Claude. Per la velocità con cui arrivano quei token di output, leggi i token al secondo di Claude Code, misurati.

Domande frequenti

Cos'è un token in Claude?

L'unità in cui Claude legge e scrive il testo: un pezzo di parola, a volte una parola breve intera, a volte un singolo carattere o un byte. Anthropic spiega che la dimensione dipende dal modello e dalla lingua: sui modelli precedenti a Claude 4.7 un token corrispondeva a circa 3,5 caratteri inglesi, e Claude 4.7 e i successivi usano un nuovo tokenizer che produce circa il 30% di token in più per lo stesso testo. Tutto ciò che Claude fa si misura in token: quello che invii, quello che ti risponde e quello che conserva nella sua cache da un turno all'altro.

Quanti caratteri o parole è un token di Claude?

Dipende dalla lingua e dal testo. Anthropic indica circa 3,5 caratteri inglesi per token sui modelli precedenti a Claude 4.7, e circa il 30% di token in più per lo stesso testo su Claude 4.7 e successivi. Su 296 risposte di solo testo che i nostri agenti hanno scritto in francese a settembre e ottobre 2026, un token corrispondeva a 2,3 caratteri, cioè circa 2,6 token per parola. Il codice, il JSON e le scritture non latine danno altri rapporti. Per un conteggio esatto, l'endpoint di conteggio dei token di Anthropic riceve il testo e il modello.

Perché Claude Code consuma così tanti token?

Perché ogni richiesta invia di nuovo l'intera conversazione: il prompt di sistema, le definizioni degli strumenti, CLAUDE.md, ogni messaggio e ogni risultato di strumento fino a quel momento. Sulle nostre 19.668 richieste, la richiesta mediana portava 179.000 token di contesto per scrivere 290 token di risposta, e il contesto passava da 52.000 token alla prima richiesta di una sessione a 237.000 dopo cinquanta richieste. La cache rende questa rilettura economica per token, ma viene comunque contata.

Quanti token consuma una sessione tipica di Claude Code?

Sulle nostre 380 sessioni di almeno tre richieste, registrate tra il 10 settembre e il 9 ottobre 2026: una mediana di 33 richieste, 27.000 token di output e 5,4 milioni di token elaborati in totale, di cui 5,1 milioni erano letture dalla cache. Metà delle sessioni si collocava tra 1,5 e 10,7 milioni di token. Ai prezzi di listino dell'API, quella sessione mediana sarebbe costata circa 4,55 dollari; con un piano Pro o Max lo stesso lavoro viene invece scalato dalle finestre di 5 ore e settimanale.

I token di ragionamento contano?

Sì. I token di ragionamento fanno parte di output_tokens in ogni blocco usage, con un campo thinking_tokens che indica quanta parte dell'output è stata ragionamento. Sono fatturati al prezzo dell'output sull'API, e Anthropic mette il livello di sforzo tra le cose che fanno esaurire più in fretta i limiti di utilizzo di un piano. Nel nostro corpus il ragionamento era il 29% di tutto ciò che i modelli hanno scritto.

Qual è la differenza tra token di scrittura in cache e token di lettura dalla cache?

Una scrittura in cache memorizza una parte del prompt perché la richiesta successiva possa riutilizzarla, e costa più dell'input semplice: 1,25 volte il prezzo dell'input per una cache di 5 minuti, 2 volte per una cache di 1 ora. Una lettura dalla cache riutilizza quella parte memorizzata e costa molto meno: 0,1 volte il prezzo dell'input sulla maggior parte dei modelli, 0,05 volte su Opus 5.5 e Sonnet 5.5, 0,025 volte su Fable 5.1. Nelle nostre sessioni le letture dalla cache erano il 98% dei token e il 46% del costo ai prezzi di listino; le scritture in cache, il 2% dei token e il 37% del costo.