Short-Form Video Analytics: Compare TikTok, Reels & Shorts in One Place

If you make short-form video, you almost certainly post the same clip to TikTok, Instagram Reels, and YouTube Shorts. And you almost certainly have no clean way to compare how it did across all three, because each app reports differently and lives behind its own dashboard. TikTok shows views and likes, Instagram shows plays and reach, YouTube shows views and average percentage viewed. Three tabs, three vocabularies, zero comparability.

This guide pulls public data from all three into one normalized table so you can actually see which platform a given video won on. Code in JavaScript. One honest note before we start: a cross-platform "view" is not the same unit on each platform (TikTok counts a view almost immediately; YouTube counts it differently), so treat the comparison as directional — great for spotting where you're strong, not for claiming "exactly 2.3x better."

Step 1: Pull from each platform

Each platform has its own endpoint and its own response shape — this is exactly the mess we're normalizing.

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 fetchAll(handles) {
  const [tk, ig, yt] = await Promise.all([
    fetch(`${BASE}/tiktok/videos?handle=${handles.tiktok}&amount=10`, {
      headers,
    }).then((r) => r.json()),
    fetch(`${BASE}/instagram/reels?handle=${handles.instagram}`, {
      headers,
    }).then((r) => r.json()),
    fetch(`${BASE}/youtube/channel/shorts?handle=${handles.youtube}`, {
      headers,
    }).then((r) => r.json()),
  ]);

  return {
    tiktok: tk.success ? tk.data.aweme_list || [] : [],
    reels: ig.success ? ig.data.items || [] : [],
    shorts: yt.success ? yt.data.videos || yt.data.shorts || [] : [],
  };
}

Step 2: Normalize into one shape

Here's where the per-platform field paths matter — and where the old version of this post got them wrong. The correct paths:

• TikTok: aweme_list[].statistics.play_count / digg_count / comment_count
• Instagram Reels: items[].media.play_count / like_count / comment_count (the reel object is nested under media)
• YouTube Shorts: view counts often come as display text ("1.2M views") and need parsing; likes/comments aren't always on the list view

function num(x) {
  if (typeof x === "number") return x;
  // Parse "1.2M" / "345K" / "1,234" style strings
  const s = String(x || "")
    .replace(/,/g, "")
    .trim()
    .toUpperCase();
  const mult = s.endsWith("M") ? 1e6 : s.endsWith("K") ? 1e3 : 1;
  return Math.round((parseFloat(s) || 0) * mult);
}

function normalize(raw) {
  const rows = [];

  for (const v of raw.tiktok) {
    const s = v.statistics || {};
    rows.push({
      platform: "TikTok",
      title: v.desc,
      views: s.play_count || 0,
      likes: s.digg_count || 0,
      comments: s.comment_count || 0,
    });
  }

  for (const item of raw.reels) {
    const m = item.media || {};
    rows.push({
      platform: "Instagram",
      title: m.caption?.text || "(no caption)",
      views: m.play_count || 0,
      likes: m.like_count || 0,
      comments: m.comment_count || 0,
    });
  }

  for (const sh of raw.shorts) {
    rows.push({
      platform: "YouTube",
      title: sh.title || "(short)",
      views: num(sh.viewCountText ?? sh.viewCount),
      likes: null,
      comments: null,
    });
  }

  return rows.map((r) => ({
    ...r,
    engagementRate:
      r.views && r.likes != null
        ? (((r.likes + r.comments) / r.views) * 100).toFixed(2) + "%"
        : "n/a",
  }));
}

The num() helper handles YouTube's "1.2M views" text, and I read every field defensively because these shapes drift — log one real response per platform and confirm before you rely on it.

Step 3: Rank across platforms

async function compare() {
  const raw = await fetchAll({
    tiktok: "garyvee",
    instagram: "garyvee",
    youtube: "GaryVee",
  });
  const rows = normalize(raw).sort((a, b) => b.views - a.views);

  console.log("\n🏆 Top videos across all platforms");
  rows
    .slice(0, 5)
    .forEach((r, i) =>
      console.log(
        `#${i + 1} [${r.platform}] ${(r.title || "").slice(0, 40)} — ${r.views.toLocaleString()} views, ER ${r.engagementRate}`,
      ),
    );

  // Per-platform averages
  for (const p of ["TikTok", "Instagram", "YouTube"]) {
    const set = rows.filter((r) => r.platform === p);
    if (!set.length) continue;
    const avg = Math.round(set.reduce((s, r) => s + r.views, 0) / set.length);
    console.log(
      `${p}: ${avg.toLocaleString()} avg views across ${set.length} videos`,
    );
  }
}

compare();

What you do with it

The normalized view answers questions no single app's dashboard can:

• Where does the same content win? If your TikTok averages 5x the views of your Shorts, that's where your audience is — weight your effort accordingly.
• Where does engagement (not just reach) live? A platform with fewer views but a much higher engagement rate is often the more valuable audience.
• Which platform has a longer tail? Re-run the comparison a month later; YouTube Shorts often keep accruing views long after TikTok has moved on, which changes how you value evergreen content.

Just keep the caveat in mind: you're comparing platforms that define a "view" differently, so read the comparison as "where am I strong," not as a precise multiplier.

Frequently Asked Questions

Can you compare TikTok, Reels, and Shorts performance in one place?

Yes — pull each platform's public video data, normalize the differing field names and metrics into a single shape, and rank them together, as this guide does. The main caveat is that a "view" isn't defined identically across platforms, so the comparison is best used directionally to see where your content performs strongest.

Why is cross-platform video comparison so hard?

Each platform uses different metric names and definitions and locks its analytics behind its own dashboard. TikTok, Instagram, and YouTube even count views differently. Normalizing the public data into one consistent structure is the only way to compare them side by side.

Where are the view counts in each platform's data?

TikTok puts them at aweme_list[].statistics.play_count, Instagram Reels at items[].media.play_count, and YouTube Shorts often as display text like "1.2M views" that needs parsing. Getting these paths right is the part most people trip on.

Are cross-platform view counts directly comparable?

Not exactly. Platforms define and trigger a "view" differently, so identical content can show different view numbers for reasons unrelated to actual performance. Use the comparison to identify where you're strong, not to claim a precise ratio between platforms.

Can I track this over time?

Yes, and you should. Re-run the comparison periodically and store the results. This reveals each platform's "shelf life" — YouTube Shorts frequently keep gaining views long after a TikTok has peaked — which should influence where you put evergreen content.

Does this work for competitors too?

Absolutely. Point the handles at a competitor's accounts to see which platform they dominate and where they're weak. It's a fast way to find a platform where you can outcompete them.

The bottom line

You're already posting everywhere — you just can't see the scoreboard. Pull all three platforms into one normalized table and you'll finally know where your content actually wins, so you can stop spraying evenly and start weighting toward what works.

Want to build your cross-platform dashboard? Start free with SociaVault with 50 credits.