Transcript format

The transcript JSON a completed transcription returns: language, segments with times, speakers and their names, and how the TXT, SRT and VTT files are built from it.

Shape

A completed transcription carries this object in transcript. Every key is always present, so your code never checks whether one exists. Times are seconds from the start of the file, rounded to hundredths.

{
  "language": "en",
  "language_source": "detected",
  "duration": 7.84,
  "text": "Hi, I'm Anna from support. Thanks Anna, this is Mark from the sales team.",
  "speakers": [
    {
      "id": "A",
      "name": "Anna"
    },
    {
      "id": "B",
      "name": "Mark"
    }
  ],
  "segments": [
    {
      "start": 0.52,
      "end": 3.9,
      "speaker": "Anna",
      "speaker_id": "A",
      "text": "Hi, I'm Anna from support.",
      "words": [
        {
          "text": "Hi,",
          "start": 0.52,
          "end": 0.8
        },
        {
          "text": "I'm",
          "start": 0.86,
          "end": 1.1
        },
        {
          "text": "Anna",
          "start": 1.16,
          "end": 1.6
        },
        {
          "text": "from",
          "start": 1.7,
          "end": 2
        },
        {
          "text": "support.",
          "start": 2.1,
          "end": 3.9
        }
      ]
    },
    {
      "start": 4.1,
      "end": 7.84,
      "speaker": "Mark",
      "speaker_id": "B",
      "text": "Thanks Anna, this is Mark from the sales team.",
      "words": [
        {
          "text": "Thanks",
          "start": 4.1,
          "end": 4.5
        },
        {
          "text": "Anna,",
          "start": 4.55,
          "end": 5
        },
        {
          "text": "this",
          "start": 5.1,
          "end": 5.3
        },
        {
          "text": "is",
          "start": 5.3,
          "end": 5.45
        },
        {
          "text": "Mark",
          "start": 5.5,
          "end": 5.9
        },
        {
          "text": "from",
          "start": 6,
          "end": 6.25
        },
        {
          "text": "the",
          "start": 6.25,
          "end": 6.4
        },
        {
          "text": "sales",
          "start": 6.45,
          "end": 6.9
        },
        {
          "text": "team.",
          "start": 6.95,
          "end": 7.84
        }
      ]
    }
  ]
}

Field	Type	Meaning
`language`	`string \| null`	The language code (list); null only if none could be detected.
`language_source`	`string`	detected when it was found from the audio, requested when you passed language.
`duration`	`number`	Seconds of audio processed.
`text`	`string`	All segment texts joined by one space (with no space for Chinese, Japanese and Cantonese).
`speakers`	`array`	One entry per speaker in order of first appearance; empty without speakers.
`segments`	`array`	The transcript in time order, one entry per stretch of speech.

Speakers and names

With speakers on, each segment belongs to one speaker. Speakers are labelled A, B and onwards in the order they first speak; one voice gives one speaker. With speaker_names on, a speaker gets a name only when it is said in the audio — someone introduces themselves or is addressed by name. MeetWave never guesses: without a spoken name, name is null and the segment shows the label. If two speakers get the same name, the segment shows it with the label, like Anna (B).

Field	Type	Meaning
`id`	`string`	A, B, C… in order of first appearance. Stable within the transcript.
`name`	`string \| null`	The name, when speaker_names was on and the name is said in the audio; otherwise null.

Without speakers, speakers is empty and each segment's speaker and speaker_id are null. The same holds when speakers were asked for but could not be told apart: the transcription's features.speakers is then failed and it is billed at the text price.

A speaker is given to each word, so a segment never holds two speakers. That needs word times, and some languages have none (or timing a file can fail). Then each segment keeps the one speaker heard most in it and can run past a change of speaker: features.speakers is partial, names are not looked for (features.speaker_names is failed), and the transcription is billed at the text price.

Segments and words

Field	Type	Meaning
`start`	`number`	Seconds from the start of the file.
`end`	`number`	Seconds from the start of the file.
`speaker`	`string \| null`	What to show: the name if one was found, else the id. Null without speakers.
`speaker_id`	`string \| null`	The id from speakers. Null without speakers.
`text`	`string`	What was said.
`words`	`array`	Words with their own start and end, when speakers are asked for. Empty for plain text and when words could not be timed.

With speakers or speaker_names, each word has its own times and each segment holds one speaker's words. Plain text has segment times only: words is empty there, and so it is on a transcription whose features.speakers is partial. A word has text, start and end.

TXT, SRT and VTT

The files from GET /v1/transcriptions/{id}/{format} are built from the same segments, in UTF-8. TXT has one line per segment with its start time and speaker:

[00:00:00] Anna: Hi, I'm Anna from support.
[00:00:04] Mark: Thanks Anna, this is Mark from the sales team.

SRT and VTT are subtitles. A cue holds at most 84 characters of speech and lasts at most 7 seconds, so a long segment becomes several cues; the speaker comes first in SRT and as a voice tag in VTT.

1
00:00:00,520 --> 00:00:03,900
Anna: Hi, I'm Anna from support.

2
00:00:04,100 --> 00:00:07,840
Mark: Thanks Anna, this is Mark from the sales team.

WEBVTT

00:00:00.520 --> 00:00:03.900
<v Anna>Hi, I'm Anna from support.

00:00:04.100 --> 00:00:07.840
<v Mark>Thanks Anna, this is Mark from the sales team.