YouTube timestamp links: how ?t=, start, and end work
How YouTube timestamp links work: the ?t= parameter on watch and youtu.be URLs, embed start and end parameters, chapter rules, and where timestamps fail.
Table of contents
TL;DR: Add ?t=90 to a youtu.be link or &t=90 to a youtube.com/watch URL to start playback at 1 minute 30 seconds. Plain seconds is the most reliable format; the s suffix (?t=90s) is optional. Embedded players ignore ?t= — they use start and end parameters in integer seconds instead. Chapters are a separate feature with strict rules: the first timestamp must be 0:00, you need at least three, and each chapter must be at least 10 seconds long.
How the ?t= parameter works
A YouTube timestamp link is an ordinary video URL with a start time attached as a query parameter. When someone opens https://youtu.be/VIDEO_ID?t=83, the player loads the video and begins playback at 83 seconds — 1 minute 23 seconds in — instead of at the beginning. The same parameter works on full watch URLs, where it joins the existing query string with an ampersand: https://www.youtube.com/watch?v=VIDEO_ID&t=83. The video itself is unchanged; the parameter only moves the initial playhead position, and the viewer can still scrub anywhere. This is the standard way to share a specific moment — a key point in a talk, a step in a tutorial, the exact second something happens — without asking the viewer to seek manually. YouTube’s own share dialog produces these links: per the official sharing help page, you check the “Start at” box and enter a time such as 2:30 before copying the link.
The share dialog converts the human-readable time into seconds for you. When building links by hand, you do the conversion yourself: 2:30 becomes ?t=150, and 1:02:03 becomes ?t=3723. epochkit’s YouTube timestamp generator does this automatically — paste any YouTube URL, type a time as HH:MM:SS, MM:SS, or plain seconds, and copy the finished link or embed code, including bulk conversion for a list of URLs.
Accepted time formats
| Format | Example | Notes |
|---|---|---|
| Plain seconds | ?t=83 | The most reliable form, and what YouTube’s share dialog generates |
| Seconds with suffix | ?t=83s | Equivalent to plain seconds |
| Hours/minutes/seconds | ?t=1h2m3s | Accepted on watch pages, but not everywhere — prefer seconds |
The 1h2m3s style is convenient to write by hand, but it is not honored in every context where a YouTube link can be opened. Converting to plain seconds (1h2m3s = 3723) removes the ambiguity, which is why generated links should always use the seconds form.
Converting a displayed time to seconds
The arithmetic is hours × 3600 + minutes × 60 + seconds. A few common values:
| Displayed time | Seconds | Parameter |
|---|---|---|
0:30 | 30 | t=30 |
2:30 | 150 | t=150 |
10:00 | 600 | t=600 |
1:02:03 | 3723 | t=3723 |
2:15:00 | 8100 | t=8100 |
Why the separator differs between URL forms
The ? and & characters are not interchangeable, and getting them wrong is the most common reason a hand-built timestamp link silently starts at zero. A URL’s query string opens with a single ?, and every parameter after the first is joined with &. A short youtu.be/VIDEO_ID link carries no parameters of its own, so the timestamp is the first one and takes the ?: youtu.be/VIDEO_ID?t=150. A full watch URL already spends its ? on the video ID (watch?v=VIDEO_ID), so the timestamp has to join with an ampersand: watch?v=VIDEO_ID&t=150. Writing watch?v=VIDEO_ID?t=150 produces a video ID that literally contains ?t=150, and YouTube either loads the video from the start or fails to resolve it at all. The order of parameters after the first does not matter, so watch?t=150&v=VIDEO_ID is equally valid — only the separators do.
Embed start and end parameters
The embedded player takes its time bounds from dedicated parameters, not from ?t=. The official player parameters documentation defines two: start “causes the player to begin playing the video at the given number of seconds from the start of the video”, and end “specifies the time, measured in seconds from the start of the video, when the player should stop playing the video”. Both take positive integers.
<!-- Player parameters: https://developers.google.com/youtube/player_parameters -->
<iframe
src="https://www.youtube.com/embed/VIDEO_ID?start=90&end=150"
title="Video segment from 1:30 to 2:30"
allowfullscreen
></iframe>Two documented details are worth knowing:
endis absolute, not relative. The stop time is measured from the beginning of the video — not from thestartvalue.start=90&end=150plays a 60-second segment from 1:30 to 2:30, not a 150-second one.- Seeking snaps to keyframes. The player looks for the closest keyframe to the requested time, so playback “may seek to just before the requested time, usually no more than around two seconds”. Do not expect frame-exact starts from an embed.
If you paste a ?t= link into an iframe src, the parameter is ignored. Convert it: the t value in seconds becomes the start value.
Timestamps in comments and descriptions
YouTube turns plain typed times in a video’s own comments and description into clickable links. Write 2:30 or 1:02:03 in a comment under the video, and viewers can click it to jump straight to that moment — no URL required. This is how “best moments” comments and creator-provided outlines work. The linking applies to times that fall within the video’s length and match the standard M:SS or H:MM:SS pattern; a stray number without the colon-separated form stays plain text.
For descriptions, timestamps do double duty: they are clickable seek links for viewers, and — when they follow specific rules — they also become chapters.
Chapters vs manual timestamps
Chapters are a structural feature that divides the progress bar into labeled, individually previewed segments; manual timestamps are just links. The official chapters documentation sets three requirements for turning description timestamps into chapters:
- The first timestamp must be
0:00. A description whose first listed time is0:45produces links, not chapters. - At least three timestamps, listed in ascending order.
- Each chapter must be at least 10 seconds long. Two timestamps closer together than that break the chapter list.
A qualifying description looks like this:
0:00 Introduction
1:30 Setting up the project
4:45 First deployment
9:20 TroubleshootingYouTube can also generate chapters automatically for eligible videos when the creator enables “Allow automatic chapters and key moments” in the video’s advanced settings; not all videos are eligible, and manually added chapters override automatic ones.
The practical difference: chapters segment the seek bar, show section titles as the viewer scrubs, and give each portion its own preview. Plain timestamps — in a comment, a chat message, or a shared ?t= link — simply move the playhead. If you control the video, chapters give viewers better navigation; if you are linking to someone else’s video, a timestamped URL is your only option.
Where timestamp links do not work
Shorts. YouTube Shorts URLs (youtube.com/shorts/VIDEO_ID) do not support start times — Shorts play from the beginning and the ?t= parameter is ignored. Only standard videos on watch?v= and youtu.be URLs honor timestamps.
Embedded players via ?t=. As covered above, iframes ignore ?t=. Use start= (and optionally end=) in the embed URL instead.
Frame-exact positions in embeds. Because the embed player snaps to the nearest keyframe, a start value can land up to roughly two seconds early. For a talk or tutorial this is invisible; for frame-precise references, mention the exact time in your text as well.
Playlists — with a caveat. A timestamp on a playlist URL works, but it applies to the video identified in the URL, not to the playlist position: https://www.youtube.com/watch?v=VIDEO_ID&list=PLAYLIST_ID&t=90 starts that specific video at 1:30.
Four mistakes that produce a link starting at zero
When a timestamp link opens at the beginning of the video, it is almost always one of four causes, and each has a mechanical fix.
- The wrong separator.
watch?v=ID?t=90is malformed; the second?must be an&. See the section above. ?t=on an embed URL. The iframe player readsstart, nott. A?t=90on an/embed/URL is silently ignored — convert the value tostart=90.- A time format the surface does not accept.
t=1h2m3sworks on a watch page but is not honored everywhere a link can be opened. Plain seconds is the form that works in every context. - A Shorts URL.
youtube.com/shorts/IDignores start times entirely. If the video is also available as a standard watch URL, link that form instead.
A fifth, subtler case: end without start is legal but rarely what you want, since the player then begins at the start of the video and stops at end. And because end counts from the beginning of the video rather than from start, an end value smaller than start produces a segment of zero length.
Building timestamp links quickly
For a one-off link, YouTube’s share dialog with the “Start at” box is the fastest path. For anything repetitive — timestamping show notes, building a set of reference links from one video, or generating an embed with both start and end bounds — epochkit’s YouTube timestamp tool accepts any URL form (youtu.be, watch?v=, embed URLs), parses times in HH:MM:SS, MM:SS, or seconds, and outputs both the shareable ?t= link and the iframe embed code. A bulk mode converts a pasted list of URL, time pairs in one step.
Related tools
Use epochkit’s YouTube timestamp generator to build shareable start-time links and start/end embed codes from any YouTube URL. For the other direction — turning a moment in time into a Unix value for scripts or APIs — the Unix timestamp converter covers it.
How we create this content: Our guides are drafted with the help of AI tools, then reviewed, fact-checked against the relevant specifications (POSIX, RFC 3339, crontab(5), or platform docs), and tested in epochkit's own tools by a human before publishing. We update them when specs or platform behavior change. Spotted something wrong? Email contact@epochkit.dev — we'll fix it.