To stream an FFmpeg playlist to YouTube with a looping background video, treat it as a pipeline: read playlist items in sequence, loop a separate background input, choose the video and audio to send, encode the output, then connect to YouTube’s current ingest details. The right command depends on your files, audio layout, FFmpeg build and channel configuration, so use the examples as patterns to adapt and test rather than as a universal recipe.
A text file of media paths is one kind of playlist; an online playlist, folder scan or live feed needs a different input setup. The examples below assume the text-file case and distinguish a background video from the programme video. If your goal is simply to repeat prepared videos without composing them locally, the decisions are different from building an FFmpeg filtergraph.
How sequencing and background looping fit together
There are separate jobs here. FFmpeg’s concat demuxer reads a list of files and processes them consecutively. An input loop repeats one input. Combining two video streams, such as placing playlist footage over a background, is a composition step. Encoding and YouTube ingest happen after those choices. Keeping the jobs separate makes it easier to identify which part needs changing when the result is wrong.
For example, a devotional channel might play a set of recorded performances in order while a slowly moving temple image loops behind them. The concat input determines which performance comes next; the loop option applies to the background file; a filter determines whether the background is visible at all. If you only want the performances in sequence, no background loop or overlay is needed. If the background should fill the screen between programme clips, that calls for a different composition than placing it behind the clips.
This is a local FFmpeg workflow: the process must keep running on the machine or host where it is launched, and that host must have access to the media and network connection. For broader decisions about a continuous file-based broadcast, see how real-estate tour videos can become a continuous YouTube stream. Do not assume that switching from a local process to another workflow preserves the same controls or failure modes.
Prepare a concat playlist
The concat demuxer takes a text file whose entries identify the media files in the order FFmpeg should read them. A simple file named playlist.txt might contain:
file '/media/show/intro.mp4'
file '/media/show/episode-01.mp4'
file '/media/show/episode-02.mp4'
Then a basic input begins like this:
ffmpeg -f concat -safe 0 -i playlist.txt ...
This is only the playlist input, not a complete streaming command. -f concat selects the concat demuxer. The safety option shown is sometimes used when paths are outside the demuxer’s restricted form; do not add it reflexively without understanding where the playlist and files reside. Use paths that the FFmpeg process can actually read. Relative paths are resolved in relation to the execution context, which may not be the directory you expected if the command is started by a service or scheduled task.
FFmpeg documents compatibility constraints for concat demuxer inputs: the files should have the same streams, codecs and time bases. In practice, joining files that differ in resolution, frame rate, codec, audio channels or stream layout can create errors or timestamp discontinuities. The demuxer may rely on file duration information; inaccurate or estimated durations can lead to gaps or unwanted timing behaviour around transitions. Check each file’s streams and duration before blaming YouTube for a glitch. If transitions misbehave, normalise the playlist items to a consistent format or use a different assembly approach suited to the source material.
A text file is not interchangeable with every thing people call a playlist. A folder of files needs to be enumerated into a deliberate order; a web playlist may need downloading or another input mechanism; a feed that changes during the broadcast needs its own update logic. Decide whether order is alphabetical, editorial or time-based before generating the list. A useful preflight is to copy the playlist file, inspect every path, and test its entries locally before connecting to the live service.
If you want to maintain separate programmes or queue different lists, the list-building concern is related to running two YouTube livestreams with different playlists, but do not assume that article’s setup is the same as this composition task.
Loop the background input
Put the background in a separate input and apply the loop option immediately before its -i option. For instance, if playlist is input 0 and background video is input 1:
ffmpeg -f concat -safe 0 -i playlist.txt \
-stream_loop -1 -i background.mp4 \
...
FFmpeg defines -stream_loop -1 as repeating the input indefinitely. The placement matters: input options apply to the next input, so placing the loop option before the playlist instead would loop the playlist input, not the background. Input order also matters later: [0:v] refers to the first input’s video stream and [1:v] to the second input’s video stream, if those streams exist.
Looping a complete video input is not the same as looping a frame or a short sequence inside a filter. If you need a static image behind the playlist, use an image-input method with duration or image-loop behaviour appropriate to your FFmpeg build. A still image is not necessarily handled like an ordinary video file, and a short animated background may need a filter-based repetition if the desired timing differs from repeating the full media input. Check the documentation for the build you have installed rather than assuming all builds and input types behave identically.
Think about what happens at the loop boundary. A background file with an abrupt final frame can visibly jump when it starts again. A seamless-looking loop needs source material whose end and beginning suit one another, or a deliberate transition. If the programme footage covers the entire frame, the background may be invisible; in that case, looping it consumes effort without changing the picture. If it is intended as a border or backdrop, test at the final output dimensions to make sure it remains visible and does not crop important content.
Combine video and choose the audio
If you are only sequencing clips and want their video output, you may be able to map the playlist video directly. If you want to put playlist video over the background, or use a background while programme clips remain in a smaller window, a complex filtergraph is generally the right place to express the composition. FFmpeg uses filtergraphs for operations involving multiple inputs and outputs; an overlay filter combines video streams.
A schematic example, not a drop-in command, is:
-filter_complex "[1:v]scale=1280:720[bg];[0:v]scale=1280:720[fg];[bg][fg]overlay=0:0[v]" \
-map "[v]" ...
Here the playlist video is labelled [0:v], and the looping background is [1:v]. The background is scaled and labelled [bg]; the foreground is scaled and labelled [fg]; overlay places the foreground over the background. This particular example would obscure the background wherever the foreground is opaque, so it is not a sensible layout if you expect to see both full-frame videos. For a picture-in-picture treatment, choose smaller foreground dimensions and coordinates. For a background with text or logos, design the layers and placement intentionally. Scaling, aspect-ratio preservation, padding, cropping and pixel format can all need adjustment to suit the source and intended canvas.
The audio choice is independent. You may want the playlist audio, a separate music input, background-video audio, a deliberate mix, or silence. A video overlay does not automatically tell you which audio should be sent. Use explicit mapping for the output streams so FFmpeg does not select an unintended audio track. For playlist audio, map the chosen playlist audio stream if every item has a compatible one. If some clips have no audio or different layouts, you may need to normalise them first or build a filtergraph that handles the cases. For separate music, add the input and deliberately map or mix its audio with the programme. For silence, create a suitable silent audio stream if your delivery setup requires audio; do not accidentally pass through background sound just because it was present in the file.
Before streaming, make a short local output test and listen on headphones. Confirm the picture composition, that sound comes from the intended source, and that levels are sensible. FFmpeg stream labels and mapping are easy to confuse when inputs have multiple audio or video tracks. A command that succeeds is not proof that it selected the right language track, channel layout or background layer.
Choose YouTube-compatible encoding
Once the streams are selected and composed, encode them for the destination. YouTube’s current live encoder settings guidance lists supported codecs and delivery recommendations for RTMP/RTMPS. It recommends a two-second keyframe interval and says not to exceed four seconds; it also describes constant bitrate encoding and frame rates up to 60 fps. These are YouTube’s published settings, not a guarantee that any specific file or connection will work. Consult the current page for the resolution and frame-rate row that matches your actual output rather than borrowing a bitrate from an unrelated resolution.
For a conventional H.264 and AAC example, the relevant output options might resemble:
-c:v libx264 -pix_fmt yuv420p -b:v <video-bitrate> \
-maxrate <video-bitrate> -bufsize <buffer-size> \
-g <keyframe-interval-in-frames> -c:a aac -b:a <audio-bitrate>
The angle-bracket values are placeholders, not recommended numeric values. Derive video bitrate and keyframe interval from the chosen resolution and frame rate in YouTube’s published guidance. For a two-second interval, the GOP frame count is tied to frame rate, so the right value differs with output frame rate. Confirm how your FFmpeg encoder interprets the option and check the resulting stream properties. YouTube lists AAC or MP3 audio for RTMP/RTMPS, but the right sample rate, channel layout and encoding parameters still depend on the material and output plan.
YouTube’s documented RTMP/RTMPS settings also include H.265/HEVC and AV1 options. Support in the FFmpeg executable, encoder implementation and channel workflow can vary, so H.264 is often the simpler interoperability target when you need a broadly understood example, not a universal rule. Verify that your build actually includes the encoder you specify. If it does not, FFmpeg will report an encoder error before it can send a stream.
Frame size and aspect ratio need attention as well. A playlist whose clips vary in size may produce inconsistent output or fail a filter expecting fixed dimensions. Decide on an output canvas, then scale and pad or crop intentionally. A local news loop may need readable lower thirds; a devotional video may need to preserve portrait footage without cutting off faces. The output should reflect the material and viewers’ devices, not just a copied command line.
Send the output to YouTube ingest
YouTube provides the ingestion details for a particular live stream. Retrieve the current server or endpoint and stream name/key from the channel’s Live Control Room or through the relevant API workflow. Google’s LiveStreams API reference describes ingestion information associated with a live stream. Never put a real stream key in a public example, screenshot, source repository or support post: it grants access to send a feed to the associated stream.
For conventional encoder workflows, YouTube supports RTMP or RTMPS. Google recommends RTMPS for secure streaming; its RTMPS ingestion guide describes the protocol and connection details. A schematic output target might look like:
rtmps://<ingestion-address>/<stream-name-or-key>
Use the exact endpoint and stream name supplied for your stream, and follow the current instructions displayed for the channel. Treat the URL as sensitive if it includes the stream key. Do not copy a key from one channel or event into another command, and avoid leaving it in shell history or logs that other people can read. YouTube’s ingestion protocol comparison is useful if you are considering HLS: HLS has segment-based requirements and generally higher latency than RTMP-based ingestion, so it is not simply a secure spelling variant of the same workflow.
The final FFmpeg command connects the output of your mapping and encoding stages to that destination. At this point, keep the input labels, maps and output target visibly separate in your working notes. That makes it easier to tell whether a failure is a missing file, a filter error, an unsupported encoder, a network problem or an incorrect ingest value. If you use an automated wrapper or a long-running host, retain a private copy of the exact command with the sensitive key stored separately.
Test the pipeline before the broadcast
Do a local preflight before opening the intended broadcast. Confirm every playlist path resolves from the process’s working directory; confirm the files’ streams, codecs, dimensions, time bases and durations are suitable for the concat method; and check that your chosen audio stream exists in every playlist item. Verify which input is the background, then inspect the filter labels and explicit maps. Make a short local render or test connection with representative movement and audio so you are checking the real kind of content, not a silent static frame.
Also check that the output configuration matches the current YouTube guidance for the selected resolution and frame rate, that the build has the encoders and filters used by the command, and that your upload connection can sustain the selected stream. A command that works on a laptop with a short sample can still fail during a long run if the host sleeps, the process is stopped, files are moved, or network access changes. For a channel that must keep running overnight, decide who will notice a stop and what will be done to restart it; local FFmpeg does not remove that operational responsibility.
YouTube’s own encoder settings page says to test before starting a live stream and to monitor stream health. Start a test with the channel’s actual ingest details, watch the preview and health indicators, and check both sound and picture at the receiver. If the stream reports health problems, change one variable at a time: first confirm the endpoint and key, then inspect encoder settings and network behaviour, then investigate media timestamps or filters. If you need a separate stream inspection primer, see how to test RTMP, HLS, RTSP and DASH streams.
For a non-technical operator who wants a prepared file broadcast without keeping an FFmpeg command and local machine running, StreamNeo removes that specific process-management task by turning an uploaded video into a 24/7 YouTube stream while the computer is off. That is a different workflow from locally composing a playlist and background in FFmpeg, so use it only if its file-based approach matches what you need.
A sensible final test is to let the stream run long enough to encounter a playlist transition and a background loop boundary. Check whether the concat hand-off introduces a pause, whether audio resumes at the expected level, and whether the background returns cleanly. Keep notes of the tested files, FFmpeg build and output configuration. If you later replace an episode or upgrade FFmpeg, repeat the relevant tests rather than assuming the previous result carries over.
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 repeat the playlist?
It repeats the input immediately following that option, not every input in the command. Put it before the background input’s -i if the background should repeat; playlist sequencing is a separate concat-demuxer job. Always check the input order because it determines both option scope and filter labels.
Can I use different video formats in one concat playlist?
The concat demuxer expects inputs with matching stream structures, codecs and time bases, so files with different formats may fail or produce timing issues. Inspect them first and, where necessary, convert them to a consistent set of streams and timing. A different playlist construction or filter-based assembly may suit mixed source material better.
What should I map as audio?
Map the audio that serves the programme: playlist audio, a separate track, a deliberate mix, or silence as required. Do not assume an overlay chooses audio for you, and do not rely on automatic stream selection when files contain multiple tracks or inconsistent layouts. Test transitions and listen to the output before the intended broadcast.
Is this a complete command for every YouTube channel?
No. The examples show how to separate playlist input, background looping, composition, encoding and ingest, but input formats, FFmpeg builds, audio layouts and channel settings vary. Use the current official YouTube encoder and ingest guidance, keep the key private, and test the exact files and endpoint you intend to use.