What is time to first token? TTFT spans 0.16 to 1.12 seconds across ten measured endpoints

Time to first token, or TTFT, is the delay between sending a prompt to a language model and receiving the first output token back. Median TTFT across ten provider endpoints in a published April 23, 2026 benchmark ranged from 0.16 seconds on Cerebras' Llama 4 70B endpoint to 1.12 seconds on OpenAI's GPT-5.5 standard endpoint; reasoning mode changes this, with Claude Opus 4.7 in extended thinking posting a 28-second median in the same window.

This article defines TTFT, works through the formula linking it to total response time, and names what these aggregated figures do not cover. Stop here with the range above, or read on for the formula and the reasoning multiplier.

Time to first token by provider and model

Time to first token by provider and model, single-turn prompt, default (non-reasoning) mode, tested 2026-04-23

Note: † output speed not published by the source. Top pick marks the tied fastest pair: the 0.02 second gap between Cerebras and Groq is smaller than typical run-to-run variation, with no published confidence interval for either, so this article treats the two as tied. Reasoning-mode configurations are excluded here and covered separately below, since they answer a different question than default mode does.

Cerebras and Groq recorded the two fastest median TTFT figures, 0.16 and 0.18 seconds; OpenAI's GPT-5.5 standard endpoint recorded the slowest, 1.12 seconds, a 2.41-second P95. All ten figures were measured April 23, 2026 and reported by Digital Applied.

Cerebras and Groq lead on hosted open weight models; every hosted flagship from Anthropic, Google, and OpenAI here posts a slower median. LLM Waves Research's model leaderboard tracks this comparison on a rolling basis, independent of this article's publication date.

Basis and method

This article aggregates figures from Artificial Analysis, Digital Applied, AIMultiple, and vendor documentation; we ran no tests for it, and every number carries a source, a URL, and a retrieval date. The Artificial Analysis performance benchmarking methodology, version 2.2.0, dated March 2, 2026, defines TTFT as the time between sending a request and receiving the first token, measured at the median over a rolling window and reported at P50/P95.

The comparison table reproduces figures Digital Applied published on April 23, 2026, sourced from Artificial Analysis, provider status pages, and its own probes; AIMultiple's separate August 12, 2026 test of 1,320 requests across 11 models is cited below where it supports the pattern. We received no pre-release access, free credits, or rate-limit exemptions from any named provider, and none reviewed this article before publication.

We retrieved figures manually on August 19, 2026 and cross-checked each against a second source where one existed. Full definitions and the comparison methodology live separately.

This article covers what TTFT counts, the formula linking it to total response time, what changes it, and where the data runs out.

The formula behind time to first token

TTFT plus decode time equals total response time

TTFT alone does not predict how long a response takes to finish. Anyscale's inference documentation gives the decomposition: end-to-end latency equals TTFT plus total generation time, generation time being output tokens minus one, multiplied by time per output token, the average gap between tokens after the first.

Applying that formula, using output speed as the inverse of time per output token, a 500-token response from Cerebras' Qwen 3 235B endpoint finishes in about 1.16 seconds, against about 6.54 seconds from GPT-5.5 standard, despite only a 0.91-second TTFT gap between the two.

Total response time reorders the field TTFT alone produces: Claude Opus 4.7 standard leads no measured axis here. Its 0.85-second TTFT sits mid-pack, but its 78-token-per-second output speed, the slowest of the seven endpoints here, pushes its total time for 500 tokens to 7.25 seconds, the longest in the set.

The P95-to-P50 gap a TTFT median hides

Digital Applied's dataset reports both P50 and P95 TTFT per endpoint, and the ratio between them varies more than the P50 figures suggest. Groq carries the tightest P95-to-P50 ratio, 1.9; GPT-5.5 standard and Claude Opus 4.7 standard both carry the widest, 2.2. A fast median paired with a wide ratio hides degradation under load the headline number does not show. None of the cited sources publish this ratio; it is calculated here from their published P50 and P95 figures.

What changes time to first token

Reasoning effort multiplies time to first token

OpenAI's reasoning models guide states that lower reasoning effort favors speed, higher effort trades latency for quality, and recommends a short preamble "for faster time to first visible token in latency-sensitive applications." The effect is large here:

Claude Opus 4.7 in extended thinking posted a 28-second median TTFT against 0.85 seconds standard, a multiplier near 33; GPT-5.5 Pro in medium reasoning posted 8.4 seconds against GPT-5.5 standard's 1.12 seconds. Neither figure marks the reasoning configuration as worse: reporting one number without naming the reasoning setting compares two different products as one.

Prompt length and unverified streaming both distort time to first token

ClickHouse's engineering documentation and IBM's technical guide both describe TTFT as covering network transit, queueing, and a prefill phase that processes every input token before generation starts, which is why TTFT scales with prompt length. Under OpenAI's tokenizer ratio of about 75 words per 100 tokens, a 1,000-token prompt runs to roughly 750 words, all processed during prefill first.

A TTFT measurement is also only as accurate as the client's definition of "first token." Deepchecks' benchmarking guide flags a client that buffers a response before displaying it, rather than streaming each token, as one that reports a first-token time inflated by buffering delay unrelated to the model.

Time to first token is not the same as latency

Redis' engineering blog cites the classic interface-response thresholds: 0.1 seconds reads as instantaneous, 1 second keeps attention intact, 10 seconds risks losing it. Every non-reasoning endpoint above, 0.16 to 1.12 seconds, sits inside the one-second band. GPT-5.5 Pro in medium reasoning, at 8.4 seconds, sits close to the 10-second threshold with nothing visible yet; Claude Opus 4.7 in extended thinking, at 28 seconds, sits well past it.

A short TTFT is one input into a responsive product, not the whole measurement of one: a model taking 28 seconds to a first token can still be the right pick when a task rewards depth over speed, a trade-off this article does not make for the reader.

What this article did not measure

We ran no benchmark of our own; every figure above is aggregated, dated, and linked. It does not cover on-device inference, self-hosted deployment, non-English prompts, or concurrent load beyond what each source tested, and it does not judge whether a figure suits a specific product, since that depends on the interface the model sits behind. Every figure reflects the endpoint as it served requests on its test date, not a model card's stated capability.

Time to first token by use case

For developers prototyping quickly: any of the ten endpoints above sits inside Redis' one-second band, so the choice matters less than confirming the figure on the exact region and account tier.

For startups watching infrastructure cost: TTFT alone will not surface pricing; cross-reference the table against each provider's own pricing page before committing.

For enterprise deployments: the P95-to-P50 ratio matters more than the median at fixed concurrency, and Groq carries the tightest ratio here, 1.9.

For high-volume applications: situational. The ratios above reflect each source's own test concurrency; queueing delay, one of four components in IBM's TTFT breakdown, generally widens past that.

For low-latency use cases: top pick goes to the tied pair, Cerebras and Groq, at 0.16 and 0.18 seconds.

For on-device deployment: insufficient data. None of the endpoints above run on-device, and no cited source publishes a comparable figure.

For self-hosting: insufficient data. AWS' Neuron benchmarking guide documents a method for measuring TTFT on self-hosted deployments without comparable figures.

For non-English workloads: none of the cited sources broke out TTFT by input language, a gap named here, not filled.

What does time to first token mean?

TTFT is the delay between sending a request and the first output token arriving, covering network transit, queueing, and the prefill pass. See the formula section above for how it combines with decode speed into total response time.

What is a good time to first token?

There is no fixed threshold. A figure inside Redis' one-second band, roughly 0.16 to 1.12 seconds across the ten endpoints above, functions for most interactive use; reasoning-mode configurations sit on a different axis, covered above.

How do you get a faster time to first token?

Two levers stand out: a provider and model combination lower on the table, and a lower reasoning effort setting where the task permits, per OpenAI's reasoning guide. Shorter prompts cut prefill time too.

Why does time to first token matter?

It is the first signal a reader gets that a request is being processed at all. Redis' cited thresholds place perceived responsiveness at one second before attention drifts: that is why the metric is tracked separately from total response time.

Is time to first token the same as latency?

No. TTFT measures the wait before any output appears; end-to-end latency measures the full response. A model can post a fast TTFT and a slow total time, or the reverse, as the calculation section shows.

How much text is 1,000 tokens?

Under OpenAI's published tokenizer ratio of about 75 words per 100 tokens, 1,000 tokens works out to roughly 750 words, all processed during prefill before the first output token appears.

The numbers above are a snapshot, not a live feed

Every figure here carries a retrieval date because provider endpoints change without changelogs. The table reflects April 23, 2026 for its primary source and August 12, 2026 for the corroborating AIMultiple test; check either provider's current TTFT and expect drift from what is published here. Raw sources and calculations are linked below.

Raw data

Source list, retrieval dates, and the total-response-time calculation referenced throughout this article.