---
title: "Latenza LLM: TTFT, token al secondo, end-to-end | BroadRouter"
description: "Cosa misurano time to first token, token al secondo e latenza end-to-end, come cronometrarli dal client con il codice e quali interventi spostano quale numero."
url: https://broadrouter.com/it/blog/llm-latency-ttft-throughput/
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/llm-latency-ttft-throughput/) (aggiornato il 2026-11-16).

# Latenza degli LLM: TTFT, token al secondo e tempo end-to-end

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

Il time to first token (TTFT) è l’attesa prima del primo token di output. I token al secondo dicono quanto velocemente arriva poi la risposta in streaming. La latenza end-to-end è il totale: TTFT più il tempo di generazione (≈ token di output ÷ velocità). Lunghezza del prompt e code determinano il TTFT, dimensione del modello e carico la velocità, lunghezza della risposta il totale. Misurali tutti e tre a p50 e p95.

## Punti chiave

-   Latenza end-to-end ≈ TTFT + (token di output − 1) × latenza tra token, cioè circa TTFT + token di output ÷ token al secondo per utente. Nelle risposte lunghe dominano velocità e lunghezza; in quelle brevi, il TTFT.
-   Nei modelli di ragionamento il primo token visibile arriva dopo il ragionamento, quindi misura il tempo al primo token di contenuto separatamente dal tempo al primo token.
-   I prompt lunghi alzano il TTFT perché il modello legge prima l’intero prompt; i prefissi in cache di solito aiutano.
-   A circa 100 token al secondo, il tempo di generazione cresce di pari passo con la lunghezza della risposta: dieci volte i token di output richiedono circa dieci volte il tempo di streaming.
-   Riporta p50 e p95 insieme alla lunghezza del prompt; una media senza la dimensione del prompt non è confrontabile.

**In questa pagina**

1.  Cosa sono TTFT, token al secondo e latenza end-to-end?
2.  Perché i modelli di ragionamento richiedono un quarto numero?
3.  Come si misura la latenza dal client?
4.  Cosa migliora davvero ciascun numero?
5.  Come cambia il compromesso con la lunghezza del prompt?
6.  Dove si colloca BroadNet Inference

«L’API è lenta» può voler dire tre cose diverse, e ognuna si risolve in modo diverso. Un utente in chat aspetta la prima parola. Un agente aspetta l’intera chiamata a un tool. A un job batch interessano i token all’ora. Questo articolo definisce i tre numeri, mostra come misurarli dal tuo codice e associa ogni intervento al numero che sposta davvero.

## Cosa sono TTFT, token al secondo e latenza end-to-end?

La guida al benchmarking di NVIDIA dà definizioni pulite, che corrispondono a ciò che puoi osservare da un client:

| Metrica | Cosa misura | Chi la percepisce | Da cosa dipende |
| --- | --- | --- | --- |
| [Time to first token](https://broadrouter.com/it/glossary/time-to-first-token/) (TTFT) | Richiesta inviata → primo token ricevuto | Utenti della chat | Rete, code, lunghezza del prompt (prefill), hit della cache |
| Latenza tra token (ITL) | Intervallo medio tra un token e l’altro | Chi legge una risposta in streaming | Dimensione del modello, hardware, carico del server |
| [Token al secondo](https://broadrouter.com/it/glossary/tokens-per-second/) per utente | Token di output dopo il primo ÷ tempo di generazione (dal primo all’ultimo token); pari a 1 ÷ ITL media | Lettori, agenti | Come per l’ITL |
| Latenza end-to-end | Richiesta inviata → ultimo token ricevuto | Agenti, API, batch | TTFT + tempo di generazione |

La formula che li lega:

**end-to-end ≈ TTFT + (token di output − 1) × ITL ≈ TTFT + token di output ÷ token al secondo per utente**

La velocità per utente non coincide con il [throughput](https://broadrouter.com/it/glossary/throughput/) del server, cioè il totale dei token che un server produce per tutti gli utenti; un provider può aumentare l’uno mentre l’altro cala.

Prendi la velocità tipica che BroadNet pubblica per il modello dei suoi piani, circa 100 token al secondo. Il tempo di generazione cresce con la lunghezza della risposta: un file di codice da 4.000 token richiede circa ottanta volte il tempo di una classificazione da 50 token, mentre entrambi aspettano lo stesso TTFT. Nelle risposte brevi il TTFT è quasi tutta l’attesa; in quelle lunghe contano velocità e lunghezza.

## Perché i modelli di ragionamento richiedono un quarto numero?

I modelli di ragionamento come [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) pensano prima di rispondere, e anche il ragionamento è fatto di token di output. Se il modello spende 800 token a ragionare a circa 100 token al secondo, l’utente aspetta che tutti gli 800 vengano generati prima di vedere la prima parola, anche se il TTFT misurato in rete sembra rapido. Quindi misura a parte il **tempo al primo token di contenuto**. Su BroadNet Inference, `reasoning_effort: "low"` accorcia il ragionamento nei passaggi semplici; la [guida al ragionamento](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/) spiega il compromesso.

## Come si misura la latenza dal client?

Misurala dove si trovano i tuoi utenti, con lo [streaming](https://broadrouter.com/it/glossary/streaming/) attivo. I timer lato server non vedono la rete né eventuali proxy.

```python
import os, time, statistics
from openai import OpenAI

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

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
```

Cinque regole per un benchmark corretto:

1.  **Fissa la lunghezza del prompt** e indicala. Il TTFT a 500 token di prompt e quello a 200.000 sono numeri diversi. Il [contatore di token](https://broadrouter.com/tools/token-counter/) ti dice quanto è lungo un prompt di test prima di inviarlo.
2.  **Fissa la lunghezza dell’output** con `max_tokens` e un prompt che la riempia, così i token al secondo sono confrontabili.
3.  **Riporta p50 e p95**, non la media. Gli utenti ricordano la latenza di coda.
4.  **Distribuisci le esecuzioni nel tempo.** Il carico cambia durante la giornata.
5.  **Fai prima un riscaldamento.** La prima chiamata paga DNS, TLS e apertura della connessione; riusa un solo client.

## Cosa migliora davvero ciascun numero?

| Per migliorare | Fai così | Perché |
| --- | --- | --- |
| TTFT | Accorcia il prefisso del prompt o mettilo in cache | Il tempo di prefill cresce con la lunghezza del prompt; i prefissi in cache saltano lavoro |
| TTFT | Tieni calde le connessioni, usa una regione vicina | Elimina setup e round trip |
| Tempo al primo token di contenuto | Abbassa lo sforzo di ragionamento, o usa un modello senza ragionamento per i passaggi semplici | Meno ragionamento nascosto prima della risposta |
| Token al secondo | Usa un modello più piccolo o più veloce per quel passaggio | La velocità di decodifica dipende da dimensione del modello e serving |
| End-to-end | Chiedi output più brevi (schemi, limiti di parole) | La lunghezza dell’output moltiplica l’ITL |
| End-to-end su molte chiamate | Esegui in parallelo le chiamate indipendenti entro il tuo limite di [concorrenza](https://broadrouter.com/it/glossary/concurrency/) | Il tempo reale scende anche se ogni chiamata resta uguale |
| Latenza percepita | Usa lo streaming verso l’utente | Legge mentre il modello scrive |

La lunghezza dell’output è la leva più sottovalutata. Chiedere «un JSON con questi quattro campi» invece di «spiega la tua risposta» può ridurre il tempo di generazione di un ordine di grandezza senza alcun lavoro sull’infrastruttura. L’[output strutturato](https://broadrouter.com/it/glossary/structured-output/) aiuta.

La leva della cache è trattata in [struttura del prompt per il caching](https://broadrouter.com/it/blog/prompt-structure-for-caching/). La leva del parallelismo si scontra presto con i rate limit; vedi [gestire gli errori 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/).

## Come cambia il compromesso con la lunghezza del prompt?

Il TTFT cresce con il prompt perché il modello deve elaborare ogni token di input prima di poter scrivere. È il costo nascosto dei prompt molto lunghi e fa parte della scelta tra [contesto lungo e RAG](https://broadrouter.com/it/blog/long-context-vs-rag/): un prompt da 1M di token risponde a domande che la RAG non gestisce, ma parte più lentamente. Se conta la velocità interattiva, tieni corto il percorso principale e invia il contesto grande solo quando la domanda lo richiede.

## Dove si colloca BroadNet Inference

BroadNet pubblica una velocità tipica di circa 100 token al secondo per il modello dei suoi piani e fa streaming nel formato SSE standard, quindi il codice qui sopra funziona senza modifiche. Non pubblica valori di TTFT né SLA di latenza, quindi misura sui tuoi prompt prima di impegnarti; un’[ora Meteor](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-latency-ttft-throughput&utm_content=body) da $1 basta per un benchmark da 50 esecuzioni, e il credito iniziale ne copre uno su Gemma 4 VL 26B. Se ti serve una latenza garantita sotto il secondo su larga scala, fai test accurati: una chiave a consumo consente 4 richieste in corso, il che si adatta più ad app e agenti che a un serving in tempo reale ad alto volume. I modelli e i loro prezzi sono nelle pagine [modelli](https://broadrouter.com/it/models/) e [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.

[Time to first token (TTFT)](https://broadrouter.com/it/glossary/time-to-first-token/)

Il time to first token (TTFT) è il tempo che passa dall’invio di una richiesta a un modello linguistico all’arrivo del primo token di output. Comprende il tempo di rete, la coda sul server e il prefill, la fase in cui il modello legge l’intero prompt, quindi cresce con la lunghezza del prompt e con il carico.

[Streaming](https://broadrouter.com/it/glossary/streaming/)

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Token al secondo (tokens per second)](https://broadrouter.com/it/glossary/tokens-per-second/)

I token al secondo (TPS) sono la velocità con cui un modello linguistico genera token di output, di solito misurata per una richiesta dopo l’arrivo del primo token. Stabiliscono quanto scorre veloce una risposta una volta partita. Sommati su tutte le richieste concorrenti diventano throughput di sistema; l’attesa del primo token si misura a parte.

[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ù.

[Throughput](https://broadrouter.com/it/glossary/throughput/)

Il throughput, nel serving di LLM, è la quantità totale di lavoro che un sistema completa per unità di tempo su tutte le richieste concorrenti, di solito misurata in token di output al secondo o richieste al secondo. È diverso dalla velocità per stream, cioè quanto rapidamente una singola richiesta riceve i suoi token.

[Latenza (latency)](https://broadrouter.com/it/glossary/latency/)

La latenza, per un’API di modelli linguistici, è il tempo che passa dall’invio di una richiesta alla ricezione dell’ultimo token di output. È la somma del time to first token e del tempo di generazione, e di solito si riporta in percentili come p50 e p95 invece che come media.

## Domande frequenti

### Qual è un buon time to first token per un’API LLM?

Per la chat, meno di circa un secondo sui prompt brevi dà una sensazione di reattività. I prompt lunghi e i modelli di ragionamento richiedono per natura più tempo. Confronta il TTFT solo a parità di lunghezza del prompt e di modello.

### I token al secondo sono la stessa cosa del throughput?

Non proprio. I token al secondo per utente dicono quanto velocemente arriva una singola risposta. Il throughput è il totale dei token che un server produce per tutti gli utenti. Un provider può aumentare il throughput totale mentre la velocità di ciascun utente cala.

### Perché il TTFT è così alto su un modello di ragionamento?

Il modello genera token di ragionamento nascosti prima della risposta visibile. Il primo token può arrivare presto, ma il primo token di contenuto aspetta la fine del ragionamento. Abbassa reasoning\_effort per i compiti semplici.

### Lo streaming riduce la latenza?

Non accorcia il tempo end-to-end. Permette all’utente di leggere la risposta mentre viene ancora scritta, quindi la latenza percepita scende più o meno al TTFT.

### Quante richieste servono per un benchmark di latenza affidabile?

Abbastanza per vedere la coda della distribuzione. Da cinquanta a cento richieste per dimensione del prompt danno un p95 utilizzabile. Distribuiscile nell’arco della giornata, perché il carico cambia.

## Continua a leggere

-   [Streaming degli LLM spiegato: chunk SSE, delta, usage e annullamento](https://broadrouter.com/it/blog/llm-streaming-sse-explained/)
-   [Come strutturare i prompt perché il prefisso vada in cache](https://broadrouter.com/it/blog/prompt-structure-for-caching/)
-   [Contesto lungo o RAG: quando 1M di token sostituisce un DB vettoriale](https://broadrouter.com/it/blog/long-context-vs-rag/)
-   [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: Streaming delle chat completions e connessioni interrotte](https://broadrouter.com/it/guides/streaming-chat-completions/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)

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-llm-latency-ttft-throughput&utm_content=page-cta) ·

**Fonti**

-   [Guida al benchmarking di NVIDIA NIM, metriche di latenza e throughput degli LLM (consultata il 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Piani di BroadNet Inference, velocità tipica (verifica del 2026-11-15) (in inglese)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Riferimento API di BroadNet Inference, streaming e ragionamento (verifica del 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, misurare latenza e throughput (consultato il 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
