A free n8n workflow template that turns a list of topics into finished 5-second video clips with audio. Paste the JSON, add one credential, and let the polling loop collect each MP4 link while you read how every node, prompt and limit works.
Most video automation tutorials stop at the first API call. The real work starts right after it, because a video job takes a minute or more, and a workflow that fires one request and moves on never sees the result. This n8n video generation workflow fixes that gap. It takes a topic, builds a shot prompt, submits the render, waits, checks the job status on a loop, and hands you a finished MP4 link. The free template below pastes straight into n8n, and every node is explained so you can bend it to your own channel, shop or client.
Think of it as a five-station assembly line. A schedule wakes it up, a list of topics feeds it, a prompt builder shapes each topic into a shot description, an HTTP request sends the job to a video model, and a polling loop waits until the clip exists. Nothing in it needs a paid add-on, and the whole thing fits on a single screen of the n8n canvas.
This kind of no-code automation pays off wherever the same type of clip is needed again and again:
| Stage | n8n node | Job |
|---|---|---|
| 1. Trigger | Schedule Trigger | Starts the run every morning at 9:00 |
| 2. Topics | Code | Returns one item per video idea |
| 3. Prompt | Code | Turns a topic into a cinematic shot description |
| 4. Render | HTTP Request | Submits the job and receives a prediction ID |
| 5. Poll and save | Wait, HTTP Request, If | Loops until the MP4 URL is ready |
The clip comes from PicassoIA Video, a text-to-video and image-to-video model that renders 5 seconds at 24 frames per second with synchronized audio. You choose 480p for the fastest render or 720p for sharper output, and the aspect ratio can be 16:9, 9:16, 1:1 and several others, so one template serves YouTube Shorts, Reels and landscape posts alike.
Three things, nothing exotic:
pia_sk_, created from your account on the PicassoIA API page.💡 Check the plan first. The API page says predictions are currently free and use no credits, while the plan details list API access on specific plans. Read the current terms before you schedule hundreds of renders, so the cost you plan for matches the cost you pay.
A text prompt becomes an image in about a second, but a video takes far longer. The example clips on the PicassoIA Video model page list generation times of roughly 31, 40 and 78 seconds. A single HTTP request therefore cannot return the video. It returns a prediction ID, and you ask for the status again and again until it reads succeeded.
That pattern is exactly where n8n is comfortable. The Wait node pauses the run, the If node decides whether to loop or move on, and Loop Over Items keeps one topic from stepping on the next. You draw the logic instead of writing a polling script.
n8n can run on your own hardware. A small always-on mini PC, a home server or an inexpensive VPS is plenty, because the workflow only sends HTTP requests and waits. The heavy lifting happens on the video model's GPUs, not on your machine. Community Edition costs nothing to run yourself, so the one variable cost left in the pipeline is the video generation itself. The n8n docs include a short Docker command that gets an instance running in a couple of minutes, and a restart policy keeps it alive after reboots, which matters for a schedule that has to fire at 9:00 every morning.
Copy the block below, open a blank workflow, click the canvas and press Ctrl+V (Cmd+V on a Mac). n8n recreates all 11 nodes and their connections.
{
"name": "Video Generation Workflow",
"nodes": [
{
"parameters": { "rule": { "interval": [ { "field": "days", "triggerAtHour": 9 } ] } },
"name": "Schedule Trigger",
"type": "n8n-nodes-base.scheduleTrigger",
"typeVersion": 1.2,
"position": [0, 0]
},
{
"parameters": {
"jsCode": "return [\n { json: { topic: 'Pour-over coffee brewed in a sunlit kitchen', ratio: '9:16' } },\n { json: { topic: 'A desk setup tour at golden hour', ratio: '16:9' } }\n];"
},
"name": "Topics",
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [220, 0]
},
{
"parameters": { "options": {} },
"name": "Loop Over Items",
"type": "n8n-nodes-base.splitInBatches",
"typeVersion": 3,
"position": [440, 0]
},
{
"parameters": {
"mode": "runOnceForEachItem",
"jsCode": "const prompt = `${$json.topic}. Slow dolly-in at eye level, soft natural window light, shallow depth of field, realistic textures. Natural ambient sound that matches the scene.`;\nreturn { json: { ratio: $json.ratio, prompt } };"
},
"name": "Build Prompt",
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [660, 0]
},
{
"parameters": {
"method": "POST",
"url": "https://api.picassoia.com/v1/models/picassoia/picassoia-video/predictions",
"authentication": "genericCredentialType",
"genericAuthType": "httpHeaderAuth",
"sendBody": true,
"specifyBody": "json",
"jsonBody": "={{ JSON.stringify({ input: { prompt: $json.prompt, resolution: '720p', aspect_ratio: $json.ratio, save_audio: true } }) }}",
"options": {}
},
"name": "Create Video",
"type": "n8n-nodes-base.httpRequest",
"typeVersion": 4.2,
"position": [880, 0]
},
{
"parameters": { "amount": 30, "unit": "seconds" },
"name": "Wait",
"type": "n8n-nodes-base.wait",
"typeVersion": 1.1,
"position": [1100, 0]
},
{
"parameters": {
"url": "=https://api.picassoia.com/v1/predictions/{{ $json.id }}",
"authentication": "genericCredentialType",
"genericAuthType": "httpHeaderAuth",
"options": {}
},
"name": "Check Status",
"type": "n8n-nodes-base.httpRequest",
"typeVersion": 4.2,
"position": [1320, 0]
},
{
"parameters": {
"conditions": {
"options": { "caseSensitive": true, "leftValue": "", "typeValidation": "strict" },
"conditions": [
{
"id": "finished",
"leftValue": "={{ ['succeeded', 'failed', 'canceled'].includes($json.status) }}",
"rightValue": "",
"operator": { "type": "boolean", "operation": "true", "singleValue": true }
}
],
"combinator": "and"
},
"options": {}
},
"name": "Finished?",
"type": "n8n-nodes-base.if",
"typeVersion": 2.2,
"position": [1540, 0]
},
{
"parameters": {
"conditions": {
"options": { "caseSensitive": true, "leftValue": "", "typeValidation": "strict" },
"conditions": [
{
"id": "succeeded",
"leftValue": "={{ $json.status }}",
"rightValue": "succeeded",
"operator": { "type": "string", "operation": "equals" }
}
],
"combinator": "and"
},
"options": {}
},
"name": "Succeeded?",
"type": "n8n-nodes-base.if",
"typeVersion": 2.2,
"position": [1760, -100]
},
{
"parameters": {
"assignments": {
"assignments": [
{ "id": "url", "name": "videoUrl", "value": "={{ Array.isArray($json.output) ? $json.output[0] : $json.output }}", "type": "string" },
{ "id": "pid", "name": "predictionId", "value": "={{ $json.id }}", "type": "string" }
]
},
"options": {}
},
"name": "Save Result",
"type": "n8n-nodes-base.set",
"typeVersion": 3.4,
"position": [1980, -100]
},
{
"parameters": { "errorMessage": "={{ 'Video job ended as ' + $json.status }}" },
"name": "Stop and Error",
"type": "n8n-nodes-base.stopAndError",
"typeVersion": 1,
"position": [1980, 100]
}
],
"connections": {
"Schedule Trigger": { "main": [[{ "node": "Topics", "type": "main", "index": 0 }]] },
"Topics": { "main": [[{ "node": "Loop Over Items", "type": "main", "index": 0 }]] },
"Loop Over Items": { "main": [[], [{ "node": "Build Prompt", "type": "main", "index": 0 }]] },
"Build Prompt": { "main": [[{ "node": "Create Video", "type": "main", "index": 0 }]] },
"Create Video": { "main": [[{ "node": "Wait", "type": "main", "index": 0 }]] },
"Wait": { "main": [[{ "node": "Check Status", "type": "main", "index": 0 }]] },
"Check Status": { "main": [[{ "node": "Finished?", "type": "main", "index": 0 }]] },
"Finished?": { "main": [[{ "node": "Succeeded?", "type": "main", "index": 0 }], [{ "node": "Wait", "type": "main", "index": 0 }]] },
"Succeeded?": { "main": [[{ "node": "Save Result", "type": "main", "index": 0 }], [{ "node": "Stop and Error", "type": "main", "index": 0 }]] },
"Save Result": { "main": [[{ "node": "Loop Over Items", "type": "main", "index": 0 }]] }
}
}
💡 Test small first. Change
resolutionto480pand keep a single topic in the list for the first run. A 480p render is the fastest, so you confirm the plumbing in minutes instead of waiting on a full batch.
Authorization.Bearer pia_sk_ followed by your token.The base URL https://api.picassoia.com/v1, the Bearer scheme and the Replicate-style routes (POST /models/{owner}/{name}/predictions to start a job, GET /predictions/{id} to read it) come from the PicassoIA API docs. Confirm the field names against the code examples there before you scale up, since the template follows the documented shape rather than guessing at it.
The model page recommends cinematic, chronological descriptions. A good prompt reads like a mini script for five seconds: what is in the frame, what moves, how the camera behaves, and what you hear.
| Part | Example | Why it matters |
|---|---|---|
| Subject | A gooseneck kettle above a glass carafe | Sets the opening frame |
| Motion | Water pours in a thin stream, steam rises | Gives the clip a verb |
| Camera | Slow dolly-in at counter height | Controls framing and pace |
| Light | Soft morning window light | Keeps the look consistent |
| Sound | A quiet pour, a spoon touching ceramic | Audio is rendered with the clip |
The Build Prompt node bakes the camera, light and sound into one sentence and only swaps the topic. Prompts can run up to 4,000 characters, so you have room to add your own brand rules, such as "no on-screen text" or "warm color palette".
Four nodes make the loop, and they run in this order:
id and a starting status.GET /predictions/{id}.succeeded, failed or canceled, and back to Wait if the job is still running.A stuck job cannot spin forever, because predictions have a 3-hour timeout and end as failed on their own. If you want a tighter ceiling, add a counter in a Code node and stop after 20 checks.
One behavior to know: Stop and Error halts the whole execution, including topics still waiting in the list. If one bad clip should not block the rest, replace that node with a Slack or email alert and connect it back to Loop Over Items.
The Save Result node leaves you with a videoUrl and a predictionId for every topic. From there, the workflow is a normal n8n pipeline, so the finished clip can go wherever your team already works:
| Destination | n8n node | Typical use |
|---|---|---|
| Content calendar | Google Sheets, Append Row | Log topic, URL and date for review |
| Team channel | Slack or Telegram | Post the link the moment a clip lands |
| Cloud storage | HTTP Request (file response), then Google Drive | Keep your own copy of the MP4 |
| Publishing | YouTube or a social scheduler node | Queue the clip for posting |
Download the file into your own storage if you need it long term, instead of depending on a hosted link forever. A human review step is worth keeping too: send the link to a channel first, and publish only after someone has watched the five seconds, because generated clips can drift from the prompt.
The Build Prompt node is a template string. It works, but every clip ends up with the same shape. A language model can write a distinct shot for every topic. Before you wire one into n8n, draft and test your instruction in the browser, where you can compare outputs side by side:
| Model | Why try it |
|---|---|
| Claude Sonnet 5 | Handles long instruction templates with many rules |
| GPT 5 Structured | Returns answers as clean JSON that maps to n8n fields |
| Gemini 3.5 Flash | Fast and light, suited to batches of short prompts |
Delete Build Prompt and put a Basic LLM Chain node in its place, with a chat model sub-node attached. In n8n that sub-node uses whichever provider credential you already hold, so the PicassoIA token stays dedicated to video. Give the chain an instruction like this:
You write shot descriptions for 5-second AI video clips. Given a topic, return JSON with "prompt" (one cinematic paragraph with subject, motion, camera, light and sound) and "ratio" ("9:16" or "16:9"). No text overlays and no brand names.
Parse the JSON reply into two fields named prompt and ratio, and the Create Video node keeps working without any other change.
💡 Keep a fallback. If the LLM returns malformed JSON, route that item to the old template-string prompt instead of failing the run.
Text-only prompts are the simplest route. When you need the opening frame to match a product shot or a brand look, start from an image instead. PicassoIA Video accepts an optional image field, uses it as the first frame and inherits its aspect ratio, so the aspect_ratio field is ignored when an image is present.
The practical way to feed it is to add an imageUrl field to each topic, generated beforehand with PicassoIA Image, then change the Create Video body to:
"jsonBody": "={{ JSON.stringify({ input: { prompt: $json.prompt, image: $json.imageUrl, resolution: '720p', save_audio: true } }) }}"
You can also generate the frame inside the workflow with a second prediction, but it needs its own Wait and status check, so start with prepared URLs.
At the time of writing (early October 2026), the PicassoIA API lists four models: PicassoIA Image, PicassoIA Image Editor Pro, PicassoIA Video and Seedance 2.5 Lite. The other video models below run in the PicassoIA app, which makes them useful for testing a prompt before you automate it.
| Model | Strength | In this template |
|---|---|---|
| PicassoIA Video | 5 s clips with audio, 480p or 720p, text or image input | Yes |
| Seedance 2.5 Lite | Clips up to 10 seconds | Yes, swap the slug and check its inputs |
| Veo 3.1 Fast | 1080p text-to-video | App only |
| Kling v3 Video | Cinematic motion | App only |
| Wan 2.7 I2V | Animates any still image | App only |
To switch the template to Seedance 2.5 Lite, change picassoia-video in the Create Video URL to seedance-2.5-lite, then open its model page and match the input fields.
An account can run 5 predictions at the same time, and that limit is shared across every token and MCP connection on the account. Loop Over Items with a batch size of 1 stays far below it. If you raise the batch size to speed things up, never go past 5, and remember that anything else using the same account counts against the same pool.
It is tempting to paste the token straight into an HTTP node header. Exported workflow JSON travels: it lands in chats, repos and forum posts. Keep the token in n8n's credential store, share only the JSON, and treat a leaked pia_sk_ token like a password by replacing it right away.
The fastest way to get a working pipeline is to start by hand. Open PicassoIA Video, write one prompt in the format from the table above, and watch the result. When the clip looks right, paste that prompt into the Topics node and let n8n repeat it on a schedule.
If your clips start from a still, make the first frame with PicassoIA Image and experiment with a few seeds until the opening shot is the one you want. Browse the full catalog at picassoia.com/en/all-models, pick a favorite, and turn your next idea into a clip that your own workflow renders while you do something else.
Start with one prompt, one clip and one scheduled run. Once that loop works, adding topics, an LLM step or a delivery node is only a matter of dragging another box onto the canvas. Your first automated video is a single paste away, so open PicassoIA, run your first prompt and see what five seconds of motion can do for your next post.
