How to Build an AI Social Media Manager Bot with n8n (Powered by Telegram)

Keeping your social media channels active is a full-time job — and most founders, creators, and small teams simply don’t have the bandwidth to do it consistently. What if you could send a voice note, a document, or a quick text to a Telegram bot and have it draft, get your approval, and publish a polished post to X and LinkedIn automatically?

That’s exactly what this n8n workflow builds: your own AI-powered social media manager, running 24/7 inside Telegram, connected to Google Gemini for smart content generation, and wired directly to your X (Twitter) and LinkedIn profiles.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. Send a text, voice note, or document to your Telegram bot — the AI understands all three formats
2. The agent drafts a platform-appropriate post, respecting X’s 280-character limit and LinkedIn’s professional tone
3. You review the draft in Telegram and approve it — nothing gets published without your explicit say-so
4. With your approval, the bot publishes instantly to X (Twitter) and/or LinkedIn
5. The bot remembers your brand voice, company details, and preferences over time — you stop repeating yourself in every session

How It Works — The Big Picture

The workflow uses a Telegram bot as the command center. Every incoming message is classified by type — text, document, voice, or button tap — and routed through the right processing pipeline before reaching a Google Gemini-powered AI Agent. The agent drafts posts, manages both short- and long-term memory, and uses LinkedIn and X tools to publish only after you approve.

┌──────────────────────────────────────────────────────────────────────┐
│  AI SMM MANAGER                                                      │
│                                                                      │
│  [Telegram Trigger] → [Set Context] → [Input Type Switch]            │
│                                              │                       │
│         ┌────────────────────────────────────┼────────────────┐      │
│         ↓                ↓                   ↓                ↓      │
│     [Text]          [Document]            [Voice]        [Callback]  │
│         │           ↓ Download           ↓ Download           │      │
│         │           ↓ Encode             ↓ Encode        [If cm?]   │
│         │           ↓ Gemini OCR         ↓ Transcribe   ↓       ↓   │
│         │           ↓ Doc Prompt         ↓ Audio Prompt [Clear] [✗]  │
│         └───────────┴────────────────────┘                          │
│                               ↓                                      │
│                         [AI Agent] ←── [Gemini LLM]                 │
│                    ↑   ↑   ↑   ↑      [Short-term Memory]           │
│                    │   │   │   └── [Retrieve Knowledge (vector)]     │
│                    │   │   └──── [Save Knowledge (sub-workflow)]     │
│                    │   └──────── [Create X (Twitter) Post]           │
│                    └──────────── [Create LinkedIn Post]              │
│                               ↓                                      │
│                    [Split Response] → [Split Out]                    │
│                               ↓                                      │
│                    [Send Response via Telegram]                      │
└──────────────────────────────────────────────────────────────────────┘
  

What You’ll Need

• n8n (cloud or self-hosted, version 1.0+)
• Telegram Bot API key — create one for free via @BotFather in Telegram
• Google AI Studio API key — free at aistudio.google.com (powers Gemini 2.0 Flash)
• X (Twitter) Developer API — free developer account at developer.x.com
• LinkedIn OAuth credentials — create an app at the LinkedIn Developer Portal
• A companion n8n sub-workflow — “Save Vector Store Record” (included in the template pack) for long-term memory storage

Estimated build time: 45–60 minutes from scratch, or under 10 minutes with the template.

Part 1 — Bot Entrance and Input Preprocessing

1 Telegram Trigger (telegramTrigger)

This is the entry point. The Telegram Trigger node opens a webhook that listens for all incoming events from your bot — text messages, documents, voice notes, and inline button taps.

Configuration:

1. Open the node and click “Credential for Telegram API”
2. Paste your BotFather token and save
3. Under “Updates”, enable: message, callback_query, inline_query, and *

{
  "message": {
    "chat": { "id": 198472651, "type": "private", "first_name": "Sarah" },
    "text": "Write a LinkedIn post about our product launch next Tuesday",
    "message_id": 142
  },
  "update_id": 553043001
}

2 Set Input Context (set)

This node normalizes the raw Telegram payload into clean, consistently named fields — regardless of whether the input is a text message, a file, or a voice note.

3 Input Type Switch (switch)

Routes execution to the correct processing branch based on update_type:

• text → straight to AI Agent via Text Prompt
• document → Download → Encode → Gemini OCR → Document Prompt → AI Agent
• voice → Download → Encode → Gemini Transcribe → Audio Prompt → AI Agent
• callback → If node (checks whether it’s a memory-clear command)

Part 2 — Document and Audio Processing

4 Document Branch (Download → Encode → Describe)

When a user sends a PDF, presentation, or any file, three nodes work in sequence. Download document fetches the raw binary from Telegram using the file_id. Encode document converts the binary to base64. Describe document sends it to Gemini 2.0 Flash via HTTP POST:

{
  "contents": [{
    "parts": [
      { "text": "Extract all the information about the company or product from this document" },
      {
        "inline_data": {
          "mime_type": "application/pdf",
          "data": "JVBERi0xLjQgJeL..."
        }
      }
    ]
  }]
}

Gemini returns a structured extraction of all company and product details, which gets injected into the AI Agent prompt alongside the document’s caption.

5 Voice Branch (Download → Encode → Transcribe)

Voice messages follow the same pattern — Download Audio → Encode Audio → call Gemini with “Generate a transcript of the speech.” The transcript becomes the chatInput field, so the agent processes it exactly like a typed message.

Part 3 — The AI Agent

6 AI Agent (agent)

The brain of the entire operation. The agent receives the normalized user input and decides autonomously what to do next: ask clarifying questions if context is missing, draft a post tailored to the target platform, send it to you for review, publish after your explicit approval, or save brand information to long-term memory.

The system message enforces a strict rule: nothing gets published without the user’s explicit “approved” signal. This is the safety net that keeps the bot from acting without consent.

7 Google Gemini Chat Model + Memory

The agent is powered by Google Gemini via the lmChatGoogleGemini node. Two memory systems work in parallel:

Short-term memory (Buffer Window Memory): Keyed to the chat_id, this stores recent conversation history so the agent maintains context within a single Telegram session.

Long-term memory (In-Memory Vector Store + Gemini Embeddings): Powered by the embedding-001 model, this lets the agent remember brand voice, company info, and preferences across completely separate sessions.

8 Memory Clear Callback

When a user taps an inline Telegram button with callback data "cm", the workflow routes to the If node, clears all buffer window memory via Chat Memory Manager, and sends a “Memory is cleaned” confirmation back to Telegram. Handy for switching between clients or starting fresh on a new campaign.

Part 4 — Response Delivery

9 Split + Send (code + telegram)

Telegram enforces a 4,096-character limit per message. The Split agent’s response node uses JavaScript to break the AI output into 3,000-character chunks, and Split Out iterates over each chunk. Every chunk is sent as a separate Telegram message so nothing is ever truncated.

function splitString(str, size) {
  let result = [];
  for (let i = 0; i < str.length; i += size) {
    result.push(str.slice(i, i + size));
  }
  return result;
}

for (const item of $input.all()) {
  const parts = splitString(item.json.output, 3000);
  item.json.parts = parts;
}

return $input.all();

Full System Flow

User sends message (text / voice / document) to Telegram bot
                          │
                          ▼
              [Telegram Trigger] → [Set Input Context]
                                            │
               ┌────────────────────────────┼───────────────────┐
               ▼                            ▼                   ▼
         [text route]               [document route]     [voice route]
               │                    ↓ Download            ↓ Download
               │                    ↓ Encode (base64)     ↓ Encode (base64)
               │                    ↓ Gemini OCR           ↓ Gemini Transcribe
               │                    ↓ Document Prompt      ↓ Audio Prompt
               └────────────────────┴──────────────────────┘
                                            │
                                            ▼
                                      [AI Agent]
                            ┌─────────────────────────┐
                            ↓                         ↓
                    [X & LinkedIn Tools]    [Memory: Save + Retrieve]
                            └─────────────────────────┘
                                            │
                                            ▼
                              [Split Response (3,000 chars)]
                                            │
                                            ▼
                              [Send each chunk via Telegram]
                                            │
                                            ▼
                                      User gets reply ✓
  

Testing Your Workflow

1. Import the JSON and attach all credentials (see the Credentials Guide PDF)
2. Activate the workflow — n8n registers the Telegram webhook automatically
3. Open Telegram, find your bot, and send: "Write a LinkedIn post about how AI is changing small business marketing"
4. Confirm the bot replies with a draft and asks for your approval
5. Reply "approved" — check your LinkedIn profile for the published post
6. Test a voice note: record 10 seconds describing a product feature and send it to the bot
7. Test document processing: send a PDF of your company overview and ask the bot to write a post about it

Frequently Asked Questions

What's Next?

• Add Instagram support via the Instagram Graph API as a new tool on the AI Agent node
• Schedule posts by connecting a Google Sheets queue and a Schedule Trigger to batch-publish at optimal times
• Add AI image generation using DALL-E or Flux to auto-create visuals for each post before publishing
• Multi-language support — instruct the agent to detect the user's language and draft posts in the same language automatically
• Analytics tracking — connect a Google Sheets node to log every post with timestamps so you can track what's performing

Managing a Shopify store means checking the dashboard, hunting for order IDs, editing products one by one, and emailing customers manually. Every one of those tasks takes you away from actually growing the business. This n8n Shopify AI agent changes that completely. First, you send a voice note or text message on WhatsApp. Next, the AI understands your command, queries your live store, and takes action — updating orders, managing products, sending customer emails, and logging everything to Google Sheets. As a result, your entire store becomes controllable from your phone, hands-free, in English, Arabic, or French.

Prefer to skip the build? Grab the ready-made template → and be managing your Shopify store by voice in under 20 minutes.

What You’ll Build

1. You send a WhatsApp text or voice note to your business number — “How many orders came in today?” or “Update the price of the blue hoodie to $49.”
2. If it’s a voice note, ElevenLabs transcribes the audio to text automatically before passing it to the AI.
3. The AI agent reads your command, calls the right Shopify tool — get orders, update a product, create a listing, delete a variant — and executes it against your live store.
4. Order data is written to a Google Sheet for tracking, and customer emails are sent via Gmail when you ask.
5. The AI replies back to WhatsApp: text if you typed, a voice note in the same Charlie voice if you spoke.
6. Every conversation is remembered per WhatsApp contact, so context carries forward across messages.

How This n8n Shopify AI Agent Works — The Big Picture

The workflow has two entry paths that merge at the AI agent, and two exit paths that split again based on whether the original message was text or audio. In between, the AI has six Shopify tools it can call autonomously, plus Google Sheets and Gmail. Here is the full picture:

┌──────────────────────────────────────────────────────────────────────────────┐
│  N8N SHOPIFY AI AGENT — WHATSAPP VOICE STORE MANAGER                        │
│                                                                              │
│  [WhatsApp Trigger]                                                          │
│          │                                                                   │
│          ▼                                                                   │
│  [Switch: text or audio?]                                                    │
│     │ text                   │ audio                                         │
│     ▼                        ▼                                               │
│  (straight to          [Get Media URL]                                       │
│   AI Agent)            [Download Audio Binary]                               │
│                        [ElevenLabs: Speech-to-Text]                         │
│                              │                                               │
│                    ──────────┘                                               │
│                    ▼                                                         │
│           [AI Agent — Store Manager]                                         │
│            │  Tools available:                                               │
│            ├─ [Shopify: Get Orders]                                          │
│            ├─ [Shopify: Get Products]                                        │
│            ├─ [Shopify: Update Order]                                        │
│            ├─ [Shopify: Create Product]                                      │
│            ├─ [Shopify: Update Product]                                      │
│            ├─ [Shopify: Delete Product]                                      │
│            ├─ [Google Sheets: database (append/update)]                      │
│            └─ [Gmail: Send Email]                                            │
│            │  Memory: Simple Memory (per WhatsApp contact)                  │
│            │  Model:  OpenRouter Chat Model                                  │
│                    │                                                         │
│                    ▼                                                         │
│           [Switch1: was original text or audio?]                             │
│             │ text                    │ audio                                │
│             ▼                         ▼                                      │
│    [WhatsApp: Send text]    [ElevenLabs: Text-to-Speech]                    │
│                             [Code: Set MIME → audio/mpeg]                   │
│                             [WhatsApp: Send voice note]                     │
└──────────────────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n — self-hosted or n8n Cloud (v1.30+). See the n8n hosting documentation for setup options.
• WhatsApp Business API — a verified Meta business phone number with a permanent access token. See the WhatsApp Cloud API getting-started guide.
• Shopify store — with a private app or OAuth app that has read/write access to Orders and Products.
• ElevenLabs account — free tier works for testing; choose any voice from your library.
• OpenRouter account — to power the AI agent; Claude, GPT-4o, or Llama 3 all work.
• Google Sheets — one spreadsheet with an “orders” tab containing the 14-column schema shown below.
• Gmail account — connected via OAuth2 in n8n for sending customer emails.

Estimated build time: 60–90 minutes from scratch, or under 20 minutes with the ready-made template.

Part 1 — Receiving the WhatsApp Message

1 WhatsApp Trigger

This node opens a webhook endpoint that Meta’s WhatsApp Cloud API calls every time a message arrives on your business number. It listens for the messages event type, which covers both text messages and media (audio, images, documents). Every incoming message delivers a payload with two fields the rest of the workflow relies on: messages[0].type (either text or audio) and contacts[0].wa_id (the sender’s phone number, used as the session key for memory).

// Incoming WhatsApp payload — text message example
{
  "messages": [
    {
      "type": "text",
      "text": { "body": "How many orders are pending today?" }
    }
  ],
  "contacts": [
    { "wa_id": "15551234567", "profile": { "name": "Sarah Thompson" } }
  ]
}

2 Switch — Text or Audio?

First, the Switch node reads $json.messages[0].type. If it equals text, the message goes directly to the AI Agent. If it equals audio, the message takes a detour through three nodes to transcribe the voice note before the AI sees it. This routing is what makes the workflow truly voice-native — the AI always receives clean text, regardless of how the user communicated.

// Switch routing logic
{
  "route_text":  "messages[0].type === 'text'",
  "route_audio": "messages[0].type === 'audio'"
}

Part 2 — Transcribing Voice Messages

3 Download Media (WhatsApp)

When the message is audio, this node calls the WhatsApp media endpoint to get the audio file’s download URL. It passes $json.messages[0].audio.id — the media ID from the trigger payload — and receives back a temporary URL that expires after a few minutes.

4 Download Audio (HTTP Request)

Next, this HTTP Request node fetches the actual audio binary from the URL returned by the previous step. It uses the WhatsApp API credentials for authentication, since Meta’s media URLs require a valid access token in the request headers. The output is a binary file that ElevenLabs can process.

5 Transcribe Audio (ElevenLabs)

ElevenLabs Speech-to-Text converts the audio binary into plain text with high accuracy, including for Arabic and French — matching the multilingual capability of the AI agent. The transcribed text arrives as $json.text, which the AI Agent reads via its Audio input: {{ $json.text }} prompt field.

Part 3 — The AI Store Manager Agent

6 AI Agent — Store Manager

This is the brain of the entire workflow. The AI Agent node receives either the text body or the transcribed audio, then decides which tools to call and in what order to fulfill the command. Its system prompt defines its role as a Shopify store manager, its available tools, its language capabilities, and one important rule: always call Get orders before updating an order, to retrieve the order ID first.

The agent prompt sets the behavior clearly. For example, the current system prompt instructs:

role: You are a smart AI voice Store Manager for my Shopify Store.
tasks:
- Always use 'Get orders' to get order/sales details
- Before you update orders, always get the order ID first from 'Get orders'
tools: shopify tool, Google Sheets 'database', Gmail
languages: English, Arabic (Modern Standard Arabic), French

7 OpenRouter Chat Model

The AI Agent is powered by OpenRouter, which gives you access to 100+ language models through a single API key. The default model is not hardcoded — you choose it in the OpenRouter Chat Model node’s dropdown. For store management commands (structured data retrieval, product updates), Claude 3.5 Sonnet or GPT-4o Mini deliver excellent results at low cost. Switch models any time without touching the rest of the workflow.

8 Simple Memory

The memory node gives the agent a 20-message conversation window, keyed to each contact’s WhatsApp phone number (wa_id). This means when a user follows up with “Actually, add a note to that order saying urgent delivery,” the agent remembers which order they were discussing without being told again. Each WhatsApp contact gets a fully isolated conversation context — 50 customers messaging simultaneously creates 50 separate memory streams.

Part 4 — Shopify Tools the Agent Can Use

The AI agent has six Shopify tools available. It calls them autonomously — you never have to specify which tool to use in your WhatsApp message. Just describe what you want in plain language, and the agent decides.

Part 5 — Database and Email Tools

9 Google Sheets — Database Tool

Every time the agent retrieves or acts on an order, it can write the data to your Google Sheet using the appendOrUpdate operation. The Order ID column is the matching key — so re-running a command on the same order updates the existing row rather than duplicating it. All 14 fields are populated via $fromAI() expressions, meaning the agent extracts each value from the Shopify response and maps it automatically.

10 Gmail — Send Email Tool

When you ask the agent to email a customer, it calls this tool, filling the To, Subject, and Message fields via $fromAI(). The sender name is set to your store name. For example, you can say: “Email james.carter@gmail.com and tell him his order shipped today” — and the agent writes and sends the email entirely on its own.

Part 6 — Sending the Reply

11 Switch1 — Reply in Text or Voice?

After the AI agent finishes, a second Switch node checks the original message type again. If you sent text, you get a text reply. If you sent a voice note, the agent converts its response to speech and sends a voice note back. The reply always matches the input format — a voice conversation stays a voice conversation.

12 Convert Text to Speech (ElevenLabs)

For audio replies, this node sends the AI agent’s text output to ElevenLabs using the “Charlie — Deep, Confident, Energetic” voice. The settings are configured for natural, professional delivery: stability at 1.0, similarity boost at 1.0, and speed at 0.82 (slightly slower than default, which works better for information-dense store management replies). The output format is MP3 at 22050 Hz.

13 Convert to MPEG (Code Node)

WhatsApp’s API is strict about audio MIME types. This Code node sets mimeType to audio/mpeg and renames the file to voice.mp3 — without this step, WhatsApp rejects the audio upload and the voice reply fails silently.

for (const item of $input.all()) {
  if (item.binary && item.binary.data) {
    item.binary.data.mimeType = 'audio/mpeg'
    item.binary.data.fileName = 'voice.mp3'
  }
}
return $input.all();

14 Send Message / Send Message1 (WhatsApp)

Two WhatsApp send nodes handle the two reply paths. Send message1 (text path) sends the AI output as a plain text body. Send message (audio path) sends the MPEG binary as an audio message. Both always reply to the original sender using $('WhatsApp Trigger').item.json.contacts[0].wa_id.

The Data Structure — Google Sheets Order Database

Create a Google Sheet with one tab named orders. The column names below are case-sensitive — the agent uses them as keys when writing rows via $fromAI().

Full System Flow — n8n Shopify AI Agent End to End

You send a WhatsApp message: "Update the Blue Hoodie price to $44"
          │
          ▼
[WhatsApp Trigger] → { messages[0].type: "text", text.body: "Update the Blue Hoodie price to $44" }
          │
          ▼
[Switch: type = "text"] → routes to AI Agent directly
          │
          ▼
[AI Agent — Store Manager]
  → calls [Get Products] → finds Blue Hoodie, product_id: 7890123456
  → calls [Update a Product] → sets title + new price on Shopify
  → calls [Google Sheets database] → logs order/product change
  → generates reply: "Done! Blue Hoodie updated to $44.00 in your store."
          │
          ▼
[Switch1: original type = "text"]
          │
          ▼
[WhatsApp: Send text reply] → "Done! Blue Hoodie updated to $44.00 in your store."

────────────────────────────────────────────────────────────

You send a WhatsApp voice note: "Send an email to James about his order"
          │
          ▼
[WhatsApp Trigger] → { messages[0].type: "audio", audio.id: "media_id_xyz" }
          │
          ▼
[Switch: type = "audio"] → routes to audio transcription path
          │
[Download Media URL] → { url: "https://lookaside.fbsbx.com/..." }
[Download Audio Binary] → binary MP3 file
[ElevenLabs: Speech-to-Text] → { text: "Send an email to James about his order" }
          │
          ▼
[AI Agent — Store Manager]
  → calls [Get Orders] → finds James Carter, order #1023, james.carter@gmail.com
  → calls [Gmail: Send Email] → sends order update email to james.carter@gmail.com
  → generates reply: "Email sent to James Carter at james.carter@gmail.com for order #1023."
          │
          ▼
[Switch1: original type = "audio"]
          │
[ElevenLabs: Text-to-Speech] → MP3 audio of reply in Charlie voice
[Code: Set mimeType = audio/mpeg]
[WhatsApp: Send voice note] → 🔊 Voice reply delivered to sender

Testing Your n8n Shopify AI Agent

1. In n8n, activate the workflow and copy the WhatsApp webhook URL. Register it in the Meta Developer Console under your app’s webhook settings.
2. Send a text message to your WhatsApp business number: “List all products.” Confirm the AI responds with your actual Shopify catalog.
3. Send a voice note saying: “How many orders do we have this week?” Confirm the audio is transcribed, the AI calls Get Orders, and you receive a voice reply with the count.
4. Send: “Create a test product called Test Widget at $9.99.” Check your Shopify Products dashboard to confirm it appeared.
5. Send: “Delete the Test Widget product.” Confirm it’s removed from Shopify. Then send the same command again — the AI should respond that the product no longer exists, demonstrating it uses Get Products before acting.
6. Send: “Email emily.rodriguez@outlook.com and tell her order #1001 has shipped.” Check your Gmail Sent folder to confirm the email was sent with the correct content.
7. Open your Google Sheet and confirm order rows are being written or updated correctly.

Frequently Asked Questions

What’s Next?

• Add a daily sales report — wire a Schedule Trigger that fires every morning and sends you a voice note summarizing the previous day’s orders, revenue, and top-selling products.
• Add inventory alerts — extend the Get Products tool call to check stock levels and automatically send a WhatsApp alert when any product drops below a minimum quantity you define.
• Connect Telegram as a second channel — duplicate the WhatsApp input/output nodes and replace them with Telegram nodes so the same AI agent is accessible from both apps with shared memory.
• Add a safety confirmation step — before any destructive action (delete product, cancel order), add a WhatsApp reply asking for confirmation, then a Wait node and an IF check on the response.
• Browse all our automation guides on the EasyWorkflows n8n blog →

If you’re posting the same video to Instagram Reels, Facebook Reels, YouTube, and TikTok, you already know the drill: download, re-upload, write a caption, find the right tags, publish, check the status, repeat — four times, for every single video. It’s not a content problem. It’s a logistics problem. And logistics problems are exactly what n8n was built to solve.

This workflow watches a Google Drive folder, picks up the next unprocessed video, uses an AI model via OpenRouter to generate a platform-optimized caption with hashtags, uploads the video to Cloudinary as a CDN host, then simultaneously publishes it as a Reel on Instagram, a Reel on Facebook, and a video on YouTube — while staging the data for TikTok in a separate sheet. Every step is tracked in a Google Sheet so your team always knows what’s been published and what’s still pending. When everything is done, the original file is moved to an archive folder so it doesn’t get picked up again.

Prefer to skip the setup? Grab the ready-made template → and be publishing cross-platform in under 20 minutes.

What You’ll Build

1. A daily schedule trigger (fires at 6 PM) scans your Google Drive folder for the next video waiting to be published.
2. A Code node strips the file extension and normalizes the filename into a clean public ID (spaces become underscores for Cloudinary).
3. The video is uploaded to Cloudinary, which provides a stable public CDN URL that all four platforms can download from.
4. An AI call to OpenRouter (Claude 3.7 Sonnet) reads the filename as a keyword and writes a Facebook-optimized caption with five hashtags — no manual copywriting needed.
5. The Cloudinary URL and AI caption are written back to your Google Sheet tracking row.
6. The video is published as a Reel on Facebook (via the Facebook Graph API) and simultaneously as a Reel on Instagram — with 30-second waits built in between API calls to respect rate limits.
7. The same video is uploaded to YouTube with the AI caption as the description, then added to a playlist.
8. A separate Google Sheets tab gets a row appended for your TikTok queue (ready for the next manual step or a future TikTok automation).
9. The main tracking sheet updates the row status to “Video Shared”, and the original Drive file is moved to your archive folder.

How It Works — The Big Picture

┌──────────────────────────────────────────────────────────────────────────────┐
│  SOCIAL MEDIA AUTOMATION (n8n)                                               │
│                                                                              │
│  [Schedule Trigger 6PM] ──► [Google Drive: Search Folder]                   │
│                                        │                                     │
│                                        ▼                                     │
│                              [Code: Clean Filename]                          │
│                                        │                                     │
│                                        ▼                                     │
│                              [Cloudinary: Upload Video]                      │
│                                        │                                     │
│                                        ▼                                     │
│                          [Sheets: Get Pending Row]                           │
│                                        │                                     │
│                                        ▼                                     │
│                         [OpenRouter AI: Generate Caption]                    │
│                                        │                                     │
│                                        ▼                                     │
│                         [Sheets: Write URL + Caption]                        │
│                                        │                                     │
│               ┌────────────────────────┤                                     │
│               │                        │                                     │
│               ▼                        ▼                                     │
│  ── FACEBOOK REELS ──       ── INSTAGRAM REELS ──                           │
│  [Init Upload Session]       [Post Container]                               │
│  [Upload Hosted File]        [Wait 30s]                                     │
│  [Publish Reel]              [Publish to Instagram]                         │
│  [Get Upload Status]         [Wait 30s]                                     │
│  [Wait 30s]                  [HTTP: Fetch Video]                            │
│               │                        │                                     │
│               └────────────────────────┘                                     │
│                                        │                                     │
│                                        ▼                                     │
│                         ── YOUTUBE ──                                        │
│                         [Upload Video]                                       │
│                         [Wait 10s]                                           │
│                         [Add to Playlist]                                    │
│                         [Wait 10s]                                           │
│                         [Sheets: Append TikTok Row]                         │
│                                        │                                     │
│                                        ▼                                     │
│                         [Sheets: Update Status → "Video Shared"]            │
│                         [Google Drive: Move to Archive Folder]              │
└──────────────────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n — self-hosted or n8n Cloud (v1.30+)
• Google Drive — one folder for new videos, one for archived videos
• Cloudinary account — free tier is sufficient; the Social_Media folder will be created automatically
• OpenRouter account — free tier works; Claude 3.7 Sonnet is configured by default (swap to any model you prefer)
• Meta Developer App — with a Facebook Page token and an Instagram Business account linked to that page
• YouTube Data API v3 — OAuth2 credentials connected in n8n; a playlist ID to post into
• Google Sheets — one spreadsheet with two tabs: one for Instagram/Facebook/YouTube tracking, one for TikTok queue

Estimated build time: 90–120 minutes from scratch. Under 20 minutes with the template.

Part 1 — Picking Up the Video

1 Schedule Trigger

The workflow fires once a day at 6 PM. You can change this to any hour — just edit the Trigger At Hour field in the Schedule Trigger node. If you want to post multiple times a day, duplicate the trigger or switch to an interval-based schedule.

// Schedule Trigger output (no data — just fires the workflow)
{}

2 Search Files and Folders (Google Drive)

This node lists files inside your designated Google Drive folder, returning the first result it finds (limit: 1). It fetches all fields, including webContentLink — a direct download URL that Cloudinary will use to pull the video.

// Google Drive file output
{
  "id": "1aBcDeFgHiJkLmNoPqRsTuV",
  "name": "Summer Sale Promo.mp4",
  "webContentLink": "https://drive.google.com/uc?id=1aBcDeFgHiJkLmNoPqRsTuV&export=download",
  "mimeType": "video/mp4",
  "size": "48234567"
}

3 Remove Space & Extensions (Code Node)

Platform APIs and CDNs don’t love filenames with spaces or extensions. This Code node strips the .mp4 (or any extension) from the filename and produces two variants: one with underscores (for Cloudinary’s public_id) and one with the original spaces preserved (for YouTube’s video title, which looks better with natural spacing).

const baseName = $json["name"]
  .replace(/\s*\.[^/.]+$/, "")  // remove file extension
  .trim();

const public_id_underscores = baseName.replace(/\s+/g, "_"); // spaces → underscores
const public_id_no_underscores = baseName;                    // natural spacing

return [{ json: { public_id_underscores, public_id_no_underscores } }];

// Output
{
  "public_id_underscores": "Summer_Sale_Promo",
  "public_id_no_underscores": "Summer Sale Promo"
}

Part 2 — Uploading to Cloudinary

4 Upload an Asset from URL (Cloudinary)

Rather than downloading the video to n8n’s memory and re-uploading it, this node passes Cloudinary the Google Drive download link directly. Cloudinary fetches it server-to-server, transcodes it if needed, and stores it in your Social_Media folder with the underscore-normalized name as the public ID. In return, Cloudinary hands you a secure_url — the stable CDN link that all four platforms will pull from.

// Cloudinary upload output (key fields)
{
  "public_id": "Social_Media/Summer_Sale_Promo",
  "secure_url": "https://res.cloudinary.com/your-cloud/video/upload/Social_Media/Summer_Sale_Promo.mp4",
  "resource_type": "video",
  "format": "mp4",
  "duration": 28.4,
  "bytes": 48234567
}

Part 3 — AI Caption Generation

5 Get Row(s) in Sheet (Google Sheets)

This node looks up the first row in your tracking sheet where the Status column is set to pending. It returns all columns for that row, including its row_number — which is used later to update the same row in place rather than creating a duplicate.

// Google Sheets row output
{
  "row_number": 4,
  "video_url": "",
  "Video Caption": "",
  "Status": "pending"
}

6 Video Caption (OpenRouter AI)

This HTTP Request node calls the OpenRouter API, sending the cleaned filename as the keyword. The system prompt tells Claude 3.7 Sonnet to act as a Facebook copywriter and return a Reel title (max 46 characters) followed by five relevant hashtags — no labels, no emojis, no markdown bold formatting. Clean, ready-to-paste copy every time.

// Request body (simplified)
{
  "model": "anthropic/claude-3.7-sonnet",
  "messages": [
    {
      "role": "system",
      "content": "You are a facebook copywriter expert. Follow formatting rules exactly."
    },
    {
      "role": "user",
      "content": "based on this keyword Summer Sale Promo Write an optimized facebook Reel title (max 46 characters), use 5 related hashtags, Do NOT include labels like (Video Reel Title, Hashtags) no emojis, don't use ** in title."
    }
  ]
}

// OpenRouter response
{
  "choices": [
    {
      "message": {
        "content": "Summer Sale — Shop the Best Deals Now\n#SummerSale #ShopNow #SaleAlert #BestDeals #LimitedTime"
      }
    }
  ]
}

7 Update Caption & Video URL (Google Sheets)

Once the AI returns the caption and Cloudinary returns the CDN URL, this node writes both values back to the pending row — matching by row_number. From this point on, every downstream node references these two fields using $('Update caption & vid url').item.json.video_url and $('Update caption & vid url').item.json['Video Caption'].

// Updated row in Google Sheets
{
  "row_number": 4,
  "video_url": "https://res.cloudinary.com/your-cloud/video/upload/Social_Media/Summer_Sale_Promo.mp4",
  "Video Caption": "Summer Sale — Shop the Best Deals Now\n#SummerSale #ShopNow #SaleAlert #BestDeals #LimitedTime",
  "Status": "pending"
}

Part 4 — Publishing to Facebook Reels

Facebook’s Reels API uses a three-step upload protocol: initialize a session, upload the file, then publish. n8n handles all three calls in sequence with a 30-second wait before the publish check — giving Facebook’s servers time to process the video before you query the status.

8 Initialize an Upload Session (Facebook Graph API)

Sends a POST to your Facebook Page’s video_reels edge with upload_phase=start and the Cloudinary video URL. Facebook returns a video_id and an upload_url that the next node uses.

// Facebook API response
{
  "video_id": "740128398210437",
  "upload_url": "https://rupload.facebook.com/video-upload/v23.0/740128398210437"
}

9 Upload a Hosted File (HTTP Request)

Posts to the upload_url from the previous step, passing the Cloudinary URL in a custom file_url header. Facebook fetches the video directly from Cloudinary — no binary upload, no memory usage in n8n.

10 Publish The Reel (Facebook Graph API)

Sends the finish signal: upload_phase=finish, video_state=PUBLISHED, the AI-generated description, and the video_id. This is the moment the Reel goes live on your Facebook Page.

11 Get the Upload Status + Wait 30s

Queries the Facebook Graph API to confirm the video’s status field. The 30-second Wait node before Instagram publishing gives Facebook time to fully process the reel and updates internal state before the workflow moves on.

Part 5 — Publishing to Instagram Reels

12 Post Container (Facebook Graph API — Instagram)

Instagram’s publishing API (also part of the Facebook Graph API) requires a two-step process. First, create a media container by posting the video URL, caption, and media_type=REELS to your Instagram Business account’s media edge. This returns a container id.

13 Wait 30s → Publish to Instagram

The 30-second wait is mandatory — Instagram needs time to process the video before you can publish the container. After the wait, a second API call to the media_publish edge with the creation_id makes the Reel visible on your Instagram profile.

Part 6 — Publishing to YouTube

14 HTTP Request — Fetch Video Binary

This node downloads the video binary from the Cloudinary URL. YouTube’s n8n node expects a binary input (unlike the Facebook API which accepts a URL), so this step bridges the gap — the response body becomes the binary data that the YouTube Upload node reads.

15 Upload a Video (YouTube)

Uploads the binary to YouTube. The title uses the un-modified filename (public_id_no_underscores — natural spaces), the description gets the AI-generated caption, and the video is published as public with notifySubscribers: true. Category 22 is “People & Blogs” — change this to match your niche.

// YouTube upload output (key fields)
{
  "uploadId": "abc123XYZ_youTubeVideoId",
  "status": { "privacyStatus": "public", "uploadStatus": "uploaded" },
  "snippet": { "title": "Summer Sale Promo", "categoryId": "22" }
}

16 Add to Playlist (YouTube)

After a 10-second wait (gives YouTube time to finish processing the upload), this node adds the video to your designated playlist using the uploadId from the previous step. Set your playlist ID in the node parameters.

Part 7 — Tracking and Cleanup

17 Append Row to TikTok Sheet (Google Sheets)

After a second 10-second wait, this node appends a new row to a separate “TikTok” tab in your spreadsheet with the video URL and caption — ready for you to post manually or wire up to a future TikTok API automation.

18 Update Row Status (Google Sheets)

Updates the original tracking row from pending to Video Shared, matched by row_number. This prevents the same video from being picked up again on the next trigger run.

19 Move File to Archive (Google Drive)

Moves the original video file from your “pending” folder to your “archive” folder. The file ID comes from the very first node (Search files and folders). Set your archive folder ID in this node’s parameters.

The Data Structure

Your Google Sheet needs two tabs with these exact column names. The workflow uses string matching on column headers, so capitalization and spacing matter.

Tab 1: instagram / Facebook / Youtube

Tab 2: Tiktok

Full System Flow

New video dropped into Google Drive "Pending" folder
          │
          ▼
[Schedule Trigger: 6PM daily]
          │
          ▼
[Google Drive: Search Folder] → { name: "Summer Sale Promo.mp4", webContentLink: "..." }
          │
          ▼
[Code: Clean Filename] → { public_id_underscores: "Summer_Sale_Promo",
                            public_id_no_underscores: "Summer Sale Promo" }
          │
          ▼
[Cloudinary: Upload Video] → { secure_url: "https://res.cloudinary.com/.../Summer_Sale_Promo.mp4" }
          │
          ▼
[Sheets: Get Pending Row] → { row_number: 4, Status: "pending" }
          │
          ▼
[OpenRouter AI: Generate Caption] → "Summer Sale — Shop the Best Deals Now\n#SummerSale..."
          │
          ▼
[Sheets: Write URL + Caption to Row 4]
          │
    ┌─────┴──────────────────────────────────┐
    ▼                                        ▼
── FACEBOOK ──                       ── INSTAGRAM ──
[Init Upload Session]                [Post Container] → { id: "17867..." }
[Upload Hosted File]                 [Wait 30s]
[Publish Reel]                       [Publish to Instagram]
[Get Upload Status]                  [Wait 30s]
[Wait 30s]                           [Fetch Video Binary (HTTP)]
    │                                        │
    └──────────────────┬─────────────────────┘
                       ▼
                 ── YOUTUBE ──
                 [Upload Video] → { uploadId: "abc123..." }
                 [Wait 10s]
                 [Add to Playlist]
                 [Wait 10s]
                 [Sheets: Append TikTok Row]
                       │
                       ▼
                 [Sheets: Update Status → "Video Shared"]
                 [Google Drive: Move to Archive Folder]
                       │
                       ▼
            ✅ Video live on Facebook, Instagram & YouTube
               TikTok row ready in queue sheet

Testing Your Workflow

1. Add a short test video (under 60 seconds) to your Google Drive “pending” folder.
2. Add a row to Tab 1 of your Google Sheet with Status = pending, leave other fields blank.
3. In n8n, click Test workflow. Watch the execution — look for green checks on each node.
4. Confirm the Code node output shows both public_id_underscores and public_id_no_underscores.
5. Check your Cloudinary account to verify the video was uploaded to the Social_Media folder.
6. Confirm the Google Sheet row now has a video_url and Video Caption filled in.
7. Check your Facebook Page and Instagram profile for the new Reel (allow 2–3 minutes for processing).
8. Check your YouTube channel for the new video and confirm it was added to the correct playlist.
9. Verify the TikTok sheet has a new row appended.
10. Confirm the original Google Drive file has been moved to the archive folder.

Frequently Asked Questions

What’s Next?

• Add a Telegram alert — wire a Telegram node at the very end to send yourself a confirmation message with the video title and publish status every time a video goes live.
• Schedule multiple posts per day — duplicate the workflow and set one trigger for 9 AM and another for 6 PM to double your daily output without any extra manual work.
• Auto-generate video thumbnails — add a Cloudinary transformation step that extracts a frame from the uploaded video and creates a custom thumbnail you can use as the YouTube cover image.
• Connect a content calendar — replace the manual “add a file to Drive” step with a Notion or Airtable database where you queue up video ideas, titles, and target dates, and let the workflow pick the next scheduled entry automatically.
• Add TikTok direct posting — once your TikTok Content Posting API access is approved, add a TikTok node after the “Append row in sheet” step and close the loop on all five platforms in a single run.