Sora2 Pro AI video generation to YouTube

High-Level Summary

This workflow automates the entire process of creating AI-generated videos using OpenAI's Sora2 Pro, saving them to Google Drive, generating optimized YouTube titles with GPT-5, and automatically uploading them to YouTube. It uses a Google Sheet as the central interface for input (prompts and durations) and output (video URLs and YouTube links). This is ideal for content creators, marketers, or anyone looking to scale video production without manual intervention.

Node-by-Node Walkthrough

  1. Schedule Trigger (No auth) — Runs the workflow at a configured interval (default: every 5 minutes). This allows the workflow to periodically check for new rows in the Google Sheet.

  2. When clicking 'Test workflow' (No auth) — A manual trigger for testing the workflow on demand. It bypasses the schedule and starts the process immediately.

  3. Get new video (Google Sheets OAuth2) — Reads rows from the Google Sheet where the "VIDEO" column is empty (unprocessed rows). It retrieves the prompt and duration for each new video to be created.

  4. Set data (No auth) — Combines the prompt and duration from the sheet into a single string formatted as: {PROMPT}\n\nDuration of the video: {DURATION}. This prepared text is sent to the AI video generation API.

  5. Create Video (Header Auth — Authorization: Key YOURAPIKEY) — Sends a POST request to the Sora2 Pro API (https://queue.fal.run/fal-ai/sora-2/text-to-video/pro) with the prompt as JSON body. This initiates the video generation process and returns a request_id for polling.

  6. Wait 60 sec. (No auth) — Pauses execution for 60 seconds to allow the Sora2 Pro API to process the video generation request.

  7. Get status (Header Auth — Authorization: Key YOURAPIKEY) — Polls the Sora2 Pro API status endpoint (https://queue.fal.run/fal-ai/sora-2/requests/{request_id}/status) to check if the video generation is complete.

  8. Completed? (No auth) — An IF node that checks if the status returned is "COMPLETED". If yes, the workflow proceeds to retrieve the video URL. If not, it loops back to wait another 60 seconds and check again.

  9. Get Url Video (Header Auth — Authorization: Key YOURAPIKEY) — Once the video is completed, this node fetches the final video metadata from https://queue.fal.run/fal-ai/sora-2/requests/{request_id}, including the video URL and file name.

  10. Generate title (OpenAI API Key auth) — Sends the original prompt to OpenAI's GPT-5 model with a system prompt that instructs it to generate an SEO-optimized YouTube title (max 60 characters, catchy, keyword-rich, in the same language as the input).

  11. Get File Video (No auth) — Downloads the actual video file from the URL returned by the Sora2 Pro API. This binary data is used for uploading to Google Drive and YouTube.

  12. Upload Video (Google Drive OAuth2) — Uploads the downloaded video file to a specific Google Drive folder ("Fal.run") with a timestamped filename.

  13. Update result (Google Sheets OAuth2) — Updates the original Google Sheet row with the video URL from Sora2 Pro, using the row number to match the correct row.

  14. HTTP Request (Header Auth — Authorization: Apikey YOUR_API_KEY_HERE) — Uploads the video to YouTube via the Upload-Post API (https://api.upload-post.com/api/upload). It sends the video binary data along with the generated title, username, and platform (YouTube) as multipart form data.

  15. Update Youtube URL (Google Sheets OAuth2) — Updates the Google Sheet row with the final YouTube URL (constructed as https://youtu.be/{video_id}) after successful upload.

Setup Instructions

To use this workflow, you'll need accounts and credentials for the following services:

  1. Google Cloud Platform — Enable the Google Sheets and Google Drive APIs. Create OAuth2 credentials and configure them in n8n for Google Sheets and Google Drive nodes.

  2. Fal.ai (Sora2 Pro) — Create an account at fal.ai and obtain an API key. This key is used in the Header Auth nodes (Create Video, Get status, Get Url Video) with the format Key YOURAPIKEY.

  3. OpenAI — Create an account at OpenAI and generate an API key. This is used for the GPT-5 title generation node.

  4. Upload-Post — Sign up at Upload-Post to get an API key (10 free uploads per month). Create a profile for your YouTube channel. The profile name becomes your username in the HTTP Request node.

  5. Google Sheet — Create a copy of this template sheet with columns: PROMPT, DURATION, VIDEO, YOUTUBE_URL, row_number. Fill in prompts and durations; leave VIDEO and YOUTUBE_URL empty.

Use Cases and Variations

  • Content Marketing: Automate daily video creation for social media campaigns, product demos, or educational content.
  • Multilingual Content: The GPT-5 prompt generates titles in the same language as the input, making it easy to create videos in multiple languages.
  • Batch Processing: Modify the Google Sheet query to process multiple rows at once, creating a queue of videos.
  • Alternative AI Models: Replace the Sora2 Pro endpoint with other video generation APIs (e.g., RunwayML, Pika Labs) by changing the URL and request format.
  • Platform Expansion: Add additional HTTP Request nodes to upload the same video to TikTok, Instagram, or Facebook using their respective APIs.
  • Scheduling: Adjust the Schedule Trigger to run hourly or daily instead of every 5 minutes for less frequent video creation.
22 nodesmanual triggerAI
HTTP RequestWaitSticky NoteIFGoogle SheetsSetGoogle DriveOpen AI

Workflow JSON

{
  "id": "IIQhSqMWv4u6e0Jh",
  "meta": {
    "instanceId": "a4bfc93e975ca233ac45ed7c9227d84cf5a2329310525917adaf3312e10d5462"
  },
  "name": "Create Video with Sora2 Pro and Upload to Youtube",
  "tags": [],
  "nodes": [
    {
      "id": "937d8d50-60e9-4ebe-a1b2-83e4e7179318",
      "name": "When clicking ‘Test workflow’",
      "type": "n8n-nodes-base.manualTrigger",
      "position": [
        -528,
        976
      ],
      "parameters": {},
      "typeVersion": 1
    },
    {
      "id": "ef6db75d-f9d9-459d-9d3f-5d77547efa36",
      "name": "Get status",
      "type": "n8n-nodes-base.httpRequest",
      "position": [
        544,
        976
      ],
      "parameters": {
        "url": "=https://queue.fal.run/fal-ai/sora-2/requests/{{ $('Create Video').item.json.request_id }}/status ",
        "options": {},
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth"
      },
      "credentials": {
        "httpHeaderAuth": {
          "id": "credential-id",
          "name": "httpHeaderAuth Credential"
        }
      },
      "typeVersion": 4.2
    },
    {
      "id": "63bd7d00-8a53-4bc3-bc8d-c09b6ecc335e",
      "name": "Wait 60 sec.",
      "type": "n8n-nodes-base.wait",
      "position": [
        352,
        976
      ],
      "webhookId": "490facb8-d0ae-402e-ab59-a87720cf0bdd",
// ... truncated (copy to see full JSON)

How to Import This Workflow

  1. 1Copy the workflow JSON above using the Copy Workflow JSON button.
  2. 2Open your n8n instance and go to Workflows.
  3. 3Click Import from JSON and paste the copied workflow.

Don't have an n8n instance? Start your free trial at n8nautomation.cloud

Related Templates

Automated Blog Post Creation from News with AI and Blogger

This workflow automates the entire process of creating a fully SEO-optimized blog post from a news article. It fetches a trending technology news headline from Mediastack, generates relevant images from Pexels, uses two AI agents (via OpenRouter) to produce a title, slug, meta description, and a complete WordPress-compatible HTML blog post, then posts it directly to Blogger and sends you a Telegram notification. It's perfect for content marketers, bloggers, or anyone who wants to consistently publish fresh, data-driven content without manual effort. Node Breakdown Schedule Trigger (No auth) — Runs the workflow at a set interval (configured every minute by default, but you should change it to daily or hourly). Mediastack News (API Key auth via query parameter) — Fetches the latest technology news article in English from the Mediastack API. Parameters: set to . Genarate image (API Key auth via header, ) — Searches Pexels for up to 2 images related to the news title. Parameters: = , = 2. Send a text message1 (Telegram bot token auth) — Sends a Telegram message with the generated image URLs to the chat ID stored in . AI Agent (Uses OpenRouter Chat Model — API Key auth) — This agent takes the news title and returns a JSON object with three fields: , , and (meta description). The prompt includes strict guidelines for SEO-friendly output. OpenRouter Chat Model (API Key auth) — The language model for the first AI agent, using . Parsing (No auth) — A Code node that cleans the raw AI output (removes markdown code fences) and parses the JSON into usable fields. Copywriter AI Agent (Uses OpenRouter Chat Model2 — API Key auth) — This agent writes a complete 1,000-word SEO blog post in HTML format. It uses the title, meta, and the two images from Pexels. The prompt is very detailed, specifying structure, keyword placement, and styling. OpenRouter Chat Model2 (API Key auth) — Same model as the first, but used for the second agent. Cleanup HTML (No auth) — A Set node that removes any leftover htmlurlhttps://www.googleapis.com/blogger/v3/blogs/$vars.bloggerid/postsPOSThttpQueryAuthAuthorization$vars.telegramchatid$vars.bloggeridbusinesssports`) to match your niche. Multi-language Support — Modify the Mediastack query to fetch news in other languages, and adjust the AI prompts to write in that language. Custom Image Sources — Replace the Pexels node with another image API (e.g., Unsplash) or use a local image generation model. Different CMS — Swap the Blogger HTTP Request node with WordPress or any other CMS API (just change the URL and body format). Human-in-the-Loop — Add a Slack or email approval step before publishing to review the AI-generated content. Newsletter Integration — Instead of posting to a blog, send the formatted content as an email newsletter via Gmail or SendGrid.

16 nodes

AI Chat Agent with OpenAI, Memory, and Web Search

Overview This workflow creates an intelligent AI chat agent that combines OpenAI's language model with conversational memory and real-time web search capabilities via SerpAPI. It is designed to power interactive chat applications where the AI can remember context across messages and fetch up-to-date information from the internet when needed. This is particularly useful for building customer support bots, research assistants, or any conversational interface that requires both knowledge retention and live data access. The workflow is triggered by incoming chat messages and processes them through an AI agent that coordinates between the language model, memory buffer, and search tool. The agent can decide when to use web search to answer questions that require current information, while maintaining conversation history for coherent multi-turn dialogues. Workflow Steps Manual Trigger (No auth) — This node allows you to manually start the workflow for testing purposes. It has no parameters configured and simply provides a button to execute the workflow on demand. When chat message received (No auth) — This is a webhook-based trigger that listens for incoming chat messages. It generates a unique webhook URL that you can integrate with your chat frontend or messaging platform. The parameter is empty, meaning default webhook behavior is used. AI Agent (No auth) — This is the core orchestrator node that manages the conversation flow. It coordinates between the OpenAI model, memory buffer, and SerpAPI tool. The agent decides which tool to use based on the user's query and maintains the conversation state. OpenAI Chat Model (API Key auth) — This node connects to OpenAI's GPT-4o-mini model to generate responses. It requires an OpenAI API key configured in n8n credentials. The parameter is set to , which is a cost-effective and fast model suitable for chat applications. The parameter is empty, using default model settings. Window Buffer Memory (No auth) — This node implements a sliding window memory that stores recent conversation history. It allows the AI to remember context from previous messages within a configurable window size. The parameters are empty, using default memory settings. SerpAPI (API Key auth) — This tool node enables web search functionality via SerpAPI (Google Search API). It requires a SerpAPI API key configured in n8n credentials. The parameter is empty, using default search settings. The agent calls this node when it determines that real-time web data is needed to answer a query. Setup Instructions To use this workflow, you need the following accounts and credentials: OpenAI Account: Sign up at platform.openai.com and create an API key. In n8n, create an "OpenAI" credential and paste your API key. SerpAPI Account: Register at serpapi.com and obtain an API key. In n8n, create a "SerpAPI" credential with your key. Webhook URL: After activating the workflow, copy the webhook URL from the "When chat message received" node. Integrate this URL into your chat application (e.g., a custom web chat widget, Slack app, or Telegram bot). Optional: Configure the memory window size in the "Window Buffer Memory" node if you want to limit or extend conversation context. Use Cases and Variations This workflow can be adapted for multiple scenarios: Customer Support Bot: Replace SerpAPI with a knowledge base tool (e.g., vector store or database lookup) to answer product-specific questions. Research Assistant: Keep SerpAPI for web search and add additional tools like Wikipedia or news APIs. Multi-Platform Chat: Connect the webhook to different messaging platforms (Slack, Discord, Telegram) by adding appropriate trigger nodes. Personal Assistant: Add calendar or email tools to let the AI manage schedules and send messages. Language Translation: Replace the OpenAI model with a translation-specific model or add a translation tool node. To extend the workflow, you can add more tool nodes (e.g., database queries, file operations) and connect them to the AI Agent. The agent will automatically learn to use new tools based on their descriptions.

6 nodes

AI Social Media Content Generator using Local Ollama

This workflow uses a local Ollama instance to automatically generate platform-specific social media content (Twitter, LinkedIn, Reddit, Instagram) for a given topic, brand voice, and target audience. It then reviews and polishes the content for consistency and quality. Perfect for content creators, marketers, or developers who want to quickly produce multi-platform posts with full control over AI model and data privacy. Workflow Steps Manual Trigger (No auth) — Manually start the workflow to generate content on demand. Content Parameters — A Set node that defines three input variables: , , and . These can be edited directly in the node to customize each generation. Generate All Platform Content (Ollama) — An HTTP Request node (No auth) that sends a prompt to the local Ollama API (). It requests the model () to output structured JSON containing posts for Twitter, LinkedIn, Reddit, and Instagram. Parse Content JSON — A Code node that extracts and parses the JSON response from Ollama, merging it with the original topic and a timestamp. Review & Polish (Ollama) — A second HTTP Request node (No auth) that sends the generated content to Ollama for quality review (grammar, tone, formatting) and returns corrected versions if needed. Final Content Output — A Code node that merges the reviewed output with the original and flags whether the content was reviewed. Setup Instructions Ollama: Download and install Ollama on your local machine. Pull the model by running . Ensure Ollama is running (default on ). n8n: The workflow uses only local connections—no external API keys or accounts required. Simply import the JSON into your n8n instance and execute it manually. Customization: Modify the node to change the topic, brand voice, or target audience. Adjust the prompt in the first HTTP Request node to add or remove platforms. Use Cases & Variations Scheduled content generation: Replace the Manual Trigger with a Cron trigger to generate posts daily or weekly. Multi-model support: Change the parameter in Ollama calls to use other models like , , or . Platform expansion: Edit the prompt to include additional platforms (e.g., Facebook, TikTok) or output formats. Integration with publishing tools: After the final output, add nodes to post directly to Twitter via API, save to a Google Sheet, or send to a CMS. Language/tonality: Adjust the and prompt instructions to generate content in different languages or styles.

6 nodes

Ready to automate with n8n?

Get affordable managed n8n hosting with 24/7 support.