Twitch Download 2026: 12 Steps to Save a VOD, 20 Min

You searched for a thing that does not exist, and the internet is about to sell it to you anyway. Let us fix both problems.

There Is No 'Twitch Download' App (And There Never Was)

Type twitch download into any search box and the results will lie to you with a straight face. You will be shown app-store listings, glossy landing pages, and a dozen official-looking websites all implying that somewhere out there sits a tidy piece of Twitch-branded software whose one job is to pull streams onto your hard drive. It does not exist. It has never existed. Amazon has owned Twitch since August 2014 — a $970 million acquisition — and in the decade-plus since, it has shipped exactly zero consumer download tools for the people who merely watch.

What Twitch actually ships are viewer-and-chat clients: a free mobile app on iOS and Android, a free desktop app for Windows 10/11 and macOS at twitch.tv/downloads, and smart-TV builds. Not one of them has a 'save this video' button for content you did not broadcast yourself. The single native download path on the entire platform is buried in the Creator Dashboard and reserved for broadcasters saving their own past streams. If you want to keep anything else, you are on your own — which is precisely why this guide exists. If you just want the fast version, we keep a stripped-down 12-step VOD quickstart around; this is the long, opinionated one.

The search that sends you in circles

The reason the search results are so polluted is that 'twitch download' has two entirely different intents jammed into one phrase. Half the people mean where do I get the Twitch app; the other half mean how do I save a stream I watched. The SEO swamp that has grown over this ambiguity is thick with browser-based grabbers that ask you to paste a VOD URL like twitch.tv/videos/1234567890 and promise MP4 output from 160p to source. Guide sites such as AppsGolem's 2026 walkthrough catalogue these; the tools themselves are ad-choked, quality-capped, privacy-hostile, and frequently just a re-skin of the open-source project we will use instead. Paying more does not buy you out of this, either: a Tier 1 sub on the Twitch iOS app costs $7.99/month against $5.99 on desktop, and neither price includes a download button.

What Twitch actually gives you

Officially, viewers get exactly one save mechanism: the Clip, capped at 60 seconds. That is the whole toolbox. Broadcasters get slightly more — the Video Producer, covered below. Everything else is off-limits by design. This is not a small platform making a quiet omission; per Icon Era's 2026 statistics, Twitch pulled roughly 240 million monthly active users in 2025, held about 54% of live-streaming market share by hours watched in Q2 2025, and counts 37.2 million U.S. users in 2026 (up from 35.6 million in 2024). It did $1.8 billion in revenue in 2024 — an 8.1% decline year over year — and still declined to build the one feature its users keep googling for. The app has been installed over 100 million times. None of those installs can download a VOD.

Why this article exists anyway

Because the actual answer is boring, free, and excellent, and nobody optimizes a landing page for it. Three open-source, auditable tools cover every case: yt-dlp for VODs, clips, and live streams; TwitchDownloader for clips and — its killer feature — chat; and Streamlink for capturing a broadcast live before it ever becomes a VOD. No accounts, no upsells, no telemetry, no watermarks. The rest of this tutorial is how to wire them together properly, with the failure modes spelled out so you do not lose an afternoon to a muted audio track you could have predicted.

The 14-Day Deletion Clock (Your Real Deadline)

Here is the part the guide-mills bury: the reason to download a Twitch VOD is not convenience, it is survival. Twitch deletes past broadcasts on a timer. If you do not pull the file, the file ceases to exist, and no tool on earth recovers a stream Twitch has already garbage-collected. This is the single most important fact in the entire workflow, so internalize it before you install anything.

VODs, highlights, clips — what survives and what doesn't

Twitch keeps a channel's Past Broadcasts (the raw VODs) for roughly 14 days for most channels, extending to about 60 days for Partners and for Prime/Turbo subscribers. After that window they are gone — see Twitch's own Video On Demand help article for the current policy. Highlights and Clips, by contrast, persist until someone deletes them, because they count as curated content rather than transient broadcast. The practical upshot: a four-hour stream you loved is on a two-week fuse, while the 45-second clip somebody made of the best moment could outlive us all. Treat a fresh VOD the way a preservationist treats a decaying cartridge — the same instinct that drives people to dump SNES and Genesis carts before the EPROMs die. If it matters and it is ephemeral, you dump it now, not later.

Broadcaster vs viewer: who can save what

The permission model is simple and asymmetric. A broadcaster can download their own past broadcasts through the Creator Dashboard's Video Producer — one file at a time, no chat, no automation. A viewer can save nothing longer than a 60-second clip through any official channel. That gap is the entire market for third-party tooling. Nothing we do here breaks into Twitch's servers; yt-dlp and friends simply read the same public HLS playlist your browser reads when it plays the video, and write the segments to disk instead of to a video element.

The legal line you should know before you start

The Machine knows the law, so let us be precise instead of scary. Twitch's Terms of Service prohibit downloading content except as expressly permitted by the service, and the content itself is copyrighted — usually by the broadcaster, sometimes by whatever record label owns the track playing in the background. Downloading your own broadcasts is uncontroversial. Downloading someone else's stream for personal archival, commentary, or criticism lives in the messy neighborhood of fair use and platform ToS, and redistributing it is where you actually get letters. There is also a technical fingerprint of the copyright regime baked right into the files: Twitch runs audio-recognition on VODs and mutes any segment that trips it. When you download such a VOD, those segments arrive silent, because the audio was destroyed at the source. No downloader restores what Twitch already deleted. Plan accordingly, and archive responsibly.

Prerequisites: Software Versions and Disk Math

This is a command-line workflow at heart, with an optional GUI for the squeamish. The prerequisites are small, free, and cross-platform, but the disk requirements are not trivial for multi-hour VODs, so do the arithmetic before you start a 12-hour subathon download onto a nearly-full drive.

The three tools that actually work

• yt-dlp — the core tool. A maintained fork of youtube-dl that handles Twitch VODs (twitch.tv/videos/ID), clips, channel VOD lists, and live streams. Open-source, on GitHub at yt-dlp/yt-dlp. This is 90% of the job.
• TwitchDownloader — for clips and, crucially, chat. It downloads chat as JSON and renders it to a video overlay, which yt-dlp cannot do. Cross-platform CLI plus a Windows GUI, on GitHub at lay295/TwitchDownloader.
• Streamlink — for capturing a stream live, before deletion is even a question. Docs at streamlink.github.io.

Versions, runtimes, and the ffmpeg dependency

yt-dlp needs Python 3.9 or newer if you install it via pip; it has dropped support for older 3.x releases. Alternatively, grab the self-contained binary (yt-dlp.exe on Windows) and skip Python entirely. Every one of these tools wants ffmpeg on your PATH — yt-dlp uses it to remux Twitch's raw transport-stream fragments into a seekable MP4, and TwitchDownloader uses it to encode rendered chat. Install it from ffmpeg.org or your package manager. TwitchDownloader is a .NET application; recent releases ship as self-contained builds so you do not need a separate runtime. On OS support: yt-dlp and Streamlink run anywhere Python does (Windows, macOS, Linux, BSD); TwitchDownloader's GUI is Windows-only, but its CLI runs on all three desktop platforms. Because Twitch periodically changes its playback API, treat 'latest version' as a hard requirement — a yt-dlp build that is a few months stale will start throwing 403s the day Twitch ships a change.

How much disk a VOD actually eats

Twitch's source encode for a 1080p60 stream sits around 6 Mbps. That single number tells you everything about storage. Do the math before you commit:

# Disk footprint of a source-quality (~6 Mbps) 1080p60 VOD
#
#   bytes  =  bitrate(bits/s) / 8  *  duration(seconds)
#
#   1 hour :  6,000,000 / 8 * 3600      ~=  2.7 GB
#   4 hours:  2.7 GB * 4               ~= 10.8 GB
#  12 hours:  2.7 GB * 12              ~= 32.4 GB
#
# Rule of thumb: budget ~2.5-3 GB per hour of 1080p60 source.

CPU and RAM are almost irrelevant for the download itself — remuxing to MP4 is a stream copy, not a re-encode, so it barely touches the processor. The exception is chat rendering in TwitchDownloader, which is genuinely CPU-heavy and can take longer than the video download. Disk is the real constraint. A fast SSD helps with the thousands of tiny fragment writes; a nearly-full spinning drive will make you regret starting.

The Official Route: Video Producer (Broadcasters Only)

Before we leave Twitch's own tooling entirely, credit where due: if the stream is yours, you do not need any of the third-party tools for the basic case. Twitch will hand you the MP4 directly. It is limited, it is one-at-a-time, and it has no idea your chat exists, but it is official and it works.

Where the download button lives

Sign in as the broadcaster and navigate to dashboard.twitch.tv → Content → Video Producer. Find the past broadcast you want, open its three-dot menu, and choose Download. Twitch stitches the segments server-side and streams you a single MP4. This path has been unchanged through Q2 2026. That is the entire feature — there are no options, no quality picker, no batch mode, and no chat.

What you get and what you don't

You get one MP4 of one broadcast at whatever source quality you streamed. You do not get: anyone else's content, your Clips or Highlights in bulk, the chat log, embedded metadata beyond the basics, or any way to script the thing. And you inherit every muted segment exactly as it appears on the VOD page, because the mute happened to the master, not to your download.

Why even broadcasters outgrow it

Two reasons, mostly. First, the browser download of a multi-hour VOD is fragile — a dropped connection at hour three means starting over, whereas yt-dlp resumes and retries fragments automatically. Second, serious archivists want the chat, consistent filenames, per-date folders, and a download archive so they never pull the same VOD twice. The moment you want any of that, you are back to the command line — which, conveniently, is the same command line a viewer uses. So let us install it.

Installing yt-dlp and ffmpeg

Pick your platform. In every case the goal is the same: yt-dlp and ffmpeg both reachable from your terminal. Verify at the end before moving on; half the 'it doesn't work' reports are just ffmpeg missing from PATH.

Windows

The package managers make this painless. In PowerShell or Windows Terminal:

:: Windows 10/11 - via winget
winget install yt-dlp.yt-dlp
winget install Gyan.FFmpeg

:: or via Scoop
scoop install yt-dlp ffmpeg

If you prefer no package manager at all, download yt-dlp.exe from the GitHub Releases page, drop it in a folder on your PATH, and grab a static ffmpeg build. The self-contained exe needs no Python.

macOS

Homebrew handles both in one line:

# macOS - Homebrew
brew install yt-dlp ffmpeg

Linux

Your distro almost certainly packages yt-dlp, but distro packages lag badly and a stale extractor is exactly what breaks on Twitch. Prefer pipx (or the binary) so you can self-update:

# Linux - keep yt-dlp current with pipx; distro builds lag
pipx install yt-dlp
sudo apt install ffmpeg        # Debian / Ubuntu

# Verify both are reachable
yt-dlp --version
ffmpeg -version | head -n1

Expected output confirms you are ready. yt-dlp uses date-based version strings:

$ yt-dlp --version
2026.MM.DD      # date-based; if this looks old, run:  yt-dlp -U

$ ffmpeg -version | head -n1
ffmpeg version 7.x  Copyright (c) 2000-2026 the FFmpeg developers

Download a VOD in 12 Steps

This is the spine of the whole tutorial: a repeatable, twelve-step path from a URL to a verified, archived MP4 that no longer lives on Twitch's deletion timer. Each step has a reason attached, because a step you do not understand is a step you will skip at the worst possible moment.

1. Confirm the VOD still exists. Open the URL in a browser. If it 404s, you are past the 14-to-60-day retention window and there is nothing to download — the file is gone. Rationale: everything downstream assumes the source is live.
2. Copy the canonical VOD URL in the form twitch.tv/videos/1234567890. Rationale: yt-dlp keys off that numeric ID; clip and channel URLs take different code paths.
3. Update yt-dlp first with yt-dlp -U (binary) or python -m pip install -U yt-dlp. Rationale: Twitch changes its playback API without warning; a stale extractor returns HTTP 403 and you will waste an hour blaming your network.
4. List the available formats with -F. Rationale: you need to see whether the transcodes (720p, 1080p) still exist or whether only chunked source survived — non-partner transcodes expire.
5. Choose a format id. Use chunked for true source quality. Rationale: source is the only guaranteed track and the only one that is never re-compressed; pick a transcode only if you deliberately want a smaller file.
6. Set an output template with -o. Rationale: sane, collision-proof filenames with the ID embedded save you from a folder full of 'video.mp4' and let a download archive dedupe correctly.
7. Run the download with concurrent fragments (--concurrent-fragments 8). Rationale: a Twitch VOD is thousands of tiny .ts fragments fetched serially by default; parallelizing them turns hours into minutes.
8. Watch the progress line. Confirm it reports the format you asked for and a plausible total size. Rationale: catching 'Downloading 1 format(s): 480p' now beats discovering it after 30 GB.
9. Let ffmpeg remux to MP4. yt-dlp does this automatically when merge output is MP4. Rationale: raw .ts is not reliably seekable; an MP4 container scrubs cleanly in every player, with zero re-encode and zero quality loss.
10. Verify integrity with ffprobe or by scrubbing the file. Rationale: confirms the duration matches, no fragments dropped, and reveals any muted segments up front.
11. Record the ID in a download archive (--download-archive). Rationale: makes re-runs idempotent, so batch jobs never re-pull what you already have.
12. Store it off Twitch's clock. Copy the file to a second drive or NAS. Rationale: the entire point was preservation; a single copy on the drive you download to is not an archive, it is a liability.

Inspecting formats before you commit (steps 3-5)

After updating, list what is actually on offer. Twitch format ids are self-describing, and chunked is always the source:

$ yt-dlp -F https://www.twitch.tv/videos/1234567890
[twitch:vod] 1234567890: Downloading stream metadata
[info] Available formats for 1234567890:
ID          EXT  RESOLUTION  FPS  │ PROTO  │ VCODEC  ACODEC
────────────────────────────────────────────────
audio_only  mp4  audio only       │ m3u8   │ audio   mp4a
160p        mp4  284x160     30   │ m3u8   │ avc1    mp4a
360p        mp4  640x360     30   │ m3u8   │ avc1    mp4a
480p        mp4  852x480     30   │ m3u8   │ avc1    mp4a
720p60      mp4  1280x720    60   │ m3u8   │ avc1    mp4a
1080p60     mp4  1920x1080   60   │ m3u8   │ avc1    mp4a
chunked     mp4  1920x1080   60   │ m3u8   │ avc1    mp4a   (source)

If this list shows only chunked and audio_only, the transcodes have expired — normal for older VODs from non-Partner channels. Pick chunked and move on; it is the best quality regardless.

The download command that works (steps 6-8)

One command does steps 6 through 9. The output template sorts by uploader and embeds the ID; the concurrent fragments keep it fast:

$ yt-dlp -f chunked --concurrent-fragments 8 \
    -o '%(uploader)s - %(title)s [%(id)s].%(ext)s' \
    https://www.twitch.tv/videos/1234567890
[twitch:vod] Extracting URL: https://www.twitch.tv/videos/1234567890
[twitch:vod] 1234567890: Downloading stream metadata
[info] 1234567890: Downloading 1 format(s): chunked
[hlsnative] Total fragments: 1442
[download] Destination: SomeStreamer - 12 Hour Subathon .mp4
[download]  37.4% of ~10.63GiB at 22.15MiB/s ETA 05:12 (frag 540/1442)

That Downloading 1 format(s): chunked line is your checkpoint — it proves you are pulling source and not silently falling back to 480p.

Verifying and archiving what you pulled (steps 9-12)

When it finishes, confirm the artifact is whole before you trust it. ffprobe reads the container in a second:

$ ffprobe -hide_banner 'SomeStreamer - 12 Hour Subathon .mp4'
Duration: 11:58:42.19, start: 0.000000, bitrate: 6021 kb/s
  Stream #0:0: Video: h264 (High), yuv420p, 1920x1080, 60 fps
  Stream #0:1: Audio: aac (LC), 44100 Hz, stereo, 128 kb/s

Duration matches the stream length, bitrate sits at the expected ~6 Mbps, and you have both a video and an audio stream. Now add --download-archive ~/twitch/archive.txt to your command going forward so this ID is logged, and copy the finished file somewhere that is not the same physical disk. That is the full loop, and it is worth roughly 20 minutes for a typical VOD once the download itself finishes.

Clips and Chat with TwitchDownloader

yt-dlp handles clips too, but the moment you care about chat — and for archival purposes you should, because the chat is half the artifact — you want TwitchDownloader. It is the only tool here that downloads a chat log and renders it back into a watchable video overlay.

Grabbing a clip

Clips are addressed by a word-slug, not a numeric ID — that is the one gotcha that trips people coming from VOD downloads. The CLI verb is clipdownload:

# VOD (numeric id or full URL both work)
TwitchDownloaderCLI videodownload --id 1234567890 -q 1080p60 -o vod.mp4

# Clip (note: clip ids are word-slugs, not numbers)
TwitchDownloaderCLI clipdownload --id CleanHelplessWalrusKappaPride -q source -o clip.mp4

Because a Twitch clip maxes out at 60 seconds at creation, there is nothing to trim and the download is near-instant. If a clip predates a VOD's deletion, the clip still survives — another reason clips are the durable currency of the platform.

Downloading and rendering chat

This is the feature nothing else replicates. Download the chat as JSON with emotes and badges embedded, then render it to an MP4 you can composite alongside the video:

# 1) Pull chat to JSON, -E embeds emotes/badges so it renders offline
TwitchDownloaderCLI chatdownload --id 1234567890 -E -o chat.json

# 2) Render that JSON to a transparent-friendly video (needs ffmpeg)
TwitchDownloaderCLI chatrender -i chat.json -h 1080 -w 340 --framerate 60 -o chat.mp4

Chat rendering is the CPU-heavy step flagged in the prerequisites; a long stream's chat can take longer to render than the video took to download. Budget for it.

The GUI vs the CLI

On Windows, TwitchDownloader ships a WPF GUI that wraps all of this in windows and buttons — ideal if the command line makes you nervous, and it previews chat rendering live. The CLI is what you want for batch jobs, headless servers, and macOS/Linux, and it is the same engine underneath. Pick the GUI to learn the tool and the CLI to scale it. Either way, the chat JSON it produces is a genuine preservation format: even if you never render it, you have kept the conversation.

Capturing a Live Stream with Streamlink

Sometimes waiting for the VOD is not an option. Some streamers disable VODs entirely; some content gets muted or DMCA-struck within hours; and the source audio you can only ever capture before Twitch's recognition engine mutes it. For all of those, you capture the broadcast live with Streamlink.

Why you can't always wait for the VOD

A live capture sidesteps the entire deletion clock — you are recording the stream as it airs, so retention policy never enters into it. It is also the only way to guarantee the unmuted audio, since the mute is applied to the VOD after the fact. The trade-off is that you have to be present (or scripted) at broadcast time, and a dropped connection loses the gap. Latency is not your friend here, and if you have ever tuned a low-latency remote link — the way we did in the PS Remote Play 1080p walkthrough — you already know that 'live' always means 'live plus a few seconds of buffer'. Streamlink writes that buffer straight to disk.

The basic capture command

Point Streamlink at the channel, ask for best, and give it an output file. The .ts container is the safe choice for a live recording because it tolerates an abrupt end:

# Record a live stream to disk at best available quality
streamlink --twitch-disable-ads https://twitch.tv/somestreamer best -o 'somestreamer.ts'

# Or just watch it in mpv/VLC without saving anything
streamlink https://twitch.tv/somestreamer best

Ads, auth, and sub-only streams

Streamlink's Twitch plugin has options for mid-roll ad segments (such as --twitch-disable-ads) and for authenticating to sub-only streams by passing your login token as a header. Because these flags change between releases, check the current plugin docs rather than trusting a flag copied off some blog:

# Authenticated capture - token comes from your logged-in browser session
streamlink --twitch-api-header 'Authorization=OAuth <your-token>' \
    https://twitch.tv/somestreamer best -o 'somestreamer.ts'

Once the stream ends, remux the .ts to MP4 with ffmpeg exactly as yt-dlp would (ffmpeg -i somestreamer.ts -c copy somestreamer.mp4) and you have a seekable archive with no quality loss.

Five Pitfalls That Waste Your Afternoon

Every one of these has burned somebody. Read them now so they do not burn you at hour three of a download.

Quality, formats, and the muted-audio trap

Pitfall 1 - grabbing a transcode instead of source. If you let yt-dlp pick a default, you may end up with 720p when 1080p60 was available, or worse, discover the transcodes expired and you got 480p. Fix: always run -F first and explicitly request chunked. Pitfall 2 - the muted-audio trap. You download a VOD and stretches of it are silent. This is not a bug in the tool; Twitch muted those segments at the source over copyrighted audio, and the silence is baked into the master. Fix: there is none after the fact — the only prevention is a live capture with Streamlink before the mute is applied.

Auth, sub-only, and deleted VODs

Pitfall 3 - waiting past the deletion clock. The most common failure of all: you bookmark a VOD to grab 'later' and later is day 15. Fix: download the day you decide it matters, or automate a channel sweep (see Advanced). Pitfall 4 - sub-only content returns a login error. Subscriber-only VODs will refuse to download anonymously. Fix: pass your browser's cookies with --cookies-from-browser firefox (or chrome, edge, etc.) so yt-dlp authenticates as you.

Storage, filenames, and sketchy sites

Pitfall 5 - trusting a random download website. Those paste-a-URL sites cap quality, inject ads, harvest data, and occasionally serve malware, all to do worse what yt-dlp does for free. Fix: use the open-source tools; they are auditable and there is no server in the middle holding your clipboard. A close cousin is filename and disk failure — Windows chokes on long titles full of emoji, and a 32 GB subathon fills a drive you thought had room. Fix: add --windows-filenames --restrict-filenames and check free space against the ~2.7 GB/hour rule before you start. Housekeeping this boring is the same discipline as periodically clearing the PS5 cache — nobody enjoys it, everybody regrets skipping it.

Troubleshooting Table

When something breaks, read the actual error text — it almost always names the fix. Here are the failures you will actually hit, in rough order of frequency.

Read the error, not the vibes

The single most useful reflex: before you google the error, re-run with -v for verbose output. Nine times in ten the traceback tells you it is an expired format, a stale extractor, or a missing ffmpeg — not a mystery.

The table

Symptom	Likely cause	Fix
HTTP Error 403: Forbidden	Stale extractor after a Twitch API change	Update: yt-dlp -U (or pip -U); then retry
Requested format is not available	Transcode expired for a non-Partner VOD	Run -F, then request chunked or audio_only
Long silent gaps in the file	Twitch muted those segments at source (copyright)	Unrecoverable; capture live with Streamlink next time
This video is only available to subscribers	Sub-only VOD, no auth	--cookies-from-browser firefox
Download crawls or stalls near the end	Serial HLS fragments / flaky fragment	--concurrent-fragments 8 --retries 20 --fragment-retries 20
Filename too long / invalid (Windows)	Emoji or reserved characters in the title	--windows-filenames --restrict-filenames
.ts file won't scrub or seek	Raw transport stream, not a real container	--merge-output-format mp4, or ffmpeg -c copy remux
ERROR: ffmpeg not found	ffmpeg absent from PATH	Install ffmpeg, or point at it with --ffmpeg-location
Clip URL fails with a weird id error	Clip ids are slugs, not numbers	Use the full clips.twitch.tv/SLUG URL, or TwitchDownloader clipdownload
404 / video does not exist	VOD already deleted past retention	Nothing to do — you missed the 14-to-60-day window

When to just update the tool

If a workflow that worked last week suddenly 403s across every VOD, do not debug your network — Twitch shipped a change and your extractor is behind. yt-dlp -U resolves the large majority of sudden, total failures. The project's FAQ wiki is the authoritative reference for anything the table above does not cover, and it is kept current with Twitch's moving target.

Advanced: Batch, Cookies, and Automation

Once the single-VOD case is muscle memory, the interesting work is doing it at scale and on a schedule so you never lose a stream to the clock again.

Batch files and download archives

Feed yt-dlp a text file of URLs, one per line, and pair it with a download archive so re-runs skip anything already pulled. This is the backbone of any real archival setup:

# A plain text file of URLs, one per line
yt-dlp -a urls.txt --download-archive archive.txt

# Sweep a whole channel's available VODs (respects the archive)
yt-dlp --download-archive archive.txt https://www.twitch.tv/somestreamer/videos

Wire that into cron and you have a machine that beats the deletion clock for you:

# crontab -e : sweep a channel every 6 hours, well inside
# Twitch's ~14-day deletion window for past broadcasts
0 */6 * * *  /home/you/save-vod.sh https://www.twitch.tv/somestreamer/videos

Cookies and sub-only content

Beyond authenticating sub-only VODs, cookies let you reach anything your logged-in account can see. And when you only want a slice of a twelve-hour stream, --download-sections with keyframe-accurate cuts saves both time and disk:

# Grab just one segment of a long VOD, keyframe-accurate
yt-dlp --download-sections '*1:20:00-1:35:00' --force-keyframes-at-cuts \
    -o 'clip-%(id)s.%(ext)s' https://www.twitch.tv/videos/1234567890

# Sub-only VOD: borrow your browser's login cookies
yt-dlp --cookies-from-browser firefox https://www.twitch.tv/videos/1234567890

Cron, sections, and chat overlays

For a preservation-grade archive, combine the tools: yt-dlp for the video, TwitchDownloader for the chat JSON and render, then ffmpeg to composite the chat panel beside the video. It is the closest you will get to reconstructing the live experience — the stream and the room reacting to it, both saved. This is exactly the instinct that makes people archive a Nintendo Direct reaction stream the moment it airs: the announcement is on YouTube forever, but the chat losing its mind in real time is ephemeral, and ephemeral is what you rescue.

The Complete Working Setup

Here is the whole thing assembled: a persistent yt-dlp config so you never retype flags, and a wrapper script so archiving a VOD is a single command. Drop both in place and the twelve steps collapse into save-vod.sh <url>.

The yt-dlp config file

Save this as ~/.config/yt-dlp/config (on Windows, %APPDATA%\\yt-dlp\\config.txt). Every yt-dlp invocation now inherits these defaults:

# ~/.config/yt-dlp/config
# Windows: %APPDATA%\\yt-dlp\\config.txt

# Quality: source first, fall back to whatever survived
-f chunked/best
--merge-output-format mp4

# Speed + resilience on Twitch's fragmented HLS
--concurrent-fragments 8
--retries 20
--fragment-retries 20
--file-access-retries 10

# Sane, portable filenames sorted per channel and date
-o %(uploader)s/%(upload_date>%Y-%m-%d)s - %(title).150B [%(id)s].%(ext)s
--windows-filenames
--restrict-filenames

# Never re-download the same VOD twice
--download-archive ~/twitch/archive.txt

# Keep metadata, don't rewrite mtimes, clean single-line logs
--embed-metadata
--no-mtime
--newline

The wrapper script

Save this as save-vod.sh, make it executable with chmod +x save-vod.sh, and you have a one-word archiver that self-updates yt-dlp before every run:

#!/usr/bin/env bash
# save-vod.sh - archive a Twitch VOD/clip/channel URL and log the id.
set -euo pipefail

URL="${1:?usage: save-vod.sh <twitch-url> [quality]}"
QUALITY="${2:-chunked}"
DEST="${HOME}/twitch"

mkdir -p "$DEST"
cd "$DEST" || exit 1

yt-dlp -U >/dev/null 2>&1 || true      # keep the extractor current

yt-dlp \
    -f "${QUALITY}/best" \
    --concurrent-fragments 8 \
    --download-archive archive.txt \
    -o '%(uploader)s/%(upload_date>%Y-%m-%d)s - %(title).150B [%(id)s].%(ext)s' \
    "$URL"

echo "Saved under: $DEST"

Final sanity check

Run it once against a live VOD. You should see yt-dlp report Downloading 1 format(s): chunked, watch the fragment counter climb, and end with an MP4 under ~/twitch/CHANNEL/ named by date and title. ffprobe it, copy it to a second drive, and you are done — you now own a copy that outlives Twitch's fourteen days. The platform never built the download button its 240 million users keep searching for, but the tools that render it unnecessary are free, open, and better than anything Amazon would have shipped. That is the whole trick: stop looking for a 'Twitch Download' app, because the good answer was never an app at all.