To rotate different playlists across several YouTube channels, run one FFmpeg process for each channel and give each process its own playlist and matching YouTube Live destination credentials. FFmpeg can read and repeat compatible files, but it does not schedule a wall-clock start in IST; use a separate scheduler configured for Asia/Kolkata and test the event in YouTube Live Control Room.
The practical order is to prepare each channel’s event and media, check whether its files can be concatenated without conversion, then configure and test one independent output per channel. That separation makes it easier to identify which playlist or destination has a problem, without implying that multiple processes guarantee an uninterrupted broadcast.
Give each channel its own FFmpeg process
Think of each channel as a separate job: one input playlist, one set of encoding choices, one YouTube event destination, and one process to supervise. If Channel A is showing a devotional programme and Channel B is running a study loop, do not try to make a single process guess which content belongs where. Keep their files and credentials separate from the beginning.
A process per channel also makes scheduling easier. You can start one channel at a particular time and leave another running, or give each a different playlist and event time. The trade-off is that each active process consumes resources and produces its own logs and failure modes. A single computer may be adequate for light, compatible stream-copy jobs but not for several concurrent transcodes; test the actual files and machine rather than assuming capacity.
Write down a small inventory before building commands:
| Channel | Playlist file | YouTube event | Start time zone | Output settings |
|---|---|---|---|---|
| Channel A | channel-a.txt |
Channel A’s scheduled event | Asia/Kolkata |
Based on its sources and ingest guidance |
| Channel B | channel-b.txt |
Channel B’s scheduled event | Asia/Kolkata |
Based on its sources and ingest guidance |
This is a planning example, not a prescribed configuration. Add columns for the process name, log location, and person responsible if more than one operator will maintain the streams. If you are deciding between FFmpeg and a simpler hosted playlist workflow, the trade-offs in YouTube gaming reruns: OBS versus a hosted playlist app may help clarify how much machine-side management you want.
Prepare playlists and Live Control Room credentials
Enable live streaming for each channel and create or schedule the corresponding event in YouTube Studio. In the event’s Live Control Room, obtain the server URL and stream key intended for that event. YouTube’s encoder guide explains that these are the destination details the encoder needs. Treat a stream key as a credential: if you publish it, include it in a public script, or expose it in logs, someone else may be able to send a stream to that destination. YouTube documents changing or resetting stream settings in its live stream settings help.
Keep the pairing explicit. Label each key by channel in a protected secrets store or another access-controlled method, and check the pairing when you configure the process. Avoid pasting the key into a command that will remain in shell history or into a shared task definition. The exact secure method depends on your operating system and scheduler; the important point is that logs and routine process listings should not casually reveal the secret.
Create one text playlist file per channel. FFmpeg’s concat demuxer uses entries such as:
file '/media/channel-a/episode-01.mp4'
file '/media/channel-a/episode-02.mp4'
Those paths are illustrative only. Confirm the directory and filenames on the machine that will run FFmpeg, and account for spaces, quotes, and path rules on that operating system. Keep each list limited to trusted files. The -safe 0 option sometimes appears in examples for paths outside the demuxer’s safe-path rules; do not add it indiscriminately, and only use it where needed with playlist files you control.
Test a playlist with a short run before attaching it to a scheduled event. A misspelled path can cause an input error before FFmpeg reaches YouTube, which is a different problem from an ingest rejection. If you are assembling a long recorded-class schedule, the preparation approach in creating a 24/7 NIOS lessons stream from recorded classes is also relevant to keeping source files organised.
Check concat compatibility before you build the loop
The concat demuxer is suitable when the files in a list have compatible stream layouts and properties. FFmpeg’s concat demuxer documentation says the files must have the same streams, codecs, and time base, among other relevant properties. In practice, two files can both be MP4 while differing in video codec, frame rate, audio layout, or time base. The extension alone does not prove that they concatenate correctly.
Inspect the files before relying on a playlist. Check that each expected video and audio stream exists and that the codecs and timing characteristics match. A missing audio track in one clip, for example, can make a seemingly ordinary sequence behave differently at the transition. Try the playlist locally, watch and listen across every boundary, and read FFmpeg’s output for warnings or errors.
There are two broad ways to deal with mixed inputs. You can make a preparation pass that normalises the sources to a common set of streams and codecs, then use the concat demuxer on those prepared files. Or you can design a concat-filter workflow that decodes, joins and usually re-encodes the material. FFmpeg’s FAQ discusses concatenation approaches. Neither method makes incompatible files magically compatible: choose based on whether the media need resizing, frame-rate changes, audio treatment, or other transformations, and test the output.
Stream copy avoids a generation loss from re-encoding and uses less processing than a transcode, but only works when the source streams are suitable for the destination and the chosen workflow. Transcoding gives you a chance to standardise formats and output settings, but takes more CPU or GPU capacity and can introduce quality changes. For several channels, estimate the combined upload requirement by adding the output bitrates, then leave headroom. YouTube’s streaming tips recommend 20% upload bandwidth headroom beyond stream needs. That recommendation is useful for planning, not a guarantee that a particular connection will remain stable.
Create one concat list and repeat it if required
Once compatibility is established, the list order defines the rotation order. Put the first item at the top, followed by each subsequent file. To change the order, edit the list and test the change; the concat demuxer reads a defined sequence, not an editorial calendar with dates or times attached.
For continuous repetition of that input, FFmpeg provides -stream_loop -1. An illustrative command shape for one channel is:
ffmpeg -re -stream_loop -1 -f concat -safe 0 -i channel-a.txt \
-c:v libx264 -c:a aac -f flv "$CHANNEL_A_INGEST_URL"
This is a schematic example, not a tested, universal production command. The encoders, stream mapping, frame size, frame rate, bitrate, keyframe interval, audio handling, protocol and destination URL all need to fit the actual source files and current YouTube guidance. -re reads media at its native playback rate rather than sending a file as quickly as possible; confirm the behavior appropriate to your input and workflow. Confirm that your installed FFmpeg build supports the protocols and encoders you select.
Use a separate list and command definition for each channel. Do not reuse Channel A’s list or output variable accidentally when copying a configuration for Channel B. Give processes clear names and keep their logs distinct, so a failed input can be traced to the right playlist. A repeat flag makes the input sequence repeat; it does not restart a process that has exited, repair a dropped connection, or create a YouTube event.
Send each process to its matching YouTube stream
For each process, direct output to the server URL and stream key obtained for that channel’s event. YouTube’s encoder guide describes entering the Live server URL and stream key in an encoder. Keep the destination pair adjacent in your configuration and label it clearly, so reviewing the setup does not require guessing which channel receives which playlist.
Use the current YouTube ingest recommendations to choose output settings. Its encoder settings page covers RTMP or RTMPS, H.264 video, AAC or MP3 audio, constant bitrate, frame-rate guidance, and keyframe intervals. YouTube recommends RTMPS for encrypted transport. The page recommends a two-second keyframe interval and says not to exceed four seconds; treat these as platform guidance to check on the current page, not a promise that any encoder configuration will be accepted.
If source files already use compatible codecs and parameters, stream copy may be the less demanding path, but only use it after verifying the source and output requirements. If they do not match, use a normalisation pass or a transcode pipeline and budget the additional processing load. This is where concurrent channels can change the answer: adding more outputs increases aggregate upload needs, and transcodes add compute work. If a dedicated computer is required, choose it only after testing the intended number of processes, source formats and output settings; no universal channel count follows from the command syntax.
Keep destination URLs and keys out of article-like runbooks that will be shared widely. Use placeholders in documentation and restrict access to the actual credentials. If a key may have been exposed, consult YouTube’s current guidance for changing it before the next event.
Schedule starts with an Asia/Kolkata-aware scheduler
Playlist repetition and wall-clock scheduling are separate jobs. FFmpeg reads and processes media when its process is launched. It does not interpret an IST label as an instruction to begin at a particular time, nor does -stream_loop -1 schedule an event. Use a scheduler or service manager that supports an explicit time zone, configure the job for Asia/Kolkata, and have it launch the relevant channel’s process at the intended instant.
Avoid relying on an ambiguous abbreviation such as IST, which can be interpreted differently by software or operators. Configure the full IANA time-zone name and verify the host’s clock and the scheduler’s own time-zone setting. Keep separate job definitions when channels have different start times or restart policies. A calendar entry in local time is not sufficient evidence that the machine will launch at that time; check the scheduler’s effective configuration and recent run history.
Decide what should happen if a process exits. A scheduler may launch it once, retry it, or manage it as a long-running service, depending on the tool and its configuration. Those behaviours are not interchangeable. Automatic retries can be useful after a transient failure, but repeated retries can also hide a bad file path or invalid key unless alerts and logs make the cause visible. Plan how an operator will learn that a process failed, and do not treat an automatic restart as proof that the live event is healthy.
Test ingest and the scheduled start
Test each channel separately before running all processes together. Start the relevant job ahead of the scheduled event, check that the correct preview appears in Live Control Room, and verify picture, sound, movement and stream health. Confirm that the event is receiving the intended channel’s playlist rather than another channel’s material. YouTube recommends testing and monitoring in its encoder guidance and streaming tips; read the messages shown for the specific event rather than assuming a successful FFmpeg launch means a healthy ingest.
Then test the scheduler’s launch behaviour. Use a controlled test event or a suitable time before the real programme, with Asia/Kolkata explicitly set. Check the recorded start time, process logs, preview, and the time at which YouTube recognises the incoming stream. Confirm that the event’s settings and encoder destination correspond. A process that starts on schedule can still fail to connect, while a connection that works manually may not work under the scheduler’s environment because its paths, permissions or secret access differ.
Before enabling concurrent outputs, check the combined upload load and machine load while all intended processes are active. Watch for dropped frames or encoding overload, and recheck sound and transitions in each preview. YouTube’s recommendation to keep 20% upload headroom is a planning guide, not a substitute for a real test on the connection that will carry the streams. For other common 24/7 ingest symptoms, the diagnostic steps in fixing OBS dropped frames during a 24/7 stream can help you think through whether the issue is local processing or delivery.
During operation, monitor both sides: the FFmpeg process and YouTube’s stream status. Save enough logs to diagnose a failed input or connection, but do not let logs reveal keys. If you need to change a playlist, test the revised list before relying on it. For switching material inside an already connected FFmpeg broadcast, see how to switch videos without disconnecting; that is a different task from scheduling a process start.
A separate process for each channel creates a manageable setup, but it also leaves you responsible for compatible files, credentials, scheduling, capacity, and monitoring. If managing a machine and its scheduled launches is the part that causes the most trouble, StreamNeo removes that specific burden by turning an uploaded video into a YouTube live stream without keeping your own computer running.
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
How do I loop a playlist with FFmpeg?
Put compatible media paths in a concat-demuxer list, then use -stream_loop -1 with that input when you want it to repeat continuously. Test the order and transitions first; the loop repeats the sequence but does not schedule a start time or supervise a failed process.
How can I stream different playlists to multiple YouTube channels?
Use an independent FFmpeg process, playlist file, and matching Live Control Room destination for each channel. Keep keys protected and check the pairing before a test; concurrent processes also require enough combined upload bandwidth and processing capacity.
How do I schedule an FFmpeg stream in IST?
Configure an external scheduler that supports time zones and set it to Asia/Kolkata. Verify its effective time zone and test an actual launch in YouTube Live Control Room, because FFmpeg itself does not schedule a wall-clock start.
Why does FFmpeg concat fail when my videos have different formats?
The concat demuxer expects matching stream layouts and compatible codec and timing properties; having the same filename extension is not enough. Normalise the files first or use an appropriate concat-filter workflow with re-encoding, then test the resulting sequence.