If FFmpeg stops at the end of a “YouTube playlist file”, first identify what you passed to -i: one media file, a local concat-demuxer list, or a YouTube playlist URL. Those are different inputs, and -stream_loop -1 is for repeating a specified input; it does not download a YouTube playlist or make every playlist repeat.
For one local file that should play continuously, put -stream_loop -1 before that file’s -i. If you have a list of files or a YouTube playlist, follow the path for that format instead of adding an infinite loop option without checking what it applies to.
Identify the input that is ending
Look at the exact command that starts FFmpeg and find each -i. The text after it tells you what FFmpeg is reading. It may be a filename such as bhajan.mp4, a text file passed to the concat demuxer, or a URL. “Playlist” is often used informally for all three, but the correct fix depends on which one you have.
| What you pass to FFmpeg | What happens when it reaches the end | First diagnostic path |
|---|---|---|
| One local media file | That input is exhausted | Repeat that input with -stream_loop -1 before its -i |
| A concat-demuxer list | Listed entries are processed in sequence, then the finite list ends | Decide whether you need one pass or a repeating sequence |
| A YouTube playlist URL | Playlist extraction and downloading are not the same as looping a local file | Use a playlist-aware download workflow, then inspect its outputs |
| A list being edited while FFmpeg runs | Whether new lines will be detected depends on the format and workflow | Test the exact command; do not assume a loop option rereads it |
A second useful distinction is what you mean by “keep it going”. You might want the same file to start over, the same set of local files to run again in order, a YouTube playlist’s entries to be downloaded, or new entries to be noticed after launch. Repeating existing media and discovering later additions are separate requirements.
If the input type is unclear, make a copy of the command and substitute a short local test file or a small test list. Do not change a working live command just because it contains the word “playlist”. Note the input format, FFmpeg version and the precise point at which it stops. That information makes it easier to distinguish normal end-of-input behaviour from a decode error or a problem with the YouTube connection.
Repeat one media input with the right option placement
When the input is one local file and you want it to repeat, FFmpeg’s documented option is -stream_loop -1. The -1 value requests infinite looping. Crucially, -stream_loop is an input option, so put it before the -i belonging to that input:
ffmpeg -stream_loop -1 -i input.mp4 -c:v copy -c:a copy output.ts
This illustrates placement, not a universal output recipe. The output format, codecs, destination and stream settings depend on your use. The important part for this diagnosis is that the loop option precedes the corresponding -i. If there is more than one input, take care not to assume an option before one -i affects every other input in the command.
An input option placed after -i may be interpreted in the wrong position, or apply differently than you intend. If the command still ends, check its ordering against the input it should repeat. Also verify that you are launching the edited command, rather than a saved script, service or scheduled task that still contains the old one. A small test on the same file can reveal a placement mistake without waiting for a live broadcast to end.
Repeating one input does not fix every kind of end-of-stream. The file must be readable, and FFmpeg must be able to decode or copy the streams as requested. If it exits with an error before reaching the end, investigate that error first. Looping a corrupt or inaccessible file does not repair it; it can simply make the same failure recur.
For a single file intended to be the entire source, compare the resulting command with the bitrate settings for a podcast with a still image. That article addresses a different part of the pipeline: output settings do not determine whether FFmpeg repeats its input, but they matter when you are preparing a stable YouTube feed.
Understand why a finite concat list ends
A concat-demuxer list is a set of inputs to process in sequence. FFmpeg reads the entries and, after the last one, has no more items to process. That is normal for a finite list, not evidence that the last file must be broken. The FFmpeg formats documentation describes the concat demuxer and its list-based input format.
Check which concat approach your command actually uses. The concat demuxer reads a list file; other ways of joining or concatenating media have different requirements. Do not assume that a text file with filenames is itself a repeat instruction. It describes what to process, and a list with a final entry has a final end unless your workflow deliberately supplies another pass.
If you only need to process the listed files once, reaching the end is the intended result. If you need the same finite order repeatedly, you need a tested workflow that repeats the sequence as a whole. The single-input loop example above demonstrates repeating an input; it does not establish that every concat list will be re-read or replayed correctly in every command. Check the exact FFmpeg version, list syntax and media properties before adopting a list-specific method.
Compatibility can matter when entries are joined. Compare their streams and containers: for example, whether each file has the expected video and audio streams, and whether their encoding properties are suitable for the way you are concatenating them. A list can run through all its entries yet produce unexpected transitions or errors if the media are not compatible with that workflow. Read the first error line and identify the entry around which it appears before changing loop behaviour.
A useful test is to run a short copy of the list once and confirm the order and transitions. Then separately test the repeat behaviour you intend to use. Keep those tests distinct: one checks that the sequence works; the other checks that it starts again. For a broader always-on setup, the practical considerations in scheduling a YouTube livestream from a VPS playlist can help you think through what is responsible for maintaining the sequence and restarting the process.
Distinguish sequencing from downloading a YouTube playlist
A YouTube playlist URL is not a local playlist file in FFmpeg’s concat-demuxer sense. If your goal is to obtain the entries from a YouTube playlist, use a playlist-aware downloader workflow. The yt-dlp project documentation covers playlist handling and options such as --concat-playlist; check its current usage for your version and intended output.
There is another distinction when downloading. A site may deliver video and audio as separate formats, and yt-dlp’s FAQ explains that FFmpeg can be used to merge separate audio and video downloads. That is a download and media-preparation step, not a command to keep a YouTube live broadcast running forever. See the yt-dlp FAQ for the current explanation of that dependency.
A sensible workflow is to handle playlist extraction and downloading first, confirm what files were produced and in which order, then decide how to play those local results. If you want to broadcast a finished sequence, prepare and test it as a local media workflow. Do not expect -stream_loop -1 to discover playlist entries online, fetch them, or merge formats: its documented role is looping the input to which it is applied.
If you are trying to stream a YouTube playlist as it changes, state that requirement explicitly. Downloading the entries available now and repeating a local output is not the same as detecting new uploads or edits later. The details of the source, downloader settings and update behaviour matter; there is no format-independent promise that an FFmpeg loop will monitor a changing online playlist.
Check process output and exit status
When FFmpeg stops, capture the command, the final part of its output and its exit status. A process that reaches end-of-file normally is different from one that exits after a decode, input or output error. The last useful message may identify the file or stream involved. Do not diagnose every stop as a loop-option issue before checking what FFmpeg reported.
Run the command in a terminal during a controlled test so you can see the output. If a script launches it, arrange for the script to record the command and exit status too. A wrapper can hide whether FFmpeg finished normally, failed, or was stopped externally. On a long-running machine, check whether a scheduler, service manager, terminal session or operating-system shutdown is ending the process.
Confirm the input path is the one you expect and remains available. Check for spelling, permissions and removable or network storage that may disappear. For a concat list, verify each referenced path and the list syntax. For a URL workflow, separate downloader output from FFmpeg output so you can see which stage ended.
Also check output-side failures. A full destination disk, an unavailable output path or a broken connection to the streaming destination can stop a process even when the input still has content. Keep the evidence from one run before changing several command options at once. Changing one thing at a time makes it possible to tell whether the fix was input looping, correcting the list, or resolving an unrelated error.
Test a restart or repeat before a long stream
Do not use the first overnight broadcast as your loop test. Make a short, representative test with the same input type and command structure. For one file, observe it pass its end and begin again. For a finite list, check that the entries play in order and that your chosen repeat workflow starts the sequence again as intended. For a YouTube playlist download, inspect the downloaded files before involving a live event.
Watch for a clean transition at the boundary. A repeated file may have a pause, a visible jump or an audio discontinuity at its end; the loop option repeats input, but it does not edit the source to make the join seamless. If continuity matters, review the end and beginning of the media itself and prepare a better transition rather than assuming a loop flag will remove it.
Test failure and recovery separately from normal repetition. Stop the process deliberately during a private test and verify that your launcher behaves as expected. A loop option only describes what FFmpeg does with its input; it does not by itself restart FFmpeg after a process failure or restore a disconnected YouTube event. If you are using a computer-based setup, preventing OBS from stopping after an update covers a related operational problem: the source can be fine while the software running the broadcast needs attention.
Keep a copy of the known-good command and note which input it applies to. If you change the media, list format, FFmpeg version or output destination, repeat the relevant test. A test on a single MP4 is not proof that a concat list or a YouTube download workflow behaves the same way.
Monitor the live event after launch
Once the broadcast is running, verify both sides of the path: FFmpeg is still producing output, and YouTube is receiving the live event. Check the event in YouTube Studio and watch for a change from healthy playback to a stalled or ended stream. Keep the terminal or process log available so a YouTube-side interruption is not confused with FFmpeg reaching the end of its input.
When the stream drops, record the time and compare it with the process output. If FFmpeg is still running but the event is no longer receiving video, investigate the connection and stream configuration. If FFmpeg exited at the same time, inspect its last messages and exit status. This is more useful than repeatedly changing loop options when the failure is actually a network or output problem. The YouTube Live unstable connection guide is relevant when the local process continues but the feed is unreliable.
A local repeat and a continuous live event are separate layers. Your input can loop correctly while the broadcast connection fails; conversely, YouTube can receive a stable feed until a finite input reaches its end. Make a simple monitoring plan that tells you who will notice an ended process and what evidence they should collect before restarting it. If your source list is meant to change during the event, check how that update is made and test whether the running workflow sees it rather than assuming it will.
For a workflow whose main burden is keeping a prepared video on air while your own computer is off, StreamNeo removes the repeated need to leave a local FFmpeg process running on that machine: you upload the video and provide the YouTube stream key, while the broadcast is monitored and restarted if it drops. It is a YouTube-only service, so it does not replace a downloader workflow for extracting a playlist or solve the question of detecting newly added entries in a changing list.
Before committing, compare the operating options on the pricing page. When the file and channel are ready, start free — 24-hour trial, no card.
FAQ
Does -stream_loop -1 make any playlist repeat forever?
No. It requests infinite looping for the input it applies to, and it belongs before the relevant -i. A finite concat list and a YouTube playlist URL are different workflows; diagnose their formats rather than treating them as one file.
Why does FFmpeg stop after the last item in my concat list?
A concat-demuxer list is finite, so reaching its final entry is expected when processing it once. If you need the sequence to repeat, test a workflow that repeats the whole list with your exact list format and FFmpeg version.
Will FFmpeg notice a new line added to a playlist file while it is running?
Do not assume so. The documented input-loop option does not establish that a running process will reread a changing list; the answer depends on the format and command. Test the exact setup and specify whether you need existing entries repeated or new ones discovered.
How do I process a YouTube playlist rather than repeat a local file?
Use a playlist-aware downloader such as yt-dlp to handle playlist extraction and downloads, then inspect the resulting files. FFmpeg may be used to merge separate audio and video formats, but that is distinct from looping a local input for a live stream.