YouTube URL Parser

Introduction

The Toollect YouTube URL Parser answers a small, daily question: what is actually in this link, and what can I safely delete before sharing it? Paste any YouTube URL and the tool splits it into its parts — video ID, start time, playlist, channel — then rebuilds it as a clean link with the tracking noise removed. No account, no API key, and zero network requests.

The problem it removes is the junk YouTube's Share button now appends to every link it produces. Copy a link to send a friend and you get ?si=…&feature=share&pp=… glued to the end — a fingerprint of your device, your sharing context, and your campaign. Paste the same link into a chat and it swallows half a line; paste it into a document and the playlist parameter silently drags readers into a whole playlist instead of the one video.

The tool runs entirely in your browser. It reads the URL with the same pattern YouTube itself uses, classifies every parameter into semantic (start time, playlist, index) or tracking (si, feature, pp, utm_*) — then reassembles the link in whatever format you want: the full watch URL, the short youtu.be link, or an embed URL for iframes. Nothing is uploaded, stored, or sent anywhere.

How It Works

Cleaning a URL is a three-step pipeline, all of it string parsing running locally.

1. Route recognition — the tool matches the URL against the same patterns YouTube uses: watch?v=, youtu.be/, /shorts/, /embed/, /live/, the legacy /v/ path, /playlist, /channel/, /user/, and @handle links, plus a bare 11-character video ID.
2. Parameter classification — every query parameter is sorted into two buckets. Semantic parameters change what plays: t= (start time), list= and index= (playlist position). Tracking parameters only tag the link's origin: si=, feature=, pp=, ab_channel=, and the utm_* family. The tracker bucket is always discarded; the semantic bucket is kept or stripped based on your toggle.
3. Reconstruction — the surviving parts are joined into a clean URL in your chosen format. The separator follows each format's own convention: & for watch URLs, ? for youtu.be and embed URLs. Embed output also translates the start time from t= to start=, because that is the parameter the embed player actually reads.

None of this touches the network. The tool deliberately performs no requests — not even the lightweight oEmbed probe other tools use. The pasted URL is parsed, split, and rebuilt entirely in your browser, so there is nothing to leak, log, or quota.

What counts as tracking

YouTube's share flow appends a small fingerprint of how the link was copied. The tool knows each one:

• si — share intent; tags the device and sharing source of the copy
• feature — which button or page produced the link (for example feature=share or feature=youtu.be)
• pp — player parameters from the mobile share sheet
• ab_channel — the channel of a related video attached on mobile
• utm_source / utm_medium / utm_campaign / utm_term / utm_content — Google Analytics campaign tags

All of them are safe to delete. They carry no playback meaning, and the tool reports each stripped name so you can see the verdict per parameter.

Use Cases

Beyond the obvious "clean this link before I send it," the parser fits into real workflows.

Content creators and everyday sharing

A link copied from the Share button carries si and feature tags from the moment you tap copy. Creators pasting their own video links into descriptions, pinned comments, and community posts get a clean URL instead of a device fingerprint — and toggling Strip playlist off for a single video keeps viewers from being pulled into a playlist context they did not ask for.

Developers and websites

Embedding video usually means hand-writing an iframe src. The parser produces the correct start= form automatically, which removes the classic t=-does-nothing-in-an-embed bug, and the Embed URL output drops straight into the snippet in Pro Tips. The same workflow scales to generated pages: feed a list of video IDs in, copy clean embed URLs out.

Data analysis and archiving

Journalists, researchers, and analysts working with link lists get two jobs done in one paste: the URL is split into structured components (ID, timestamp, playlist, channel) for logging, and the stripped-parameter list records exactly which trackers each link carried. Batch work is a series of pastes with no waiting — parsing is instant and local, so a hundred links take about as long as a hundred keystrokes.

Supported Link Formats

The input accepts every format YouTube itself produces. Each one yields a video ID — except the playlist and channel links, which are recognized as their own kind:

A bare 11-character video ID — dQw4w9WgXcQ — is accepted on its own, which is handy when you are pulling IDs out of an API response or a database export. A channel link yields the handle or channel ID as the channel component without resolving it further; see What It Doesn't Do for why.

Usage

The tool parses as you type — there is no button to press:

1. Paste a YouTube link — anything from the formats above, or type a bare video ID.
2. Read the result panel — the video ID, link kind, start time, playlist, and channel appear as you type, updated on every keystroke.
3. Choose the output format — the radio group switches the generated link between Watch URL, Short link, and Embed URL.
4. Set the toggles — Keep start time preserves the t= or start= parameter; Strip playlist drops list= and index=.
5. Copy the result — the generated link appears in the output field, ready to copy.

The result panel also lists which tracking parameters were stripped, so the cleanup is auditable: you see si and feature removed, not just a shorter URL.

Options explained

Tutorial

Walk one messy link from Share button to clean URL.

Step 1 — Get a messy link. Open any video in the YouTube app, tap Share, and copy the link. It will look something like https://youtu.be/dQw4w9WgXcQ?si=3Fb2kF9mXzL1c5Qd&feature=share. Two tracking parameters are already glued on.

Step 2 — Paste it. Click the input and paste (Ctrl+V or Cmd+V). The result panel fills in immediately: video ID dQw4w9WgXcQ, kind short, and the stripped-parameter list shows si, feature.

Step 3 — Copy the clean watch link. Switch the format radio to Watch URL. The output now reads https://www.youtube.com/watch?v=dQw4w9WgXcQ — the same video, no fingerprint.

Step 4 — Try a link with a timecode. Paste https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=1h2m3s&list=PL123…&index=2. The panel shows the start time converted to 3723 seconds (1:02:03), and the playlist appears as a link to the playlist itself.

Step 5 — Decide what the recipient should see. Toggle Strip playlist on and the output drops list= and index=, so the recipient lands on the single video instead of being pulled into the playlist. Toggle Keep start time off and the link starts at the beginning.

Step 6 — Switch to embed. Set the format to Embed URL. The output becomes https://www.youtube.com/embed/dQw4w9WgXcQ?start=3723 — note the start= parameter, because the embed player ignores t=. This is the src you want for an iframe; pair it with the snippet in Pro Tips.

Start Time & Timestamps

The parser accepts all three ways YouTube writes a start time, and converts between them:

The result panel always shows the canonical form — the number of seconds plus a human h:mm:ss reading — so 1h2m3s and 3723 both render as 3723 s (1:02:03).

The one rule to remember is the embed exception. A watch URL and a short link both read the start time from t=, but the embed player reads start= instead. The tool translates automatically: paste ?t=90 and switch to Embed URL and you get ?start=90, not a silently broken timecode. This is the classic gotcha when someone hand-builds an embed link that ignores the t= parameter — the parser gets it right every time.

Output Format Guide

The three output formats point at the same video; they differ in where they fit:

Pick the format by where the link will live. A tweet or a message earns the short link; an article or knowledge base reads better with the full watch URL; a page that renders video needs the embed URL. Because the parser converts freely, you never have to remember which parameter each one takes — paste once, switch, copy.

Pro Tips

• Strip the playlist before sending. A link with list= in it silently drags the recipient into a playlist context. If you mean one video, strip it — the parser makes that a single toggle.
• Clean every share link you copy. The Share button's si and feature tags identify how a link was copied and from which device. Running the paste through the parser is a two-second habit that removes them every time.
• Build embed URLs for iframes. Switch to Embed URL and you get the correct start= form for free. Pair it with the privacy-friendly youtube-nocookie.com domain:

  <iframe
    src="https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ?start=90"
    width="100%"
    height="100%"
    frameborder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowfullscreen
    loading="lazy"
  ></iframe>
  

• Paste a bare ID. Working from an API response or a spreadsheet of IDs? Type the 11 characters on their own and the parser treats them as a full link, format conversion included.
• Use the stripped-parameter list as an audit. The panel tells you exactly which trackers each link carried — useful when you are curating a link archive and want to confirm nothing leaked into the saved URLs.

Alternatives

How do people usually clean a YouTube link? The table fills out the options:

The Share button is the source of the noise rather than a cure. Manual deletion works but is error-prone — t= versus start= alone trips up most hand edits. Third-party shorteners replace tracking with their own redirect and upload the URL to their server. This tool is the only row with zero upload, and it surfaces what it removed instead of silently rewriting.

Against the Official APIs

The parser's zero-request design is a deliberate trade-off, and the other side of the trade is worth naming. The two public YouTube surfaces that do answer questions about a video are oEmbed and the Data API — and the table shows where each of the three paths wins:

oEmbed answers what is this video called, in one keyless request; the Data API answers everything, at the price of a key and a quota; this tool answers what is in this link, with no request at all. The three do not compete — parsing is a browser job, metadata is a network job. If a workflow needs both, run the parser for the URL and call oEmbed for the title: each one does its own job without the other's cost.

What It Doesn't Do

Honesty about the limits is part of what makes a parser trustworthy.

• It does not resolve a handle to a channel ID. @handle stays a handle. Resolution needs the official Data API, which this tool deliberately never calls.
• It does not verify the video exists. A valid 11-character ID parses cleanly whether the video is live, removed, or never existed. Checking existence would require a network call.
• It does not show titles, view counts, or channel names. Those come from the Data API or oEmbed — both network calls. The tool's zero-request design trades enrichment for privacy.
• It does not fetch or download anything. No thumbnail requests, no player loading, no analytics beacons. Parsing is pure local string work.

Everything that makes the parser useful — splitting, cleaning, converting — is local. Everything that needs the network is a separate service, and the trade-off is documented here rather than hidden.

Troubleshooting

Privacy & Data Handling

The parser follows the strictest privacy model of the Toollect tools: it makes no network requests at all.

• Nothing is uploaded. The URL is parsed in your browser. No request containing it is ever sent — not to a server, not to YouTube's oEmbed endpoint, not to an analytics beacon.
• No account, no tracking. There is no login, no analytics, and no history of the links you paste.
• Nothing is stored. The tool keeps no state between visits; close the tab and the pasted link is gone.
• No third-party scripts. Unlike tools that load player or share APIs, this page runs entirely on its own code.

If privacy is why you are here: this is the page where you can paste the link you would not paste anywhere else.

Technical Specs

Details:

• Input formats: watch, youtu.be, Shorts, embed, live, legacy /v/ path, bare 11-character ID, playlist, channel (@handle, /channel/, /user/)
• Tracking parameters removed: si, feature, pp, ab_channel, utm_source, utm_medium, utm_campaign, utm_term, utm_content
• Semantic parameters kept by default: t= (start time), list= and index= (playlist); both optional via toggles
• Output formats: watch URL (&-joined), short link (?-joined), embed URL (start=-joined, translated from t=)
• Timestamp parsing: plain seconds, Ns suffix, and h m s clock notation, normalized to seconds plus h:mm:ss
• Processing: 100% client-side JavaScript with zero network requests, no API key, no server
• Browser support: all modern browsers with URLSearchParams (Chrome, Edge, Firefox, Safari)

Features

• Parses watch, Shorts, embed, live, youtu.be, channel, and playlist links into video ID, timestamp, playlist, and channel components
• Removes tracking parameters such as si, feature, pp, ab_channel, and utm_* while showing exactly what was stripped
• Converts YouTube timestamps between seconds, h:m:s, and t= parameter formats
• Generates watch URLs, short youtu.be links, or embed URLs from any parsed link
• Keeps or strips the start time and playlist parameters as you choose
• 100% client-side processing with zero network requests, no API key required

Frequently Asked Questions