The Visualizer Content Pipeline
Last reviewed
AdvancedWhat you'll learn
~40 min- Build a Node.js CLI that batch-generates visualizer content for multiple platforms
- Understand headless browser rendering with Puppeteer for automated video capture
- Integrate cover art, track metadata, and visualizer themes into a content package
- Produce platform-ready clips for Spotify Canvas, Instagram Reels, YouTube Shorts, and TikTok
What you’re building
You built an audio-reactive visualizer in Lesson 7. It looks great in a browser. But now you need that visualizer as actual video files — a looping 8-second clip for Spotify Canvas, a 15-second vertical for Instagram Reels, a 60-second Short for YouTube, and a full-length 16:9 background for your YouTube uploads. Four platforms, four aspect ratios, four durations. Normally you’d screen-record each one manually, crop it, trim it, export it. Four times. For every single release.
You’re going to build a CLI that does all of that in one command. Point it at a release config, and it renders every clip headlessly — no screen recording, no manual cropping, no export dialogs. One command, four platform-ready files, a manifest listing everything it produced.
This is the capstone. Every lesson in this module feeds into this one.
Rotor Videos, Specterr, Vizzy, Renderforest, and similar services sell visualizer rendering as paid plans for what is fundamentally the same thing: rendering an animation over your audio at specific dimensions. Your pipeline does this for free, uses YOUR visualizer design (not a generic template), and runs locally. Check each vendor’s current pricing and add up what a year of monthly releases would cost you. Over a catalog? It adds up fast.
How the pieces connect
This lesson pulls from almost everything you’ve built:
| Lesson | What this pipeline uses |
|---|---|
| L1 | Cover art from release-assets/ — composited into the visualizer |
| L2 | Track metadata from campaign data — title, artist, album baked into clips |
| L6 | Command center integration — visualizer render status on your dashboard |
| L7 | The visualizer HTML itself — loaded headlessly by Puppeteer |
The pipeline takes a release config file (YAML), loads your L7 visualizer in a headless browser, captures it at multiple resolutions and durations, and outputs platform-ready video files. That’s it. Config in, videos out.
Puppeteer opens Chrome without showing it on your screen. No window, no UI — just Chrome running invisibly in the background. It loads your visualizer HTML, plays the audio, and records what the browser is rendering into a video file. Think of it as automated screen recording. Same result as if you pointed OBS at your browser, but no human needs to sit there pressing buttons.
The release config
Here’s what a release config looks like. This is the single file that drives the entire pipeline:
REFERENCE CONFIG release.yaml multi-platform visualizer render configuration open reference hide reference Reference example of the YAML configuration your agent generates and reads to batch-render all four platform clips.
track: title: "JADED" artist: "moodmixformat" album: "MIXTAPE FORMAT" audio: "./audio/jaded.mp3" cover: "./assets/jaded-cover.jpg"
visualizer: theme: "tape-deck" color: "#f97316"
outputs: - platform: spotify-canvas width: 576 height: 1024 duration: 8 loop: true - platform: instagram-reel width: 1080 height: 1920 duration: 15 - platform: youtube-short width: 1080 height: 1920 duration: 60 - platform: youtube-background width: 1920 height: 1080 duration: 0 # full track lengthEach output entry defines a platform, dimensions, and duration. Duration 0 means full track length. The loop: true flag on Spotify Canvas tells the renderer to pick the best 8-second loop point (or just grab the first 8 seconds if peak detection isn’t available).
Before you start
First, if your AI tool is still open, leave it: type /exit and press Enter (if you use Antigravity, press Ctrl+D with nothing typed instead), and wait until you see the $ or % prompt. Make a clean folder for this lesson inside ~/producer-workbench:
mkdir -p ~/producer-workbench/08-visualizer-content-pipeline && cd ~/producer-workbench/08-visualizer-content-pipelineOn Windows PowerShell, run mkdir -Force ~/producer-workbench/08-visualizer-content-pipeline; cd ~/producer-workbench/08-visualizer-content-pipeline, or open the folder in your desktop agent app. Then start your agent the way your track’s setup lesson showed.
Switch to plan mode
Once your agent is open, switch to Plan mode inside the session (Shift+Tab, /plan, or your desktop app’s mode picker). In plan mode it asks clarifying questions and shows you a plan before building.
The conversation
Each message below is an example. Say it in your own words.
Say what you want
Start with a short plain-English description of what you want to build:
I want to build a batch pipeline tool that reads release.yaml, renders my browser audio visualizer automatically at multiple platform sizes with the track audio, and writes manifest.json. Ask me what you need first.Answer its questions
Your agent will ask a few questions about CLI flags, video capture, and outputs. Answer each briefly:
| If it asks | You might say |
|---|---|
| Which tools and command-line options should it support? | Use whatever headless browser and video tools work best, with options for output folder, —preview, —draft, and —format mp4. |
| What four platform outputs should the sample release.yaml define? | Spotify Canvas (576x1024, 8s), Instagram Reel (1080x1920, 15s), YouTube Short (1080x1920, 60s), and YouTube background (1920x1080, full track). |
| How should the visualizer page receive track metadata and play audio? | Pass the track audio, cover art, title, artist, theme, and color into the visualizer page and start playback automatically. |
| How should video frames and audio be captured and encoded? | Capture 30fps visualizer frames and combine them with the original track audio into platform-ready MP4 video files. |
| What should happen if ffmpeg is not installed on the machine? | Log a clear warning and keep the captured PNG frames in a subfolder with instructions for manual encoding. |
Read the plan
Before approving, check the plan for four domain essentials:
- Local Express server and autoplay flags let headless Chrome play audio. Puppeteer launches with
--autoplay-policy=no-user-gesture-requiredand loadsvisualizer.htmlfrom a local HTTP server so the Web AudioAnalyserNodeand cover art load without CORS or user-gesture blocks. - Each platform output renders at its exact dimensions and duration. Viewport size matches
widthandheight(or half resolution when--draftis set), and filenames follow{platform}_{width}x{height}_{duration}s.mp4. - FFmpeg muxes the original audio into every MP4 (with a PNG fallback). The wrapper checks
ffmpeg -version, combines the recorded video or 30fps PNG frames with the source audio (-c:v libx264 -pix_fmt yuv420p -c:a aac -shortest), and falls back cleanly ifffmpegis absent. - A
--previewmode andmanifest.jsonare included. Running--previewopens a visible browser window without recording so you can inspect the visualizer first, and every render writesmanifest.jsonwith dimensions, durations, and human-readable file sizes.
If the first plan opens visualizer.html directly from a local file path or doesn’t enable automatic audio playback in the headless browser, say so briefly:
Serve the visualizer page and audio files over a local web server and allow automatic audio playback in the headless browser so frequencies animate without a click.When the plan covers all four, approve it: pick the option to proceed or say Yes, go ahead and build it (in Codex, press Shift+Tab first to leave plan mode). Once you verify --preview and a --draft render, ask your agent to save a Git checkpoint:
Save a checkpoint with Git so we can roll back if needed.The first time you run npm install in this project, Puppeteer will download a recent Chrome for Testing build plus a chrome-headless-shell binary into ~/.cache/puppeteer (Puppeteer’s install guide lists about 170 to 280 MB, depending on platform, as of 2026-11-07). Some package managers block install scripts by default; if yours does, the download is skipped and you run npx puppeteer browsers install yourself. It’s a one-time download — subsequent installs will use the cached version. If you’re on a slow connection, be patient. If it fails, check the Puppeteer troubleshooting section below.
The audio step and the frame fallback both run ffmpeg. Install it once with sudo apt install ffmpeg on Ubuntu or WSL, or brew install ffmpeg on macOS.
What you get
After your AI CLI tool finishes, you’ll have a project folder structure like this:
content-pipeline/ package.json release.yaml README.md src/ cli.js renderer.js config-loader.js ffmpeg-wrapper.js manifest.js templates/ visualizer.htmlSet it up and run
Drop your audio file and cover art into audio/jaded.mp3 and assets/jaded-cover.jpg (or update the paths in release.yaml), then ask your agent to install what is needed, open the preview, and render the clips:
Install what the pipeline needs, open the visualizer in --preview mode so I can check it, and then render the MP4 clips.If you prefer running the steps in a terminal yourself:
cd content-pipelinenpm installmkdir -p audio assets# Copy your audio and cover art (or edit release.yaml to point to your files):cp ~/Music/jaded.mp3 ./audio/jaded.mp3cp ~/Design/jaded-cover.jpg ./assets/jaded-cover.jpgThe first npm install takes a minute because Puppeteer downloads Chrome for Testing.
Preview first
Before rendering, check that the visualizer looks right (either by asking your agent or running the preview command):
node src/cli.js --previewThis opens a browser window with your visualizer running — audio playing, bars reacting, cover art displayed, track title showing. Make sure you like how it looks. Close the browser when you’re done.
Render everything
Ask your agent to render all four platform MP4 clips, or run:
node src/cli.js --format mp4You should see output like:
REFERENCE OUTPUT Sample batch visualizer render terminal output open reference hide reference Reference example of the terminal output when all four platform clips finish rendering and manifest.json is written.
Loading config: release.yaml Track: JADED by moodmixformat Cover: ./assets/jaded-cover.jpg Theme: tape-deck (#f97316) Outputs: 4 platforms
Starting local server on port 3456...
Rendering spotify-canvas (576x1024, 8s)... done [12s]Rendering instagram-reel (1080x1920, 15s)... done [28s]Rendering youtube-short (1080x1920, 60s)... done [94s]Rendering youtube-background (1920x1080, full track)... done [187s]
Output directory: ./output/ spotify-canvas_576x1024_8s.mp4 1.1 MB instagram-reel_1080x1920_15s.mp4 3.8 MB youtube-short_1080x1920_60s.mp4 12.4 MB youtube-background_1920x1080_238s.mp4 42.1 MB manifest.json 0.4 KB
4 clips rendered, manifest written.Full-resolution rendering takes a while — a 60-second clip at 1080x1920 might take 90+ seconds. When you’re tweaking the visualizer theme or testing a new color, use node src/cli.js --draft to render at half resolution. It’s faster and good enough to check if the visual style is right. Save full-res renders for the final export.
A worked example: the full pipeline for a single release
Here’s the end-to-end workflow. You just finished mastering “JADED” and you have your cover art ready.
Step 1: Set up the release config
Edit release.yaml with your track details. Point the audio and cover paths to your actual files.
Step 2: Preview the visualizer
node src/cli.js --previewThe browser opens. Your cover art is centered, the tape deck theme is running, frequency bars are reacting to the audio in your signature orange. The track title “JADED” sits at the bottom in monospace. It looks right.
Step 3: Render all platforms
node src/cli.js --format mp4 -o ./jaded-visualsGo make coffee. The pipeline renders all four clips.
Step 4: Check the outputs
ls -la ./jaded-visuals/The command prints output like this:
spotify-canvas_576x1024_8s.mp4 1.1 MBinstagram-reel_1080x1920_15s.mp4 3.8 MByoutube-short_1080x1920_60s.mp4 12.4 MByoutube-background_1920x1080_238s.mp4 42.1 MBmanifest.json 0.4 KBOpen each file. Check:
- Does the Spotify Canvas loop cleanly? (It should be 8 seconds or less)
- Does the Instagram Reel look good at 9:16 vertical?
- Does the YouTube Short have enough visual interest for 60 seconds?
- Does the YouTube background look right at 16:9 for use behind your mix?
Step 5: Upload
- Spotify Canvas: Upload through Spotify for Artists: go to Music, select the track, click Add Canvas (in the mobile app, tap Canvas). Must be 3-8 seconds, vertical 9:16, as an MP4 or JPG (Spotify’s Canvas guidelines).
- Instagram Reel: Upload from the Instagram app.
- YouTube Short: Upload as a Short (vertical, up to 3 minutes; this lesson renders 60 seconds by choice, not because of a limit).
- YouTube background: Use as the visual layer in your RECORDED LOCATIONS episode or as a standalone visualizer video.
One command. Four platforms. Done.
🔍Platform-specific requirementsclick to expand
Each platform has its own specs, and getting them wrong means rejected uploads or bad quality:
Spotify Canvas
- Dimensions: vertical 9:16; this sample uses 576x1024, within the 720-1080 px height range Spotify publishes. Confirm in the upload screen.
- Duration: 3-8 seconds (looping is optional, but a clean loop looks best)
- File size: Spotify’s Canvas guidelines page lists no size limit; keep clips small and check the upload screen
- Format: MP4 (H.264) or a single JPG
- Encoded size depends on duration, bitrate, codec, and visual complexity
Instagram Reels / TikTok
- Dimensions: 1080x1920 (9:16) preferred (typical; check each platform’s current spec)
- Duration: Reels now allow longer videos; check Instagram’s current limit (15 or 30 seconds is the sweet spot for music content)
- File size: check each platform’s current upload limit
- Format: MP4 (H.264 + AAC)
- Check each platform’s minimum resolution; 1080p generally looks better
YouTube Shorts
- Dimensions: 1080x1920 (9:16)
- Duration: up to 3 minutes (this lesson’s 60-second output is a choice, not a limit)
- Format: standard YouTube upload formats (MP4 preferred)
- Must be vertical — YouTube treats short vertical videos as Shorts (check YouTube’s current rules)
YouTube (standard video)
- Dimensions: 1920x1080 (16:9) minimum for HD
- Duration: no practical limit for music content
- Format: MP4 (H.264 + AAC)
- This is your RECORDED LOCATIONS background or standalone visualizer upload
The pipeline handles all of these dimensions and durations automatically from the release config. You define it once and forget about the specs.
If something is off
| Problem | Follow-up prompt |
|---|---|
| Visualizer has no audio reaction (bars are flat) | The visualizer bars aren't reacting to the audio. Make sure the frequency analyzer receives the playing track and the headless browser allows automatic audio playback without waiting for a click. |
| Colors don’t match the config | The visualizer is using default blue bars instead of my configured orange (#f97316). Make sure the color from release.yaml is passed into the visualizer and applied to the bars and accents. |
| Cover art doesn’t appear | The cover art image isn't showing in the visualizer. Make sure the local server exposes the assets folder and resolves the cover path from release.yaml correctly. |
| Rendering produces black frames | The rendered video is all black. Wait for the visualizer page and cover art to finish loading and for audio playback to begin before capturing video frames. |
When Things Go Wrong
Use the Symptom → Evidence → Request pattern: describe what you see, paste the error, then ask for a fix.
Customize it
Batch-render an entire album
Add a --batch flag taking an album YAML with a tracks array, rendering all platform outputs into per-track subfolders, and writing an album manifest.json.Auto-upload to YouTube
Add a --upload-youtube flag that connects to my YouTube account and uploads the rendered Short and standard background video with the track metadata.Highlight reel mode
Add a --highlight flag that analyzes the track's loudness curve and automatically picks the highest-energy drop section for the 8-second and 15-second clips.Text overlay system
Add support for a textOverlay section in release.yaml that renders timestamped text entries on the visualizer with 0.3-second fade transitions.Your content pipeline uses Puppeteer to render visualizer videos. What does Puppeteer actually do in this workflow?
The complete module: everything you built
This is lesson 8 of 8. Here’s the full system you now have:
| # | Tool | What it does |
|---|---|---|
| 1 | Release Asset Engine | One cover image in, six platform-sized assets out |
| 2 | Campaign Generator | One metadata file in, captions, hashtags, calendar, and EPK out |
| 3 | RECORDED LOCATIONS Builder | Episode notes in, all YouTube publishing metadata out |
| 4 | Moodmix Control Room | CSV exports in, geographic and business intelligence out |
| 5 | Royalty Reconciler | Distributor CSVs in, discrepancy flags and revenue report out |
| 6 | Release Ops Command Center | All of the above in, one weekly action-plan dashboard out |
| 7 | Audio Visualizer Generator | Audio file in, signature tape deck visualizer out |
| 8 | Visualizer Content Pipeline | Release config in, platform-ready video clips out |
These tools chain together. The asset engine’s cover art feeds into the visualizer pipeline. The campaign generator’s metadata populates your content clips. The control room and reconciler feed the command center. The visualizer from L7 is the core of the content pipeline in L8. Everything connects.
What you actually built in this module
Eight CLI tools, each built in a single session with AI assistance. What you got:
A complete release operations system. From the moment you finish mastering a track to the moment it’s live on every platform, you have a tool for every step. Cover art resized for 6 platforms. Campaign captions and calendar generated. YouTube episode metadata ready. Analytics dashboard running. Royalties reconciled. Command center showing your weekly priorities. Visualizer content rendered for 4 platforms. All in one pipeline, all running locally, all free.
The dollar math. Add up what this replaces: Canva Pro, Later or Buffer, Chartmetric (from $40/month billed yearly as of November 2026, per chartmetric.com/pricing), a royalty tracking service, Rotor Videos or Specterr, plus the time cost of doing everything manually. Check each vendor’s current pricing and total it for your own stack. Your tools cost nothing to run after they’re built. Your data never leaves your machine. And they work exactly the way you want them to because you directed the AI that built them.
A repeatable pattern. Every tool follows the same structure: define a config, run a command, get outputs. The config-to-output pipeline pattern is the same one used by labels, distributors, and music tech companies — they just have engineering teams building it. You have a CLI and an AI tool. The result is the same.
Key takeaways
- Automation compounds. Measure the time each tool saves across your own release workflow and use it to prioritize further automation.
- The pipeline pattern is universal. Config file in, processed outputs out. It’s the same structure whether you’re rendering visualizers, resizing cover art, or generating campaign content. Once you internalize this pattern, you can build a pipeline for anything.
- Your content pipeline is your competitive advantage. Major labels have teams of people doing content operations — resizing art, scheduling posts, reconciling royalties, rendering promo clips. You have a set of CLI tools that do it all in minutes. The playing field is more level than it’s ever been.
- Everything runs locally, costs nothing, and is yours forever. No subscriptions to cancel. No platform changes breaking your workflow. No vendor lock-in. The tools live on your machine. You can modify them, extend them, chain them together. They evolve with your workflow.
- The only thing left is making the music. That was always the point. Every minute spent on release operations is a minute not spent creating. These tools exist so you can stop resizing images, stop copy-pasting captions, stop manually screen-recording visualizers, and go make something.
Try it yourself
- Open your AI tool in your lesson folder and switch to plan mode.
- Talk your agent through the plan and approve it to build the pipeline.
- Ask your agent to install what is needed (or run
npm installin your terminal) and wait for the headless browser download. - Drop an audio file and cover art into the project.
- Edit
release.yamlwith your track details. - Ask your agent to run
--preview(or runnode src/cli.js --preview) to check the visualizer. - Ask your agent to render all four platform clips (or run
node src/cli.js --format mp4). - Open the outputs. Upload them. Release your music.
Every new release is now a pipeline. The tools are built. The workflow is yours. Go make music.