Cos'è un Token e Perché Ti Costa Soldi
Ogni volta che parli con un LLM, paghi in token. Cos'è un token, come funziona BPE, perché Python costa meno di Java e dove finiscono i tuoi soldi.
Alessandro Saiani
Human in the Loop

Ogni volta che scrivi un prompt, leggi un file, o lasci girare Claude Code su un progetto — stai consumando token. E ogni token ha un prezzo.
Ma cos'è esattamente un token? Non è una parola. Non è un carattere. Non è una riga di codice. È qualcosa di più strano, più contro-intuitivo, e più importante di quello che pensi — perché è l'unità fondamentale con cui ragiona (e fattura) ogni LLM.
Un Token Non È una Parola
Un token è un frammento di testo di lunghezza variabile, appreso statisticamente dal corpus di addestramento. L'algoritmo che taglia il testo in token si chiama tokenizzatore, e il più diffuso è BPE (Byte Pair Encoding).
La regola pratica: 1 token ≈ 4 caratteri ≈ 0.75 parole in inglese. Ma è una media che nasconde molta varianza.
Ecco come un tokenizzatore vede del testo reale — con esempi in italiano:
| Testo | Token | Quanti |
|---|---|---|
Ciao | ["C", "iao"] | 2 |
Buongiorno | ["Bu", "on", "gi", "orno"] | 4 |
Hello | ["Hello"] | 1 |
sviluppatore | ["sv", "il", "upp", "atore"] | 4 |
developer | ["developer"] | 1 |
intelligenza artificiale | ["intell", "ig", "enza", " artificial", "e"] | 5 |
artificial intelligence | ["artificial", " intelligence"] | 2 |
tokenization | ["token", "ization"] | 2 |
1+2=3 | ["1", "+", "2", "=", "3"] | 5 |
Nota il pattern: le parole inglesi comuni sono quasi sempre 1 token perché il corpus di addestramento è prevalentemente in inglese. "Developer" è 1 token, "sviluppatore" ne consuma 4. "Hello" è 1 token, "Buongiorno" ne richiede 4. Questo ha conseguenze dirette sui costi — ne parliamo tra poco.
E nota come 1+2=3 — cinque caratteri — diventa cinque token, uno per simbolo. Questo è il motivo per cui gli LLM faticano con la matematica: non "vedono" i numeri come li vediamo noi.
Come Funziona BPE (in 30 Secondi)
BPE è un algoritmo di compressione riadattato per il linguaggio. Il principio è semplice:
- Parti dai singoli caratteri/byte
- Trova la coppia più frequente nel corpus di testo
- Fondi quella coppia in un nuovo token
- Ripeti finché raggiungi il vocabolario target (50.000-100.000 token)
Corpus: "low lower lowest"
Passo 1: l, o, w, _, l, o, w, e, r, _, l, o, w, e, s, t
Coppia più frequente: (l, o) → "lo"
Passo 2: lo, w, _, lo, w, e, r, _, lo, w, e, s, t
Coppia più frequente: (lo, w) → "low"
Passo 3: low, _, low, e, r, _, low, e, s, t
Il risultato è un vocabolario dove le sequenze più comuni del linguaggio diventano singoli token. La parola "the" è un solo token. La parola "antidisestablishmentarianism" diventa sei token: ["anti", "dis", "establish", "ment", "arian", "ism"].
Dettaglio importante: modelli diversi usano tokenizzatori diversi. Lo stesso testo produce conteggi diversi su Claude, GPT-4 e Gemini. Non esiste un "numero di token" universale.
Il Codice Costa Token Diversamente
La tokenizzazione del codice ha sfide particolari:
==,=,===devono essere token distinti- L'indentazione di Python consuma token (ogni spazio o tab)
- I nomi lunghi come
getUserAccountBalancevengono spezzati in più token - Ogni parentesi, punto e virgola, virgola è un token separato
E non tutti i linguaggi costano uguale.
Classifica Efficienza Token per Linguaggio
Un'analisi su 100 task di Rosetta Code con il tokenizzatore GPT-4 ha prodotto questa classifica (normalizzata, 1.00 = più efficiente):
| Linguaggio | Score | Categoria |
|---|---|---|
| Clojure | 1.00 | Più efficiente |
| Haskell | ~1.05 | Molto efficiente |
| F# | 1.05 | Molto efficiente |
| Python | 1.12 | Efficiente |
| Ruby | ~1.2 | Efficiente |
| Java | 1.35 | Moderato |
| Go | ~1.4 | Moderato |
| C# | ~1.5 | Moderato-verboso |
| JavaScript | ~1.6 | Il più verboso tra i dinamici |
| Rust | 1.91 | Verboso |
| C++ | 2.24 | Molto verboso |
| C | 2.59 | Meno efficiente |
TypeScript non è incluso nello studio (pochi campioni disponibili), ma è ragionevole stimarlo vicino a JavaScript con un leggero overhead per le annotazioni di tipo.
Differenza di 2.6x tra il più efficiente e il meno efficiente. Lo stesso algoritmo in C costa quasi il triplo in token rispetto a Clojure.
Sorprese: JavaScript è il più verboso tra i linguaggi dinamici — la sintassi con parentesi graffe, function, const, e la standard library meno espressiva lo penalizzano rispetto a Python. C# si posiziona nella zona media, simile a Java ma leggermente peggio per la verbosità delle dichiarazioni. I linguaggi funzionali (Haskell, F#) sono quasi efficienti quanto i dinamici grazie al type inference che evita annotazioni esplicite.
In pratica: 100 righe di Python ≈ 1.000 token. 100 righe di Java ≈ 1.350 token. 100 righe di C# ≈ 1.500 token. Se lavori tutto il giorno su una codebase C#, stai pagando circa il 50% in più rispetto a Python — a parità di logica implementata.
Quanto Costa un Token nel 2026
Ecco i prezzi attuali dei modelli principali (per milione di token):
Claude (Anthropic)
| Modello | Input | Output |
|---|---|---|
| Opus 4.6 | $5.00 | $25.00 |
| Sonnet 4.5 | $3.00 | $15.00 |
| Haiku 4.5 | $1.00 | $5.00 |
OpenAI
| Modello | Input | Output |
|---|---|---|
| GPT-5 | $1.25 | $10.00 |
| GPT-4o | $2.50 | $10.00 |
| o3 | $2.00 | $8.00 |
| Modello | Input | Output |
|---|---|---|
| Gemini 3 Pro | $2.00 | $12.00 |
| Gemini 2.5 Flash | $0.30 | $2.50 |
Nota chiave: l'output costa 3-5x più dell'input. Generare codice costa molto di più che leggerlo. Questo è il motivo per cui un modello che "parla troppo" nel ragionamento ti costa caro — e perché il thinking budget di Claude è configurabile.
Dove Vanno i Tuoi Token (Il Costo Invisibile)
Ecco la parte che quasi nessuno sa. Quando usi Claude Code, non stai pagando solo per i tuoi prompt e le risposte. C'è un overhead fisso che consuma contesto ad ogni chiamata.
Budget di 200K Token: Come Viene Speso
| Componente | Token | % del totale |
|---|---|---|
| System prompt | ~3.100 | 1.5% |
| Tool built-in (Bash, Read, Edit...) | ~12.400 | 6.2% |
| CLAUDE.md (fino a 3 file) | ~4.200 | 2.1% |
| Rules directory | ~2.100 | 1.0% |
| Buffer risposta (riservato) | ~40.000 | 20% |
| Overhead fisso totale | ~62.000 | ~31% |
| Disponibile per la conversazione | ~138.000 | ~69% |
Il 31% del tuo contesto è già occupato prima che tu scriva una sola parola.
MCP: Il Consumatore Silenzioso
Se hai server MCP attivi, le loro definizioni di tool occupano contesto anche quando non li usi:
| Server MCP | Token occupati |
|---|---|
| Playwright (22 tool) | ~14.300 |
| Jira | ~17.000 |
| Setup tipico (5 server, 58 tool) | ~55.000 |
Con 5 server MCP attivi perdi un altro 27% del contesto. Totale overhead: quasi il 60%. Ti resta il 40% per lavorare.
Soluzione: ENABLE_TOOL_SEARCH=auto riduce questo overhead dell'85%, caricando i tool on-demand invece di tenerli tutti in memoria.
Una Sessione Reale: Quanto Costa
Secondo i dati ufficiali di Anthropic, una giornata tipo con Claude Code (Sonnet 4.5) costa:
- Media: $6 per sviluppatore al giorno
- 90° percentile: sotto $12/giorno
- Stima mensile: ~$100-200/mese
Per una singola sessione intensa di un'ora con Sonnet 4.5:
- ~20-30 prompt
- ~10.000-20.000 token di input per prompt (contesto incluso)
- ~2.000-5.000 token di output per prompt
- Stima: $2-8 per ora
Con Opus 4.6, la stessa sessione costa $3-13 per ora.
Confronto pratico: stesso task, modelli diversi
Supponiamo un task da 50K token di input e 5K di output:
| Modello | Costo input | Costo output | Totale |
|---|---|---|---|
| Opus 4.6 | $0.25 | $0.125 | $0.375 |
| Sonnet 4.5 | $0.15 | $0.075 | $0.225 |
| Haiku 4.5 | $0.05 | $0.025 | $0.075 |
| GPT-5 | $0.06 | $0.05 | $0.11 |
Haiku costa 5x meno di Opus per lo stesso task. La scelta del modello è la prima leva di ottimizzazione.
La Tassa Linguistica
Un dettaglio che riguarda direttamente chi scrive in italiano: le lingue non-inglesi costano di più.
Lo stesso concetto semantico richiede più token in italiano che in inglese, perché i tokenizzatori sono addestrati prevalentemente su testo inglese:
| Lingua | Token per lo stesso concetto | Moltiplicatore |
|---|---|---|
| Inglese | baseline | 1x |
| Italiano | +40% | ~1.4x |
| Cinese | +50-70% | ~1.5-1.7x |
| Hindi | +200% | ~3x |
| Alcune lingue | fino a +1500% | ~15x |
Chi sviluppa con prompt in italiano sta pagando circa il 40% in più rispetto a chi scrive in inglese. Non è enorme, ma su una sessione intensiva si nota. È uno dei motivi per cui molti sviluppatori scrivono i prompt in inglese anche quando non è la loro lingua madre.
Come Risparmiare (Concretamente)
- Scegli il modello giusto: Haiku per task semplici, Sonnet per la maggior parte del coding, Opus solo per decisioni architetturali complesse
- Usa il prompt caching: i cache hit costano il 10% del prezzo base — un risparmio del 90%
- Batch API: sconto del 50% per operazioni non urgenti
/cleartra task diversi: evita che il contesto cresca inutilmente/compactregolarmente: comprimi la cronologia della conversazione- Disabilita MCP server inutilizzati: ogni server inattivo spreca migliaia di token
- Prompt specifici: "Migliora questa codebase" costa 10x più di "Aggiungi validazione a login() in auth.ts"
- Scrivi in inglese: ~40% di risparmio rispetto all'italiano
- Riduci il thinking budget: il default è ~32K token di output (fatturato come output!) — per task semplici abbassalo con
MAX_THINKING_TOKENS=8000
Combinando queste strategie, il risparmio stimato è del 60-80% senza perdita di qualità.
Il Paradosso del Token
I token sono un'astrazione strana. Non corrispondono a nessuna unità linguistica che usiamo — non sono parole, non sono sillabe, non sono concetti. Sono frammenti statistici ottimizzati per la compressione del linguaggio.
Eppure sono l'unità fondamentale di tutto: di come l'AI "pensa", di come comunica, di quanto costa usarla, e di quanto contesto può elaborare in una volta.
Capire i token non ti rende un programmatore migliore. Ma ti rende un utente consapevole — uno che sa perché la conversazione si è "dimenticata" qualcosa (contesto pieno), perché un modello costa più di un altro, perché il codice Java costa più del Python, e dove vanno i soldi quando lasci girare un agente tutta la notte.
E nel 2026, sapere dove vanno i soldi è già metà del lavoro.
Fonti e approfondimenti:
- OpenAI Tokenizer — Prova tu stesso come viene tokenizzato il testo
- Claude Official Pricing
- Claude Code - Manage Costs — Dati ufficiali sui costi per sviluppatore
- Token Efficiency by Programming Language - Martin Alderson
- USENIX Security 2025 - Package Hallucination Study — 576.000 campioni analizzati