---
title: "Cinematic VFX video ad from a product photo"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/45c2d82c-26cb-4a82-bd9d-8249fb84991d"
updated: "2026-11-09"
---

# Cinematic VFX video ad from a product photo

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

An n8n workflow that turns a product photo or a logo into a short cinematic ad. OpenAI reads the picture and writes a VFX-style video brief, and Veo 3 Fast on Kie.ai renders it, all from one form.

Cinematic VFX video ad from a product photo is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, 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 turns one picture of a product or a logo into a short cinematic ad. Eleven nodes run in a line. A form takes the picture, a business name, a description and an optional video idea. Cloudinary stores the picture at a public address, and OpenAI judges whether it shows a product or a logo and describes it. An agent, briefed as a Hollywood VFX director, writes the video brief as JSON. Two code nodes shape that brief for Kie.ai, which renders it with Veo 3 Fast. After a three-minute wait the workflow asks for the result and downloads the clip.

A form takes the picture and the business details → Cloudinary stores it and OpenAI describes it → A VFX director agent writes the video brief → Veo 3 Fast on Kie.ai renders the clip → The clip is downloaded after a three-minute wait

### Who it suits

Small brands and shops that want a dramatic motion ad from a single picture, and the marketers who make those ads for them. The director’s brief leans toward food and drink, with ingredients assembling in slow motion. Other products work, but you may want to rewrite the brief.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Food and drink | Small brands and cafés | Send a pack shot and let the brief build an ingredient-assembly scene around it | A biscuit maker sends a photo of a pack and gets a clip where flour and sugar swirl into the product. |
| Online retail | Shop owners | Send each new product photo through the form for a short ad | A shop turns a new item’s photo into a clip for its social channels. |
| Local businesses with a logo | Owners without footage | Send the logo and describe the story in the video idea field | A bakery sends its logo and asks for a warm morning scene, and gets a brand clip with no footage shot. |
| Marketing agencies | Creative leads | Send a client’s picture and use the clip as a first draft | An agency shows a client a draft clip before any shoot is booked. |

Skip it if you want a calm, true-to-life product clip. The brief asks for particles, volumetric light and bold camera moves, which makes a loud result.

### Where to use it

Any n8n that can reach Cloudinary, OpenAI and Kie.ai.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file, the same steps
- Ad and social channels: the clip comes back as a file, ready for an ad, a Reel or a Short
- A drive or another app: add a node after \`HTTP Request2\` to save the clip or send it on

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. The file holds no credential, and it calls no sub-workflow.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Cloudinary | An account with an upload preset whose signing mode is Unsigned |
| OpenAI | An API key, for the picture analysis and the director agent |
| Kie.ai | An API key for its Veo endpoints |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Open `Upload Photo1`. In its address, put your cloud name where it says `<YOUR_CLOUD_NAME>`. Swap `YOUR_PRESET_NAME` for your preset and `YOUR_FOLDER_NAME` for a folder.
3. Add an OpenAI credential and select it in `Analyze image` and `OpenAI Chat Model`.
4. In `HTTP Request` and `HTTP Request1`, replace `<YOUR_KIE_API_KEY>` after `Bearer ` with your Kie.ai key.
5. Save, send a test picture through the form’s test address, then press Publish.

### How to use it

Open the form from `VFX Ad Video`, attach a product photo or a logo and fill in the fields. The form confirms at once. The run goes on behind it: upload, analysis, brief, render, download. The clip lands in the run’s execution data as a file, so open the run under Executions to see it.

The form’s fields

| Field | Needed | What it does |
| --- | --- | --- |
| product\_image | Yes | The photo or logo. It is uploaded and analyzed |
| business\_name | Yes | Goes into the brief, and is sent to Kie.ai as the clip’s watermark |
| business\_description | Yes | What you sell and what sets it apart. It goes into the brief |
| video\_idea | No | How you want the ad to look. Left empty, the brief asks for a professional video with strong camera movement |

To change the look, edit the system message in `AI Agent`. The extra product wording sits in `Code in JavaScript1`, the frame in `aspectRatio` in `HTTP Request`, and the render wait in `Wait`.

### Example

A photo of a pack of oat biscuits, with the description “small-batch oat biscuits” and no video idea. OpenAI is asked to label the picture a product or a logo and to describe its colors, packaging and mood. The agent answers with a JSON brief of this shape:

```json
{
  "description": "…",
  "style": "…",
  "camera": "…",
  "lighting": "…",
  "environment": "…",
  "elements": ["…"],
  "motion": "…",
  "ending": "…",
  "text": "none",
  "keywords": ["16:9", "…"]
}
```

The description and the camera line are joined, with extra effects wording added when the analysis reads as a product, and sent to Kie.ai with the photo’s address.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. A credential is a key n8n keeps for you and hands to the node you pick it in. Run the form from its test address first. Every node then shows what it received and what it sent, which is where a wrong preset or key turns up.

**For experts.** One OpenAI model does both AI jobs, and Kie.ai does the render.

The model behind each step

| Step | Model | What to know |
| --- | --- | --- |
| Analyze image | OpenAI chatgpt-4o-latest, 500 tokens at most | Asked to open with Type: PRODUCT or Type: LOGO, then describe colors, brand feel and video ideas |
| AI Agent | The same model, through the OpenAI Chat Model node | It answers with the JSON brief. \`Code in JavaScript\` tries to parse it and falls back to the raw text |
| Video | Kie.ai Veo 3 Fast (veo3\_fast), 16:9, fallback off, translation on | The prompt is the brief’s description plus its camera line |
| Wait | One fixed pause of 3 minutes | Then one status check and one download, with no retry |

The product test in `Code in JavaScript1` is a keyword search of the analysis for words such as product, food, packaging, ingredients, cookie and snack. A logo whose analysis mentions a product gets product effects. The first code node’s output is not used by the second, which reads the agent and the analysis itself.

### Good to know

Each run costs money, and the render time is a guess.

- Billing: OpenAI and Kie.ai bill their own part of a run
- One wait: if the render is not ready after the three minutes, there is no address to download and the run fails, so raise the wait for long clips
- Open form: once the workflow is published, anyone with the form’s address can start a run on your keys, so turn on the form’s basic authentication or keep the address to yourself
- The picture: an unsigned upload makes it public on Cloudinary, and it also goes to OpenAI and Kie.ai
- Quotes: \`JSON.stringify\` wraps the prompt and the watermark in quotation marks, so the marks may show up in the text Kie.ai receives
- The model name: chatgpt-4o-latest is a moving alias that OpenAI may retire, so pick another vision model in both nodes if one says it is gone
- File types: the form’s file field takes any file type, so send pictures only

## README

```markdown
# Cinematic VFX video ad from a product photo

An n8n workflow. Send a product photo or a logo through its form, with the business name and what it sells, and it returns a
short cinematic ad clip made by Veo 3 Fast.

## What is inside

- `workflow.json`: the workflow as n8n exports it, eleven nodes in one line. It holds no credential and calls no sub-workflow.
- `README.md`: these notes.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Cloudinary account with an upload preset whose signing mode is Unsigned.
- An OpenAI API key.
- A Kie.ai API key.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Open the node named `Upload Photo1`. In its address, put your cloud name where it says `<YOUR_CLOUD_NAME>`. Then swap
   `YOUR_PRESET_NAME` for your preset and `YOUR_FOLDER_NAME` for the folder the pictures should land in.
3. Add an OpenAI credential and select it in `Analyze image` and `OpenAI Chat Model`.
4. Open `HTTP Request` and `HTTP Request1`. In each one's `Authorization` header, replace `<YOUR_KIE_API_KEY>` after
   `Bearer ` with your Kie.ai key.
5. Save, run it once from the form's test address, then press Publish at the top of the canvas (or Shift+P).

## The form

| Field | Needed | What it does |
|---|---|---|
| `product_image` | Yes | The photo or logo. It is uploaded to Cloudinary and analyzed |
| `business_name` | Yes | Goes into the brief, and is sent to Kie.ai as the clip's watermark |
| `business_description` | Yes | What you sell and what sets it apart. It goes into the brief |
| `video_idea` | No | How you want the ad to look. Left empty, the brief asks for a professional video with strong camera movement |

## How a run goes

1. `Upload Photo1` sends the picture to Cloudinary and gets its `secure_url`.
2. `Analyze image` asks OpenAI whether the picture is a product or a logo and for a description, up to 500 tokens.
3. `AI Agent` writes the video brief as JSON from that analysis, the business name and description, and the video idea.
4. `Code in JavaScript` takes the brief's description. `Code in JavaScript1` reads the brief and the analysis again. If the
   analysis contains words like product, food, packaging, ingredients, cookie or snack, it adds extra effects wording to the
   description and the camera line.
5. `HTTP Request` posts to Kie.ai's `veo/generate` endpoint with the prompt, the picture's address, `veo3_fast`, a 16:9 frame,
   the business name as the watermark, fallback off and translation on.
6. `Wait` pauses for 3 minutes. `HTTP Request1` asks `veo/record-info` for the task, and `HTTP Request2` downloads the first
   address in the result.

The clip lands in the run's execution data as a file, so add a node after `HTTP Request2` to save it to a drive or send it on.

## Change it

- Look and effects: edit the system message in `AI Agent`. It lists the effects, camera moves and lighting it asks for.
- Extra product wording: the sentences added for products are in `Code in JavaScript1`.
- Frame: change `aspectRatio` in `HTTP Request`, for example to `9:16` for Reels and Shorts.
- Render time: raise the amount in `Wait` for longer clips.
- Storage: rename the Cloudinary folder per brand or per campaign.
- Models: both OpenAI nodes name `chatgpt-4o-latest`, and any vision-capable model can take its place in each.

## Good to know

- Each run costs money on OpenAI and Kie.ai.
- The workflow waits once, for 3 minutes. If the render is not ready by then, `HTTP Request2` has no address to download and the
  run fails. Raise the wait for long clips.
- Once the workflow is published, anyone with the form's address can start a run on your keys. Turn on the form trigger's
  basic authentication or keep the address private.
- An unsigned upload gives the picture a public address. The picture also goes to OpenAI and Kie.ai.
- `JSON.stringify` wraps the prompt and the watermark in quotation marks, so the marks may show up in the text Kie.ai receives.
- The brief leans toward food and drink, with ingredients assembling in slow motion. For other products, rewrite the system message.
- `chatgpt-4o-latest` is a moving alias that OpenAI may retire, and a node that reports it gone needs a different model.
- The form's file field takes any file type, so send pictures only.
```

## What is in it

2 files, 21 KB, downloaded as a zip.

```text
README.md  4 KB
workflow.json  16 KB
```

## Workflow check

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

- Steps: 10 steps, starting on a form
- AI: 2 steps call an AI model: Analyze image and AI Agent
- Sign-ins: Signs in to: OpenAI and 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 6 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/45c2d82c-26cb-4a82-bd9d-8249fb84991d)
- [Its page on Mindket](https://mindket.com/p/45c2d82c-26cb-4a82-bd9d-8249fb84991d)
