DEV Community: Rohan sirohi

How to Schedule Social Media Posts to Instagram, TikTok, and YouTube with Node.js

Rohan sirohi — Wed, 29 Apr 2026 09:49:06 +0000

Scheduling a social media post sounds simple. You pick a time, you publish at that time. But if you've tried to build this yourself, you know there are at least three ways it can quietly fail:

Your cron job runs but the token expired overnight
The video is still processing on Instagram's side when you try to publish
Your server restarts and the in-memory job queue is gone

This tutorial covers a robust approach to scheduling posts to Instagram, TikTok, and YouTube using Node.js — including how to handle all three failure modes above.

Prerequisites

Node.js 18+
An InReelForge account (free tier works) — indreelforge.com
Your social accounts connected in the InReelForge dashboard

Setup

mkdir social-scheduler && cd social-scheduler
npm init -y
npm install indreelforge dotenv

Create .env:

INDREELFORGE_API_KEY=your_api_key_here

Basic Scheduling

The simplest case — schedule a post with a future timestamp:

import InReelForge from 'indreelforge';
import 'dotenv/config';

const client = new InReelForge({ apiKey: process.env.INDREELFORGE_API_KEY });

async function schedulePost(videoPath, publishAt) {
  const result = await client.publish({
    video: videoPath,
    platforms: ['instagram', 'tiktok', 'youtube'],
    caption: 'New video dropping now 🎬',
    hashtags: ['content', 'video'],
    schedule: publishAt.toISOString(),
  });

  console.log('Scheduled:', result.jobId);
  console.log('Status per platform:', result.platforms);
  return result;
}

// Schedule for tomorrow at 9am UTC
const tomorrow9am = new Date();
tomorrow9am.setUTCDate(tomorrow9am.getUTCDate() + 1);
tomorrow9am.setUTCHours(9, 0, 0, 0);

await schedulePost('./my-video.mp4', tomorrow9am);

The schedule is persisted server-side in a database-backed queue — if InReelForge restarts, your job survives. You don't need to run your own scheduler.

Per-Platform Scheduling

Different platforms have different peak times. You can send each platform its own schedule:

const result = await client.publish({
  video: './video.mp4',
  caption: 'Default caption',
  platforms: ['instagram', 'tiktok', 'youtube'],
  overrides: {
    instagram: {
      schedule: '2026-06-01T11:00:00Z', // 11am UTC
      caption: 'Instagram-specific caption with #reels #viral',
    },
    tiktok: {
      schedule: '2026-06-01T18:00:00Z', // 6pm UTC — peak TikTok time
      caption: 'TikTok hook caption here',
    },
    youtube: {
      schedule: '2026-06-01T14:00:00Z', // 2pm UTC
      caption: 'Full YouTube description with timestamps\n\n0:00 Intro\n0:30 Main content',
    },
  },
});

Building a Simple Content Queue

If you're managing a backlog of content, here's a pattern for a queue processor:

import { readdir, readFile } from 'fs/promises';
import path from 'path';
import InReelForge from 'indreelforge';

const client = new InReelForge({ apiKey: process.env.INDREELFORGE_API_KEY });

// Each file in /queue/ is a JSON job descriptor
async function processQueue(queueDir) {
  const files = await readdir(queueDir);
  const pending = files.filter(f => f.endsWith('.json'));

  for (const file of pending) {
    const job = JSON.parse(await readFile(path.join(queueDir, file), 'utf8'));

    try {
      const result = await client.publish({
        video: job.videoPath,
        platforms: job.platforms,
        caption: job.caption,
        hashtags: job.hashtags,
        schedule: job.publishAt,
      });

      console.log(`✓ Scheduled ${file} → jobId: ${result.jobId}`);

      // Move to /done/
      await rename(
        path.join(queueDir, file),
        path.join(queueDir, '../done', file)
      );
    } catch (err) {
      console.error(`✗ Failed ${file}:`, err.message);
    }
  }
}

await processQueue('./queue');

A job JSON file (queue/post-001.json) looks like:

{
  "videoPath": "./videos/demo.mp4",
  "platforms": ["instagram", "tiktok", "youtube"],
  "caption": "New video — check it out!",
  "hashtags": ["saas", "demo"],
  "publishAt": "2026-06-01T09:00:00Z"
}

Checking Job Status

After scheduling, poll for results or set up a webhook:

// Poll approach
async function waitForResult(jobId, intervalMs = 5000) {
  while (true) {
    const status = await client.getJob(jobId);

    const allDone = Object.values(status.platforms).every(
      s => s === 'published' || s === 'failed'
    );

    if (allDone) return status;

    console.log('Still processing...', status.platforms);
    await new Promise(r => setTimeout(r, intervalMs));
  }
}

const final = await waitForResult(result.jobId);
console.log('Final status:', final.platforms);

Webhook Approach (Better for Production)

Instead of polling, receive a callback when each platform finishes:

import express from 'express';
import crypto from 'crypto';

const app = express();
app.use(express.raw({ type: 'application/json' }));

app.post('/webhooks/indreelforge', (req, res) => {
  const sig = req.headers['x-irf-signature'];
  const digest = 'sha256=' + crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(req.body)
    .digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(digest))) {
    return res.status(403).send('Invalid signature');
  }

  const event = JSON.parse(req.body);
  console.log(`${event.platform}: ${event.status}`);

  // event.status: 'published' | 'failed'
  // event.platform: 'instagram' | 'tiktok' | 'youtube' etc.
  // event.url: public URL of the published post (when published)

  res.sendStatus(200);
});

app.listen(3000);

Set your webhook URL in the InReelForge dashboard under Settings → Webhooks.

Common Mistakes

Don't schedule in the past. The API will reject timestamps more than 5 minutes behind the current time.

Don't assume immediate publishing. Even "publish now" goes through a queue — Instagram and TikTok take 30–120 seconds to process video.

Do validate video before scheduling. Use the /validate endpoint to check format compatibility before uploading:

const validation = await client.validate({
  video: './video.mp4',
  platforms: ['instagram', 'tiktok'],
});

if (!validation.compatible) {
  console.log('Issues:', validation.issues);
  // e.g. [{ platform: 'instagram', issue: 'aspect_ratio', detail: 'Expected 9:16, got 16:9' }]
}

Full Example Script

import InReelForge from 'indreelforge';
import 'dotenv/config';

const client = new InReelForge({ apiKey: process.env.INDREELFORGE_API_KEY });

const video = './product-launch.mp4';
const platforms = ['instagram', 'tiktok', 'youtube'];
const publishAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(); // 24h from now

// 1. Validate
const check = await client.validate({ video, platforms });
if (!check.compatible) {
  console.error('Video not compatible:', check.issues);
  process.exit(1);
}

// 2. Schedule
const job = await client.publish({
  video,
  platforms,
  caption: 'We just launched something big. Check it out.',
  hashtags: ['launch', 'saas', 'buildinpublic'],
  schedule: publishAt,
  overrides: {
    youtube: { caption: 'Full product demo with timestamps...' },
  },
});

console.log(`Scheduled ${platforms.length} posts for ${publishAt}`);
console.log(`Job ID: ${job.jobId}`);

Full API reference: docs.indreelforge.com

Free tier — 10 posts/month: indreelforge.com

Stop Maintaining 10 Social Media API Integrations: A Developer's Guide

Rohan sirohi — Wed, 29 Apr 2026 09:33:25 +0000

Let me give you a number: 2,400 hours.

That's a rough estimate of how long it takes a small engineering team to build and maintain direct integrations with 10 major social media platforms over two years. Not build them once — maintain them. API deprecations, auth flow changes, new video format requirements, quota adjustments, token refresh bugs.

If you're building anything that touches social media publishing, this post is for you.

Why Each Integration Is Harder Than It Looks

Instagram Graph API

The container-publish two-step is the first surprise. You don't just upload a video — you create a container, wait for it to process (poll for status), then call a separate publish endpoint. Reels have a strict aspect ratio requirement (9:16). If your video is 16:9, Instagram silently crops it rather than returning an error.

// Step 1 — create container
const container = await fetch(
  `https://graph.facebook.com/v19.0/${userId}/media`,
  {
    method: "POST",
    body: new URLSearchParams({
      media_type: "REELS",
      video_url: publicVideoUrl,  // must be publicly accessible
      caption: text,
      access_token: token,
    }),
  }
);

// Step 2 — poll until status = FINISHED (can take 60+ seconds)
// Step 3 — publish

That's before you handle token refresh (60-day expiry), rate limits, and the fact that video_url must be a publicly accessible URL — not a local file path.

TikTok Content Posting API

TikTok has two upload flows: URL-based and file-based (chunked). The chunked upload requires you to split the video into chunks of exactly the right size, send them in order, and then call a finalize endpoint. Title is required (not caption — title). Duration limits differ by account type and are not documented clearly.

YouTube Data API v3

Three separate API calls: initialize the upload session, upload the file (multipart), then check processing status. Processing can take anywhere from 30 seconds to 15 minutes. OAuth refresh tokens expire if not used for 6 months.

The Hidden Costs

Platform	Auth complexity	Video requirements	Gotchas
Instagram	High (2-step container)	9:16, H.264, AAC	Public URL required, silent crop
TikTok	High (chunked upload)	H.264, AAC, max 4GB	Title required, codec sensitivity
YouTube	Medium	Most formats accepted	Processing delay 30s–15min
Facebook	High (same as Instagram)	Varies by post type	Separate page token flow
X (Twitter)	Medium	512MB max, chunked	Media endpoint separate from tweet
LinkedIn	Medium	MP4 preferred	Asset registration before upload
Pinterest	Low	Most formats	Slower approval timeline
Threads	Medium	Same account as Instagram	Newer, less stable API
Bluesky	Low (AT Protocol)	Max 100MB	Different protocol entirely
Reddit	Low	Limited video support	DASH format for native video

The True Cost Model

Let's model this for a team of two developers maintaining these integrations:

Initial build: 2 weeks per platform × 10 platforms = 20 dev-weeks

Quarterly maintenance: Each platform changes something significant ~2x/year = 10 platforms × 2 changes × 4 hours = 80 hours/year

Incident response: Each platform causes ~2 incidents/year = 20 incidents × 3 hours = 60 hours/year

Total over 2 years: ~960 hours = ~$96,000 at $100/hr fully-loaded engineering cost

And that's a conservative estimate.

The Unified API Approach

Instead of building 10 integrations, build one. InReelForge exposes a single endpoint:

const response = await fetch("https://api.indreelforge.com/v1/publish", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.INDREELFORGE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    video: videoBase64OrUrl,
    platforms: ["instagram", "tiktok", "youtube", "facebook", "x", "linkedin",
                 "pinterest", "threads", "bluesky", "reddit", "google-business"],
    caption: "Your caption here",
    hashtags: ["yourhashtag"],
    schedule: "2026-06-01T10:00:00Z", // optional
  }),
});

const result = await response.json();
// { jobId: "...", platforms: { instagram: "scheduled", tiktok: "scheduled", ... } }

What you get vs. DIY:

	DIY 10 integrations	InReelForge
Time to first publish	10–20 weeks	< 1 hour
Platforms	Build each one	11 included
Video transcoding	You handle FFmpeg	Included
Token refresh	Per-platform	Handled
Scheduling	Build your own queue	Included
Ongoing maintenance	Your problem	Our problem
Cost	Engineering time	From $19/month

When to DIY vs. Use an API

Use a unified API like InReelForge when:

Social media publishing is not your core product
You need to ship fast
You can't justify a dedicated integration engineer

DIY when:

You're building a social media platform and deep platform access is your moat
You need unpublished/beta API features
You have compliance requirements that prevent third-party data handling

For 90% of teams, the math heavily favors the API.

Getting Started

npm install indreelforge

import InReelForge from 'indreelforge';

const client = new InReelForge({ apiKey: process.env.INDREELFORGE_API_KEY });
await client.publish({ video: './clip.mp4', platforms: ['instagram', 'tiktok'] });

Free tier: 10 uploads/month, 2 connected profiles, no credit card. indreelforge.com

The integration tax is real. You can pay it, or you can route around it.

How I Built a Multi-Platform Social Publisher in 50 Lines of Python

Rohan sirohi — Wed, 29 Apr 2026 09:32:27 +0000

Every developer building something with social media eventually hits the same wall. You ship Instagram first, it takes a week. Then the client asks for TikTok. Another week. Then YouTube. Then Facebook. By the time you've wired up five platforms, you've got five separate auth flows, five different video format requirements, five rate limit strategies, and five things that will break independently on a Friday night.

This is the integration tax. And it's brutal.

Here's how I stopped paying it.

The Problem in Numbers

Let me be specific about what "maintaining 10 social media integrations" actually costs:

Instagram Graph API: OAuth 2.0, chunked resumable uploads, a separate container creation step, then a publish step. Reels require a specific aspect ratio or they silently crop.
TikTok Content Posting API: Different OAuth flow, .mp4 only, max 4GB, title required (not optional), and video duration limits that differ by account type.
YouTube Data API v3: OAuth with refresh tokens, multipart upload, processing delay before the video is available.
X (Twitter) v2: 512MB limit for video, requires a chunked upload via a media endpoint separate from the tweet endpoint.

And that's before you add scheduling, retries, format conversion, or per-platform captions.

The real cost isn't the first integration. It's every API change, every quota increase request, every token refresh bug at 3am.

The Alternative

I built InReelForge to solve this for myself first. One REST endpoint that handles all of it. Here's what a complete cross-platform publish looks like in Python:

import indreelforge
import os

client = indreelforge.Client(api_key=os.environ["INDREELFORGE_API_KEY"])

result = client.publish(
    video="./product-demo.mp4",
    platforms=["instagram", "tiktok", "youtube", "facebook", "x", "linkedin"],
    caption="Shipping something new today. Here's a quick look.",
    hashtags=["buildinpublic", "saas", "developer"],
    schedule="2026-05-01T09:00:00Z",  # optional — omit to publish immediately
)

print(result)

That's 15 lines including imports and the print. The SDK handles:

Format validation and FFmpeg transcoding per platform
OAuth token refresh for each connected account
Retry logic on rate limits
Returning per-platform status (published, scheduled, failed, pending)

Per-Platform Customization

Most content isn't identical across platforms. LinkedIn audiences expect more context. TikTok wants a hook in the first two seconds. You can override per platform without losing the defaults:

result = client.publish(
    video="./demo.mp4",
    caption="Default caption for all platforms",
    hashtags=["saas"],
    platforms=["instagram", "linkedin", "tiktok"],
    overrides={
        "linkedin": {
            "caption": "We just launched a new feature for our enterprise clients. Here's a walkthrough of the new team workspace controls.",
            "hashtags=["b2bsaas", "productlaunch", "enterprisetech"],
        },
        "tiktok": {
            "caption": "POV: shipping to prod on a Friday 🚀",
            "hashtags": ["devlife", "coding", "saas"],
        },
    },
)

Handling the Async Reality

Social media platforms don't give you an instant success response. They accept the video, process it, then publish. InReelForge surfaces this with a webhook on Advanced+ plans:

# Your webhook endpoint (Flask example)
from flask import Flask, request
import hmac, hashlib

app = Flask(__name__)

@app.post("/webhooks/indreelforge")
def handle():
    sig = request.headers.get("X-IRF-Signature")
    body = request.get_data()
    expected = hmac.new(
        os.environ["WEBHOOK_SECRET"].encode(),
        body,
        hashlib.sha256,
    ).hexdigest()

    if not hmac.compare_digest(sig, f"sha256={expected}"):
        return "Forbidden", 403

    event = request.json
    print(f"{event['platform']} — {event['status']}")  # published | failed
    return "ok"

What This Replaced

Before this, my content pipeline looked like:

instagram_publisher.py — 340 lines
tiktok_publisher.py — 280 lines
youtube_uploader.py — 210 lines
facebook_publisher.py — 195 lines
A cron job per platform, each with its own failure mode

Now it's one file, 50 lines, one API key. The platforms still have all their quirks — the SDK just hides them from my application code.

Getting Started

Sign up free at indreelforge.com — 10 uploads/month on the free tier, no credit card required. The Python SDK is on PyPI:

pip install indreelforge

Full docs at docs.indreelforge.com.

If you've dealt with the integration tax yourself, I'd be curious what your worst platform experience was. Mine was TikTok's undocumented video codec requirements. Drop it in the comments.