Threads vs Twitter (X): Which Drives More Engagement? Measure It

Threads hit 100 million users in five days, then went quiet, then climbed back. X became more chaotic but stayed the home of breaking news. So the question every creator and brand keeps asking — "where should I actually post?" — has no universal answer. It depends on your audience, your niche, and your content. The good news: it's measurable.

This guide compares the same creator's recent posts on both platforms and reports the engagement gap. The important nuance, which most "X vs Threads" takes miss, is that raw likes favor whichever platform has the bigger audience — so we'll look at likes-per-follower too. Code in JavaScript.

Step 1: Pull Threads posts

The Threads user-posts endpoint takes a handle; posts come back under data.items with a like_count.

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 threadsStats(handle) {
  const res = await fetch(`${BASE}/threads/user-posts?handle=${handle}`, {
    headers,
  });
  const json = await res.json();
  if (!json.success) return null;
  const posts = (json.data.items || []).slice(0, 10);
  const likes = posts.reduce((s, p) => s + (p.like_count || 0), 0);
  return {
    platform: "Threads",
    avgLikes: Math.round(likes / (posts.length || 1)),
  };
}

Step 2: Pull X posts

The Twitter user-tweets endpoint also takes a handle; tweets come back under data.tweets with a likes field.

async function twitterStats(handle) {
  const res = await fetch(`${BASE}/twitter/user-tweets?handle=${handle}`, {
    headers,
  });
  const json = await res.json();
  if (!json.success) return null;
  const tweets = (json.data.tweets || []).slice(0, 10);
  const likes = tweets.reduce((s, t) => s + (t.likes || 0), 0);
  return { platform: "X", avgLikes: Math.round(likes / (tweets.length || 1)) };
}

Note the field difference that trips people up: Threads posts use like_count, X tweets use likes, and the containers are items vs tweets. Normalizing those is half the job.

Step 3: Compare — raw and per-follower

async function compare(threadsHandle, xHandle) {
  const [th, tw] = await Promise.all([
    threadsStats(threadsHandle),
    twitterStats(xHandle),
  ]);
  if (!th || !tw) return console.log("Couldn't fetch both platforms.");

  console.log(`\n📊 Avg likes per post`);
  console.log(`  🧵 Threads: ${th.avgLikes.toLocaleString()}`);
  console.log(`  ✖️  X:       ${tw.avgLikes.toLocaleString()}`);

  // For a fair comparison, divide by each platform's follower count
  // (pull from the respective profile endpoints) to get likes-per-follower.
}

compare("mkbhd", "mkbhd");

Why per-follower matters more than raw likes

Here's the trap: a creator with 18M followers on X and 2M on Threads will almost always show higher raw likes on X — that tells you nothing except "X audience is bigger." The fairer question is which platform's audience is more engaged: likes divided by followers. It's common to see X win on raw volume while Threads wins on engagement rate, because a smaller, newer audience is often more active per capita.

So pull each platform's follower count (from the profile endpoints) and compute likes-per-follower before you conclude anything. And weigh the fit: Threads tends to reward lifestyle and visual content, X rewards news, tech, and timely commentary. Run this for your own accounts and your specific niche rather than trusting a generic "Threads is better/worse" headline.

Frequently Asked Questions

Is Threads or X better for engagement?

It depends on your audience and niche, which is why measuring beats guessing. X usually wins on raw likes because its audiences are larger, but Threads frequently wins on engagement rate (likes per follower). Compare both metrics for your own accounts before deciding.

Why shouldn't I just compare raw likes?

Raw likes mostly reflect audience size, not engagement quality. A platform where you have more followers will show more likes regardless of how engaged that audience is. Likes-per-follower normalizes for audience size and tells you where people actually interact more.

What fields hold the like counts?

On Threads, posts carry like_count and come under data.items; on X, tweets carry likes under data.tweets. Normalizing those different field names and containers is the main work in building the comparison.

Should I post the same content to both platforms?

Often yes as a starting point, but the platforms reward different things — Threads leans visual and lifestyle, X leans news and commentary. Use the engagement comparison to see where each piece of content lands, then tailor rather than blindly cross-post.

Can I compare any creator, or just my own accounts?

Any public accounts. Comparing competitors or creators in your niche is a great way to see which platform your target audience engages with more, which can inform where you invest your own effort.

How many posts should I compare?

The last 10–20 per platform is a reasonable sample that smooths out the occasional viral outlier. Pull more if a creator posts infrequently, so you're not comparing one big hit against a quiet week.

The bottom line

"Threads or X?" is answerable with data, not vibes. Compare the same creator on both, normalize by follower count, and weigh content fit. You'll usually find one wins on reach and the other on engagement rate — and which matters depends on your goals.

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