Social Media Automation

You’ve spent hours filming, editing, and posting a killer TikTok video. Your creator account is gaining traction. But here’s the thing—you’re leaving money on the table if that video only lives on TikTok. YouTube Shorts has a completely different audience, different monetization rules, and different growth potential. The problem? Manually downloading from TikTok, re-uploading to YouTube, writing metadata, and repeating this process for every video is a soul-crushing grind that pulls you away from creating.

What if you could automate the entire repurposing pipeline? Post to TikTok once, and within minutes, your video automatically appears on YouTube Shorts with optimized metadata, proper formatting, and zero manual intervention. That’s exactly what we’re building today with n8n.

Save hours each week by automating your cross-platform distribution. Grab the ready-made template and skip the setup headaches.

What You’ll Build

By the end of this guide, you’ll have a fully automated workflow that handles every step of repurposing TikTok content to YouTube Shorts. Here’s what your system will do:

1. Monitor your TikTok profile — Every 6 hours, the workflow automatically checks your TikTok account for new videos using the RapidAPI TikTok Scraper.
2. Detect fresh uploads — A filtering system identifies videos you haven’t already repurposed, preventing duplicates and wasted resources.
3. Download video files — Your videos are fetched directly from TikTok in YouTube-compatible formats.
4. Generate YouTube metadata — The system automatically creates optimized titles, descriptions, and tags based on your TikTok content.
5. Upload to YouTube Shorts — Videos are submitted via YouTube’s Data API v3 with proper resumable session handling for reliability.
6. Log everything to Google Sheets — You get a growing inventory of what’s been repurposed, timestamps, and upload status.
7. Trigger alerts via Telegram — You’re notified the moment a video hits YouTube, plus you can manually trigger reposts via a Telegram command.

How It Works—The Big Picture

This workflow operates on a dual-trigger model. It can run on a schedule (every 6 hours) or be triggered manually through Telegram. Let’s map out the flow:

┌─────────────────────────────────────────────────────────────┐
│                       TWO ENTRY POINTS                      │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Trigger A: Schedule (Every 6 Hours)    Trigger B: Telegram │
│  │                                       │                   │
│  └──────────────────┬──────────────────┬─┘                   │
│                     │                  │                     │
│              Set TikTok Username    Parse Telegram           │
│                     │                  │ /repost @username   │
│                     └──────────────────┘                     │
│                            │                                  │
│                   Fetch TikTok Videos                        │
│                 (HTTP: RapidAPI Scraper)                    │
│                            │                                  │
│                  Filter New Videos Only                      │
│                  (Code: Parse Response)                      │
│                            │                                  │
│              ┌─────────────┴─────────────┐                   │
│              │                           │                   │
│        Log to Google Sheets      Prepare YouTube Metadata    │
│              │                           │                   │
│              └─────────────┬─────────────┘                   │
│                            │                                  │
│            Create YouTube Upload Session                     │
│           (YouTube API v3: Resumable)                       │
│                            │                                  │
│          Download TikTok Video (Temp)                        │
│                            │                                  │
│      Upload Video to YouTube Shorts                          │
│            (YouTube API v3)                                  │
│                            │                                  │
│       Send Telegram Notification                             │
│              (Success Alert)                                  │
│                                                               │
└─────────────────────────────────────────────────────────────┘

What You’ll Need

Before we build, make sure you have these pieces in place. The entire setup takes about 30–45 minutes.

• n8n account (free tier works, but Pro is recommended for multiple simultaneous workflows)
• RapidAPI account with an active TikTok Scraper subscription ($10–30/month depending on request volume)
• YouTube Data API v3 enabled in Google Cloud Console with OAuth 2.0 credentials
• Google Sheets API enabled in the same GCP project
• Telegram Bot Token from BotFather (free, takes 2 minutes)
• Google Account with OAuth access for YouTube and Sheets
• Creator account on both TikTok and YouTube (with YouTube Studio access)
• Minimum 2GB free storage on n8n for temporary video files

Step 1: Create the Schedule Trigger

1 Schedule Trigger Node

Start with n8n’s built-in Schedule node. This will kick off your workflow every 6 hours, allowing you to check for new TikTok videos automatically.

Node Configuration:

• Set trigger to Every 6 hours
• Leave timezone as default (your account timezone)
• Check the box for “Activate node immediately on deployment”

The Schedule trigger feeds directly into a Set TikTok Username node, which we’ll cover next.

Step 2: Add Manual Trigger with Telegram

2 Telegram Bot Trigger

To give yourself on-demand control, add a Telegram trigger. This lets you manually request a repost without waiting for the 6-hour schedule.

Setup steps:

1. Message @BotFather on Telegram and create a new bot (copy the token)
2. In n8n, create a Telegram trigger node
3. Add your Bot Token (paste from BotFather)
4. Set trigger to New Message
5. Configure message filter: Message starts with /repost

This trigger runs independently of the schedule, so you can trigger reposts manually anytime via Telegram.

Step 3: Set TikTok Username

3 Set Username Node (Code)

Both triggers converge here. This code node normalizes the TikTok username input—whether it came from the schedule default or a Telegram command.

Node configuration:

• Node type: Code
• Language: JavaScript

Code snippet:

// If triggered via Telegram, extract username from message
// Otherwise, use default username

if (items[0].json.message !== undefined) {
  // Telegram trigger: extract username from /repost @username
  const messageText = items[0].json.message;
  const parts = messageText.split(' ');
  const username = parts[1] ? parts[1].replace('@', '') : 'erinchen_creates';

  return [{
    json: {
      tikTokUsername: username,
      source: 'telegram'
    }
  }];
} else {
  // Schedule trigger: use default
  return [{
    json: {
      tikTokUsername: 'erinchen_creates',
      source: 'schedule'
    }
  }];
}

This node creates a standardized output that the next nodes can reliably consume, regardless of trigger source.

Step 4: Fetch TikTok Videos via HTTP Request

4 HTTP Request Node (RapidAPI)

Now we actually fetch the TikTok video data. We’re using RapidAPI’s TikTok Scraper—a reliable, legal way to pull public TikTok metadata.

Node configuration:

• Method: GET
• URL: https://tiktok-api.p.rapidapi.com/user/posts

Headers (add all three):

x-rapidapi-key: YOUR_RAPIDAPI_KEY
x-rapidapi-host: tiktok-api.p.rapidapi.com
Accept: application/json

Query parameters:

The response includes video ID, caption, duration, engagement metrics, and download URL. You’ll parse this in the next step.

Step 5: Filter New Videos with Code

5 Filter Code Node

The RapidAPI response might include videos you’ve already repurposed. This code node filters the response, comparing against your Google Sheets log of uploaded videos.

Node configuration:

• Node type: Code
• Language: JavaScript

Code snippet:

// Parse TikTok API response
const videos = items[0].json.data || [];

// Get list of already-uploaded video IDs from Sheets context
const uploadedIds = items[1]?.json?.uploadedVideoIds || [];

// Filter to only new videos
const newVideos = videos.filter(video => {
  return !uploadedIds.includes(video.id);
});

// Return filtered array (will create one item per video)
return newVideos.map(video => {
  return {
    json: {
      videoId: video.id,
      caption: video.desc,
      downloadUrl: video.downloadUrl,
      duration: video.duration,
      likes: video.stats?.likes || 0,
      shares: video.stats?.shares || 0,
      comments: video.stats?.comments || 0,
      createTime: video.createTime
    }
  };
});

The output is now one item per new video, ready to fan out across parallel processing.

Step 6: Log to Google Sheets

6 Google Sheets Append Node

Keep a permanent record of every repurposed video. This becomes your audit log and prevents duplicate uploads.

Setup:

1. Create a new Google Sheet named “TikTok Reposts” (or similar)
2. Create columns: TikTok Video ID, Caption, Duration, Likes, Date Posted, YouTube Link, Upload Status, Timestamp
3. In n8n, add a Google Sheets node
4. Authenticate with your Google account (OAuth 2.0)

Node configuration:

• Operation: Append
• Spreadsheet: Select “TikTok Reposts”
• Sheet: Select your data sheet
• Map columns to video data from the filter node

Column mappings:

This node executes in parallel with the YouTube upload process—we’re logging first, then processing.

Step 7: Prepare YouTube Metadata

7 Prepare Metadata (Code Node)

YouTube has strict requirements for title, description, and tags. This node transforms your TikTok caption into YouTube-optimized metadata.

Code snippet:

// Transform TikTok caption to YouTube metadata
const tiktokCaption = items[0].json.caption || '';
const videoId = items[0].json.videoId;

// Generate YouTube title (max 100 chars)
let youtubeTitle = tiktokCaption.substring(0, 100);
if (tiktokCaption.length > 100) {
  youtubeTitle += '...';
}

// Generate YouTube description
const description = `Originally posted on TikTok. Subscribe for more shorts!\n\n${tiktokCaption}\n\n#Shorts #TikTok #YouTubeShorts`;

// Extract hashtags from caption for YouTube tags
const hashtags = tiktokCaption.match(/#\w+/g) || [];
const tags = [...hashtags, 'shorts', 'tiktok', 'video'].slice(0, 30); // YouTube max 30 tags

return [{
  json: {
    title: youtubeTitle,
    description: description,
    tags: tags,
    privacyStatus: 'public',
    categoryId: '24', // Entertainment category
    duration: items[0].json.duration,
    downloadUrl: items[0].json.downloadUrl,
    videoId: videoId
  }
}];

This ensures your YouTube content is discoverable and follows platform best practices.

Step 8: Create YouTube Upload Session

8 YouTube API: Create Resumable Session

YouTube requires a two-step upload process: first create a resumable session, then upload the file. This prevents re-uploads if the connection drops.

Node type: HTTP Request

Method: POST

URL:

https://www.googleapis.com/youtube/v3/videos?uploadType=resumable&part=snippet,status

Headers:

Body (JSON):

{
  "snippet": {
    "title": "{{ $node['Prepare Metadata'].json.title }}",
    "description": "{{ $node['Prepare Metadata'].json.description }}",
    "tags": {{ JSON.stringify($node['Prepare Metadata'].json.tags) }},
    "categoryId": "24"
  },
  "status": {
    "privacyStatus": "public",
    "selfDeclaredMadeForKids": false
  }
}

YouTube responds with a resumable session URL in the Location header. Store this for the next step.

Step 9: Download TikTok Video

9 HTTP Request: Download Video

Fetch the actual video file from TikTok. n8n will store this temporarily in memory.

Node type: HTTP Request

Method: GET

URL:

{{ $node["Filter Code"].json.downloadUrl }}

Options:

• Set “Response Format” to File
• Add header User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
• Set timeout to 60 seconds

The downloaded file is automatically staged for upload in the next step.

Step 10: Upload Video to YouTube

10 YouTube API: Upload Video Chunk

Now upload the downloaded video file to YouTube using the resumable session created in Step 8.

Node type: HTTP Request

Method: PUT

URL:

{{ $node["Create Upload Session"].headers.location }}

Headers:

Body: Set to Binary and map the file from the Download Video node.

Upon success, YouTube returns a 200 response with video metadata including the id field (your new YouTube video ID).

Step 11: Send Telegram Notification

11 Telegram Bot Send Message

Celebrate the successful upload. Send yourself a Telegram notification with the YouTube link.

Node type: Telegram

Configuration:

• Operation: Send Message
• Bot Token: (same as Step 2)
• Chat ID: Your personal Telegram user ID

Message text:

✅ Video Uploaded to YouTube!

Title: {{ $node['Prepare Metadata'].json.title }}
YouTube URL: https://youtube.com/shorts/{{ $node['Upload Video'].json.id }}
Duration: {{ $node['Filter Code'].json.duration }}s
Likes: {{ $node['Filter Code'].json.likes }}

Check it out and update the sheet when ready.

This becomes your real-time alert system—you’ll know instantly when each video goes live.

The Data Structure

Your Google Sheets log is the backbone of the system. Here’s what your tracking sheet should look like:

Each row represents one repurposed video. Over time, this sheet becomes your content inventory—searchable, sortable, and exportable for analytics.

Full System Flow

Here’s the complete, end-to-end picture of your automated workflow:

┌──────────────────────────────────────────────────────────────┐
│                    START: DUAL TRIGGERS                      │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│   Schedule: Every 6 hours          Telegram: /repost cmd      │
│   (Morning, Noon, Evening, Night)  (Manual on-demand)         │
│                                                                │
│   └──────────────────────┬──────────────────────┘            │
│                          │                                    │
│                   [Set TikTok Username]                       │
│              Extract or use default username                 │
│                          │                                    │
│          [HTTP: Fetch TikTok Videos via RapidAPI]            │
│               Get latest 10 videos, newest first              │
│                          │                                    │
│              [Code: Filter New Videos Only]                  │
│        Compare against Sheets log, skip already-uploaded    │
│                          │                                    │
│              ┌───────────┴───────────┐                        │
│              │ (Loop: Per New Video) │                        │
│              └───────────┬───────────┘                        │
│                          │                                    │
│         ┌────────────────┴────────────────┐                   │
│         │                                 │                   │
│    [Google Sheets]              [Code: Prepare YouTube     │
│    Append Row                    Metadata & Tags]            │
│    - Video ID                    - Title (max 100 chars)     │
│    - Caption                     - Description + Hashtags    │
│    - Duration                    - Category: Entertainment   │
│    - Likes/Shares                - Privacy: Public           │
│    - Status: Pending             - Tags: 30 max             │
│         │                                 │                  │
│         └────────────────┬────────────────┘                   │
│                          │                                    │
│      [YouTube API: Create Resumable Session]                 │
│           POST to /videos?uploadType=resumable               │
│           Receive: X-Goog-Upload-Protocol Location           │
│                          │                                    │
│         [HTTP: Download TikTok Video File]                    │
│           Temporary storage in n8n memory/disk                │
│                          │                                    │
│      [YouTube API: Upload Video File (PUT)]                  │
│      Send binary file to resumable session URL               │
│                          │                                    │
│         [Code: Extract YouTube Video ID]                     │
│           Parse response, get youtu.be ID                    │
│                          │                                    │
│    [Google Sheets: Update Row]                               │
│    - YouTube Video ID column                                 │
│    - Status: Success                                         │
│    - Timestamp: Upload completion time                       │
│                          │                                    │
│    [Telegram: Send Notification]                             │
│    "✅ Video uploaded: [title] [youtube.com/shorts/ID]"      │
│                          │                                    │
│             [Workflow End for This Video]                    │
│      (Loop continues for next new video if exists)           │
│                          │                                    │
│         ┌────────────────┴────────────────┐                   │
│    [All videos processed?]                                   │
│         Yes ↓              No ↓                               │
│    [Workflow Done]    [Continue loop]                        │
│                                                                │
└──────────────────────────────────────────────────────────────┘

Testing Your Workflow

Before activating on the real 6-hour schedule, test everything in isolation. Here’s a systematic approach:

Test Plan

1. Test TikTok Fetch (Step 4)
   • Run just the HTTP RapidAPI node with a username you know has videos
   • Check that the response contains video objects with id, desc, downloadUrl
   • Verify API rate limit isn’t exceeded (check RapidAPI dashboard)
2. Test Filter Logic (Step 5)
   • Mock the RapidAPI response with sample video data
   • Verify the filter code correctly identifies new vs. already-uploaded videos
   • Use a small test Sheets with 1-2 pre-existing IDs to confirm filtering works
3. Test YouTube OAuth (Step 8)
   • Create a test n8n YouTube node and authenticate
   • Verify your token is valid and has youtube.upload scope
   • Try creating a resumable session (you can discard it—don’t upload yet)
4. Test End-to-End with a Real Video
   • Use the workflow’s “Test” button to run from the Schedule trigger
   • Upload one real video to YouTube to verify the full pipeline
   • Check the YouTube Studio to confirm the video appears with correct metadata
   • Verify Telegram notification was sent
   • Verify Google Sheets row was created and updated

Troubleshooting Guide

Frequently Asked Questions

What’s Next?

Once your core workflow is humming, consider these extensions:

• Instagram Reels Integration — Add Instagram Data API to cross-post to Reels with the same metadata pipeline. Instagram and YouTube have slightly different format requirements, so you’d branch the metadata preparation.
• Analytics Tracking — Pull daily YouTube Analytics API data for each uploaded video and log performance metrics (views, watch time, CTR) back to your Sheets. Identify which TikToks perform best on YouTube.
• Smart Scheduling — Use n8n’s AI nodes to analyze your audience timezone and schedule uploads when your audience is most active. YouTube Shorts have different peak times than TikTok.
• Content Moderation — Add a screening step using OpenAI’s moderation API to flag videos with potentially problematic content before they go live on YouTube.
• Thumbnail Generation — Automatically extract a frame from each TikTok and use an image-to-text API to generate optimized YouTube thumbnail text overlays.
• Multi-Platform Dashboard — Build a custom UI with Webflow or Bubble that displays your reposts, engagement metrics, and upload history—no more spreadsheet hunting.

The modular nature of n8n means each extension is just a few new nodes. Start simple, and scale as your workflow matures.