How to Auto-Generate Faceless Shorts with ChatGPT and n8n

Learn how to build an n8n workflow that turns a topic into an AI-generated Short with a ChatGPT-written script, AI voiceover, animated subtitles, and automatic YouTube upload.

Faceless channels run on volume: short, narrated videos that don't need a camera, a studio, or even your own voice. The bottleneck is producing them consistently. In this step-by-step guide, we'll automate that process with n8n.

You provide a topic and a set of images. ChatGPT writes the script, ElevenLabs turns it into a voiceover, and Creatomate assembles the finished Short with animated subtitles, ready to publish on YouTube.

By the end of this tutorial, you'll have generated a Short just like the one above – written, voiced, subtitled, and uploaded without any manual video editing.

Want a different look? Creatomate's online template editor lets you customize the complete video design, including the scenes, branding, subtitle styling, animation, and voice.

Prerequisites

These are the tools we'll use:

• Creatomate: to customize the video template and generate the finished Shorts.
• OpenAI: to let ChatGPT write the narration, YouTube title, and description. You'll need an OpenAI API key with API billing enabled.
• ElevenLabs: to produce the AI voiceover. The standard voice included in the template works with a free ElevenLabs account, provided the account has enough credits.
• n8n: to build and run the automated workflow.
• YouTube (optional): to publish the generated Shorts.

How to create AI-generated Shorts with ChatGPT and n8n

We'll start in ElevenLabs by creating an API key and connecting it to the Creatomate project. Next, we'll import a reusable video template with six visual slots, each shown for an equal portion of the video, a dynamic voiceover element that determines the video's duration, and animated subtitles transcribed from the narration.

In n8n, a Manual Trigger starts the example workflow and an Edit Fields node supplies a topic and six image URLs. ChatGPT uses the topic to write the narration, along with a title and description for YouTube.

Next, the Creatomate node maps the images and narration to the template. Creatomate sends the text to ElevenLabs, generates synchronized subtitles, and renders the complete video. Once it is ready, n8n downloads the MP4 and uploads it to YouTube.

This is the workflow we'll build:

Copy this workflow and paste it into an empty n8n canvas with Ctrl+V.

Copy workflow

Let's get started!

1. Set up ElevenLabs

Creatomate uses ElevenLabs to generate the voiceover while the video is being rendered. To authorize these requests, we'll create an ElevenLabs API key and add it to the Creatomate project.

Create an ElevenLabs API key

Sign in to your ElevenLabs account or create one if necessary. Click Developers in the left sidebar, open the API Keys tab, and click Create Key:

Give the key a descriptive name, such as Creatomate faceless shorts, so you can recognize it later. Configure the key as follows:

• Expire After: select Never for an ongoing workflow, or choose an expiration period if you regularly rotate API keys
• Restrict Key: keep this enabled
• Endpoints: set Text to Speech to Access and leave the other endpoints set to No Access
• Usage Limits (Credits) (optional): set a limit if you want to control how many ElevenLabs credits the key can consume

Then click Create Key:

Copy the API key when it appears. ElevenLabs only shows the complete key once, so store it securely before closing the dialog.

Connect ElevenLabs to Creatomate

Log in to your Creatomate account or sign up for free if you don't have one yet.

Click your project in the top-left corner and choose Project Settings. Open the Integration tab, enable ElevenLabs, paste the API key you just created, and click Confirm:

Creatomate can now use your ElevenLabs account to generate voiceovers during rendering. The API key remains stored in the Creatomate project and does not need to be added to n8n.

2. Import the faceless video template

For this tutorial, we'll use the Faceless Short template. Click the banner below to add a copy directly to your Creatomate project:

Template used in this tutorial

Faceless Short

A copy lands in your project, ready to edit.

Import template

Once imported, the template opens in the editor. It defines the design and automation settings, while the n8n workflow supplies the variable content for every video.

Don't worry if the canvas looks mostly empty. The voiceover and subtitles are generated during rendering, and the dynamic visual elements will be filled by the workflow.

How the voiceover is generated

Select the Voiceover element. In the Properties panel, its audio Provider is set to ElevenLabs. When the workflow supplies the narration written by ChatGPT, Creatomate sends that text to ElevenLabs and uses the generated audio as the video's voiceover.

The template uses the Eleven Multilingual v2 model and the Matilda voice by default. You can keep these settings for this tutorial or choose another supported voice. The Stability, Similarity, Style, and Speaker Boost settings let you fine-tune how the narration sounds.

The generated voiceover determines the video's duration.

How the subtitles are generated

Select the Subtitles element. Its Source is connected to the Voiceover element. This tells Creatomate to transcribe the generated narration and turn it into synchronized subtitles during rendering.

The text shown in the editor is only a preview. The actual subtitles are generated from the ElevenLabs voiceover, so you don't need to create or synchronize a separate subtitle file.

The default subtitle design is ready to use. If you'd like to customize it, you can adjust the font, size, spacing, alignment, fill, stroke, background, and position using the remaining properties.

Customize the subtitle animation

To change how the captions appear as the words are spoken, open the Animation panel and select Caption. The editor provides live previews of the available effects, so you can try different styles and immediately see how they behave.

Use Split and Max. length to control how much text appears at once. The template is already set to Word with a Max. length of 1, creating the one-word-at-a-time style commonly used in Shorts, Reels, and TikTok videos. Increase Max. length if you prefer to display several words together. You can also adjust the placement and highlight color:

Dynamic visuals

Clip-1 through Clip-6 are dynamic visual elements. The workflow can replace each source with a publicly accessible image or video URL. The template distributes the six visuals evenly across the generated voiceover. We'll map these elements in step 5.

Any changes you make to the template will automatically be used in future renders. For more information about customizing scenes and elements, see the Creatomate template editor guide.

The template is ready. Let's move on to n8n.

3. Start your n8n workflow

The goal of this step is to provide a topic for the video and six images for its visual scenes. To keep the example easy to follow, we'll use a Manual Trigger and an Edit Fields node.

In your n8n dashboard, click Create workflow.

Click Add first step... and choose Trigger manually. The node appears on the canvas as When clicking 'Execute workflow'.

Click the + after the trigger and add an Edit Fields (Set) node.

Set Mode to JSON. Remove the example content and replace it with:

You can replace the topic and sample images with your own. Each image must be available through a direct, publicly accessible URL. Keep the field names Topic and Clip-1 through Clip-6 unchanged for now, because we'll use them in the following steps.

Click Execute step. The output should contain the topic and six image URLs:

4. Write the script with ChatGPT

ChatGPT will now turn the topic into a complete narration, along with a title and description for YouTube.

Connect OpenAI to n8n

If you already have an OpenAI credential in n8n, you can reuse it and continue with the node configuration below.

Otherwise, sign in to the OpenAI Platform or create an account. OpenAI API usage is billed separately from ChatGPT, so a ChatGPT subscription does not cover requests made by n8n. Open the Billing page and make sure your API account has sufficient credit before continuing.

Next, open the API Keys page and click Create new secret key. Give the key a descriptive name, such as n8n faceless shorts, select the OpenAI project you want to use, and review the expiration and permission settings. Then click Create secret key.

Copy the key when it appears. OpenAI only shows the complete secret key once.

Configure the OpenAI node

Click the + after Edit Fields, search for OpenAI, and select the Message a Model action.

Under Credential, select an existing OpenAI credential. If you haven't connected OpenAI to n8n yet, choose Create new credential, paste the API key you just created, and click Save. Then return to the OpenAI node and select the saved credential.

Configure the node as follows:

• Resource: Text
• Operation: Message a Model
• Model: GPT-5.6-SOL

Sol prioritizes output quality. If you plan to generate videos at scale, you can also test a faster or lower-cost model and compare whether the narration still meets your requirements.

Under Messages, paste the following into the Prompt field:

The expression {{ $json.Topic }} inserts the topic from Edit Fields. The preview underneath the input should show the actual topic. If n8n treats the expression as plain text, switch the field from Fixed to Expression.

Click Execute step. The OpenAI node should return the requested JSON as text under output → content → text:

Before these values can be mapped to other nodes, we need to parse the returned text.

Add a Code node and select Code in JavaScript. Replace the sample code with:

1const text = $input.first().json.output[0].content[0].text;
2return [{ json: JSON.parse(text) }];

The first line retrieves ChatGPT's response. The second converts the JSON string into separate n8n fields.

Click Execute step. The output should now contain Voiceover, Title, and Description:

We'll use Voiceover to generate the video, while Title and Description will be used for the YouTube upload.

5. Generate the faceless Short with Creatomate

Click the + after the Code node and search for Creatomate.

If you haven't used the node before, open its details and click Install node. n8n installs the verified Creatomate node into your workspace:

After installation, choose Create a render under Render actions:

Connect your Creatomate account

Under Credential, click Connect to Creatomate:

In a separate browser tab, return to Creatomate. Click your project in the top-left corner and choose Project Settings. Open the API section and copy the API key for this project:

Back in n8n, paste the key into the Creatomate credential and click Save:

An API key belongs to one Creatomate project. If you use multiple projects, create a separate n8n credential for each one.

Select the faceless video template

Return to the Creatomate node. Under Template, leave From list selected and choose the Faceless Short template imported in step 2.

The node loads the template's dynamic elements under Values to Send:

Map the content

Set Mapping Column Mode to Map Each Column Manually.

Map the template elements as follows:

• Clip-1 → {{ $('Edit Fields').item.json['Clip-1'] }}
• Clip-2 → {{ $('Edit Fields').item.json['Clip-2'] }}
• Clip-3 → {{ $('Edit Fields').item.json['Clip-3'] }}
• Clip-4 → {{ $('Edit Fields').item.json['Clip-4'] }}
• Clip-5 → {{ $('Edit Fields').item.json['Clip-5'] }}
• Clip-6 → {{ $('Edit Fields').item.json['Clip-6'] }}
• Voiceover → {{ $json.Voiceover }}

The clip expressions explicitly retrieve the images from Edit Fields. The voiceover can use $json directly because the Creatomate node receives the parsed ChatGPT output from the Code node.

Check the previews underneath the expressions. They should show six image URLs and the complete voiceover text.

Generate the video

Before running the node, leave Wait for Completion enabled. This ensures that the workflow continues only after the finished MP4 is ready.

Click Execute step. Creatomate sends the narration to ElevenLabs to generate the voiceover, uses the resulting audio to determine the video's duration, distributes the six supplied visuals across the timeline, transcribes the voiceover into synchronized subtitles, and renders the complete Short.

Once the video is ready, the output should show a successful render and include a public url for the MP4:

Open the URL to watch your generated video. Because ChatGPT may produce a different narration each time, your result will likely differ from ours. Here's the Short generated during our test run:

You can also review your renders on the API Log page in Creatomate. Each entry shows the render status, video output, render time, resolution, and the number of Creatomate credits used. These credits cover Creatomate rendering only; ElevenLabs and OpenAI usage are tracked separately by those services. If a render fails, the API Log displays the complete error message. Use this information to identify and fix the problem before running the workflow again.

6. Download the finished video

The YouTube node requires the actual video file rather than a URL, so we'll download the finished MP4 first.

Click the + after the Creatomate node and add an HTTP Request node. Rename it Download Video.

Configure it as follows:

• Method: GET
• URL: {{ $json.url }}

Under Options, add Response and configure:

• Response Format: File
• Put Output in Field: data

No authentication is required because the finished video is available through a public URL.

Click Execute step. The output should contain a binary file named data:

7. Upload the Short to YouTube

Click the + after Download Video, search for YouTube, and select the Upload a video action.

Connect your YouTube channel

Under Credential, select an existing YouTube credential. If you haven't connected your channel yet, create a new credential and follow the n8n YouTube credential documentation to authorize the Google account that manages your YouTube channel.

Configure the upload

Configure the node as follows:

• Resource: Video
• Operation: Upload
• Region Code: select the region whose available YouTube categories you want to load, such as US
• Category Name or ID: select the category that best matches the video, such as Entertainment
• Input Binary Field: data

For Title, enter: {{ $('Code in JavaScript').item.json.Title }}

Under Options, click Add option, select Description, and enter: {{ $('Code in JavaScript').item.json.Description }}

These expressions retrieve the title and description generated by ChatGPT:

Click Execute step to test the upload.

Open the Content page in YouTube Studio. The new Short should appear with the title and description written by ChatGPT:

That's it – the workflow can now turn a topic and six images into a complete faceless Short and upload it to YouTube.

What's next for faceless Shorts with n8n

The Manual Trigger and sample content make it easy to test the workflow. For a live automation, replace them with a trigger and content sources that match how you plan and produce your videos.

For example, you could start the workflow on a schedule, when a new spreadsheet row is added, after receiving a form submission, or when another workflow provides a new video idea.

You'll also need a source for the topic and visuals. These could come from a spreadsheet, database, CMS, cloud storage folder, or another AI workflow. If you want to generate the visuals from prompts, see how to create AI-generated Shorts with GPT Image and n8n.

Once the workflow has been tested with your own content, activate it so the chosen trigger can run automatically. Each time it receives a new topic and set of images, ChatGPT writes the content, ElevenLabs generates the narration, Creatomate renders the video, and n8n sends it to your selected destination.

Here are some related tutorials:

👉 How to Create AI Voiceover Videos with n8n – choose an ElevenLabs voice and customize the video and subtitle styling.
👉 How to Create AI-Generated Shorts with GPT Image and n8n – generate the background visuals from text prompts.
👉 How to Automatically Create YouTube Shorts with n8n – create Shorts using your own images and pre-recorded voiceover files.