Timestamps

Speech Revolutions returns a start and end time for every word, in seconds from the beginning of the audio. Word timestamps are on by default (word_timestamps=true); leave them on and read them off the result. They power everything downstream — subtitle cues, speaker turns, clip extraction, and karaoke-style highlighting.

Read them off .words

With the default output_type="json" the SDK parses the response into a transcript object. Each entry in result.words carries the word text plus its start and end (floats, in seconds), and — when speaker labels are on — a speaker.

result = client.transcribe("meeting.mp3")  # word_timestamps=True by default

for w in result.words[:5]:
    print(f"{w.start:6.2f}–{w.end:6.2f}  {w.word}")
# 0.48–  0.71  Hello
# 0.71–  1.02  everyone

Per-word fields

Field	Type	Meaning
`word`	`string`	The token. `.text` is an AssemblyAI-compatible alias.
`start`	`float`	Seconds from the start of the audio to the word onset.
`end`	`float`	Seconds to the word offset.
`speaker`	`string \| null`	Set when `speaker_labels` is on; otherwise absent.
`confidence`	`float \| null`	Per-word confidence when the model reports it.
`language`	`string \| null`	The detected language for this word — see language detection for the transcript-level `result.languages` segments.

The JSON shape

Under the hood the json output is a document with a words array. The SDK parses this into result.words and derives result.text and result.utterances from it. You rarely need the raw form, but it's available as result.raw.

json output (abridged)

{
  "words": [
    { "word": "Hello",    "start": 0.48, "end": 0.71, "speaker": "SPEAKER_0" },
    { "word": "everyone", "start": 0.71, "end": 1.02, "speaker": "SPEAKER_0" }
  ]
}

Prefer result.to_dict() for a normalized, provider-neutral dict, or result.to_deepgram() for a Deepgram-shaped response during a migration — both preserve the per-word start/end.

python

normalized = result.to_dict()      # {"id", "text", "words": [...], "utterances": [...]}
first = normalized["words"][0]
print(first["start"], first["end"], first["word"])

Timestamps without JSON

Choosing srt or vtt gives you timestamps already formatted as subtitle cues; docx/pdf are formatted documents. To work with timings in code, use the default json output and read .words. See output formats & subtitles.

Turning timestamps into cues

You don't have to build cues yourself — request output_type="srt" or "vtt" and the server emits properly timed subtitles. Reach for .words only when you need custom windows, e.g. grouping words into fixed-length caption lines or extracting a clip between two timestamps.

Accuracy

Timestamp accuracy is measured in our public benchmark suite alongside word error rate and diarization. Rather than quote a figure here, see the benchmarks page for the current numbers and methodology.

Speaker diarization adds a speaker to each word and groups them into turns. The cookbook has copy-pasteable subtitle recipes.