Skip to content

JSON to SRT by segment or word by word.

To convert a JSON transcript to SRT, paste the contents or drop the .json file and click convert. We read the segments from Whisper and other speech to text tools and, when there are word timestamps, build subtitles from the words, up to 2 lines of 42 characters. The SRT comes back numbered and in UTF-8.

Free, no sign-up Updated
What to do
Output format
Cleanup (optional)

Removes [Music], (laughs), lines with ♪ and capitalized speaker names like PASTOR: at the start of a line.

How to use it

How to turn a transcription JSON into an SRT

  1. 01

    Paste or drop the .json

    The JSON that AI transcription tools and speech to text APIs return works, with segments holding a start, an end, and text. We recognize the structure on our own.

  2. 02

    Pick segments or words

    If the file has word timestamps, the option to build the subtitles from the words is already checked. Unchecked, each segment becomes one or more subtitles.

  3. 03

    Review the report and download

    Check reading speed and long lines for every subtitle, fix overlaps if needed, and download the SRT in UTF-8.

What makes it from the JSON into the SRT

A transcription JSON holds far more than a subtitle file needs. Each segment carries its text, a start and end in seconds (like 4.3 and 6.1), and a pile of technical numbers: token ids, average log probability, the odds that nobody is speaking, compression ratio, and the decoding temperature. An SRT only cares about timing and text.

We turn the seconds into 00:00:04,300, number the subtitles from 1, and trim the leading space that usually opens each text. The technical fields and the detected language are dropped, since SRT has no place to store them.

In the JSONIn the SRT
start and end in seconds00:00:04,300 --> 00:00:06,100
text with a leading spaceTrimmed text, up to 2 lines
words with per-word timingSubtitles built from the words (optional)
tokens, avg_logprob, temperatureIgnored
no_speech_prob, compression_ratioIgnored
languageIgnored: SRT has no language field

Segments or words: which gives better subtitles?

Segments are built for transcripts, not for the screen. One segment can span dozens of seconds of speech and hold a 200 character sentence on a single line. In segment mode, we wrap the text into lines of up to 42 characters, and when it still doesn't fit in 2 lines, we split the segment into several subtitles and share out the time in proportion to the text.

When the JSON has word timestamps, the option to build from the words is already checked, and it gives the best result. Each subtitle ends after a period, question mark, or exclamation point, at a pause of 0.7 seconds or longer, or once it reaches 7 seconds, always within 2 lines of 42 characters. The text shows up and leaves the screen right along with the speech.

One segment with word timestamps and the SRT it becomes
JSON
{
  "language": "en",
  "segments": [{
    "start": 0.0, "end": 4.1,
    "text": " Good morning, everyone. Today we'll edit on our phones.",
    "avg_logprob": -0.21,
    "words": [
      {"word": " Good", "start": 0.0, "end": 0.3},
      {"word": " morning,", "start": 0.3, "end": 0.7},
      {"word": " everyone.", "start": 0.7, "end": 1.4},
      {"word": " Today", "start": 2.2, "end": 2.5},
      {"word": " we'll", "start": 2.5, "end": 2.7},
      {"word": " edit", "start": 2.7, "end": 3.0},
      {"word": " on", "start": 3.0, "end": 3.1},
      {"word": " our", "start": 3.1, "end": 3.3},
      {"word": " phones.", "start": 3.3, "end": 4.1}
    ]
  }]
}

SRT with the option on (from the words)
1
00:00:00,000 --> 00:00:01,400
Good morning, everyone.

2
00:00:02,200 --> 00:00:04,100
Today we'll edit on our phones.

SRT with the option off (from the segment)
1
00:00:00,000 --> 00:00:04,100
Good morning, everyone. Today
we'll edit on our phones.

Which transcription JSON files we read

We recognize the structure from the content, so the file name doesn't matter. The text encoding (UTF-8, UTF-16, or Windows-1252) is detected as the file loads. These are the shapes we read:

  • A segments list with start, end, and text in seconds, like Whisper's verbose_json. start_time and end_time work too.
  • Timed words inside each segment (words or tokens), as in Whisper with word timestamps and in WhisperX, or in a top-level words or word_segments list.
  • A transcription list with offsets in milliseconds, the JSON output of whisper.cpp.
  • A chunks list with a timestamp pair, from the Hugging Face speech pipeline, or a bare list of segments with nothing around it.

Where to use the SRT you get from the JSON

SRT is the subtitle format almost every app accepts: YouTube Studio uploads it directly, Premiere Pro opens it through File > Import, DaVinci Resolve brings it in from the Media Pool, and CapCut reads it in its captions panel.

Before you download, take a look at the report. It lists the duration, characters per line, and reading speed of every subtitle, and flags anything over 17 characters per second, lines longer than 42 characters, and subtitles longer than 7 seconds, which are common when a segment ran long. Transcripts sometimes include [Music] or (applause): the option to remove sound descriptions cleans that up in the same pass.

Frequently asked questions

How do I convert a JSON transcript to SRT?

Paste the .json contents or drop the file, leave SRT as the output, and click convert. We turn each segment's seconds into 00:00:04,300, number the subtitles, and wrap lines at 42 characters. If the file has word timestamps, the option to build the subtitles from the words is already checked.

Why are my subtitles too long?

Because segments are designed for transcripts and can last dozens of seconds. In segment mode, we split whatever doesn't fit in 2 lines and share out the time by text length. For subtitles that follow the speech closely, export the JSON with word timestamps and use the option to build from the words.

How do I get a JSON with word timestamps?

Turn on word timestamps in the tool or API that made the transcript. The words then show up in a words array, either at the top level or inside each segment. We read both layouts, and the option to build the subtitles from the words shows up already checked.

What happens to avg_logprob, tokens, and no_speech_prob?

They're ignored. Those fields measure how confident the transcription was and help with debugging, but an SRT only holds a number, a time, and text. The detected language is dropped too. If you want to use confidence to review shaky passages, open the original JSON in a code editor before converting.

Can I turn the same JSON into VTT, TXT, or CSV?

Yes. The same JSON can come out as SRT, VTT, TXT, SBV, ASS, TTML, or CSV, and also as Word or PDF: just pick a different output format before you download. CSV is handy for reviewing the text in a spreadsheet, and TXT without timestamps becomes plain prose.

The transcript has [Music] and (applause). Can I remove them?

Yes. Check the option to remove sound descriptions: we delete anything inside square brackets or parentheses plus lines with ♪, and any subtitle left empty is dropped. In the same conversion you can also strip formatting tags and fix overlapping subtitles.

My JSON gave an error or the times came out wrong. Why?

Outside the offsets field, we read every time in seconds: a JSON with start and end in milliseconds comes out with times a thousand times too long. A structure other than the ones listed above, with the words at other levels, gets the no subtitles warning. In those cases, export the SRT straight from the source tool, if it has that option.

Sources

The official specifications this tool follows.

  1. 01Supported subtitle and closed caption files(opens in a new tab) · YouTube Help
  2. 02WebVTT: The Web Video Text Tracks Format(opens in a new tab) · W3C
  3. 03Timed Text Markup Language 1 (TTML1)(opens in a new tab) · W3C

Skip the JSON: we make the SRT from your video. With speakers and word-level timing.

Upload your video or paste a YouTube link. We transcribe it word by word, in 90+ languages, and you download the SRT, TXT, or PDF without converting anything.

See the result on your own recording before adding a card.