---
title: "Kie.ai Veo video sub-workflow"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/3c892155-b0e6-4d6d-9611-c8cbf7731c82"
updated: "2026-11-09"
---

# Kie.ai Veo video sub-workflow

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n sub-workflow that another workflow calls to make one video on Kie.ai’s Veo model. It posts a prompt, a frame and reference images, checks the task every five seconds, and returns the first video address as resultUrls.

Kie.ai Veo video sub-workflow is an n8n workflow in the Developer category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow is a building block. Another workflow calls it to make one video on Kie.ai’s Veo model, and it hands back the video’s address. Seven nodes do the work. It receives a prompt, a frame shape, a list of image addresses and a generation type, and posts them to Kie.ai. Then it asks for the task’s status, waits five seconds and asks again until the video is ready, and returns the first address as `resultUrls`. Those are the four fields Mindket’s AI product photo to video generator sends to its own video sub-workflow, so this file can fill that slot.

Called with a prompt, a frame, images and a type → Posts the request to Kie.ai’s Veo endpoint → Asks for the task’s status → While it runs, waits five seconds and asks again → Returns the first video address as resultUrls

### Who it suits

n8n builders who make video workflows and want the Kie.ai call, with its waiting loop, in one place that several workflows share. Skip it if you want something to press: it has no form or button of its own and runs only when another workflow calls it.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Online retail | Shop owners who automate their ads | Call it from the photo-to-video workflow, once per product | A shop’s workflow calls it for every new product photo. |
| Agencies | Automation freelancers | Keep the Kie.ai call in one place and reuse it across client workflows | A freelancer fixes an API change once, and three client workflows pick it up. |
| Social video | Teams that make Reels and Shorts | Send \`9:16\` as the frame and get a vertical clip | A team’s caller sets \`aspect\_ratio\` to \`9:16\` for every run. |
| n8n development | Builders of long-running API calls | Copy the submit, check and wait pattern for another service | A builder reuses the loop for a different image API. |

### Where to use it

It runs on the same n8n as the workflow that calls it, because an Execute Workflow node can only pick a workflow from its own n8n.

- n8n Cloud or your own server: import it next to the calling workflow
- The calling workflow: an Execute Workflow node that picks this one and sends the four fields
- AI product photo to video generator: it sends exactly these four fields to its sub-workflow
- The node after the call: it receives \`resultUrls\`, ready to download or send on

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Its author puts setup at about 5 minutes.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Kie.ai | An account and its API key |
| A calling workflow | One with an Execute Workflow node, such as AI product photo to video generator |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. In `Submit generation request` and in `Get request status`, replace `<YOUR_KIE_AI_API_KEY>` in the Authorization header with your Kie.ai key. The brackets go too, so each header reads Bearer, a space and the key.
3. Save the workflow. It does not need to be published, because another workflow starts it.
4. In the calling workflow, open its Execute Workflow node, choose this workflow in the list and map the four fields.

### How to use it

The caller sends four fields. Each goes to Kie.ai under the name the request needs.

The four fields

| Field | Type | What to send |
| --- | --- | --- |
| \`video\_prompt\` | Text | The prompt for the video. It reaches Kie.ai as \`prompt\` |
| \`aspect\_ratio\` | Text | The frame, such as \`16:9\` or \`9:16\`. It reaches Kie.ai as \`aspectRatio\` |
| \`imageUrls\` | List of addresses | Addresses of the reference images, which Kie.ai must be able to open |
| \`generationType\` | Text | Passed on as it is. The photo-to-video listing sends \`REFERENCE\_2\_VIDEO\` |

The file also fixes `model` at `veo3_fast` and sets `enableFallback` to true, both in the body of `Submit generation request`. Kie.ai’s own Veo pages explain what the fallback option changes.

### Example

A caller sends this for a product shot.

```json
{
  "video_prompt": "Cold brew bottle on a sunny café counter, slow dolly-in",
  "aspect_ratio": "9:16",
  "imageUrls": ["https://example.com/bottle.jpg"],
  "generationType": "REFERENCE_2_VIDEO"
}
```

The call comes back with one field, `resultUrls`, holding the first video address as text.

```text
{ "resultUrls": "https://…" }
```

### For newcomers and experts

**If you are new.** A sub-workflow is a workflow that other workflows call, the way a program calls a function. This one holds the slow part of making a video, which is sending the request and waiting for it. Test it from the calling workflow. Then open this one under Executions to see what each node received.

**For experts.** The status check runs once straight after the submit, with no wait, and later after each pause. `Switch1` reads `data.successFlag` from Kie.ai’s reply.

What each status does

| successFlag | Output of \`Switch1\` | What happens |
| --- | --- | --- |
| 1 | Completed | \`Edit Fields\` keeps the first entry of \`data.response.resultUrls\` as \`resultUrls\`, and the call returns |
| 0 | Retry | \`Wait2\` pauses, \`Edit Fields14\` copies \`data.taskId\` forward, and \`Get request status\` runs again |
| 2 | Failed | No line leaves this output, so the run ends |
| 3 | Failed | The same |

`Wait2` has no settings of its own, so it uses n8n’s default of five seconds for this version of the node. Change it there to poll less often.

### Good to know

Each generation costs money, and a failed task ends without a message.

- Billing: Kie.ai bills each generation to your account
- Silent failure: flags 2 and 3 go nowhere, so the caller gets no item back and you read the run under Executions to see why
- No retry limit: a task that stays at 0 is checked every five seconds until it changes
- Your key: it sits in two header fields as plain text, so anyone who can open the workflow can read it. A header credential in n8n avoids that
- Images: Kie.ai fetches them from the addresses you send, so private links will not work
- Credentials: the JSON holds none, and nothing from its author’s account

## README

```markdown
# Kie.ai Veo video sub-workflow

An n8n sub-workflow. Another workflow calls it with a prompt, a frame, a list of image addresses and a generation type, and
it returns the address of a video that Kie.ai's Veo model made.

It takes the four fields that Mindket's "AI product photo to video generator" listing sends to its own video
sub-workflow, so it can be the one that listing asks you to supply.

## What is inside

- `workflow.json`: the sub-workflow as n8n exports it, seven nodes. It holds no credential. Your Kie.ai key goes into
  two header fields.
- `README.md`: these notes.

## Before you start

- An n8n instance, on n8n Cloud or your own server. The calling workflow has to be on the same one.
- A Kie.ai account and its API key.
- A calling workflow with an Execute Workflow node.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Open `Submit generation request` and `Get request status`. In each one's Authorization header, replace
   `<YOUR_KIE_AI_API_KEY>` with your Kie.ai key. The brackets go too, so the value reads Bearer, a space, then the key.
   If you prefer, delete those two headers and use an HTTP Header Auth credential with the same name and value.
3. Save the workflow. It does not need to be published, because another workflow starts it.
4. In the calling workflow, open its Execute Workflow node, choose this workflow in the list and map the fields below.

## What it receives and returns

| Field | Type | What to send |
|---|---|---|
| `video_prompt` | text | The prompt for the video. It reaches Kie.ai as `prompt`. |
| `aspect_ratio` | text | The frame, such as `16:9` or `9:16`. It reaches Kie.ai as `aspectRatio`. |
| `imageUrls` | list of addresses | Addresses of the reference images, which Kie.ai must be able to open. |
| `generationType` | text | Passed on as it is. The photo-to-video listing sends `REFERENCE_2_VIDEO`. |

It returns one item with one field, `resultUrls`: the first video address, as text.

## How it runs

1. `Submit generation request` posts the four fields to `https://api.kie.ai/api/v1/veo/generate`, with `model` fixed at
   `veo3_fast` and `enableFallback` set to true.
2. `Get request status` asks `https://api.kie.ai/api/v1/veo/record-info` for the task, straight away.
3. `Switch1` reads `data.successFlag`. A 1 goes to `Edit Fields`, which keeps the first entry of
   `data.response.resultUrls`, and the call returns. A 0 goes through `Wait2` and `Edit Fields14` back to
   `Get request status`. A 2 or a 3 has no line out, so the run ends.

`Wait2` has no settings of its own, so it waits n8n's default for this version of the node, five seconds. Change it there
to check less often.

## Good to know

- Kie.ai bills each generation to your account.
- A failed task ends without a message and the caller gets no item back. Open the run under Executions to see the status.
- Nothing limits the loop: a task that stays at 0 is checked until it changes.
- Your key sits in two header fields as plain text, so anyone who can open the workflow can read it.
- Kie.ai fetches the images from the addresses you send, so private links will not work.
- Kie.ai's own Veo pages explain what `enableFallback` changes and what the other generation types need.
```

## What is in it

2 files, 12 KB, downloaded as a zip.

```text
README.md  3 KB
workflow.json  9 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 7 steps, starting when another workflow calls it
- AI: No step calls an AI model
- Sign-ins: Signs in to: Kie.ai
- API keys: No API key is left in the file; 1 blank in it for your own key
- Step types: Mindket’s checker reads all 5 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/3c892155-b0e6-4d6d-9611-c8cbf7731c82)
- [Its page on Mindket](https://mindket.com/p/3c892155-b0e6-4d6d-9611-c8cbf7731c82)
