---
title: "Six photos to one morphing transformation video"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/053881af-8c48-4f09-993d-df93c5a55900"
updated: "2026-11-09"
---

# Six photos to one morphing transformation video

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

An n8n workflow that turns six pictures into one morphing video. RunningHub makes a two-second clip between each neighbouring pair, and fal.ai joins the five clips in the order you sent them.

Six photos to one morphing transformation video 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 six pictures into one video that morphs from each picture into the next. You send them through a form. RunningHub makes five clips of two seconds, one for each neighbouring pair, with the first picture of a pair as the opening frame and the second as the closing one. Then fal.ai joins the five clips in order, and the last node downloads the result. Fifty-seven nodes run it, most of them one short chain repeated for each pair.

### Who it suits

People who show change over time, such as a room during a renovation, a garden through a season or a product across its versions. You bring the six pictures. Skip it if you want music, captions or a voice added. It only joins the clips.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Social video | Creators who post Reels and Shorts | Send six moments in order and post the vertical clip | A creator morphs six photos of a puppy into the grown dog. |
| Home renovation | Builders and interior designers | Show one room at each stage of the job | A designer sends six photos of a kitchen, from bare walls to the finished room. |
| Fitness coaching | Coaches who track clients | Send a client’s monthly progress photos, with the client’s consent | A coach gives a client a clip of six months of progress. |
| Consumer brands | Product marketers | Show one product line across its releases | A shoe brand runs six versions of one model through it, oldest first. |

You need a little n8n: importing a file, pasting two keys and publishing a form. There are no credentials to add. Its author puts setup at about five minutes, with both accounts already open.

### Where to use it

Any n8n that can reach RunningHub and fal.ai will run it. The video lands in the run itself, so decide where it goes next.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file, the same steps
- Reels, Shorts and TikTok: the file makes vertical clips, ready for those feeds
- A drive or a chat app: add a node after \`downloadVideo\` to save the video 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. Both keys go into one node, so setup is short.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| RunningHub | An account and its API key. Each clip is a paid task |
| fal.ai | An account and its API key, for the job that joins the clips |
| Six pictures | In \`.jpg\`, \`.jpeg\`, \`.png\` or \`.webp\`, in the order the video should follow |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Open `API Setup` and replace `YOUR_RUNNINGHUB_API_KEY` with your RunningHub key.
3. In the same node, replace `YOUR_FAL_KEY` with your fal.ai key alone. The fal.ai nodes put the word `Key` in front of it themselves.
4. Optional: in `On form submission`, turn Multiple Files off on the fifth and sixth fields, as it already is on the first four.
5. Save, send six pictures through the form’s test address, then press Publish.

### How to use it

Open the form, attach one picture to each of its six fields in the order you want, and send it. The form confirms at once while the run goes on. Expect several minutes. The workflow waits a minute before every check, and the clips are made one after another. When `downloadVideo` has run, open the run under Executions to get the file.

What to change for a different result

| To change | Where |
| --- | --- |
| Frame | Node 304 in all five \`HTTP Request\` nodes: \`1\` is vertical, as in the file, and \`0\` horizontal |
| Length of each clip | Node 307 in the same five nodes, \`2\` seconds in the file |
| Order | The form’s fields: the first picture opens the video and the sixth closes it |
| Check timing | \`Wait\` to \`Wait4\`, one minute each, and \`Wait5\`, 30 seconds |
| Which RunningHub app | \`webappId\` in the same five nodes. Its node numbers belong to that app |

### Example

You send six photos of a garden, one taken each month from March to August, all from the same spot.

The five clips

| Clip | Opens on | Closes on |
| --- | --- | --- |
| 1 | March | April |
| 2 | April | May |
| 3 | May | June |
| 4 | June | July |
| 5 | July | August |

fal.ai joins the five in that order. With the file’s settings, you get a vertical video of about ten seconds that grows from bare soil to full summer. Photos from one spot suit it best, since each clip has only its two frames to work from.

### 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. This one looks big. It is one chain five times over: upload two pictures, start a clip, wait, check, fetch. Send six small test pictures first, then open each node in the run to see what RunningHub sent back.

**For experts.** The five pairs sit side by side on the canvas, but n8n’s v1 execution order runs them one at a time.

The parts that repeat

| Part | Nodes | What to know |
| --- | --- | --- |
| Uploads | Ten upload nodes | Pictures two to five go up twice, once for each pair they belong to |
| Pairs | \`Merge\` and \`Merge2\` to \`Merge5\`, each with an \`Aggregate\` | Append mode, so \`data\[0\]\` is the opening frame and \`data\[1\]\` the closing one |
| Clips | \`HTTP Request\` to \`HTTP Request4\` | The RunningHub AI app \`1935261777502601217\`, its nodes 64 and 112 taking the two frames |
| Polling | \`Wait\`, \`checkStatus\` and \`If\`, five times | Only SUCCESS leaves the loop |
| Joining | \`Merge All links\`, \`Aggregate5\`, \`Submit merge job\` | Five inputs in pair order, sent to fal.ai’s \`ffmpeg-api/merge-videos\` queue |

Uploading each picture once and pairing the stored names would save four uploads on every run.

### Good to know

It costs money at two vendors, and one failed clip keeps the run waiting.

- Billing: RunningHub bills five clip tasks for each run, and fal.ai one merge job
- A failed clip: the \`If\` nodes look for SUCCESS only, so a task that fails is checked every minute without end. Stop that run under Executions
- Two files in one field: the fifth and sixth fields leave Multiple Files on. Two files there get numbered names, and the upload node finds neither
- Open form: once the workflow is published, anyone with the form’s address can start a run on your accounts
- Your keys: both sit as plain text in \`API Setup\`, so take them out before you share the workflow
- Your pictures: they go to RunningHub, and the clips’ addresses to fal.ai. Use pictures you have the right to use
- Credentials: the JSON holds none, and nothing from its author’s accounts

## README

```markdown
# Six photos to one morphing transformation video

An n8n workflow. Send six pictures through its form, and RunningHub turns each neighbouring pair into a short clip that
morphs one picture into the next. Then fal.ai joins the five clips into one video, in the order you sent the pictures.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 57 nodes and no sticky notes. It holds no credential. Your two keys go
  into one node, `API Setup`.
- `README.md`: these notes.

## What we changed from the original copy

- Both fields of `API Setup` held the same words asking for a key. They are now `YOUR_RUNNINGHUB_API_KEY` and
  `YOUR_FAL_KEY`, so you can tell them apart.
- Nothing else. Its one Code node, `getBinaryFile`, needed no repair.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A RunningHub account and its API key. Each clip is a paid task there.
- A fal.ai account and its API key, for the job that joins the clips.
- Six pictures in `.jpg`, `.jpeg`, `.png` or `.webp`, in the order the video should follow.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Open `API Setup` and replace `YOUR_RUNNINGHUB_API_KEY` with your RunningHub key.
3. In the same node, replace `YOUR_FAL_KEY` with your fal.ai key, and nothing more. The three fal.ai nodes put `Key` and a
   space in front of it themselves, so a value typed as `Key …` would reach fal.ai as `Key Key …` and be refused.
4. Optional: open `On form submission` and turn Multiple Files off on the fifth and sixth fields, as it already is on the
   first four (see Good to know).
5. Save, open the form's test address and send six pictures through it.
6. Press Publish, then share the form's production address.

The form confirms at once, and the run goes on behind it. The joined video ends up as a file in `downloadVideo`, so open
the run under Executions to get it, or add a node after `downloadVideo` to save it to a drive or send it on.

## How a run goes

1. `On form submission` takes the six files. `getBinaryFile` passes them on, and `Merge1` puts them in one item with the
   two keys from `API Setup`.
2. Ten upload nodes send the pictures to RunningHub. Pictures two to five go up twice, once as the closing frame of one
   pair and once as the opening frame of the next.
3. `Merge` and `Merge2` to `Merge5`, each followed by an `Aggregate` node, build the five pairs: 1 and 2, 2 and 3, 3 and 4,
   4 and 5, 5 and 6.
4. For each pair, one of `HTTP Request` to `HTTP Request4` starts the RunningHub AI app `1935261777502601217`. The opening
   frame goes into its node 64 and the closing frame into node 112. Two more of its nodes set a vertical frame and a clip
   of two seconds (Change the look).
5. A `Wait` node pauses one minute, then a `checkStatus` node asks for the task's state. Its `If` node sends SUCCESS on to
   `getOutput`, which reads the clip's address. Any other state goes back to the same `Wait` for another minute.
6. `Merge All links` collects the five clips in pair order, and `Aggregate5` puts their addresses in one list.
7. `Submit merge job` sends the list to fal.ai's FFmpeg merge endpoint. `Wait5` pauses 30 seconds, `Check Status` asks for
   the job's state, and `If5` loops back to `Wait5` until fal.ai reports COMPLETED.
8. `Get Final Result` reads the joined video's address, and `downloadVideo` fetches the file.

| Node | Endpoint | Sends | Gets back |
|---|---|---|---|
| The ten upload nodes | RunningHub `/task/openapi/upload` | the key and one picture | the stored picture's `fileName` |
| `HTTP Request` to `HTTP Request4` | RunningHub `/task/openapi/ai-app/run` | the key, `webappId` and `nodeInfoList` | a `taskId` |
| `checkStatus` to `checkStatus4` | RunningHub `/task/openapi/status` | the key and the `taskId` | the task's state, such as SUCCESS |
| `getOutput` to `getOutput4` | RunningHub `/task/openapi/outputs` | the key and the `taskId` | the clip's `fileUrl` |
| `Submit merge job` | fal.ai `fal-ai/ffmpeg-api/merge-videos`, on its queue | the five addresses in `video_urls` | a `request_id` |
| `Check Status`, `Get Final Result` | fal.ai `fal-ai/ffmpeg-api/requests/<request_id>` | the key | the job's state, then `video.url` |

## Change the look

- Frame: node 304 in all five `HTTP Request` nodes, `1` for vertical and `0` for horizontal. Change all five, or the clips
  will not match when they are joined.
- Clip length: node 307 in the same five nodes. The file sets `2` seconds, so the joined video runs about ten seconds.
- Order: the form's fields. The first picture opens the video and the sixth closes it.
- Check timing: `Wait` to `Wait4` pause one minute before each RunningHub check, and `Wait5` pauses 30 seconds before each
  fal.ai check.
- The form: its title reads `Start & End Frame Tranformation Creator`, spelled as in the file. Rename it in
  `On form submission`. If you rename a field, change the upload nodes too: they read the files as
  `Upload_your_1st_image` to `Upload_your_6th_image`, names n8n makes from the field labels.
- Which app makes the clips: `webappId` in the five `HTTP Request` nodes. The node numbers in `nodeInfoList` belong to
  that app, so check them if you point it at another.

## Good to know

- RunningHub bills five clip tasks for each run, and fal.ai bills one merge job.
- A clip that fails never ends the run. The `If` nodes look for SUCCESS only, so a failed task is checked again every
  minute. When no video has arrived after a long wait, open the run under Executions and stop it.
- n8n's v1 execution order, which this file uses, runs the five branches one at a time. The clips are made one after
  another, each with at least a minute of waiting, before the merge starts.
- The fifth and sixth form fields leave Multiple Files at n8n's default, which is on. Send one picture in each. Two files in
  one field get numbered names, such as `Upload_your_5th_image_0`, and the upload node finds neither.
- Once the workflow is published, anyone with the form's address can start a run on your RunningHub and fal.ai accounts.
- Both keys sit as plain text in `API Setup`, so anyone who can open the workflow can read them. Take them out before you
  share it.
- The pictures go to RunningHub, and the clips' addresses go to fal.ai. Use pictures you have the right to use, and show
  a person's face only with their consent.
```

## What is in it

2 files, 60 KB, downloaded as a zip.

```text
README.md  6 KB
workflow.json  54 KB
```

## Workflow check

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

- Steps: 57 steps, starting on a form
- AI: No step calls an AI model
- Sign-ins: Signs in to: RunningHub and fal.ai
- API keys: No API key is left in the file; 2 blanks in it for your own key
- Step types: Mindket’s checker reads all 8 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/053881af-8c48-4f09-993d-df93c5a55900)
- [Its page on Mindket](https://mindket.com/p/053881af-8c48-4f09-993d-df93c5a55900)