--- title: "Blog post turned into 9:16 scene images and a thumbnail" kind: "Kit" category: "Marketing & SEO" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/45c3af03-b918-4767-bc06-da42f5b23622" updated: "2026-11-12" --- # Blog post turned into 9:16 scene images and a thumbnail > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that takes a blog post from Airtable, has OpenAI write a four-scene video script, and draws a 9:16 image for each scene and the thumbnail with Leonardo.ai. The image links go into an Assets table. Blog post turned into 9:16 scene images and a thumbnail is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. 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 blog post into the pictures for a short vertical video. It reads a post from Airtable, and an OpenAI model writes a script of four scenes with an image prompt for each, plus a prompt for the thumbnail. Leonardo.ai improves each prompt and draws the picture, and the links land in an Assets table in Airtable. Twenty-seven nodes do the work, beside twelve sticky notes. ### Who it suits Content marketers and small video teams who keep posts in Airtable and want storyboard pictures without a designer for each one. Skip it if your posts do not live in Airtable, or if you need the finished video. This makes the script and the pictures only. It does not cut a video. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Marketing | Content marketers | Turn a post into scene art for a short video | A marketer picks a post by keyword and gets four scene images. | | Media | Video producers | Get a first storyboard before a shoot | A producer reads the four scripts beside their images. | | Agencies | Social media managers | Prepare vertical covers for a client’s posts | A manager gets a thumbnail and scenes in one run. | | E-commerce | Brand teams | Illustrate a buying guide for a short clip | A brand team runs a product article through it. | You need a little n8n, an Airtable base laid out as described below and two API keys. Budget for image credits too. ### Where to use it Any n8n that can reach Airtable, OpenAI and Leonardo.ai will run it. The pictures appear as links in your Assets table. - n8n Cloud: import the file into a new workflow there - Your own n8n server: the same file and steps - Your Airtable base: four tables, listed under the setup - Other workflows: reuse the loop that draws one scene for any list of image prompts ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Setup is three credentials, five Airtable ids and one keyword. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | Airtable | A base with four tables, listed next | | OpenAI | An API key | | Leonardo.ai | An API key with API credits, which are sold apart from its website plans | The four Airtable tables | Table | Fields the workflow reads or writes | | --- | --- | | Brand guidelines | Any rows. Only their record ids are read | | SEO keywords | \`Keyword\` and \`RelatedContent\`, a link to the content table | | Content | \`Title\` and \`Content\` | | Assets | \`Asset Name\`, \`Asset Type\` with an \`Image\` choice, \`File Size\` and \`Asset URL\` | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Add an Airtable credential and select it in the five Airtable nodes. In each, write your base id and table id over the placeholders. `Get Content` takes the id of your content table. 3. Add an OpenAI credential and select it in `Script Prep`. Its model, `gpt-4o-mini`, is due to shut down on 14 January 2027, so pick another before then. 4. Add a Custom Auth credential with `{"headers": {"authorization": "Bearer "}}` and select it in the six Leonardo.ai calls. 5. In `Keyword Filter`, replace `ai automation` with a word from your own keyword rows. 6. Press Execute workflow, then look at your Assets table. ### How to use it Run it once for each post. The keyword filter picks which post, and `Limit` passes the first one on. A run ends with five rows in the Assets table. Each scene row carries the scene’s script in its name, and the thumbnail row carries the post’s title. What to change for a different result | To change | Where | | --- | --- | | The post | The text in \`Keyword Filter\` | | The script | The prompt in \`Script Prep\` | | The picture style | The \`presetStyle\` in the generate calls | | The size | \`width\` and \`height\` in the generate calls | | The pictures per scene | \`num\_images\` in the generate calls | ### Example A marketer runs a post about AI automation through it to get a storyboard for a vertical clip. The model writes four scripts with image prompts and a thumbnail prompt. Leonardo.ai draws one 768 by 1376 picture for each scene and one for the thumbnail, and the Assets table gains five rows with image links. Look at the pictures before you use them, because a prompt can miss the point of the post. ### For newcomers and experts **If you are new.** A script here is a few words of narration for each scene. An image prompt is a sentence that tells the picture maker what to draw. The workflow takes the scenes one at a time and waits between steps, so Leonardo.ai has time to finish each picture. **For experts.** `Script Prep` is the OpenAI node in its message mode, with JSON output on and the Wikipedia tool attached. `Loop Over Items` runs the scene line at a batch size of one. The thumbnail has its own line of nodes beside the loop. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Get SEO Keywords\` | Searches the keyword table once for each brand row | \`Remove Duplicates\` drops the repeats | | \`Script Prep\` | Writes the script and the image prompts as JSON | The prompt names no JSON keys, so a run can stop at \`Split Out Scenes\` | | The scene generate call | Starts a 768 by 1376 picture with \`ultra\` on | It returns an id, not the picture | | \`Wait 30 Seconds1\` | Waits before the fetch | A slow picture is not ready, and the next step fails | | \`Add Asset Info1\` | Writes one Assets row for the scene | \`File Size\` is always 0 | ### Good to know The script step uses a model that is due to shut down, and a few details are worth a look. - Models: \`Script Prep\` uses \`gpt-4o-mini\`. OpenAI’s deprecations page, read on 12 November 2026, lists the snapshot \`gpt-4o-mini-2024-07-18\` for shutdown on 14 January 2027, with \`gpt-6-luna\` as the replacement. Pick another model in the node before then - Names: the prompt gives the model a layout and no key names. The next steps look for a \`scenes\` list with \`script\` and \`image\_prompt\` in each scene, and for \`thumbnail\_prompt\`. If a run stops at a Split Out node, add those names to the prompt - Thumbnail field: the thumbnail’s improve call reads \`message.content\['Thumbnail Prompt'\]\`, while the split step before it uses \`message.content.thumbnail\_prompt\`. If that prompt arrives empty, make the two names the same - Brand table: its rows are fetched and none of their text reaches a prompt. The \`additional\` field is set and not used - Cost: a run makes one OpenAI call and fifteen Leonardo.ai calls, five of them generations. The scenes use \`ultra\` and the thumbnail uses \`alchemy\` with high resolution, which cost more than a plain generation - Time: each generation is followed by a fixed wait of half a minute. Raise it if a picture is not ready by then - The API: the workflow calls Leonardo’s v1 generations endpoint, which its documentation still lists on 12 November 2026 - Your data: the post goes to OpenAI, the prompts go to Leonardo.ai, and the generations are set to private on your Leonardo account - Credentials: the JSON holds none, and the Airtable ids are placeholders ## README ```markdown # Blog post turned into 9:16 scene images and a thumbnail An n8n workflow that takes one blog post from Airtable and has an OpenAI model write a four-scene script for a short vertical video. Leonardo.ai then draws an image for every scene and one for the thumbnail, and the image links go into an Assets table. The video itself is not made here. You get the script and the pictures to build it from. ## What is inside - `workflow.json`: the workflow as n8n exports it, 39 nodes, twelve of them sticky notes that label the stages on the canvas. It holds no credential, no Airtable id and no saved sample data. - `README.md`: these notes. ## What we changed from the original copy - Every credential link is gone: Airtable, OpenAI and the Leonardo.ai Custom Auth credential. Select your own. - The Airtable base id and the ids of the three tables the workflow names are now placeholders: ``, ``, `` and ``. - `Get Content` pointed at the same table as the keyword search, but it reads a post by the record id the keyword row links to. It now has its own placeholder, ``. Put the id of the table that holds your posts there. - The saved sample data from the author's test runs is cleared, and the export's tags, instance id and version id are gone. - One sticky note was an author's promotion. It is now a short title note. The two notes beside the model ids called the Leonardo.ai model the latest. They now name it, Phoenix 1.0. ## Before you start - An n8n instance. - An Airtable base with four tables, described next. - An OpenAI API key. - A Leonardo.ai API key with API credits. Leonardo sells API credits apart from its website plans. The four tables, with the fields the workflow reads and writes: - Brand guidelines: any rows. Their record ids are read, and no text from them reaches a prompt. - SEO keywords: `Keyword` (text) and `RelatedContent` (a link to a record in the content table). - Content: `Title` and `Content` (text). - Assets: `Asset Name` (text), `Asset Type` (single select with `Image`), `File Size` (number) and `Asset URL` (text). ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. Add an Airtable credential. Select it in the five Airtable nodes, and write your base id and the four table ids over the placeholders in each of them. 3. Add an OpenAI credential and select it in `Script Prep`. Its model, `gpt-4o-mini`, is due to shut down on 14 January 2027, so pick another before then. 4. Add a Custom Auth credential for the six Leonardo.ai calls, with this JSON, and select it in `Leo - Improve Prompt`, `Leo - Generate Image`, `Leo - Get imageId`, `Leo - Improve Prompt1`, `Leo - Generate Image1` and `Leo - Get imageId1`: `{"headers": {"authorization": "Bearer "}}` 5. In `Keyword Filter`, replace `ai automation` with a word that appears in the `Keyword` of the post you want. 6. Press Execute workflow, then look at your Assets table. ## How a run goes 1. `When clicking ‘Test workflow’` starts the run by hand. 2. `Get Brand Guidelines` reads every row of the brand table. `Set Guidelines` keeps each row's `id`. 3. `Get SEO Keywords` searches the keyword table once for each brand row and returns `Keyword` and `RelatedContent`. 4. `Keyword Filter` keeps the rows whose `Keyword` contains `ai automation`, ignoring case. `Remove Duplicates` drops repeats of the same `id`, because the search ran once per brand row. 5. `Split Out Keywords` makes one item for each linked post, and `Get Content` reads that post by record id. `Split Out Content` and `Limit` pass on a single post. 6. `Script Prep` sends the post's title and content to OpenAI, with the Wikipedia tool attached. It asks for a script of four scenes that runs under 30 seconds in 9:16. Each scene gets an image prompt, and the thumbnail gets its own. The reply is JSON. 7. `Split Out Scenes` makes one item for each scene, and `Loop Over Items` takes them one at a time. Each scene goes through `Prompt Settings1`, which adds a model id, and `Leo - Improve Prompt`, which asks Leonardo to improve the image prompt. Then `Leo - Generate Image` makes a picture 768 by 1376 pixels with `ultra` on. `Wait 30 Seconds1` waits, `Leo - Get imageId` fetches the finished picture and `Add Asset Info1` adds a row to the Assets table. The loop then takes the next scene. 8. Beside the loop, `Split Out TN Prompt` sends the thumbnail prompt down its own line, through `Prompt Settings`, `Leo - Improve Prompt1`, `Leo - Generate Image1` (`alchemy` and high resolution on), `Wait 30 Seconds`, `Leo - Get imageId1` and `Add Asset Info`. A run ends with five rows in the Assets table. The four scene rows have an `Asset Name` that starts with `Scene` and the scene's script, and the thumbnail row starts with `TN` and the post's title. Every row has the image link in `Asset URL`, type `Image` and a file size of 0. ## Change the look - The post: the text in `Keyword Filter`. Take away `Limit`'s one-item cap to run more posts, and you pay for every one. - The script: the prompt in `Script Prep`, which sets the scene count and the length. - The picture style: the `presetStyle` in the generate calls, and the image prompt itself. The model id is in the two Prompt Settings nodes, and the note beside each says it is Phoenix 1.0. - The size: `width` and `height` in the generate calls. - The pictures per scene: `num_images` in the generate calls, which the two optional notes on the canvas point to. Only the first picture of each generation is filed in the Assets table. ## Good to know - Models: `Script Prep` uses `gpt-4o-mini`. OpenAI's deprecations page, read on 12 November 2026, lists the `gpt-4o-mini` snapshot `gpt-4o-mini-2024-07-18` for shutdown on 14 January 2027, with `gpt-6-luna` as the replacement. Pick another model in the node before then. - Names: the prompt gives the model a layout, not key names. The next steps look for a `scenes` list with `script` and `image_prompt` in each scene, and for `thumbnail_prompt`. If a run stops at a Split Out node, add those names to the prompt. - The thumbnail's improve call reads the field `message.content['Thumbnail Prompt']`, while the split step before it is set to `message.content.thumbnail_prompt`. If the thumbnail prompt arrives empty, make the two names the same. - The brand table does not shape the output. Its rows are fetched, and none of their text reaches a prompt. The `additional` field is set and not used. - Cost: a run makes one OpenAI call and fifteen Leonardo.ai calls, five of them generations: four scenes and the thumbnail. The scenes use `ultra` and the thumbnail uses `alchemy` with high resolution, which cost more than a plain generation. Check Leonardo's pricing page for the current rate. - Time: each generation is followed by a fixed wait of half a minute. If a picture is not ready by then, the fetch can return no image, and the Airtable step then fails. Raise the wait. - The API: the workflow calls Leonardo's v1 generations endpoint, which its documentation still lists on 12 November 2026. - Your data: the post goes to OpenAI, the prompts go to Leonardo.ai, and the generations are set to private on your Leonardo account. - One post per run, on purpose: `Limit` passes a single item. ``` ## What is in it 3 files, 45 KB, downloaded as a zip. ```text NOTICE.md 627 B README.md 7 KB workflow.json 37 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 26 steps, starting by hand - AI: 1 step calls an AI model: Script Prep - Sign-ins: Signs in to: Airtable and cloud.leonardo.ai - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 11 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/45c3af03-b918-4767-bc06-da42f5b23622) - [Its page on Mindket](https://mindket.com/p/45c3af03-b918-4767-bc06-da42f5b23622)