YouTube Transcript with Timestamps: Every Way to Get One

Every transcript Scriptube processes stores timed segments, not just plain text — each one carries its own start time and duration down to the second. You don't need a separate feature to "add" timestamps; they're already there, and how you get at them depends on what you're using them for: reading in the browser, working with the raw data, or generating subtitle files.

What a timestamp actually is here

Every segment of a transcript is stored as {text, start, duration}, with start and duration in seconds. A transcript is really an ordered list of these segments, not one long block of text — which is why the same underlying data can become a readable page, a JSON array, or a subtitle file depending on how you export it.

Method 1: Read the transcript in the dashboard

Open any processed video from your dashboard or your library and you'll see the transcript as plain, readable text — the dashboard shows the words, not a timestamp next to each line. It's the fastest option if a person, not a program, just needs to read or skim the content. If you need the exact second a line starts, use your browser's find function to locate it (see searching inside a transcript) and pull that video's segments from the API for the precise start value.

Method 2: Raw segments as JSON

For programmatic use — citations, syncing to other data, building your own player — pull the segments directly with include_segments=true:

curl "https://scriptube.me/api/v1/transcripts/{batch_id}?include_segments=true" \
  -H "X-API-Key: YOUR_API_KEY"

Each item in the response includes its segments in the {text, start, duration} shape, for example (illustrative values):

{
  "text": "so today we're going to look at",
  "start": 12.4,
  "duration": 2.1
}

This is the format to reach for if you need exact second-level timing for anything other than subtitles — the full field-by-field schema for JSON, JSONL, and CSV exports is covered in the developer reference for export schemas.

Method 3: SRT or VTT for subtitles

If the timestamps are going into a video player or YouTube Studio as a subtitle file, export directly as SRT or VTT — both are generated from the same underlying segments:

curl "https://scriptube.me/api/v1/transcripts/{batch_id}/export?format=srt" \
  -H "X-API-Key: YOUR_API_KEY" -o captions.srt

Auto-generated YouTube captions sometimes have overlapping cues — rolling, overlapping caption windows that look fine in YouTube's own player but produce messy subtitle files. Scriptube cleans these up during export, so the SRT/VTT you get is one clean sequence of non-overlapping cues rather than a literal dump of YouTube's raw caption timing. For the syntax differences between the two formats and which tools expect which, see SRT vs. VTT.

Method 4: Why CSV, JSON, and JSONL exports aren't a timing source

CSV, JSON, and JSONL exports are one row per video — a plain-text text column plus metadata columns like title, channel, and language. They don't carry per-segment timing, so they're the wrong export to reach for if timestamps are the point. If you want timed rows in a spreadsheet or line-delimited dataset, fetch segments with include_segments=true and write the {text, start, duration} array out yourself, one row per segment. See getting a transcript into Excel or Google Sheets for working with the plain-text CSV export, and the schema reference for the exact columns in each format.

Segments and metadata are independent

include_segments=true and include_metadata=true are separate toggles on the same endpoint, and you can use either, both, or neither. Segments get you the timed text; metadata gets you the video's title, channel, duration, and similar details. Asking for timestamps doesn't pull in metadata automatically, and asking for metadata doesn't pull in timestamps — combine both flags if you want everything in one call:

curl "https://scriptube.me/api/v1/transcripts/{batch_id}?include_segments=true&include_metadata=true" \
  -H "X-API-Key: YOUR_API_KEY"

If you only need the metadata fields and not the timed text, see pulling description, chapters, and tags from video metadata.

Precision and consistency

start and duration are both given in seconds, with decimal precision — not rounded to the nearest whole second or minute:second display format. That raw numeric form is what gets converted into the HH:MM:SS,mmm or HH:MM:SS.mmm timestamp strings you see in SRT and VTT exports; the underlying precision doesn't change based on which export format you choose, only how it's displayed.

Timestamps work the same at any batch size

A single video, a full playlist, or a whole channel batch all store segments the same way — requesting include_segments=true or exporting as SRT/VTT works identically whether the batch has one item or a thousand. There's no separate "bulk timestamps" mode to reach for.

Choosing a method

You need	Use
To skim or read a video's content	Dashboard transcript view
Exact second-level timing for your own code	JSON with `include_segments=true`
A subtitle file for a video player or YouTube Studio	SRT or VTT export
Timed rows in a spreadsheet or dataset	Fetch segments via the API, then write your own rows

A worked example

Take https://www.youtube.com/watch?v=dQw4w9WgXcQ. Submit it, then pull it back three ways depending on what you need next:

# Read it with timing data, for your own processing
curl "https://scriptube.me/api/v1/transcripts/{batch_id}?include_segments=true" \
  -H "X-API-Key: YOUR_API_KEY"

# Export as VTT, ready to attach to a web video player
curl "https://scriptube.me/api/v1/transcripts/{batch_id}/export?format=vtt" \
  -H "X-API-Key: YOUR_API_KEY" -o captions.vtt

# Export as CSV, ready to open in a spreadsheet
curl "https://scriptube.me/api/v1/transcripts/{batch_id}/export?format=csv" \
  -H "X-API-Key: YOUR_API_KEY" -o transcript.csv

All three come from the same stored segments — only the shape changes.

How to do it in Scriptube

Submit the video from your dashboard or the API, same as any other transcript.
Open the result in the dashboard to read the plain text, or call the API with include_segments=true for the raw timed data.
Export as SRT or VTT if the destination is a video player or subtitle upload; export as CSV or JSONL if the destination is a spreadsheet or dataset.

Timestamps and language

If you're also working with multiple caption languages, timing is tracked per language track — switching the language parameter changes which track's segments you get back, not whether timing is included. See translating a transcript into any language for how language selection works alongside timestamps.

Quick answers to common questions

Do timestamps survive translation? It depends which kind. A YouTube auto-translated track (switching language to another language YouTube itself offers) keeps its timed segments, same as any native track. The Google English translation (translate_to_english) is text-only — it returns translated_text with no segments, so SRT/VTT subtitles always come from a timed track, never from the Google translation.

Can I get timestamps without paying for the whole transcript again? If the video is already in your library, re-requesting it with include_segments=true or re-exporting as SRT/VTT is free — you're not resubmitting the video, just reading it back in a different shape.

Why does my SRT file look different from what I saw on YouTube's own captions panel? YouTube's auto-generated captions use overlapping, rolling cue windows designed for its own player. Scriptube cleans these up into a single non-overlapping sequence of cues on export, which is why a downloaded SRT or VTT file reads more cleanly than a raw dump of YouTube's caption timing would.