Content Repurposing Strategy: Optimize One Piece Across Every Platform

Creating content for 7 platforms individually is a full-time job. Creating one great piece and adapting it to 7 platforms takes 2 hours. The difference isn't laziness — it's strategy.

Here's how to use data to figure out what works on each platform, then repurpose a single idea everywhere.

---

Analyze What Works on Each Platform for Your Niche

Before repurposing, understand what resonates where:

const API_KEY = process.env.SOCIAVAULT_API_KEY;
const BASE = 'https://api.sociavault.com/v1/scrape';
const headers = { 'X-API-Key': API_KEY };

async function analyzeContentPerformanceByPlatform(username) {
  const report = {};

  // Instagram
  const igRes = await fetch(
    `${BASE}/instagram/posts?username=${encodeURIComponent(username.instagram)}`,
    { headers }
  );
  const igPosts = (await igRes.json()).data || [];

  if (igPosts.length > 0) {
    const avgLikes = Math.round(igPosts.reduce((s, p) => s + (p.like_count || 0), 0) / igPosts.length);
    const avgComments = Math.round(igPosts.reduce((s, p) => s + (p.comment_count || 0), 0) / igPosts.length);

    // Categorize by type
    const types = { carousel: [], reel: [], image: [] };
    igPosts.forEach(p => {
      const type = p.product_type === 'clips' ? 'reel'
        : p.carousel_media ? 'carousel' : 'image';
      types[type].push(p.like_count || 0);
    });

    report.instagram = {
      avgLikes,
      avgComments,
      topFormat: Object.entries(types)
        .map(([type, likes]) => ({
          type,
          avg: likes.length > 0 ? Math.round(likes.reduce((a, b) => a + b, 0) / likes.length) : 0,
          count: likes.length
        }))
        .sort((a, b) => b.avg - a.avg)
    };
  }

  await new Promise(r => setTimeout(r, 1200));

  // TikTok
  const tkRes = await fetch(
    `${BASE}/tiktok/user/posts?username=${encodeURIComponent(username.tiktok)}`,
    { headers }
  );
  const tkVideos = (await tkRes.json()).data || [];

  if (tkVideos.length > 0) {
    const avgViews = Math.round(tkVideos.reduce((s, v) => s + (v.stats?.playCount || 0), 0) / tkVideos.length);
    const avgLikes = Math.round(tkVideos.reduce((s, v) => s + (v.stats?.diggCount || 0), 0) / tkVideos.length);

    // Categorize by duration
    const short = tkVideos.filter(v => (v.video?.duration || 0) < 30);
    const medium = tkVideos.filter(v => {
      const d = v.video?.duration || 0;
      return d >= 30 && d < 60;
    });
    const long = tkVideos.filter(v => (v.video?.duration || 0) >= 60);

    report.tiktok = {
      avgViews,
      avgLikes,
      byDuration: [
        { label: '<30s', count: short.length, avgViews: short.length > 0 ? Math.round(short.reduce((s, v) => s + (v.stats?.playCount || 0), 0) / short.length) : 0 },
        { label: '30-60s', count: medium.length, avgViews: medium.length > 0 ? Math.round(medium.reduce((s, v) => s + (v.stats?.playCount || 0), 0) / medium.length) : 0 },
        { label: '60s+', count: long.length, avgViews: long.length > 0 ? Math.round(long.reduce((s, v) => s + (v.stats?.playCount || 0), 0) / long.length) : 0 }
      ]
    };
  }

  await new Promise(r => setTimeout(r, 1200));

  // Twitter
  const twRes = await fetch(
    `${BASE}/twitter/user-tweets?username=${encodeURIComponent(username.twitter)}`,
    { headers }
  );
  const tweets = (await twRes.json()).data || [];

  if (tweets.length > 0) {
    const avgLikes = Math.round(tweets.reduce((s, t) => s + (t.legacy?.favorite_count || 0), 0) / tweets.length);
    const avgRTs = Math.round(tweets.reduce((s, t) => s + (t.legacy?.retweet_count || 0), 0) / tweets.length);

    // Threads vs regular tweets
    const threads = tweets.filter(t => t.legacy?.in_reply_to_status_id_str && t.legacy?.in_reply_to_user_id_str === t.legacy?.user_id_str);
    const regular = tweets.filter(t => !t.legacy?.in_reply_to_status_id_str);

    report.twitter = {
      avgLikes,
      avgRTs,
      regularAvg: regular.length > 0 ? Math.round(regular.reduce((s, t) => s + (t.legacy?.favorite_count || 0), 0) / regular.length) : 0,
      threadAvg: threads.length > 0 ? Math.round(threads.reduce((s, t) => s + (t.legacy?.favorite_count || 0), 0) / threads.length) : 0
    };
  }

  // Print insights
  console.log('\n📊 Content Performance by Platform');
  console.log('═'.repeat(55));

  if (report.instagram) {
    console.log('\n  Instagram:');
    console.log(`    Avg: ${report.instagram.avgLikes.toLocaleString()} likes, ${report.instagram.avgComments} comments`);
    console.log('    Format ranking:');
    report.instagram.topFormat.forEach(f =>
      console.log(`      ${f.type}: ${f.avg.toLocaleString()} avg likes (${f.count} posts)`)
    );
  }

  if (report.tiktok) {
    console.log('\n  TikTok:');
    console.log(`    Avg: ${report.tiktok.avgViews.toLocaleString()} views, ${report.tiktok.avgLikes.toLocaleString()} likes`);
    console.log('    Duration performance:');
    report.tiktok.byDuration.forEach(d =>
      console.log(`      ${d.label}: ${d.avgViews.toLocaleString()} avg views (${d.count} videos)`)
    );
  }

  if (report.twitter) {
    console.log('\n  Twitter/X:');
    console.log(`    Avg: ${report.twitter.avgLikes.toLocaleString()} likes, ${report.twitter.avgRTs.toLocaleString()} RTs`);
    console.log(`    Regular tweets: ${report.twitter.regularAvg.toLocaleString()} avg likes`);
    console.log(`    Thread replies: ${report.twitter.threadAvg.toLocaleString()} avg likes`);
  }

  return report;
}

analyzeContentPerformanceByPlatform({
  instagram: 'garyvee',
  tiktok: 'garyvee',
  twitter: 'garyvee'
});

---

Find Your Best Content to Repurpose

Look at your top-performing content and map it to other platforms:

import os
import time
import requests

API_KEY = os.environ["SOCIAVAULT_API_KEY"]
BASE = "https://api.sociavault.com/v1/scrape"
HEADERS = {"X-API-Key": API_KEY}

def find_repurposable_content(username_ig, username_tk, top_n=5):
    """Find top content from each platform and suggest repurposing"""
    suggestions = []

    # Get top Instagram posts
    r = requests.get(f"{BASE}/instagram/posts", headers=HEADERS,
                    params={"username": username_ig})
    ig_posts = r.json().get("data", [])

    if ig_posts:
        ig_sorted = sorted(ig_posts, key=lambda p: p.get("like_count", 0), reverse=True)
        for p in ig_sorted[:top_n]:
            caption = (p.get("caption") or {}).get("text", "")[:200]
            likes = p.get("like_count", 0)

            repurpose_to = []
            if len(caption) > 50:
                repurpose_to.append("Twitter thread (break caption into tweets)")
                repurpose_to.append("LinkedIn post (add professional context)")
            if p.get("product_type") == "clips":
                repurpose_to.append("TikTok (re-edit with TikTok trends/sounds)")
                repurpose_to.append("YouTube Short (add end screen)")
            else:
                repurpose_to.append("TikTok slideshow (turn images into video)")
                repurpose_to.append("Pinterest pin (resize to 2:3)")

            suggestions.append({
                "source": "Instagram",
                "content": caption[:100],
                "performance": f"{likes:,} likes",
                "repurpose_to": repurpose_to
            })

    time.sleep(1.2)

    # Get top TikTok videos
    r = requests.get(f"{BASE}/tiktok/user/posts", headers=HEADERS,
                    params={"username": username_tk})
    tk_videos = r.json().get("data", [])

    if tk_videos:
        tk_sorted = sorted(tk_videos,
                          key=lambda v: (v.get("stats") or {}).get("playCount", 0),
                          reverse=True)
        for v in tk_sorted[:top_n]:
            views = (v.get("stats") or {}).get("playCount", 0)
            desc = v.get("desc", "")[:200]
            duration = (v.get("video") or {}).get("duration", 0)

            repurpose_to = []
            repurpose_to.append("Instagram Reel (add IG-native caption)")
            repurpose_to.append("YouTube Short")
            if duration > 60:
                repurpose_to.append("YouTube video (expand to full tutorial)")
            repurpose_to.append("Twitter clip (embed with commentary)")
            repurpose_to.append("Blog post (transcribe and expand)")

            suggestions.append({
                "source": "TikTok",
                "content": desc[:100],
                "performance": f"{views:,} views",
                "repurpose_to": repurpose_to
            })

    # Print
    print("\n♻️ Content Repurposing Suggestions")
    print("=" * 55)

    for i, s in enumerate(suggestions, 1):
        print(f"\n  {i}. [{s['source']}] {s['performance']}")
        print(f"     \"{s['content']}...\"")
        print(f"     Repurpose to:")
        for r in s["repurpose_to"]:
            print(f"       → {r}")

    return suggestions

find_repurposable_content("garyvee", "garyvee")

---

Platform Adaptation Cheat Sheet

Original Format	TikTok	Instagram	YouTube	Twitter	LinkedIn	Threads	Pinterest
Blog post	Key points as talking head	Carousel slides	Video essay	Thread	Long-form post	Discussion starter	Infographic pin
Podcast clip	Hook + clip	Audiogram reel	Full episode	Quote + link	Takeaway post	Hot take	Quote graphic
Long video	3-5 short clips	Reel highlights	Original	Thread recap	Key insight post	Behind-the-scenes	Thumbnail pin
Data/research	Duet/stitch format	Data carousel	Explainer video	Key stat tweets	Article recap	Discussion prompt	Data infographic
Tutorial	Step-by-step short	Step carousel	Screen recording	Tip thread	How-to guide	Quick tip	Step pins

---

Optimal Content Specs by Platform

Platform	Video Length	Image Size	Caption Length	Hashtags
TikTok	15-60s (sweet spot)	N/A	150 chars	3-5
Instagram Reels	15-30s	1080x1920	2200 max	5-10
Instagram Carousel	N/A	1080x1350	2200 max	5-10
YouTube Shorts	30-60s	1080x1920	100 chars title	Tags in desc
Twitter/X	2:20 max	1200x675	280 chars	1-2
LinkedIn	10 min max	1200x627	3000 chars	3-5
Threads	N/A	1080x1080	500 chars	0-2
Pinterest	15s-1 min	1000x1500	500 chars desc	N/A

---

The 1:7 Workflow

1. Create one anchor piece (blog, video, or podcast)
2. Extract 5-7 key insights from the piece
3. Format each insight for the platform it's going to
4. Check your data — what format works best per platform for YOUR audience
5. Publish native — don't cross-post the same thing everywhere
6. Track results — which platform gave the best ROI for this topic
7. Double down — create more of what worked, skip what didn't

The key word is "native." Don't just post your TikTok with a watermark to Instagram. Each platform has different audience expectations, aspect ratios, and culture.

---

Get Started

Sign up free — analyze your content performance across platforms to build a smarter repurposing strategy.

---

Related Reading

• Cross-Posting Strategy: What to Post Where
• Multi-Platform Influencer Report
• YouTube Shorts Analytics
• Threads Analytics