> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cartesia.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Word Timestamps

> Get the start and end time of every word

Word timestamps tell you when each word was spoken, so you can highlight words as they're said, line up captions, redact audio, or measure how quickly your agent responds.

`ink-preview` includes them in every transcript, with nothing to turn on.

## Which models return them

| Model | Word timestamps |
| - | - |
| `ink-preview` | Always, on Realtime STT (Auto) and Realtime STT (Manual) |
| `ink-whisper` | Always on Realtime STT (Manual). On Batch STT, only when you set `timestamp_granularities` to `["word"]` |
| `ink-2` | Not available yet |

## What each word looks like

Each entry in the `words` list has three fields:

| Field | Type | Description |
| - | - | - |
| `word` | string | The word as it appears in the transcript, including any punctuation attached to it |
| `start` | number | When the word starts, in seconds |
| `end` | number | When the word ends, in seconds |

Times are measured from the first audio you send on the connection, not from the start of each turn. They're rounded to the nearest 10 ms.

## Realtime STT (Auto)

`turn.update`, `turn.eager_end`, and `turn.end` carry `words`, just as they carry `transcript`. `turn.update` has the words so far, and `turn.eager_end` and `turn.end` have every word in the turn. Each new turn starts a fresh list.

A word is added once the model has heard all of it, and its entry never changes after that. So while someone is still talking, `words` can trail the transcript slightly. Here, `someone` is in the transcript but not in `words` yet:

```json theme={null}
{ "type": "turn.update", "transcript": "When you call someone", "words": [
    { "word": "When", "start": 1.11, "end": 1.29 },
    { "word": "you", "start": 1.29, "end": 1.41 },
    { "word": "call", "start": 1.41, "end": 1.68 } ] }
```

`words` is left out until the turn has its first complete word, so treat a missing `words` as an empty list.

## Realtime STT (Manual)

On [Realtime STT (Manual)](https://docs.cartesia.ai/api-reference/stt/websocket.md), each `transcript` event includes only the words that finished since the last event, just as `text` includes only the new text. Keep a running list and add each event's words to it. When `flush_done` or `done` arrives, you have every word for the audio you finalized.

Timestamps can trail the text slightly. In this example, `away` is in the first event's text, but its entry arrives with the second event. `satellite` is in the second event's text, and its entry arrives later still:

```json theme={null}
{ "type": "transcript", "is_final": true, "text": " miles away", "words": [
    { "word": "miles", "start": 3.15, "end": 3.48 } ] }
{ "type": "transcript", "is_final": true, "text": ", you are using a satellite", "words": [
    { "word": "away,", "start": 3.51, "end": 3.93 },
    { "word": "you", "start": 4.29, "end": 4.44 },
    { "word": "are", "start": 4.44, "end": 4.50 },
    { "word": "using", "start": 4.53, "end": 4.83 },
    { "word": "a", "start": 4.86, "end": 4.92 } ] }
```

Late words can also arrive in an event with empty `text`. Keep the words, and add nothing to the transcript.

## How words are split

In languages written with spaces, each entry is one word. Punctuation goes with the word before it, as in `away,` and `please.`, but opening quotes and brackets go with the word after, as in `"Hello` and `(see`.

In languages written without spaces, such as Chinese, Japanese, and Thai, the model decides where to split, so an entry can be part of a word, a whole word, or a few words. English words and numbers inside Chinese or Japanese text come back as their own entries.

Either way, once all the words have arrived, the entries cover the whole transcript, in the correct order.

## How accurate the times are

The model predicts each timestamp rather than measuring it, so expect them to be close but not always exact:

* A long word, such as a spelled-out email address or a long number, can get a `start` that's later than when the speaker began the word.
* An entry can have zero length, with `start` equal to `end`. This is rare in languages written with spaces, and common in Mandarin, Cantonese, Japanese, and Thai, where a word can come back in pieces. Its text still belongs in the transcript.

## Where to go next

> [card] [Turn detection](https://docs.cartesia.ai/use-the-api/stt/turns.md)
>
> How `words` fits into the turn lifecycle

> [card] [Languages](https://docs.cartesia.ai/use-the-api/stt/languages.md)
>
> Detected languages arrive on the same events

> [card] [API reference](https://docs.cartesia.ai/api-reference/stt/turns/websocket.md)
>
> Every event and field


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.