Build a TikTok Content Automation Pipeline with n8n

A pipeline that turns one video into ten TikTok posts

You have a source video. You need it posted across 10 TikTok accounts, each with a slightly different version. Each version needs to be 9:16, under 287MB, with unique encoding so TikTok doesn't flag duplicates.

Doing this manually takes an hour per video. Building it as an n8n pipeline takes an afternoon of setup. After that, it runs on autopilot.

If you're not familiar with the FFmpeg commands used throughout this pipeline, the FFmpeg command reference covers the fundamentals. And if you want to understand how TikTok detects duplicate content (and why the variation step matters), read about avoiding TikTok duplicate detection first.

Start with the RenderIO n8n node

RenderIO has a partner-verified community node on the n8n marketplace. It lets you run FFmpeg commands, chain multi-step pipelines, and manage files — all from a visual interface. Install from Settings → Community Nodes → search "renderio".

For TikTok automation, the node's "Run Chained" operation is useful for multi-step processing (resize + re-encode + strip metadata) in a single call. The workflows below use HTTP Request nodes for granular control, but the same commands work with the native node.

Pipeline architecture

Source Video → Resize to 9:16 → Generate 10 Variations → Quality Check → Store URLs → Trigger Scheduling

Five stages. Each stage is a group of n8n nodes. The whole pipeline executes in 5-10 minutes depending on video length.

Stage 1: n8n TikTok automation trigger setup

Your pipeline starts with a trigger. Pick the one that fits your content workflow:

Option A: Webhook trigger POST to your n8n webhook with { "videoUrl": "https://...", "title": "..." }. This is the most flexible option. Any script, Zapier zap, or external service can kick off your pipeline with a single HTTP request. In n8n, add a Webhook node, set the method to POST, and copy the production URL. That URL is your pipeline's front door.

Option B: Google Drive trigger Watch a folder. When a new video lands, the pipeline starts. Good for teams where someone uploads raw footage manually.

Option C: Airtable trigger New row with a video URL column. The pipeline processes it and updates the row with output URLs. This works well when you want a visual dashboard of pipeline status.

Option D: Schedule trigger Run at 6 AM daily. Pull unprocessed videos from a database or spreadsheet. Best for fully hands-off operation.

Whichever trigger you use, the next node should output a videoUrl field.

One thing to watch: n8n's webhook URLs change between test and production modes. If you're testing with the "Test URL" and then switch to production, you'll need to update any external services calling the webhook. It's a small thing that burns 30 minutes of debugging when you forget.

Stage 2: Resize to TikTok dimensions

First, get the video into TikTok format. This runs once (not per variation):

HTTP Request node, POST to https://renderio.dev/api/v1/run-ffmpeg-command:

{
  "ffmpeg_command": "-i {{in_video}} -vf \"scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black\" -c:v libx264 -crf 22 -preset fast -c:a aac -b:a 128k -movflags +faststart {{out_video}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_video": "base_tiktok.mp4" }
}

Headers:

Content-Type: application/json
X-API-KEY: your_renderio_key

Poll for completion by hitting GET https://renderio.dev/api/v1/commands/COMMAND_ID with the same API key header. The result is a TikTok-sized base video that all variations will derive from.

If you want a deeper walkthrough of resizing video in n8n, that guide covers edge cases like ultra-wide source footage and vertical-to-vertical scaling.

Stage 3: Generate unique variations

This is where the pipeline earns its keep. Each variation uses randomized FFmpeg parameters: different crop amounts, brightness shifts, pitch adjustments, CRF values, and noise levels. TikTok's fingerprinting system compares uploaded videos against its database, and even small encoding differences are enough to pass as distinct content.

Code node to create variation parameters:

const baseVideoUrl = $input.first().json.output_files.out_video.storage_url;
const accountCount = 10;
const variations = [];

for (let i = 0; i < accountCount; i++) {
  // Each variation gets unique parameters
  const crop = 2 + Math.floor(Math.random() * 6);
  const brightness = (Math.random() * 0.04 - 0.02).toFixed(3);
  const pitch = (1.0 + (Math.random() * 0.02 - 0.01)).toFixed(4);
  const crf = 21 + Math.floor(Math.random() * 5);
  const noise = 3 + Math.floor(Math.random() * 5);

  variations.push({
    json: {
      baseVideoUrl,
      accountIndex: i,
      accountName: `account_${i + 1}`,
      crop,
      brightness,
      pitch,
      crf,
      noise
    }
  });
}

return variations;

This generates 10 items, each with randomized parameters. No two variations will be identical.

Split in Batches (size: 3):

Process 3 at a time to stay within rate limits. If you're on the Business plan ($99/mo, 20,000 commands), you can bump this to 5-10. More parallelism means faster pipeline completion.

HTTP Request, POST to https://renderio.dev/api/v1/run-ffmpeg-command:

{
  "ffmpeg_command": "-i {{in_video}} -vf \"crop=iw-{{ $json.crop }}:ih-{{ $json.crop }}:{{ $json.crop }}/2:{{ $json.crop }}/2,scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black,eq=brightness={{ $json.brightness }},noise=alls={{ $json.noise }}:allf=t\" -af \"asetrate=44100*{{ $json.pitch }},aresample=44100\" -c:v libx264 -crf {{ $json.crf }} -map_metadata -1 {{out_video}}",
  "input_files": { "in_video": "{{ $json.baseVideoUrl }}" },
  "output_files": { "out_video": "tiktok_{{ $json.accountName }}.mp4" }
}

Standard polling loop for each variation. For the full submit-poll-download pattern, see the complete API guide.

Stage 4: Quality check

After each variation completes, verify it meets TikTok requirements:

Code node (check constraints):

const item = $input.first().json;

// Check that we got output files
if (!item.output_files || !item.output_files.out_video.storage_url) {
  return [{ json: { ...item, passed: false, reason: "No output file" } }];
}

// Mark as passed (file size check would require downloading)
return [{ json: { ...item, passed: true } }];

Route failed items to an error log. Route passed items to storage.

Stage 5: Store and schedule

Option A: Google Sheets

Write each variation's download URL to a row:

Account	Video URL	Status	Scheduled
account_1	https://media.renderio.dev/tiktok_account_1.mp4	ready	no
account_2	https://media.renderio.dev/tiktok_account_2.mp4	ready	no

Your team picks up from the spreadsheet for manual scheduling.

Option B: Database

Insert into your videos table:

INSERT INTO scheduled_posts (account_name, video_url, status, created_at)
VALUES ('account_1', 'https://...', 'ready', NOW());

A separate scheduling service picks up ready posts.

Option C: Direct API posting

If you have TikTok API access (Content Posting API), trigger uploads directly:

{
  "method": "POST",
  "url": "https://open.tiktokapis.com/v2/post/publish/video/init/",
  "headers": { "Authorization": "Bearer {{ $json.accessToken }}" },
  "body": {
    "post_info": { "title": "{{ $json.title }}" },
    "source_info": { "source": "PULL_FROM_URL", "video_url": "{{ $json.videoUrl }}" }
  }
}

Full pipeline as n8n JSON

Here's the node structure for import:

1. Webhook Trigger (/tiktok-pipeline)
2. HTTP Request: Resize to TikTok (POST to RenderIO)
3. Wait (5s)
4. HTTP Request: Check resize status
5. IF: Resize complete?
   → False: Back to Wait
   → True: Continue
6. Code: Generate 10 variation parameters
7. Split in Batches (size: 3)
8. HTTP Request: Submit variation (POST to RenderIO)
9. Wait (5s)
10. HTTP Request: Check variation status
11. IF: Complete?
    → False: IF failed? → Log error / Back to Wait
    → True: Continue
12. Google Sheets: Write output URL
13. Back to Split in Batches
14. Slack: Send "Pipeline complete" notification

14 nodes. 10 unique TikTok-ready videos from a single source.

Optimizing pipeline speed

The bottleneck is encoding time. Tips to speed things up:

Use -preset veryfast: 3x faster than medium. Slightly larger file size but fine for TikTok since TikTok re-encodes everything anyway.

Process from the resized base: Don't resize and create variations in one step. Resize once, then generate variations from the smaller file. Faster downloads, faster encodes.

Increase batch size: If your RenderIO plan supports it, process 5-10 variations simultaneously instead of 3.

Use webhooks: Replace the polling loop with webhook triggers. Submit all 10 variations, then wait for 10 webhook callbacks. This is covered in the complete API guide.

Common pitfalls

Rate limiting: If you submit all 10 variations at once, you might hit rate limits depending on your plan. The Split in Batches node is there for a reason. Start with batches of 3. If that works cleanly, try 5.

n8n cloud vs self-hosted timeout differences: n8n cloud has execution time limits on some plans. A pipeline that processes 10 variations with polling can take 5-10 minutes. If your executions get killed halfway through, you're hitting the timeout. Self-hosted n8n doesn't have this limit. Check your plan's execution time cap before scaling up.

Polling loop gets stuck: If the API returns an unexpected status (not SUCCESS, not FAILED, not PENDING), your IF node won't match any condition and the workflow stalls. Add a third branch for "unknown status" that logs the response and breaks the loop after 10 retries.

Forgetting -map_metadata -1: Without this flag, your output videos keep metadata from the source file: creation date, GPS coordinates, encoder info. TikTok can use metadata for fingerprinting. Always strip it. If you want to understand the full picture, read about batch video processing in n8n where metadata handling is covered in depth.

Error recovery

If a variation fails, don't stop the pipeline:

Enable "Continue on Fail" on the submit HTTP Request node
Check for errors after each submission
Log failed variations to a separate error sheet
At the end of the pipeline, retry failed variations

IF: Submit failed?
  → True: Write to Error Sheet → Back to Split in Batches
  → False: Continue polling

Failed variations can be retried in a separate cleanup workflow that runs hourly.

FAQ

How many variations can I create per source video?

As many as you want. The code node generates parameters for each variation, so change accountCount from 10 to 50 if you need 50 versions. The limiting factor is your RenderIO plan. Starter covers 500 commands/mo, Growth handles 1,000, and Business gives you 20,000.

What if a variation fails during processing?

Enable "Continue on Fail" on the HTTP Request node so the pipeline keeps going. Failed variations get routed to an error log. You can retry them manually or with a separate cleanup workflow. Common failure reasons: source video is corrupted, video exceeds the 500MB input limit, or the FFmpeg command has a filter syntax error.

Does this work with n8n cloud or only self-hosted?

Both. The only difference is execution time limits. n8n cloud plans have different timeout caps. If your pipeline takes longer than the allowed execution time, it gets killed. Self-hosted n8n has no such limit. For a 10-variation pipeline, expect 5-10 minutes of total execution time. Check your n8n cloud plan's limits.

How much does the full pipeline cost per video?

One source video uses 1 resize command + 10 variation commands = 11 API calls. On the Growth plan ( $29/mo, 1,000 commands), that's about 90 videos per month. On Business ($ 99/mo, 20,000 commands), you can process over 1,800 videos per month.

Can I add watermarks or text overlays in the same pipeline?

Yes. Extend the variation FFmpeg command to include overlay or drawtext filters. For example, add ,drawtext=text='@YourBrand':fontsize=24:fontcolor=white:x=20:y=H-60 to the video filter chain. The adding watermarks to video guide has the full filter syntax.

Get started

Sign up at renderio.dev
Copy the pipeline structure above into n8n
Test with one source video and 3 variations
Scale to 10 variations and multiple daily videos

The Growth plan at $29/mo covers 1,000 commands per month, enough for daily TikTok content production.