YouTube Shorts vs Long-Form: Compare View Velocity With Data

"Shorts wreck your retention." "Shorts explode your reach." Both camps are loud and both are sometimes right, because the answer depends entirely on a specific channel's numbers. The only way to settle it for your channel (or a competitor's) is to measure — and to measure fairly, because comparing a Short posted yesterday to a long-form video posted last month using raw views is meaningless.

The fair metric is view velocity: views per day since upload. That levels the field between new and old uploads. This guide pulls a channel's recent long-form videos and Shorts, computes velocity for each, and gives you a real head-to-head. Code in JavaScript.

Why velocity, not raw views

A video with 500k views over two months (≈8k/day) is a slower performer than a Short with 200k views in three days (≈67k/day), even though the long-form video has more total views. Velocity captures that. To compute it you need each item's view count and its publish date — so the honest requirement here is a usable timestamp, which YouTube provides as a published date/relative time field.

Step 1: Pull both formats

const API_KEY = process.env.SOCIAVAULT_API_KEY;
const BASE = "https://api.sociavault.com/v1/scrape/youtube";
const headers = { "x-api-key": API_KEY };

async function getFormat(path, handle, sortParam) {
  const res = await fetch(`${BASE}/${path}?handle=${handle}&${sortParam}`, {
    headers,
  });
  const json = await res.json();
  if (!json.success) return [];
  let list = json.data.videos || json.data.shorts || [];
  if (!Array.isArray(list)) list = Object.values(list);
  return list;
}

async function pull(handle) {
  const [longform, shorts] = await Promise.all([
    getFormat("channel-videos", handle, "sort=latest"),
    getFormat("channel/shorts", handle, "sort=newest"),
  ]);
  return { longform: longform.slice(0, 20), shorts: shorts.slice(0, 20) };
}

Step 2: Compute velocity

function daysSince(publishedField) {
  // Prefer an ISO date; fall back to parsing relative text like "3 days ago".
  const d = new Date(publishedField);
  if (!isNaN(d)) return Math.max(1, (Date.now() - d) / 86400000);

  const m = String(publishedField || "").match(
    /(\d+)\s+(day|week|month|year)/i,
  );
  if (!m) return null; // can't date it → skip from velocity
  const mult = { day: 1, week: 7, month: 30, year: 365 }[m[2].toLowerCase()];
  return Math.max(1, +m[1] * mult);
}

function velocity(items) {
  const scored = items
    .map((v) => {
      const views = v.viewCountInt ?? 0;
      const days = daysSince(
        v.publishedTime || v.publishDate || v.publishedTimeText,
      );
      return days ? { views, perDay: Math.round(views / days) } : null;
    })
    .filter(Boolean);

  const avg = scored.reduce((s, x) => s + x.perDay, 0) / (scored.length || 1);
  return { sample: scored.length, avgPerDay: Math.round(avg) };
}

I skip any item I can't reliably date rather than inventing a timestamp — that keeps the velocity honest, even if it means a slightly smaller sample.

Step 3: The head-to-head

async function compare(handle) {
  const { longform, shorts } = await pull(handle);
  const lf = velocity(longform);
  const sh = velocity(shorts);

  console.log(`\n📊 ${handle}`);
  console.log(
    `🎥 Long-form: ${lf.avgPerDay.toLocaleString()} views/day (n=${lf.sample})`,
  );
  console.log(
    `📱 Shorts:    ${sh.avgPerDay.toLocaleString()} views/day (n=${sh.sample})`,
  );

  if (lf.avgPerDay > 0) {
    const x = (sh.avgPerDay / lf.avgPerDay).toFixed(1);
    console.log(`→ Shorts pull ~${x}x the daily velocity of long-form`);
  }
}

compare("MarquesBrownlee");

Reading the result

A few honest rules of thumb once you have the numbers:

• The 10x test. Shorts viewers subscribe and convert at much lower rates than long-form viewers, so Shorts generally need a large velocity multiple (often cited around 10x) to justify the effort versus long-form. If your Shorts only pull 2x, the trade may not be worth it.
• Use Shorts as a funnel, not a destination. If Shorts have high velocity but low loyalty, treat them as a discovery engine that points viewers to your long-form, rather than expecting them to build a deep audience alone.
• Niche matters enormously. Entertainment channels often see huge Shorts multiples; education channels far less. Benchmark against competitors in your niche, not a generic stat. Run the same script on a few rivals.

And the caveat worth repeating: velocity from public data is a strong directional metric, but it can't see watch time, retention, or revenue per view — the things that ultimately decide whether a format is "worth it." Use velocity to frame the question, then weigh it against your own retention and revenue data.

Frequently Asked Questions

Should I post YouTube Shorts or long-form videos?

It depends on your channel's data, not a universal rule. Compare the view velocity (views per day) of your Shorts versus your long-form, factor in that Shorts convert subscribers at lower rates, and decide based on the multiple. The script here gives you that comparison for any channel.

What is view velocity?

Views per day since a video was published. It's a fairer comparison metric than raw views because it normalizes for how long each video has been live — letting you compare a brand-new Short against an older long-form video meaningfully.

Why do Shorts need so many more views to be "worth it"?

Shorts viewers subscribe and convert at substantially lower rates than long-form viewers, and Shorts earn less per view. So Shorts typically need a large reach advantage — often cited around 10x the velocity — to deliver comparable value to a long-form upload.

Can I run this on a competitor's channel?

Yes, and you should. Benchmarking a competitor's Shorts-vs-long-form split in your specific niche is far more useful than generic industry stats, because Shorts multiples vary wildly by niche.

What data do I need to calculate velocity?

Each item's view count and a usable publish date. YouTube provides view counts as integers and a published date/relative-time field. Items you can't reliably date should be excluded from the velocity calculation rather than estimated.

Does high Shorts velocity mean I should drop long-form?

Not necessarily. High velocity signals reach, but it doesn't capture loyalty, watch time, or revenue per view — areas where long-form usually wins. The smart play is often using Shorts as a discovery funnel into long-form, not replacing one with the other.

The bottom line

The Shorts debate is unwinnable in the abstract and trivial with data. Pull both formats, compute views-per-day, and let your channel's actual numbers decide where your effort goes. Just remember velocity is reach, not the whole story.

Want to run the comparison? Start free with SociaVault with 50 credits.