---
title: "Contare i token prima dell’invio: stime, margini, lingue"
description: "Stima i token del prompt per lingua e modello prima di chiamare un’API LLM: perché i tokenizer cambiano, esempi in cinque lingue e margini per max_tokens."
url: https://broadrouter.com/it/blog/count-tokens-before-sending/
lang: it
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/count-tokens-before-sending/) (aggiornato il 2026-11-16).

# Come contare i token prima di inviare una richiesta a un LLM

A cura del team di BroadNet Inference · 5 min di lettura · Pubblicato 2026-11-14 · Aggiornato 2026-11-16

Conta i token con il tokenizer del modello che chiami, se è pubblico; altrimenti calibra un rapporto caratteri per token dal campo usage di richieste reali, per lingua e tipo di contenuto. Aggiungi un margine dal 10 al 20 percento, poi verifica che token del prompt più max\_tokens stiano nella finestra di contesto, lasciando spazio ai token di ragionamento sui modelli thinking.

## Punti chiave

-   I tokenizer cambiano da modello a modello. Nel nostro test la stessa frase in arabo ha misurato 102 token con cl100k\_base, 46 con o200k\_base e da 48 a 58 con i tokenizer dei modelli aperti.
-   In questo breve test la prosa inglese ha reso circa 4,5 caratteri per token su ogni tokenizer; codice, JSON e gran parte delle scritture non latine usano più token per carattere.
-   Se il tokenizer di un modello non è pubblico, calibra: invia dei campioni, leggi usage.prompt\_tokens e salva un rapporto per lingua e tipo di contenuto.
-   La finestra di contesto copre prompt più output. Metti a budget prompt + max\_tokens + un margine, mai il solo prompt.
-   Sui modelli di ragionamento il thinking conta in max\_tokens; BroadNet consiglia almeno 1.000 oppure reasoning\_effort low.

**In questa pagina**

1.  Perché il numero di token cambia da un modello all’altro?
2.  Come si contano i token in modo esatto?
3.  Come si stimano i token se il tokenizer non è pubblico?
4.  Che margini usare per max\_tokens e contesto?
5.  Cosa va storto nelle stime dei token?
6.  Dove si inserisce BroadNet Inference

Ti serve un conteggio dei [token](https://broadrouter.com/it/glossary/token/) prima di inviare una richiesta per tre motivi: restare dentro la [finestra di contesto](https://broadrouter.com/it/glossary/context-window/), scegliere un [max\_tokens](https://broadrouter.com/it/glossary/max-tokens/) sensato e stimare il costo. I conteggi esatti arrivano solo dal tokenizer del modello. Le buone stime arrivano dalla calibrazione. Questo articolo mostra entrambe le cose, con misurazioni reali.

## Perché il numero di token cambia da un modello all’altro?

Un tokenizer spezza il testo in pezzi presi da un vocabolario fisso. Ogni famiglia di modelli addestra il proprio. Un vocabolario più grande, o addestrato su più testo in una certa lingua, produce meno token per quella lingua. Quindi la domanda “quanti token è questo prompt” ha una risposta diversa per ogni modello.

Abbiamo misurato lo stesso breve messaggio di assistenza clienti, tradotto in quattro lingue, più una piccola funzione Python e un oggetto JSON di fattura. I conteggi OpenAI vengono da [tiktoken](https://github.com/openai/tiktoken) (`cl100k_base`, epoca GPT-4, e `o200k_base`, epoca GPT-4o). I conteggi dei modelli aperti vengono dai file del tokenizer che ogni famiglia pubblica su Hugging Face, contati senza chat template, il 14 novembre 2026.

| Testo (stesso significato) | Caratteri | cl100k\_base | o200k\_base | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B | Gemma 4 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Inglese, 31 parole | 173 | 37 | 37 | 37 | 38 | 39 | 39 |
| Spagnolo | 160 | 47 | 40 | 50 | 45 | 43 | 42 |
| Arabo | 142 | 102 | 46 | 55 | 58 | 48 | 49 |
| Cinese | 54 | 51 | 37 | 34 | 35 | 36 | 38 |
| Funzione Python | 94 | 33 | 33 | 35 | 33 | 35 | 38 |
| JSON di fattura | 140 | 59 | 60 | 63 | 60 | 72 | 72 |

Un solo campione per riga: prendi i numeri come un esempio, non come un benchmark. Tre lezioni valgono comunque. La generazione del tokenizer conta: il testo arabo si è più che dimezzato passando da `cl100k_base` a `o200k_base`. Anche i modelli aperti differiscono tra loro: lo stesso testo arabo è andato da 48 a 58 token, e il JSON da 60 a 72. E il contenuto strutturato è denso di token ovunque: il JSON ha reso circa 2 caratteri per token su ogni tokenizer.

Puoi ripetere la prova sul tuo testo con il [contatore di token](https://broadrouter.com/tools/token-counter/) gratuito, oppure con i contatori per famiglia di [DeepSeek](https://broadrouter.com/tools/deepseek-token-counter/), [Qwen](https://broadrouter.com/tools/qwen-token-counter/) e [GPT](https://broadrouter.com/tools/gpt-token-counter/). Per vedere quanto fa risparmiare una modifica al prompt, confronta le due versioni nel [diff di token del prompt](https://broadrouter.com/tools/prompt-token-diff/). Perché proprio l’arabo costi più token, misurato su testi più lunghi, lo spiega [token per parola in arabo e in inglese](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/).

## Come si contano i token in modo esatto?

Se il tokenizer del modello è pubblico, caricalo e conta in locale. Per i modelli OpenAI:

```python
import tiktoken
enc = tiktoken.encoding_for_model("gpt-4o")
n = len(enc.encode(text))
```

Per le famiglie open-weight il tokenizer di solito viene distribuito con il modello su Hugging Face e si carica con `AutoTokenizer.from_pretrained(...)`. Due avvertenze: il chat template aggiunge token per ruoli e separatori, e la versione messa in produzione da un provider API può differire dai file pubblici. Il riferimento API di BroadNet non documenta un endpoint per contare i token né il tokenizer di ciascun modello, quindi il tokenizer pubblico dà una stima vicina e il numero esatto è `usage.prompt_tokens` dopo la chiamata.

## Come si stimano i token se il tokenizer non è pubblico?

Calibra una volta per modello, poi stima in locale:

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def prompt_tokens(model, text):
    r = client.chat.completions.create(
        model=model, max_tokens=1000,  # room for reasoning on thinking models
        messages=[{"role": "user", "content": text}],
    )
    return r.usage.prompt_tokens

def measure(model, samples: dict[str, list[str]]):
    base = prompt_tokens(model, "hi")  # chat-template overhead plus one short word
    ratios = {}
    for kind, texts in samples.items():
        chars = toks = 0
        for t in texts:
            chars += len(t)
            toks += prompt_tokens(model, t) - base
        ratios[kind] = chars / toks
    return ratios  # e.g. {"english": 4.1, "arabic": 2.9, "json": 2.3}

def estimate(text, kind, ratios, overhead=10):
    return int(len(text) / ratios[kind]) + overhead
```

Usa almeno 20 campioni reali per tipo di contenuto (i tuoi prompt veri, non lorem ipsum). La richiesta di base con una sola parola elimina l’overhead fisso del chat template, che `estimate` riaggiunge come `overhead`; impostalo sulla base che hai misurato. Calibra sul modello più economico di BroadNet solo se è quello che chiamerai: i rapporti di [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/) non valgono per [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/). Anche le immagini sono fatturate come token di input, e quelle più grandi ne usano di più, quindi calibrale a parte per risoluzione.

## Che margini usare per max\_tokens e contesto?

La finestra copre prompt **e** output. Sui modelli di ragionamento l’output include il thinking nascosto, riportato come [token di ragionamento](https://broadrouter.com/it/glossary/reasoning-tokens/). Fai il budget così:

1.  **Stima del prompt** = conteggio calibrato × 1,15 (un margine di sicurezza del 15 percento).
2.  **Budget di risposta** = la risposta più lunga che accetti.
3.  **Budget di ragionamento** = per i modelli thinking, almeno 1.000 token; la documentazione di BroadNet consiglia almeno 1.000 oppure `reasoning_effort: "low"`, perché un limite basso può restituire una risposta vuota.
4.  **max\_tokens** = budget di risposta + budget di ragionamento.
5.  **Verifica**: stima del prompt + max\_tokens ≤ finestra di contesto. Se non ci sta, taglia il prompt, non la risposta.

Finestre di contesto su BroadNet Inference, dal file dei prezzi pubblicato:

| Modello | Finestra di contesto | Tetto pratico del prompt con 16K di output e margine del 15% |
| --- | --- | --- |
| DeepSeek V4.1 Flash | 1.048.576 | circa 897.000 |
| [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) | 1.048.576 | circa 897.000 |
| [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/) | 262.144 | circa 213.000 |
| Gemma 4 VL 26B | 32.768 | circa 14.000 |

La colonna del tetto è (finestra − 16.384) ÷ 1,15, arrotondata per difetto. Sostituisci 16.384 con il tuo max\_tokens.

## Cosa va storto nelle stime dei token?

-   **Contare le parole invece dei token.** La regola delle 0,75 parole per token vale per l’inglese. Il nostro campione arabo di 29 parole andava da 46 a 102 token a seconda del tokenizer.
-   **Dimenticare tool e prompt di sistema.** Gli schemi dei tool sono JSON, che è denso di token. Contali come parte del prompt.
-   **Dare per scontato un troncamento silenzioso.** Alcuni strumenti scartano i messaggi vecchi senza dirtelo. BroadNet dichiara di non tagliare il tuo contesto, quindi verifica la dimensione prima dell’invio invece di contare sul server per tagliarla. Il [calcolatore della finestra di contesto](https://broadrouter.com/tools/context-window-calculator/) fa la verifica per te.
-   **Ignorare la crescita della cronologia.** In una chat o in un ciclo di agente il prompt cresce a ogni turno. Ricontrolla il budget a ogni chiamata, non una volta per sessione. Una cronologia stabile sfrutta anche meglio la cache; vedi [struttura del prompt per la cache](https://broadrouter.com/it/blog/prompt-structure-for-caching/).

Se lavori in arabo, il tokenizer è un motivo in più per provare i modelli sul tuo testo; il resto è in [scegliere un LLM per l’arabo](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/). Per trasformare i conteggi di token in una fattura mensile, vedi [come stimare il costo di un’API LLM prima del lancio](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/).

## Dove si inserisce BroadNet Inference

BroadNet Inference restituisce in ogni risposta `prompt_tokens`, `completion_tokens` e, quando il modello li riporta, i conteggi dei token in cache e di ragionamento: è tutto ciò che serve per calibrare. Non pubblica un endpoint di conteggio né i tokenizer per modello, quindi i conteggi prima dell’invio sono stime. Il lavoro a contesto lungo sui modelli da 1M di token è trattato nella [guida alla finestra di contesto](https://broadrouter.com/it/blog/million-token-context-window-guide/), e i prezzi per 1M di token sono nella [pagina dei prezzi](https://broadrouter.com/it/pricing/).

Strumenti gratuiti sul tema (in inglese)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Tokenizer](https://broadrouter.com/it/glossary/tokenizer/)

Un tokenizer è il componente che converte il testo nella sequenza di ID interi di token che un modello linguistico legge, e riconverte in testo gli ID generati. Ogni modello ha il proprio tokenizer, quindi lo stesso testo può produrre un numero di token diverso su modelli diversi.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Finestra di contesto (context window)](https://broadrouter.com/it/glossary/context-window/)

La finestra di contesto è il numero massimo di token con cui un modello linguistico può lavorare in una singola richiesta. Comprende prompt, cronologia della conversazione, definizioni degli strumenti, immagini e output generato, token di ragionamento inclusi. Ciò che non ci sta va tagliato, riassunto o diviso su più richieste.

[max\_tokens](https://broadrouter.com/it/glossary/max-tokens/)

max\_tokens è un parametro delle API LLM che fissa il numero massimo di token che un modello può generare in una risposta. Quando la generazione raggiunge il limite, si ferma e la risposta viene segnata come troncata, per esempio con finish\_reason impostato a "length".

[Chat template](https://broadrouter.com/it/glossary/chat-template/)

Un chat template è la regola di formattazione, di solito scritta in Jinja e distribuita con il tokenizer di un modello, che converte una lista di messaggi di chat con i rispettivi ruoli nell’unica sequenza di token che il modello si aspetta, compresi i suoi token speciali di controllo. Usare il template sbagliato può peggiorare molto le risposte del modello.

[Token di input e di output](https://broadrouter.com/it/glossary/input-and-output-tokens/)

I token di input sono quelli che un modello linguistico legge in una richiesta: system prompt, cronologia, definizioni degli strumenti e immagini. I token di output sono quelli che genera in risposta, ragionamento compreso. Le API LLM di solito li prezzano separatamente, e l’output costa di più.

[System prompt (prompt di sistema)](https://broadrouter.com/it/glossary/system-prompt/)

Il system prompt è il testo di istruzioni che un’applicazione invia a un modello linguistico prima della conversazione, di solito come messaggio con ruolo system o developer. Stabilisce ruolo, regole, tono e formato di output del modello, che dovrebbe seguirlo anche quando i messaggi dell’utente lo contraddicono.

## Domande frequenti

### Quanti token sono una parola?

Nel dataset di tokenizer di BroadRouter, che riunisce cinque tokenizer (quelli dei quattro modelli chat di BroadNet e o200k\_base di OpenAI; la tabella di esempio dell’articolo aggiunge cl100k\_base), 1.000 parole in inglese sono circa 1,290 token, cioè circa 1.29 token per parola. La regola empirica diffusa, 0,75 parole per token, è vicina per la prosa inglese. L’arabo, le altre scritture non latine e il codice usano più token per parola. Misura il tuo testo con il modello che chiami.

### Posso usare tiktoken per contare i token di DeepSeek, Qwen o Gemma?

Solo come stima approssimativa. tiktoken implementa le codifiche di OpenAI. Le altre famiglie di modelli distribuiscono tokenizer propri, spesso su Hugging Face, e i conteggi cambiano. Calibra sul campo usage.

### Esiste uno strumento gratuito per contare i token di DeepSeek, Qwen, GLM o Gemma?

Sì. Il contatore di token gratuito di BroadRouter esegue nel browser i tokenizer pubblicati di queste famiglie di modelli, quindi il testo non lascia il tuo computer. Considera il conteggio una stima di ciò che riporterà l’API, perché i chat template aggiungono qualche token.

### Cosa succede se il mio prompt è più lungo della finestra di contesto?

La maggior parte delle API restituisce un errore. Alcuni strumenti tagliano in silenzio i messaggi vecchi. BroadNet non taglia il tuo contesto, quindi verifica prompt più max\_tokens rispetto alla finestra prima dell’invio.

### Quanto margine devo lasciare per max\_tokens?

Stima la risposta più lunga che ti aspetti, aggiungi il budget di ragionamento per i modelli thinking e tieni libero dal 10 al 20 percento della finestra per l’errore di stima.

## Continua a leggere

-   [Token per parola in arabo e in inglese: perché l’arabo costa di più](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/)
-   [Quando conviene una finestra di contesto da 1M di token (e quando no)](https://broadrouter.com/it/blog/million-token-context-window-guide/)
-   [Come stimare il costo delle API LLM prima di lanciare una funzione](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/)
-   [Come strutturare i prompt perché il prefisso vada in cache](https://broadrouter.com/it/blog/prompt-structure-for-caching/)
-   [Ridurre i token del prompt: tagli misurati su sistema, tool e dati](https://broadrouter.com/it/blog/reduce-prompt-tokens/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-count-tokens-before-sending&utm_content=page-cta) ·

**Fonti**

-   [README di tiktoken: codifiche e circa 4 byte per token (consultato il 2026-11-14)](https://github.com/openai/tiktoken)
-   [Riferimento API di BroadNet Inference: max\_tokens e ragionamento (consultato il 2026-11-14) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-count-tokens-before-sending&utm_content=sources)
-   [Prezzi e lunghezze di contesto di BroadNet Inference in formato leggibile dalle macchine (pricing.json, consultato il 2026-11-14) (in inglese)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-count-tokens-before-sending&utm_content=sources)
-   [Hugging Face Transformers, documentazione del tokenizer (consultata il 2026-11-14)](https://huggingface.co/docs/transformers/main_classes/tokenizer)
