--- title: "Faceless YouTube Shorts maker with an idea picker" kind: "Kit" category: "Marketing & SEO" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/69cb8f7b-859b-4e1a-98c0-cda5269e4c5f" updated: "2026-11-09" --- # Faceless YouTube Shorts maker with an idea picker > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow that makes a faceless short from a category or your own idea. OpenAI suggests ten hooks to pick from, Tavily and Claude research and script it, and JSON2Video renders the video and Gmail sends you the link. Faceless YouTube Shorts maker with an idea picker 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 makes a faceless short video from a category or an idea of your own and emails you its address. Twenty-seven nodes run in three stages. First, OpenAI’s `gpt-4.1` with web search suggests ten hook ideas on a second form page, where you pick one or ask for ten more. Then Tavily searches the web for the chosen idea, `gpt-4.1` condenses the results, and an agent on Claude 3.7 Sonnet writes a scene-by-scene script. Last, a JSON2Video template of your own renders the video, with an image and a voice line for every scene, and Gmail sends the finished address. A form takes a category or your own idea → OpenAI suggests ten hooks and you pick one → Tavily research and a summary feed the script → Claude writes a scene-by-scene script → JSON2Video renders it and Gmail sends the link ### Who it suits Creators and agencies that post faceless Shorts and want an idea picker, a research step and a finished render in one run. It needs five accounts besides n8n and a JSON2Video template that you make or copy first. Skip it for a single quick clip. The template and the accounts take longer to set up than the clip takes to make by hand. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Faceless channels | Creators who run Shorts without being on camera | Pick one of the ten ideas, let the run research and render, then post the clip | A channel owner picks a Did you know hook each morning and uploads the result. | | Education | Teachers and course makers | Type a question as your own idea and get a short illustrated explainer | A teacher asks why volcanoes erupt and gets a 30-second clip in a hand-drawn style. | | Content agencies | Social media teams | Set one style per client and send the form’s address to the client | An agency gives a garden brand a form that always uses the Gardening category. | | Niche brands | Pet and garden shops | Run a weekly series from one category | A pet shop posts a Cool Animal Facts short every Friday. | ### Where to use it Any n8n that can reach OpenAI, Tavily, Anthropic, JSON2Video and Gmail will run it. The form is the front door, and the inbox is where the result lands. - n8n Cloud: import the file into a new workflow there - Your own n8n server: the same file, the same steps - The form’s address: share it with a teammate or a client who picks the topics - YouTube Shorts, Reels and TikTok: download the video from the emailed address and upload it where you post ### 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 17 minutes, which assumes the accounts and the template already exist. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | OpenAI | An API key, for the ideas and the research summary | | Tavily | An API key, for the web search | | Anthropic | An API key, for the script | | JSON2Video | An account, its API key and a template of your own that reads the variables below | | Gmail | An account for a Gmail OAuth2 credential | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. In JSON2Video, make or copy a template that reads the variables below, and note its template ID. 3. Open `Paste your template id` and replace `YOUR_TEMPLATE_ID` with that ID. 4. Add an OpenAI credential and select it in `Submit Idea Prompt to OpenAI`, `Search (Regenerated)` and `Summarize Web Context`. 5. In `Search Web for Script Context`, replace `` after `Bearer ` with your Tavily key. The brackets go too. 6. Add an Anthropic credential and select it in `Anthropic Chat Model`. 7. Add an HTTP Header Auth credential with the header name `x-api-key` and your JSON2Video key as the value. Select it in `Send to Video Generation API` and `Check Video Status`. 8. Add a Gmail OAuth2 credential and select it in `Email Video to User`. 9. Save, send the form once from its test address and pick an idea, then press Publish. The template is not in the file. `Build Video Creation Payload` posts its ID with these variables, and your template has to read them: ```json { "template": "", "comment": "", "variables": { "voiceModel": "azure", "imageModel": "flux-schnell", "audioURL": "", "introImagePrompt": "", "introText": "", "scenes": [{ "voiceOverText": "", "imagePrompt": "" }] } } ``` The code also names `voiceID`, but no value reaches it. The Good to know list says why. ### How to use it Open the form from `User Input Form`, choose a category or type an idea of your own, then set the duration, the style, a voice and the audio address. Add an email address too, because the last step sends to it. The next page lists ten ideas. Pick one, or answer Yes under Regenerate for ten new ones. Once you pick, the form closes and the run goes on behind it: research, script, render, email. The form’s fields | Field | Needed | What it does | | --- | --- | --- | | \`Choose a Category\` | No | A starting phrase or topic, from a list of eight | | \`Or Enter Your Own Idea\` | No | Your own topic. When it is filled, it replaces the category | | \`Duration\` | Yes | 30 seconds, 1 minute, 1 minute 30 seconds or 2 minutes. It sets the number of scenes | | \`Generative Style\` | Yes | The look of the images, from a list of nine | | \`Voice Model\` | Yes | One of ten Azure voices | | \`Audio url\` | Yes | The address of an audio file for your template to play | | \`Email\` | No, but the last step needs it | Where the finished video’s address is sent | What to change for a different result | To change | Where | | --- | --- | | Categories, styles, voices | The dropdown options in \`User Input Form\`. The hook-style categories are also named in the code of \`Generate Video Ideas Prompt\` and \`Build Payload (Regenerated)\` | | Scene counts | \`Calculate Scene Count\`, 6, 12, 18 and 24 scenes | | Research sites | The 64 names in \`include\_domains\` of \`Search Web for Script Context\` | | Script tone and structure | The system message of \`Script Generator (AI)\` | | The email | The subject and text in \`Email Video to User\` | | Waits | \`Wait for Video Rendering\`, 3 minutes, and \`Retry Wait Before Recheck\`, 10 seconds | ### Example You choose Cool Animal Facts, a duration of 30 seconds and the hand-drawn style. The ideas page lists ten one-sentence hooks, each starting with the words Cool Animal Facts, and you pick one. Tavily searches the file’s list of sites, `Calculate Scene Count` sets six scenes, and the script writer answers in this shape, trimmed here: ```json { "comment": "…", "variables": { "introImagePrompt": "…", "introVoiceoverText": "\n<hook>", "scenes": [{ "voiceOverText": "…", "imagePrompt": "…" }] } } ``` JSON2Video renders it from your template. After the three-minute wait the status is checked, and the email carries `movie.url`. ### 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. A JSON2Video template is a video layout with blanks, and this workflow fills them with the script, the image prompts and the voice. Send the form from its test address first. Every node then shows what it received and what it sent, which is where a wrong key or a missing template ID turns up. **For experts.** Three models share the writing, and the idea step is not a chat model node. `Generate Video Ideas Prompt` builds a request body in code and `Submit Idea Prompt to OpenAI` posts it to OpenAI’s Responses API. A second pair does the same for regenerated ideas. The model behind each step | Step | Model | What to know | | --- | --- | --- | | The two idea requests | \`gpt-4.1\` through the Responses API, with its web search tool at high context | Asked for a JSON array of ten strings. The parser nodes strip code fences before reading it | | \`Summarize Web Context\` | \`gpt-4.1\` | Writes one paragraph from the first four Tavily results, with a plain-language reason behind the main point | | \`Script Generator (AI)\` | Claude 3.7 Sonnet (\`claude-3-7-sonnet-20250219\`) | Writes an intro and one-sentence scenes, 3 to 6 seconds each, and holds every image prompt to the chosen style | | JSON2Video | Azure voices and \`flux-schnell\` images, set in your template’s variables | The workflow only sends the script and polls the project | ### Good to know Every run spends money in five places, and several steps fail quietly. - Billing: OpenAI, Tavily, Anthropic and JSON2Video each bill their own part, and every regeneration repeats the idea step - The voice: the pick does not reach JSON2Video as exported. \`Extract Script JSON\` reads \`voiceID\` from the script writer’s reply, which has no such field, so \`Build Video Creation Payload\` sends none. Set \`voiceID\` there to \`$("Prepare Input Variables").first().json.voiceID\` to make it count - Failed renders: the \`Error\` output of \`Handle Video Render Status\` also goes to the email node, so a failed render still sends a message with no usable link - No limit: a render that stays \`running\` is checked every ten seconds until it changes - The email: it is optional on the form, but without it the last step has no one to send to, after the video is paid for - The agent: Require Specific Output Format is on, yet no parser is attached, so the answer comes back as text that \`Extract Script JSON\` reads. If n8n flags the node, switch that option off - The original copy’s code had lost its backslashes: the error messages in three code nodes and the \`.join("\\n\\n")\` in \`Summarize Web Context\`. This copy has them back - The model name: Anthropic may retire \`claude-3-7-sonnet-20250219\`, so pick a current Claude model in \`Anthropic Chat Model\` if it reports that - 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 trigger’s basic authentication or keep the address to yourself - Your topic: it goes to OpenAI, Tavily and Anthropic, and the script goes to JSON2Video - Credentials: the JSON holds none, and nothing from its author’s account ## README ````markdown # Faceless YouTube Shorts maker with an idea picker An n8n workflow. Pick a category or type your own idea, choose one of ten hook ideas an AI suggests, and the workflow researches the topic, writes a scene-by-scene script and has JSON2Video render a faceless short. The finished video's address arrives by email. ## What is inside - `workflow.json`: the workflow as n8n exports it, 27 nodes. It holds no credential and calls no sub-workflow. It does not hold the JSON2Video template either: you bring your own (below). - `README.md`: these notes. ## Before you start - An n8n instance, on n8n Cloud or your own server. - An OpenAI API key, for the idea step and the research summary. - A Tavily API key, for the web search. - An Anthropic API key, for the script. - A JSON2Video account, its API key and a template that reads the variables listed below. - A Gmail account that n8n can send from. ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. In JSON2Video, make or copy the template, and note its template ID. 3. Open `Paste your template id` and replace `YOUR_TEMPLATE_ID` with that ID. 4. Add an OpenAI credential and select it in `Submit Idea Prompt to OpenAI`, `Search (Regenerated)` and `Summarize Web Context`. 5. In `Search Web for Script Context`, replace `<YOUR_TAVILY_KEY>` after `Bearer ` with your Tavily key. The brackets go too. 6. Add an Anthropic credential and select it in `Anthropic Chat Model`. 7. Add an HTTP Header Auth credential with the header name `x-api-key` and your JSON2Video key as the value. Select it in `Send to Video Generation API` and `Check Video Status`. 8. Add a Gmail OAuth2 credential and select it in `Email Video to User`. 9. Save, send the form once from its test address, pick an idea, then press Publish at the top of the canvas (or Shift+P). ## The form | Field | Needed | What it does | |---|---|---| | `Choose a Category` | No | A starting phrase or topic, from a list of eight | | `Or Enter Your Own Idea` | No | Your own topic. When filled, it replaces the category | | `Duration` | Yes | 30 seconds, 1 minute, 1 minute 30 seconds or 2 minutes. It sets the number of scenes | | `Generative Style` | Yes | The look of the images, from a list of nine | | `Voice Model` | Yes | One of ten Azure voices | | `Audio url` | Yes | The address of an audio file for your template to play | | `Email` | No, but the last step needs it | Where the finished video's address is sent | ## What the template receives `Build Video Creation Payload` posts this to JSON2Video's movie endpoint, and your template reads the `variables`: ```json { "template": "<your template ID>", "comment": "<the script writer's note>", "variables": { "voiceModel": "azure", "imageModel": "flux-schnell", "audioURL": "<the Audio url you gave>", "introImagePrompt": "<the opening image's prompt>", "introText": "<the title and the hook, on two lines>", "scenes": [{ "voiceOverText": "<one sentence>", "imagePrompt": "<one image>" }] } } ``` The code also names `voiceID`, but no value reaches it (see Good to know). ## How a run goes 1. The form's data passes through `Merge` and `Prepare Input Variables`, which keeps the topic, the audio address, the duration, the style and the voice. 2. `Generate Video Ideas Prompt` builds a request for OpenAI's Responses API with `gpt-4.1` and its web search tool, and `Submit Idea Prompt to OpenAI` sends it. A category such as `What if` or `Did you know` asks for ten one-sentence hooks that start with that phrase. Any other topic asks for ten hook ideas about it. `Parse Idea Response JSON` strips code fences and reads the JSON array. 3. `Idea Suggestions` shows the ten as a dropdown on a second page. `Regenerate Idea Decision` reads the second dropdown: `Yes` goes through `Build Payload (Regenerated)`, `Search (Regenerated)` and `Parse Results (Regenerated)` and shows a new ten. Anything else goes to `End Form`, which tells the reader the video will come by email. 4. `Search Web for Script Context` asks Tavily for 10 results on the chosen idea, with an answer and the raw page content, limited to 64 sites in `include_domains`. `Summarize Web Context` has `gpt-4.1` write one paragraph from the first four results. 5. `Calculate Scene Count` turns the duration into 6, 12, 18 or 24 scenes. 6. `Script Generator (AI)` is an agent on Claude 3.7 Sonnet. It writes an intro with a title and a hook of at most eight words, then one-sentence scenes that each carry an image prompt in the chosen style. 7. `Combine Input and Script Output` joins the script to the form's data. `Extract Script JSON` strips code fences and parses it, and `Build Video Creation Payload` shapes the request. 8. `Send to Video Generation API` posts it to JSON2Video. `Wait for Video Rendering` pauses 3 minutes, and `Check Video Status` asks for the project. 9. `Handle Video Render Status` reads `movie.status`. `done` and `error` both go to `Email Video to User`. `running` goes through `Retry Wait Before Recheck`, ten seconds, back to `Check Video Status`. ## Change the look - Categories, styles and voices: the dropdown options in `User Input Form`. The categories that ask for hook phrases are also named in the code of `Generate Video Ideas Prompt` and `Build Payload (Regenerated)`. - Scene counts: `Calculate Scene Count`. - Research sites: the `include_domains` list in `Search Web for Script Context`. - Tone and structure of the script: the system message in `Script Generator (AI)`. - The email: subject and text in `Email Video to User`. - Waits: `Wait for Video Rendering` and `Retry Wait Before Recheck`. - Models: `gpt-4.1` in three nodes, and `claude-3-7-sonnet-20250219` in `Anthropic Chat Model`. Pick a current Claude model there if Anthropic reports that one retired. ## Good to know - Every run spends money on OpenAI, Tavily, Anthropic and JSON2Video, and each regeneration spends the idea step again. - The voice you pick does not reach JSON2Video as exported. `Extract Script JSON` reads `voiceID` from the script writer's reply, which has no such field, so `Build Video Creation Payload` sends none. To make the pick count, set `voiceID` there to `$("Prepare Input Variables").first().json.voiceID`, as the node already does for the audio. - The person who sends the form picks an idea on the next page, so they stay until `End Form` appears. - A failed render still sends the email, with no usable link. The status loop for a render that stays `running` has no limit. - The Email field is optional on the form, but the Gmail node needs an address. Without one, the last step has no one to send to, after the video is already paid for. - The agent has Require Specific Output Format switched on, yet no parser is attached, so it answers in plain text and `Extract Script JSON` reads it. If n8n flags the node, switch that option off. - The original copy's code had lost its backslashes: the error messages in `Parse Idea Response JSON`, `Parse Results (Regenerated)` and `Extract Script JSON`, and the `.join("\n\n")` in `Summarize Web Context`. This copy has them back. - Once the workflow is published, anyone with the form's address can start a run on your keys. The form trigger can ask for a username and password. - The topic goes to OpenAI, Tavily and Anthropic, and the script goes to JSON2Video. The finished video is on JSON2Video's address. ```` ## What is in it 2 files, 49 KB, downloaded as a zip. ```text README.md 7 KB workflow.json 42 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 26 steps, starting on a form - AI: 2 steps call an AI model: Summarize Web Context and Script Generator (AI) - Sign-ins: Signs in to: OpenAI, JSON2Video, Gmail, Anthropic and Tavily - 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 12 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/69cb8f7b-859b-4e1a-98c0-cda5269e4c5f) - [Its page on Mindket](https://mindket.com/p/69cb8f7b-859b-4e1a-98c0-cda5269e4c5f)