DEV Community: Joe Vezzani

The 50 X Creators Driving the Iran War Conversation (607.9M Engagements) -- With Code

Joe Vezzani — Tue, 14 Apr 2026 02:05:02 +0000

The Iran-Israel conflict generated 607.9 million engagements on X in Q1 2026 from just the top 50 creators. We tracked 22 war-related topics to find who actually drives the conversation and how to pull this data yourself.

GitHub repo: JoeVezzani/iran-war-creators

The Scale of the Conversation

Across 22 topics -- from "Iran" and "Israel" to "Strait of Hormuz" and "Airstrikes" -- the top 50 creators alone generated 607.9M engagements. Engagement peaked on February 28, coinciding with Strait of Hormuz escalations and nuclear deal negotiations.

The Top 10 Creators

Rank	Creator	Engagements	Topics Covered
1	@MarioNawfal	161.4M	19 of 22
2	@netanyahu	28.5M	2
3	@RyanRozbiani	22.3M	10
4	@A_K_Mandhan	20.5M	7
5	@BRICSinfo	20.3M	11
6	@jacksonhinklle	20.3M	15
7	@rebelliousdogra	19.8M	7
8	@KobeissiLetter	18.8M	7
9	@MOSSADil	18.7M	16
10	@Osint613	14.4M	17

@MarioNawfal's dominance is remarkable -- 161.4M engagements across 19 of 22 topics. More than the next five creators combined. His breadth of coverage is what separates him.

@Osint613 covers 17 topics with the broadest intelligence coverage. @MOSSADil covers 16. Citizen journalists and independent accounts consistently outperform legacy media on engagement.

Pull This Data Yourself

Track any geopolitical topic in real time with the LunarCrush API:

const API_KEY = process.env.LUNARCRUSH_API_KEY;

async function getTopicData(keyword) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/topic/${encodeURIComponent(keyword)}/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function getTopicPosts(keyword) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/topic/${encodeURIComponent(keyword)}/posts/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

// Track multiple war-related topics
async function scanConflict() {
  const topics = [
    "iran", "israel", "strait of hormuz", "airstrikes",
    "ceasefire", "nuclear deal", "oil prices", "sanctions"
  ];

  for (const topic of topics) {
    const data = await getTopicData(topic);
    console.log(
      `${topic.padEnd(20)} | ` +
      `${(data.data?.num_posts || 0).toLocaleString().padStart(8)} mentions | ` +
      `${(data.data?.interactions || 0).toLocaleString().padStart(12)} engagements | ` +
      `sentiment: ${data.data?.sentiment || 'N/A'}%`
    );
  }
}

scanConflict();

Track Top Creators on Any Topic

async function getTopCreators(topic) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/topic/${encodeURIComponent(topic)}/creators/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function main() {
  const creators = await getTopCreators("iran");

  console.log(`
Top Creators for "Iran":
`);
  for (const c of (creators.data || []).slice(0, 10)) {
    console.log(
      `  @${(c.screen_name || '').padEnd(20)} | ` +
      `${(c.interactions || 0).toLocaleString().padStart(12)} eng | ` +
      `${(c.followers_count || 0).toLocaleString().padStart(10)} followers`
    );
  }
}

main();

Build a Sentiment Alert for Geopolitical Events

const fs = require("fs");
const STATE_FILE = "./conflict_state.json";

function loadState() {
  try { return JSON.parse(fs.readFileSync(STATE_FILE)); }
  catch { return {}; }
}

function saveState(state) {
  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
}

async function checkConflictShifts() {
  const state = loadState();
  const topics = ["iran", "israel", "oil", "ceasefire", "strait of hormuz"];

  for (const topic of topics) {
    const data = await getTopicData(topic);
    const current = data.data?.sentiment || 0;
    const previous = state[topic]?.sentiment;

    if (previous && Math.abs(current - previous) > 10) {
      const dir = current > previous ? "UP" : "DOWN";
      console.log(
        `ALERT: "${topic}" sentiment shifted ${dir} ` +
        `(${previous}% -> ${current}%)`
      );
    }

    state[topic] = {
      sentiment: current,
      mentions: data.data?.num_posts || 0,
      timestamp: new Date().toISOString()
    };
  }

  saveState(state);
}

checkConflictShifts();

Run on a cron during active conflict periods. When sentiment shifts 10+ points, you know something just happened.

Why Social Data Matters for Geopolitics

Oil hit $114/barrel during the Strait of Hormuz situation. X produced 92,066 mentions of oil in 24 hours -- more than Reddit (22K), YouTube (46K), TikTok (44K), and all news sources (1.3K) combined.

For traders, researchers, and prediction market participants, social data is the fastest signal for geopolitical events. The conversation happens on X before it hits Bloomberg.

Try It

API key: lunarcrush.com/developers
API docs: lunarcrush.com/developers/api
MCP server (use with Claude): lunarcrush.com/products/lunarcrush-mcpserver
Full analysis with heatmaps: lunarcrush.com/blog/iran-war-creators-2026

I'm building a bunch of small projects like this. Follow along if you're into this kind of thing.

The Real X Creator Rankings for 2026 (With Code to Pull Them Yourself)

Joe Vezzani — Fri, 10 Apr 2026 16:58:36 +0000

Most rankings of X accounts use follower count. That tells you almost nothing about who actually drives conversation on the platform.

LunarCrush processes 50M+ social posts per hour across X, Reddit, TikTok, YouTube, Instagram, and 10K+ news sources. We ranked every X account by actual engagements (likes, reposts, replies, quotes, impressions) for 2026. The results are surprising.

GitHub repo: JoeVezzani/x-creator-rankings

X post: @joevezz

The Top 25 by 2026 Engagements

Rank	Creator	Category	Followers	Engagements
1	@elonmusk	Tech	237.8M	54.4B
2	@PopBase	Entertainment	2.9M	7.7B
3	@MarioNawfal	News	3.3M	7.3B
4	@narendramodi	Politics	106.6M	7.2B
5	@FabrizioRomano	Sports	27.2M	5.9B
6	@centralreality	Geopolitics	1.3M	5.7B
7	@DiscussingFilm	Entertainment	2.8M	5.3B
8	@TheCinesthetic	Entertainment	1.6M	5.1B
9	@Rainmaker1973	Science	4.3M	3.8B
10	@PopCrave	Entertainment	3.0M	3.5B
11	@EricLDaugh	Politics	1.0M	3.5B
12	@Variety	Entertainment	3.2M	3.4B
13	@sciencegirl	Science	5.8M	3.3B
14	@nypost	News	3.7M	3.2B
15	@Polymarket	Brand	1.4M	3.2B
16	@TouchlineX	Sports	1.6M	3.0B
17	@starlink	Tech	1.6M	3.0B
18	@WhiteHouse	Politics	4.4M	2.7B
19	@tmz	Entertainment	8.6M	2.7B
20	@bosunatiklama	Entertainment	1.3M	2.6B
21	@Dexerto	Entertainment	1.3M	2.5B
22	@BRICSinfo	Geopolitics	2.0M	2.4B
23	@FilmUpdates	Entertainment	1.4M	2.4B
24	@cristiano	Sports	106.6M	2.4B
25	@foxnews	News	28.7M	2.3B

You have to get to #11 before you find a partisan political commentator. The top 10 is entertainment, news, sports, science, and tech.

@cristiano has 106M followers but ranks 24th. @centralreality has 1.3M followers and ranks 6th with 2.5x more engagement. Follower count is not engagement.

Pull This Data Yourself

The LunarCrush API exposes creator-level data for any public X account.

const API_KEY = process.env.LUNARCRUSH_API_KEY;

async function getCreator(network, username) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/creator/${network}/${username}/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function main() {
  const creator = await getCreator("twitter", "PopBase");

  console.log(`\n${creator.data?.display_name} (@${creator.data?.screen_name})`);
  console.log(`Followers: ${creator.data?.followers_count?.toLocaleString()}`);
  console.log(`Engagements (24h): ${creator.data?.interactions?.toLocaleString()}`);
  console.log(`CreatorRank: ${creator.data?.creator_rank}`);
  console.log(`Posts tracked: ${creator.data?.num_posts}`);
}

main();

Compare Creators Head-to-Head

async function compareCreators(usernames) {
  const results = [];

  for (const username of usernames) {
    const data = await getCreator("twitter", username);
    results.push({
      name: data.data?.display_name || username,
      username,
      followers: data.data?.followers_count || 0,
      engagements: data.data?.interactions || 0,
      rank: data.data?.creator_rank || 0,
    });
  }

  results.sort((a, b) => b.engagements - a.engagements);

  console.log(`\nCreator Comparison:\n`);
  for (const r of results) {
    const ratio = r.followers > 0
      ? (r.engagements / r.followers).toFixed(1) : "N/A";
    console.log(
      `  @${r.username.padEnd(20)} ` +
      `${r.engagements.toLocaleString().padStart(15)} eng | ` +
      `${r.followers.toLocaleString().padStart(12)} followers | ` +
      `ratio: ${ratio}x | rank: #${r.rank}`
    );
  }
}

compareCreators([
  "PopBase", "Cristiano", "FabrizioRomano",
  "Rainmaker1973", "Polymarket", "NASA"
]);

The engagement-to-follower ratio reveals who is actually resonating. @PopBase gets 2,638x its follower count in engagements. @nasa gets 9.2x. Both are valuable, but they serve completely different purposes.

Build an Alert for Rising Creators

const fs = require("fs");
const STATE_FILE = "./creator_state.json";

function loadState() {
  try { return JSON.parse(fs.readFileSync(STATE_FILE)); }
  catch { return {}; }
}

function saveState(state) {
  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
}

async function checkForRising(usernames) {
  const state = loadState();

  for (const username of usernames) {
    const data = await getCreator("twitter", username);
    const current = data.data?.interactions || 0;
    const previous = state[username]?.engagements || 0;

    if (previous > 0 && current > previous * 1.5) {
      console.log(
        `RISING: @${username} engagements jumped ` +
        `${previous.toLocaleString()} -> ${current.toLocaleString()} ` +
        `(${((current/previous - 1) * 100).toFixed(0)}% increase)`
      );
    }

    state[username] = {
      engagements: current,
      timestamp: new Date().toISOString()
    };
  }

  saveState(state);
}

checkForRising([
  "PopBase", "MarioNawfal", "Rainmaker1973",
  "Polymarket", "KobeissiLetter", "sciencegirl"
]);

Run on a cron. When a creator's engagement spikes 50%+, you get alerted. Useful for spotting breaking news, viral moments, or emerging narratives.

Try It

API key: lunarcrush.com/developers
API docs: lunarcrush.com/developers/api
MCP server (use with Claude): lunarcrush.com/products/lunarcrush-mcpserver

I'm building a bunch of small projects like this. Follow along if you're into this kind of thing.

Building a Prediction Market Signal Detector with Social Sentiment Data

Joe Vezzani — Thu, 09 Apr 2026 16:20:15 +0000

Prediction markets are having a moment. Polymarket hit 112M engagements in a single day last week. Kalshi is expanding into sports. Bonding curve platforms are popping up everywhere.

But here's the thing about prediction markets: the prices move after the crowd forms an opinion. And the crowd forms its opinion on social media before it places bets.

I built a Node.js tool that compares real-time social sentiment data against prediction market topics to find those early signals -- the moments when social volume spikes or sentiment shifts before the market catches up.

GitHub repo: JoeVezzani/prediction-market-signals

The thesis

Prediction market contracts are priced by supply and demand. When a big event happens -- a policy announcement, an earnings surprise, a geopolitical shift -- social media reacts first. Millions of people start posting, sharing, arguing. That wave of activity carries a measurable sentiment signal.

If you can detect that signal early enough, you know where the prediction market is likely to move next.

LunarCrush processes 50M+ social posts per hour across X, Reddit, TikTok, YouTube, Instagram, and 10K+ news sources. That gives us the raw material to build this.

What we're building

A signal detector that:

Tracks social sentiment and volume for prediction market topics in real time
Detects anomalies -- sudden spikes in volume, sharp sentiment shifts
Compares multiple topics side by side to spot divergences
Logs signals over time so you can backtest against actual market moves

Setup

mkdir prediction-market-signals && cd prediction-market-signals
npm init -y
touch index.js

Grab an API key at lunarcrush.com/developers.

The core: pulling social data for any topic

const API_KEY = process.env.LUNARCRUSH_API_KEY;
const BASE = "https://lunarcrush.com/api4/public/topic";

async function getTopicData(keyword) {
  const res = await fetch(
    `${BASE}/${encodeURIComponent(keyword)}/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function getTimeSeries(keyword) {
  const res = await fetch(
    `${BASE}/${encodeURIComponent(keyword)}/time-series/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function getTopPosts(keyword) {
  const res = await fetch(
    `${BASE}/${encodeURIComponent(keyword)}/posts/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

Three endpoints, three views into the same conversation. Topic data gives you the current snapshot. Time series gives you the trend. Posts give you the actual content driving sentiment.

Pick your prediction market topics

The best signals come from topics where prediction markets are active and social conversation is loud. Right now, three topics fit perfectly:

Tariffs -- Will new tariffs stick? What's the economic impact? Polymarket and Kalshi both have active tariff-related contracts.
Bitcoin -- Price prediction contracts are everywhere. BTC social data is the deepest dataset LunarCrush has.
Recession -- "Will the US enter a recession in 2026?" is one of the most traded prediction market questions right now.

const TOPICS = [
  { keyword: "tariffs", label: "Tariffs / Trade Policy" },
  { keyword: "bitcoin", label: "Bitcoin Price Direction" },
  { keyword: "recession", label: "US Recession Odds" },
];

Build the signal detector

Here's where it gets interesting. We pull social data for each topic, calculate whether sentiment or volume is moving abnormally, and flag anything that looks like a leading indicator.

const fs = require("fs");
const STATE_FILE = "./signal_state.json";
const SIGNAL_LOG = "./signals.json";

function loadJSON(path) {
  try { return JSON.parse(fs.readFileSync(path, "utf-8")); }
  catch { return {}; }
}

function saveJSON(path, data) {
  fs.writeFileSync(path, JSON.stringify(data, null, 2));
}

function detectSignals(current, previous, label) {
  const signals = [];

  // Sentiment shift detection
  if (previous?.sentiment && current.sentiment) {
    const delta = current.sentiment - previous.sentiment;
    if (Math.abs(delta) >= 8) {
      signals.push({
        type: "SENTIMENT_SHIFT",
        topic: label,
        direction: delta > 0 ? "BULLISH" : "BEARISH",
        previous: previous.sentiment,
        current: current.sentiment,
        delta,
        strength: Math.abs(delta) >= 15 ? "STRONG" : "MODERATE",
      });
    }
  }

  // Volume spike detection
  if (previous?.posts && current.posts) {
    const ratio = current.posts / previous.posts;
    if (ratio >= 1.5) {
      signals.push({
        type: "VOLUME_SPIKE",
        topic: label,
        previous: previous.posts,
        current: current.posts,
        multiplier: ratio.toFixed(2) + "x",
        strength: ratio >= 3 ? "STRONG" : "MODERATE",
      });
    }
  }

  // Engagement explosion
  if (previous?.engagements && current.engagements) {
    const ratio = current.engagements / previous.engagements;
    if (ratio >= 2) {
      signals.push({
        type: "ENGAGEMENT_SURGE",
        topic: label,
        previous: previous.engagements,
        current: current.engagements,
        multiplier: ratio.toFixed(2) + "x",
      });
    }
  }

  return signals;
}

The main loop

This pulls data for all your tracked topics, compares against the last reading, and logs any signals it finds.

async function scan() {
  const state = loadJSON(STATE_FILE);
  const signalLog = loadJSON(SIGNAL_LOG);
  if (!Array.isArray(signalLog.signals)) signalLog.signals = [];

  const timestamp = new Date().toISOString();
  console.log(`\n--- Prediction Market Signal Scan: ${timestamp} ---\n`);

  for (const { keyword, label } of TOPICS) {
    const data = await getTopicData(keyword);
    const topic = data.data || {};

    const current = {
      sentiment: topic.sentiment,
      posts: topic.num_posts,
      engagements: topic.interactions,
      contributors: topic.num_contributors,
      timestamp,
    };

    console.log(`${label}`);
    console.log(`  Sentiment:    ${current.sentiment}%`);
    console.log(`  Posts (24h):  ${(current.posts || 0).toLocaleString()}`);
    console.log(`  Engagements:  ${(current.engagements || 0).toLocaleString()}`);
    console.log(`  Contributors: ${(current.contributors || 0).toLocaleString()}`);

    const previous = state[keyword];
    const signals = detectSignals(current, previous, label);

    if (signals.length > 0) {
      console.log(`  ** ${signals.length} SIGNAL(S) DETECTED **`);
      for (const sig of signals) {
        console.log(`    [${sig.strength || ""}] ${sig.type}: ${sig.direction || sig.multiplier}`);
        signalLog.signals.push({ ...sig, timestamp });
      }
    } else {
      console.log(`  No signals (within normal range)`);
    }

    state[keyword] = current;
    console.log();
  }

  saveJSON(STATE_FILE, state);
  saveJSON(SIGNAL_LOG, signalLog);
  console.log(`State saved. ${signalLog.signals.length} total signals logged.`);
}

scan();

Run it

LUNARCRUSH_API_KEY=your_key node index.js

First run establishes your baseline. Second run (and every run after) compares against the previous reading and flags anomalies:

--- Prediction Market Signal Scan: 2026-04-06T14:32:00.000Z ---

Tariffs / Trade Policy
  Sentiment:    71%
  Posts (24h):  18,075
  Engagements:  14,264,207
  Contributors: 12,744
  ** 1 SIGNAL(S) DETECTED **
    [MODERATE] SENTIMENT_SHIFT: BULLISH

Bitcoin Price Direction
  Sentiment:    75%
  Posts (24h):  172,155
  Engagements:  135,115,413
  Contributors: 68,883
  No signals (within normal range)

US Recession Odds
  Sentiment:    54%
  Posts (24h):  2,212
  Engagements:  8,258,373
  Contributors: 1,855
  ** 1 SIGNAL(S) DETECTED **
    [STRONG] SENTIMENT_SHIFT: BEARISH

State saved. 2 total signals logged.

That recession signal is exactly the kind of thing that matters. Sentiment dropping while engagement surges means people are increasingly bearish and talking about it more. On a prediction market, that's likely to push "recession" contract prices up.

Add a cross-topic divergence detector

Sometimes the most interesting signal isn't within a single topic -- it's between topics. If Bitcoin sentiment is surging while recession fears are spiking, that's a divergence worth watching.

function detectDivergences(snapshots) {
  const divergences = [];
  const entries = Object.entries(snapshots);

  for (let i = 0; i < entries.length; i++) {
    for (let j = i + 1; j < entries.length; j++) {
      const [labelA, dataA] = entries[i];
      const [labelB, dataB] = entries[j];

      if (dataA.sentiment && dataB.sentiment) {
        const gap = Math.abs(dataA.sentiment - dataB.sentiment);
        if (gap >= 20) {
          divergences.push({
            type: "SENTIMENT_DIVERGENCE",
            topicA: labelA,
            sentimentA: dataA.sentiment,
            topicB: labelB,
            sentimentB: dataB.sentiment,
            gap,
          });
        }
      }
    }
  }

  return divergences;
}

Drop this into your scan loop after collecting all the snapshots:

// After the main loop, check for cross-topic divergences
const snapshots = {};
for (const { keyword, label } of TOPICS) {
  snapshots[label] = state[keyword];
}

const divergences = detectDivergences(snapshots);
if (divergences.length > 0) {
  console.log("Cross-topic divergences:");
  for (const d of divergences) {
    console.log(
      `  ${d.topicA} (${d.sentimentA}%) vs ${d.topicB} (${d.sentimentB}%) -- ${d.gap}pt gap`
    );
  }
}

Right now this would flag:

Cross-topic divergences:
  Bitcoin Price Direction (75%) vs US Recession Odds (54%) -- 21pt gap

Bitcoin sentiment is bullish while recession sentiment is bearish. That's a real tension -- and exactly the kind of thing prediction market traders are betting on.

Run it on a schedule

Set up a cron to scan every hour and build up your signal log:

# crontab -e
0 * * * * cd /path/to/prediction-market-signals && LUNARCRUSH_API_KEY=your_key node index.js >> scan.log 2>&1

After a few days, you'll have a dataset of timestamped signals you can compare against actual prediction market price movements. That's when it gets really useful -- you can start measuring which signal types actually lead market moves and by how much.

Dig into the posts driving the signal

When a signal fires, you want to know why. The posts endpoint shows you the actual social content behind the numbers:

async function investigateSignal(keyword, label) {
  const posts = await getTopPosts(keyword);
  const topPosts = (posts.data || []).slice(0, 5);

  console.log(`\nTop posts driving "${label}" sentiment:\n`);
  for (const post of topPosts) {
    const platform = post.network || "unknown";
    const engagement = (post.interactions_total || 0).toLocaleString();
    const text = (post.body || post.title || "").slice(0, 120);
    console.log(`  [${platform}] ${engagement} engagements`);
    console.log(`  ${text}...`);
    console.log();
  }
}

// Call it when a signal fires
investigateSignal("recession", "US Recession Odds");

This is the part that turns a quantitative signal into something you can actually reason about. A sentiment drop is just a number until you see that the top 5 posts are all reacting to the same PMI report or the same oil price spike.

Why social data works for this

Prediction markets aggregate opinions into prices. Social media is where those opinions form. The sequence is:

Something happens (policy announcement, earnings, geopolitical event)
Social media reacts -- volume spikes, sentiment shifts, creators amplify
People form opinions and update their beliefs
Those beliefs get priced into prediction market contracts

LunarCrush is sitting at step 2, processing 50M+ posts per hour across X, Reddit, TikTok, YouTube, Instagram, and 10K+ news sources. By the time a prediction market contract moves, the social signal has usually already fired.

The tool we built here is simple on purpose. The point isn't to build an automated trading bot -- it's to build a detection system that tells you when something is happening in the social conversation before the market fully reflects it.

Try it yourself

Get an API key: lunarcrush.com/developers
Full API docs: lunarcrush.com/developers/api
MCP server (use with Claude): lunarcrush.com/mcp

Swap in any topic you want. Elections, Fed rate decisions, crypto launches, sports outcomes -- if people are talking about it online and betting on it in a prediction market, you can build a signal from it.

Track World Cup 2026 Social Buzz With a Simple Node.js Script

Joe Vezzani — Tue, 07 Apr 2026 15:10:58 +0000

The 2026 FIFA World Cup starts June 11 across the US, Canada, and Mexico. 48 teams for the first time ever. More matches, more upsets, more chaos -- and a ridiculous amount of social media activity.

Headlines will tell you who won. Social data tells you who the internet is actually talking about, which fan bases are the loudest, and which underdog is going viral before the pundits catch on.

I built a tracker that pulls real-time social intelligence on World Cup teams using LunarCrush's API. It processes 50M+ social posts per hour across X, Reddit, TikTok, YouTube, Instagram, and 10K+ news sources.

Here's how to build it yourself.

GitHub repo: JoeVezzani/world-cup-tracker

What we're building

A Node.js script that:

Tracks social volume, sentiment, and engagement for any World Cup team
Compares teams head-to-head (USA vs Mexico, Argentina vs Brazil, etc.)
Ranks all 48 teams by social buzz to find who's trending
Surfaces the most viral posts driving each team's conversation

Setup

mkdir world-cup-tracker && cd world-cup-tracker
npm init -y

Grab an API key at lunarcrush.com/developers.

The core functions

Two endpoints do all the heavy lifting -- one for metrics, one for posts:

const API_KEY = process.env.LUNARCRUSH_API_KEY;
const BASE = "https://lunarcrush.com/api4/public/topic";

async function getTopicData(keyword) {
  const res = await fetch(
    `${BASE}/${encodeURIComponent(keyword)}/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function getTopicPosts(keyword) {
  const res = await fetch(
    `${BASE}/${encodeURIComponent(keyword)}/posts/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

Track a single team

Start simple. Pull the social pulse on any team:

async function teamReport(team) {
  const topic = await getTopicData(team);
  const d = topic.data || {};

  console.log(`\nSOCIAL REPORT: ${team.toUpperCase()}`);
  console.log("=".repeat(50));
  console.log(`Posts (24h):       ${(d.num_posts || 0).toLocaleString()}`);
  console.log(`Engagements:       ${(d.interactions || 0).toLocaleString()}`);
  console.log(`Sentiment:         ${d.sentiment || "N/A"}% bullish`);
  console.log(`Contributors:      ${(d.num_contributors || 0).toLocaleString()}`);

  const posts = await getTopicPosts(team);
  console.log(`\nTop Posts:`);
  for (const post of (posts.data || []).slice(0, 3)) {
    const platform = post.network || "unknown";
    const engagement = (post.interactions_total || 0).toLocaleString();
    const text = (post.body || post.title || "").slice(0, 100);
    console.log(`  [${platform}] ${engagement} engagements: ${text}...`);
  }
}

teamReport("USA World Cup");

LUNARCRUSH_API_KEY=your_key node index.js

Head-to-head comparison

This is where it gets fun. Pit two rival fan bases against each other:

async function headToHead(teamA, teamB) {
  const [a, b] = await Promise.all([
    getTopicData(teamA),
    getTopicData(teamB),
  ]);

  const dataA = a.data || {};
  const dataB = b.data || {};

  console.log(`\nHEAD TO HEAD: ${teamA.toUpperCase()} vs ${teamB.toUpperCase()}`);
  console.log("=".repeat(55));

  const metrics = [
    ["Posts (24h)", "num_posts"],
    ["Engagements", "interactions"],
    ["Sentiment", "sentiment"],
    ["Contributors", "num_contributors"],
  ];

  for (const [label, key] of metrics) {
    const valA = dataA[key] || 0;
    const valB = dataB[key] || 0;
    const winner = valA > valB ? teamA : valA < valB ? teamB : "TIE";
    const format = (v) => key === "sentiment" ? `${v}%` : v.toLocaleString();
    console.log(
      `${label.padEnd(18)} ${format(valA).padStart(12)}  vs  ${format(valB).padEnd(12)}  --> ${winner}`
    );
  }
}

headToHead("USA soccer", "Mexico soccer");

Sample output:

HEAD TO HEAD: USA SOCCER vs MEXICO SOCCER
=======================================================
Posts (24h)              48,291  vs  63,817        --> Mexico soccer
Engagements           1,203,441  vs  2,891,003     --> Mexico soccer
Sentiment                   72%  vs  68%           --> USA soccer
Contributors             31,204  vs  44,109        --> Mexico soccer

Run it for any matchup. Argentina vs Brazil. England vs France. Japan vs South Korea. The data is there for all of them.

Rank all 48 teams by buzz

Here's the full leaderboard. Throw every team in, sort by social volume, see who's dominating the conversation:

const TEAMS = [
  "Argentina World Cup", "Brazil World Cup", "France World Cup",
  "England World Cup", "Germany World Cup", "Spain World Cup",
  "USA World Cup", "Mexico World Cup", "Canada World Cup",
  "Japan World Cup", "South Korea World Cup", "Australia World Cup",
  "Netherlands World Cup", "Portugal World Cup", "Belgium World Cup",
  "Croatia World Cup", "Morocco World Cup", "Senegal World Cup",
  "Uruguay World Cup", "Colombia World Cup", "Ecuador World Cup",
  "Saudi Arabia World Cup", "Qatar World Cup", "Iran World Cup",
];

async function buzzLeaderboard(teams) {
  const results = [];

  for (const team of teams) {
    const data = await getTopicData(team);
    const d = data.data || {};
    results.push({
      team,
      posts: d.num_posts || 0,
      engagements: d.interactions || 0,
      sentiment: d.sentiment || 0,
    });
    // Small delay to be polite to the API
    await new Promise((r) => setTimeout(r, 200));
  }

  results.sort((a, b) => b.posts - a.posts);

  console.log(`\nWORLD CUP 2026 - SOCIAL BUZZ LEADERBOARD`);
  console.log("=".repeat(65));
  console.log(
    `${"#".padEnd(4)}${"Team".padEnd(28)}${"Posts".padStart(10)}${"Engagements".padStart(14)}${"Sentiment".padStart(10)}`
  );
  console.log("-".repeat(65));

  results.forEach((r, i) => {
    const name = r.team.replace(" World Cup", "");
    console.log(
      `${String(i + 1).padEnd(4)}${name.padEnd(28)}${r.posts.toLocaleString().padStart(10)}${r.engagements.toLocaleString().padStart(14)}${(r.sentiment + "%").padStart(10)}`
    );
  });
}

buzzLeaderboard(TEAMS);

Add or remove teams from the array as the tournament bracket fills out. You can also swap "World Cup" for more specific queries like "USMNT" or "Les Bleus" depending on what fan communities call their team.

Find trending moments

The most interesting thing during a tournament isn't steady buzz -- it's spikes. An upset, a red card, a last-minute goal. This function checks for teams with unusual social activity:

const fs = require("fs");
const STATE_FILE = "./buzz_state.json";

function loadState() {
  try { return JSON.parse(fs.readFileSync(STATE_FILE)); }
  catch { return {}; }
}

function saveState(state) {
  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
}

async function detectSpikes(teams) {
  const state = loadState();
  const spikes = [];

  for (const team of teams) {
    const data = await getTopicData(team);
    const current = data.data?.num_posts || 0;
    const previous = state[team]?.posts || 0;

    if (previous > 0 && current > previous * 2) {
      spikes.push({
        team,
        previous,
        current,
        multiplier: (current / previous).toFixed(1),
      });
    }

    state[team] = { posts: current, timestamp: new Date().toISOString() };
    await new Promise((r) => setTimeout(r, 200));
  }

  saveState(state);

  if (spikes.length === 0) {
    console.log("\nNo major spikes detected. Check back after a match.");
    return;
  }

  spikes.sort((a, b) => b.multiplier - a.multiplier);
  console.log(`\nSPIKE ALERT - Something is happening:`);
  console.log("=".repeat(55));
  for (const s of spikes) {
    const name = s.team.replace(" World Cup", "");
    console.log(
      `${name}: ${s.previous.toLocaleString()} -> ${s.current.toLocaleString()} posts (${s.multiplier}x increase)`
    );
  }
}

detectSpikes(TEAMS);

Run this on a cron every 30 minutes during match days:

# crontab -e
*/30 * * * * cd /path/to/world-cup-tracker && LUNARCRUSH_API_KEY=your_key node spikes.js >> spikes.log

When Japan pulls off an upset against Germany (again), you'll see the spike before ESPN runs the highlight reel.

Why social data matters for sports

Traditional sports coverage tells you who scored. Social data tells you:

Which teams have the most passionate fan bases -- not just the biggest
Where the conversation is happening -- is it TikTok memes or Reddit analysis?
Sentiment shifts in real time -- a team can go from beloved to villain in 90 minutes
Underdog stories forming -- viral moments surface in social data before they hit mainstream media

With 48 teams across three countries, this World Cup is going to generate more social activity than any sporting event in history. Having a way to actually measure and compare that activity is more interesting than refreshing a score app.

Try it

API key: lunarcrush.com/developers
Full API docs: lunarcrush.com/developers/api
MCP server (use with Claude): lunarcrush.com/mcp

I Built a Tariff Impact Tracker That Shows What the Internet Actually Thinks

Joe Vezzani — Mon, 06 Apr 2026 22:07:38 +0000

Tariffs are dominating the news cycle right now. But the headlines only tell you what journalists think. What does the actual internet think?

I built a quick tracker that pulls real-time social data on tariffs -- volume, sentiment, top posts, which platforms are driving the conversation -- using LunarCrush's API. It processes 50M+ social posts per hour across X, Reddit, TikTok, YouTube, Instagram, and 10K+ news sources.

Here's what I found and how to build it yourself.

GitHub repo: JoeVezzani/tariff-tracker

What we're building

A simple Node.js script that:

Tracks social volume and sentiment for any keyword (tariffs, trade war, specific companies)
Compares how different platforms feel about the same topic
Finds the most viral posts driving the conversation
Runs on a cron to alert you when sentiment shifts

Setup (2 minutes)

mkdir tariff-tracker && cd tariff-tracker
npm init -y

Grab an API key at lunarcrush.com/developers.

Pull the data

const API_KEY = process.env.LUNARCRUSH_API_KEY;

async function getTopicData(keyword) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/topic/${encodeURIComponent(keyword)}/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function getTopicPosts(keyword) {
  const res = await fetch(
    `https://lunarcrush.com/api4/public/topic/${encodeURIComponent(keyword)}/posts/v1`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  );
  return res.json();
}

async function main() {
  const topic = await getTopicData("tariffs");

  console.log(`\n📊 TARIFFS - Social Intelligence Report`);
  console.log(`${"=".repeat(50)}`);
  console.log(`Total posts (24h):    ${topic.data?.num_posts?.toLocaleString()}`);
  console.log(`Total engagements:    ${topic.data?.interactions?.toLocaleString()}`);
  console.log(`Sentiment:            ${topic.data?.sentiment}% bullish`);
  console.log(`Contributors:         ${topic.data?.num_contributors?.toLocaleString()}`);

  // Get the posts driving the conversation
  const posts = await getTopicPosts("tariffs");

  console.log(`\n🔥 Top Posts Right Now:`);
  for (const post of (posts.data || []).slice(0, 5)) {
    const platform = post.network || "unknown";
    const engagement = post.interactions_total?.toLocaleString() || "0";
    const text = (post.body || post.title || "").slice(0, 100);
    console.log(`  [${platform}] ${engagement} engagements: ${text}...`);
  }
}

main();

Run it

LUNARCRUSH_API_KEY=your_key node index.js

Output looks something like:

📊 TARIFFS - Social Intelligence Report
==================================================
Total posts (24h):    847,291
Total engagements:    2,341,882,104
Sentiment:            38% bullish
Contributors:         412,847

🔥 Top Posts Right Now:
  [twitter] 1,247,382 engagements: Breaking: EU announces retaliatory tariffs...
  [reddit] 892,411 engagements: Can someone ELI5 why tariffs make everything...
  [youtube] 743,219 engagements: The REAL impact of tariffs on your wallet...
  [tiktok] 521,883 engagements: POV: you work in manufacturing and just heard...
  [news] 412,092 engagements: Apple warns tariffs could increase iPhone price...

Make it interesting: compare companies

Want to see how tariffs are hitting different stocks in the social conversation?

async function compareTariffImpact(tickers) {
  const results = [];

  for (const ticker of tickers) {
    const data = await getTopicData(ticker);
    results.push({
      ticker,
      sentiment: data.data?.sentiment,
      volume: data.data?.num_posts,
      engagements: data.data?.interactions,
    });
  }

  // Sort by most negative sentiment
  results.sort((a, b) => (a.sentiment || 0) - (b.sentiment || 0));

  console.log(`\n📉 Tariff Sentiment Impact by Company:`);
  console.log(`${"Ticker":<10} ${"Sentiment":<12} ${"Posts (24h)":<15} ${"Engagements"}`);
  console.log("-".repeat(55));

  for (const r of results) {
    const mood = r.sentiment < 40 ? "😰" : r.sentiment < 60 ? "😐" : "😎";
    console.log(
      `${mood} ${r.ticker:<8} ${r.sentiment || "N/A":<12} ${(r.volume || 0).toLocaleString():<15} ${(r.engagements || 0).toLocaleString()}`
    );
  }
}

compareTariffImpact(["apple", "nike", "tesla", "walmart", "amazon"]);

Add a sentiment shift alert

Run this on a cron and get notified when public opinion changes:

const fs = require("fs");
const STATE_FILE = "./sentiment_state.json";

function loadState() {
  try { return JSON.parse(fs.readFileSync(STATE_FILE)); } 
  catch { return {}; }
}

function saveState(state) {
  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
}

async function checkForShifts(keywords) {
  const state = loadState();

  for (const keyword of keywords) {
    const data = await getTopicData(keyword);
    const current = data.data?.sentiment;
    const previous = state[keyword]?.sentiment;

    if (previous && Math.abs(current - previous) > 10) {
      const direction = current > previous ? "📈 UP" : "📉 DOWN";
      console.log(
        `🚨 ALERT: "${keyword}" sentiment shifted ${direction} ` +
        `(${previous}% -> ${current}%, change: ${current - previous > 0 ? "+" : ""}${current - previous}%)`
      );
    }

    state[keyword] = { sentiment: current, timestamp: new Date().toISOString() };
  }

  saveState(state);
}

checkForShifts(["tariffs", "trade war", "apple", "tesla", "nvidia"]);

Set it up as a cron job to run every hour:

# crontab -e
0 * * * * cd /path/to/tariff-tracker && LUNARCRUSH_API_KEY=your_key node alert.js >> alerts.log

What's cool about this

The LunarCrush API isn't just price data or news feeds. It's aggregating the actual social conversation -- 50M+ posts per hour -- across every major platform. You get:

Sentiment that's calculated from real posts, not just positive/negative keyword matching
Cross-platform comparison -- is Reddit bearish while TikTok is bullish?
Creator-level data -- who's driving the conversation?
Galaxy Score and AltRank -- proprietary metrics that rank social health

This works for crypto, stocks, topics, people -- basically anything the internet talks about.

Try it

API key: lunarcrush.com/developers
Full API docs: lunarcrush.com/developers/api
MCP server (use with Claude): lunarcrush.com/mcp

I'm building a bunch of small projects like this. Follow along if you're into this kind of thing.