DEV Community: Olamide Olaniyan

Build a "Who Unfollowed Me" Tracker with Node.js

Olamide Olaniyan — Fri, 17 Apr 2026 19:33:00 +0000

Three months ago I had 12,400 followers. Now I have 12,380. That's 20 people who decided I wasn't worth it.

But who? And more importantly — was it organic churn or did a competitor poach them?

Most "who unfollowed me" apps are either dead (RIP Crowdfire), full of ads, or ask for your password (please don't). So I built my own. It runs on my machine, stores data locally, and tells me exactly who left.

How It Works

The concept is embarrassingly simple:

Fetch your follower list
Save it
Wait
Fetch again
Diff

The followers in snapshot #1 that aren't in snapshot #2 — those are your unfollowers. The followers in #2 that weren't in #1 — those are new followers.

The Stack

Node.js – runtime
SociaVault API – fetch follower lists
better-sqlite3 – local storage for snapshots
node-cron – schedule daily checks

The Catch

Fetching a full follower list for accounts with 100K+ followers is expensive and slow. For accounts under 10K, it's fine — a few API calls and you have everyone.

For larger accounts, we'll sample. Grab the most recent 5,000 followers each day. That catches the churn that matters — the people who followed recently and then bounced.

Setup

mkdir unfollow-tracker && cd unfollow-tracker
npm init -y
npm install axios better-sqlite3 node-cron dotenv

# .env
SOCIAVAULT_API_KEY=your_key
PLATFORM=tiktok
USERNAME=your_username

Step 1: Database

// db.js
const Database = require('better-sqlite3');
const db = new Database('./followers.db');

db.exec(`
  CREATE TABLE IF NOT EXISTS snapshots (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    taken_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );

  CREATE TABLE IF NOT EXISTS snapshot_followers (
    snapshot_id INTEGER NOT NULL,
    user_id TEXT NOT NULL,
    username TEXT,
    display_name TEXT,
    follower_count INTEGER DEFAULT 0,
    PRIMARY KEY (snapshot_id, user_id),
    FOREIGN KEY (snapshot_id) REFERENCES snapshots(id)
  );

  CREATE TABLE IF NOT EXISTS unfollow_events (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id TEXT NOT NULL,
    username TEXT,
    display_name TEXT,
    unfollowed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    was_follower_since DATETIME
  );

  CREATE TABLE IF NOT EXISTS follow_events (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id TEXT NOT NULL,
    username TEXT,
    display_name TEXT,
    followed_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );
`);

module.exports = {
  createSnapshot: () => {
    const result = db.prepare('INSERT INTO snapshots DEFAULT VALUES').run();
    return result.lastInsertRowid;
  },

  addFollowerToSnapshot: db.prepare(`
    INSERT INTO snapshot_followers (snapshot_id, user_id, username, display_name, follower_count)
    VALUES (?, ?, ?, ?, ?)
  `),

  getLatestSnapshotId: () => {
    const row = db.prepare('SELECT id FROM snapshots ORDER BY id DESC LIMIT 1').get();
    return row?.id || null;
  },

  getPreviousSnapshotId: () => {
    const row = db.prepare('SELECT id FROM snapshots ORDER BY id DESC LIMIT 1 OFFSET 1').get();
    return row?.id || null;
  },

  getFollowerIds: (snapshotId) => {
    return db.prepare('SELECT user_id, username, display_name FROM snapshot_followers WHERE snapshot_id = ?')
      .all(snapshotId);
  },

  recordUnfollow: db.prepare(`
    INSERT INTO unfollow_events (user_id, username, display_name) VALUES (?, ?, ?)
  `),

  recordFollow: db.prepare(`
    INSERT INTO follow_events (user_id, username, display_name) VALUES (?, ?, ?)
  `),

  getRecentUnfollows: (days = 7) => {
    return db.prepare(`
      SELECT * FROM unfollow_events
      WHERE unfollowed_at > datetime('now', '-' || ? || ' days')
      ORDER BY unfollowed_at DESC
    `).all(days);
  },

  getRecentFollows: (days = 7) => {
    return db.prepare(`
      SELECT * FROM follow_events
      WHERE followed_at > datetime('now', '-' || ? || ' days')
      ORDER BY followed_at DESC
    `).all(days);
  },

  getStats: () => {
    return {
      totalSnapshots: db.prepare('SELECT COUNT(*) as count FROM snapshots').get().count,
      totalUnfollows: db.prepare('SELECT COUNT(*) as count FROM unfollow_events').get().count,
      totalFollows: db.prepare('SELECT COUNT(*) as count FROM follow_events').get().count,
    };
  },

  db, // expose for transactions
};

Step 2: Fetch Followers

// fetcher.js
const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function fetchFollowers(platform, username, maxCount = 5000) {
  const followers = [];
  let cursor = null;

  const endpoint = platform === 'tiktok'
    ? `/tiktok/followers?username=${username}`
    : `/instagram/followers?username=${username}`;

  while (followers.length < maxCount) {
    const params = new URLSearchParams({
      limit: String(Math.min(200, maxCount - followers.length)),
    });
    if (cursor) params.set('cursor', cursor);

    try {
      const { data } = await api.get(`${endpoint}&${params.toString()}`);

      const batch = data.data || data.followers || [];
      followers.push(...batch);

      cursor = data.nextCursor || data.cursor;
      if (!cursor || batch.length === 0) break;

      console.log(`  ...fetched ${followers.length} followers`);
    } catch (err) {
      console.error(`Fetch error: ${err.message}`);
      break;
    }
  }

  return followers.map(f => ({
    userId: f.userId || f.id || f.uniqueId,
    username: f.uniqueId || f.username || 'unknown',
    displayName: f.nickname || f.fullName || f.uniqueId || '',
    followerCount: f.followerCount || f.followersCount || 0,
  }));
}

module.exports = { fetchFollowers };

Step 3: The Diff Engine

This is where it gets interesting:

// diff.js
const db = require('./db');

function computeDiff() {
  const latestId = db.getLatestSnapshotId();
  const previousId = db.getPreviousSnapshotId();

  if (!latestId || !previousId) {
    console.log('Need at least 2 snapshots to compute diff.');
    return null;
  }

  const latest = db.getFollowerIds(latestId);
  const previous = db.getFollowerIds(previousId);

  const latestSet = new Map(latest.map(f => [f.user_id, f]));
  const previousSet = new Map(previous.map(f => [f.user_id, f]));

  // Unfollowers: were in previous, not in latest
  const unfollowers = [];
  for (const [userId, follower] of previousSet) {
    if (!latestSet.has(userId)) {
      unfollowers.push(follower);
    }
  }

  // New followers: in latest, not in previous
  const newFollowers = [];
  for (const [userId, follower] of latestSet) {
    if (!previousSet.has(userId)) {
      newFollowers.push(follower);
    }
  }

  // Record events
  const recordUnfollows = db.db.transaction((unfollows) => {
    for (const u of unfollows) {
      db.recordUnfollow.run(u.user_id, u.username, u.display_name);
    }
  });

  const recordFollows = db.db.transaction((follows) => {
    for (const f of follows) {
      db.recordFollow.run(f.user_id, f.username, f.display_name);
    }
  });

  recordUnfollows(unfollowers);
  recordFollows(newFollowers);

  return {
    unfollowers,
    newFollowers,
    netChange: newFollowers.length - unfollowers.length,
  };
}

module.exports = { computeDiff };

Step 4: Main Script

// index.js
require('dotenv').config();
const cron = require('node-cron');
const { fetchFollowers } = require('./fetcher');
const { computeDiff } = require('./diff');
const db = require('./db');

const PLATFORM = process.env.PLATFORM;
const USERNAME = process.env.USERNAME;

async function takeSnapshot() {
  console.log(`\n[${new Date().toISOString()}] Taking snapshot for ${PLATFORM}/@${USERNAME}`);

  // Fetch current followers
  const followers = await fetchFollowers(PLATFORM, USERNAME, 5000);
  console.log(`Fetched ${followers.length} followers`);

  // Save snapshot
  const snapshotId = db.createSnapshot();
  const insert = db.db.transaction((data) => {
    for (const f of data) {
      db.addFollowerToSnapshot.run(snapshotId, f.userId, f.username, f.displayName, f.followerCount);
    }
  });
  insert(followers);

  // Compute diff against previous snapshot
  const diff = computeDiff();

  if (diff) {
    console.log('\n--- RESULTS ---');
    console.log(`New followers: +${diff.newFollowers.length}`);
    console.log(`Unfollowers: -${diff.unfollowers.length}`);
    console.log(`Net change: ${diff.netChange > 0 ? '+' : ''}${diff.netChange}`);

    if (diff.unfollowers.length > 0) {
      console.log('\nWho unfollowed:');
      for (const u of diff.unfollowers) {
        console.log(`  ❌ @${u.username} (${u.display_name})`);
      }
    }

    if (diff.newFollowers.length > 0) {
      console.log('\nNew followers:');
      for (const f of diff.newFollowers.slice(0, 10)) {
        console.log(`  ✅ @${f.username} (${f.display_name})`);
      }
      if (diff.newFollowers.length > 10) {
        console.log(`  ... and ${diff.newFollowers.length - 10} more`);
      }
    }
  }
}

// Run commands
const command = process.argv[2];

if (command === 'snapshot' || command === '--now') {
  takeSnapshot().then(() => process.exit(0));

} else if (command === 'unfollows') {
  const days = parseInt(process.argv[3]) || 7;
  const unfollows = db.getRecentUnfollows(days);
  console.log(`\nUnfollowers in the last ${days} days:`);
  for (const u of unfollows) {
    console.log(`  ❌ @${u.username} — ${new Date(u.unfollowed_at).toLocaleDateString()}`);
  }
  console.log(`\nTotal: ${unfollows.length}`);
  process.exit(0);

} else if (command === 'stats') {
  const stats = db.getStats();
  console.log(`\nSnapshots taken: ${stats.totalSnapshots}`);
  console.log(`Total unfollows tracked: ${stats.totalUnfollows}`);
  console.log(`Total new follows tracked: ${stats.totalFollows}`);
  process.exit(0);

} else {
  // Default: run on schedule
  console.log(`Unfollow tracker started for ${PLATFORM}/@${USERNAME}`);
  console.log('Taking daily snapshots at 8am...');

  // Initial snapshot
  takeSnapshot();

  // Daily at 8am
  cron.schedule('0 8 * * *', takeSnapshot);
}

Usage

# Take a snapshot now
node index.js snapshot

# Wait a day (or at least a few hours), take another
node index.js snapshot

# See who unfollowed
node index.js unfollows

# See unfollows from last 30 days
node index.js unfollows 30

# See overall stats
node index.js stats

# Run as daemon (takes daily snapshots)
node index.js

Sample Output

[2026-04-05T08:00:00.000Z] Taking snapshot for tiktok/@your_username
Fetched 4,832 followers

--- RESULTS ---
New followers: +47
Unfollowers: -12
Net change: +35

Who unfollowed:
  ❌ @former_fan_123 (Mike Johnson)
  ❌ @brand_that_left (Old Partner Brand)
  ❌ @competitor_spy (lol)
  ❌ @random_user_1 (Unknown)
  ...8 more

New followers:
  ✅ @new_person (Sarah K)
  ✅ @interested_brand (Cool Brand)
  ... and 45 more

What Makes This Better Than Apps

Your data stays local. No third-party app storing your follower list.
No password required. We're using public API data, not logging into your account.
Historical tracking. After a month you have 30 snapshots. You can analyze churn patterns, identify which posts triggered unfollows, etc.
Customizable. Want a Slack notification when someone with 10K+ followers unfollows? Add 5 lines of code.

Extending It

Notification on high-value unfollows — if someone with 50K+ followers leaves, you probably want to know
Correlation with posting — did unfollows spike after a specific post?
Weekly email digest — combine with the weekly report script from my other article
Web UI — simple Express + HTML table showing follow/unfollow history

Read the Full Guide

Build a Who Unfollowed Me Tracker → SociaVault Blog

Track followers, posts, and engagement across platforms with SociaVault — unified API for TikTok, Instagram, YouTube, and 10+ social platforms.

Discussion

Do you track who unfollows you? Is it useful intel or just anxiety fuel? Genuinely curious how others think about this.

javascript #nodejs #api #webdev #tutorial

Build a Weekly Social Media Report That Emails Itself

Olamide Olaniyan — Thu, 16 Apr 2026 19:32:00 +0000

Nobody reads dashboards.

I've built dashboards with real-time charts, sparklines, color-coded KPIs — the works. Usage logs showed the team checked them twice the first week, then never again.

You know what people actually read? Emails.

So I stopped building dashboards and started building reports that email themselves every Monday at 9am. One email. Key metrics. Week-over-week changes. Done.

Here's how.

What We're Building

A Node.js script that:

Fetches this week's social media stats for your accounts
Compares them to last week
Generates a clean HTML email with the delta
Sends it to your team via Resend (or any email provider)
Runs automatically every Monday morning via cron

The Stack

Node.js – runtime
SociaVault API – fetch profile stats and post performance
Resend – send HTML emails ($0 for first 3,000/month)
node-cron – scheduling
better-sqlite3 – store weekly snapshots for comparison

Setup

mkdir weekly-report && cd weekly-report
npm init -y
npm install axios resend node-cron better-sqlite3 dotenv

# .env
SOCIAVAULT_API_KEY=your_key
RESEND_API_KEY=re_your_key
REPORT_RECIPIENTS=team@yourcompany.com,founder@yourcompany.com

Step 1: Store Weekly Snapshots

We need last week's numbers to calculate deltas. SQLite handles this perfectly.

// db.js
const Database = require('better-sqlite3');
const db = new Database('./snapshots.db');

db.exec(`
  CREATE TABLE IF NOT EXISTS snapshots (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    platform TEXT NOT NULL,
    username TEXT NOT NULL,
    followers INTEGER,
    following INTEGER,
    posts_count INTEGER,
    avg_likes REAL,
    avg_comments REAL,
    engagement_rate REAL,
    snapshot_date DATE DEFAULT (date('now')),
    UNIQUE(platform, username, snapshot_date)
  )
`);

const insertSnapshot = db.prepare(`
  INSERT OR REPLACE INTO snapshots
  (platform, username, followers, following, posts_count, avg_likes, avg_comments, engagement_rate, snapshot_date)
  VALUES (?, ?, ?, ?, ?, ?, ?, ?, date('now'))
`);

const getSnapshot = db.prepare(`
  SELECT * FROM snapshots
  WHERE platform = ? AND username = ? AND snapshot_date = date('now', ?)
`);

module.exports = {
  saveSnapshot: (data) => insertSnapshot.run(
    data.platform, data.username, data.followers, data.following,
    data.postsCount, data.avgLikes, data.avgComments, data.engagementRate
  ),
  getLastWeek: (platform, username) => getSnapshot.get(platform, username, '-7 days'),
  getThisWeek: (platform, username) => getSnapshot.get(platform, username, '0 days'),
};

Step 2: Fetch Current Stats

// fetcher.js
const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function getAccountStats(platform, username) {
  const profileEndpoint = platform === 'instagram'
    ? `/instagram/profile?username=${username}`
    : `/tiktok/profile?username=${username}`;

  const postsEndpoint = platform === 'instagram'
    ? `/instagram/posts?username=${username}&limit=12`
    : `/tiktok/profile-videos?username=${username}&limit=12`;

  const [profileRes, postsRes] = await Promise.all([
    api.get(profileEndpoint),
    api.get(postsEndpoint),
  ]);

  const profile = profileRes.data.data || profileRes.data;
  const posts = postsRes.data.data || postsRes.data.posts || [];

  // Calculate averages from recent posts
  const totalLikes = posts.reduce((sum, p) => sum + (p.likesCount || p.diggCount || 0), 0);
  const totalComments = posts.reduce((sum, p) => sum + (p.commentsCount || p.commentCount || 0), 0);
  const avgLikes = posts.length > 0 ? totalLikes / posts.length : 0;
  const avgComments = posts.length > 0 ? totalComments / posts.length : 0;

  const followers = profile.followersCount || profile.followerCount || 0;
  const engagementRate = followers > 0 ? ((avgLikes + avgComments) / followers) * 100 : 0;

  return {
    platform,
    username,
    followers,
    following: profile.followingCount || 0,
    postsCount: profile.postsCount || profile.videoCount || 0,
    avgLikes: Math.round(avgLikes),
    avgComments: Math.round(avgComments),
    engagementRate: parseFloat(engagementRate.toFixed(2)),
  };
}

module.exports = { getAccountStats };

Step 3: Calculate Week-over-Week Changes

// compare.js
function delta(current, previous) {
  if (!previous || previous === 0) return { value: current, change: null, percent: null };

  const change = current - previous;
  const percent = ((change / previous) * 100).toFixed(1);

  return {
    value: current,
    change,
    percent: parseFloat(percent),
    direction: change > 0 ? 'up' : change < 0 ? 'down' : 'flat',
  };
}

function compareSnapshots(current, lastWeek) {
  if (!lastWeek) {
    return {
      followers: { value: current.followers, change: null },
      avgLikes: { value: current.avgLikes, change: null },
      avgComments: { value: current.avgComments, change: null },
      engagementRate: { value: current.engagementRate, change: null },
      isFirstWeek: true,
    };
  }

  return {
    followers: delta(current.followers, lastWeek.followers),
    avgLikes: delta(current.avgLikes, lastWeek.avg_likes),
    avgComments: delta(current.avgComments, lastWeek.avg_comments),
    engagementRate: delta(current.engagementRate, lastWeek.engagement_rate),
    isFirstWeek: false,
  };
}

module.exports = { compareSnapshots };

Step 4: Generate the HTML Email

This is where most automated reports fail. They send ugly plain text. We're sending something that looks like it was designed.

// email-template.js
function arrow(direction) {
  if (direction === 'up') return '↑';
  if (direction === 'down') return '↓';
  return '→';
}

function changeColor(direction) {
  if (direction === 'up') return '#22c55e';
  if (direction === 'down') return '#ef4444';
  return '#94a3b8';
}

function formatChange(metric) {
  if (metric.change === null) return '<span style="color:#94a3b8">First week</span>';

  const color = changeColor(metric.direction);
  const sign = metric.change > 0 ? '+' : '';
  return `<span style="color:${color}">${arrow(metric.direction)} ${sign}${metric.percent}%</span>`;
}

function buildEmailHTML(reports) {
  const date = new Date().toLocaleDateString('en-US', {
    weekday: 'long', month: 'long', day: 'numeric', year: 'numeric',
  });

  const accountRows = reports.map(r => `
    <tr>
      <td style="padding:12px 16px;border-bottom:1px solid #e2e8f0">
        <strong>${r.platform}</strong> @${r.username}
      </td>
      <td style="padding:12px 16px;border-bottom:1px solid #e2e8f0;text-align:right">
        ${r.comparison.followers.value.toLocaleString()} ${formatChange(r.comparison.followers)}
      </td>
      <td style="padding:12px 16px;border-bottom:1px solid #e2e8f0;text-align:right">
        ${r.comparison.engagementRate.value}% ${formatChange(r.comparison.engagementRate)}
      </td>
      <td style="padding:12px 16px;border-bottom:1px solid #e2e8f0;text-align:right">
        ${r.comparison.avgLikes.value.toLocaleString()} ${formatChange(r.comparison.avgLikes)}
      </td>
    </tr>
  `).join('');

  return `
<!DOCTYPE html>
<html>
<head><meta charset="utf-8"></head>
<body style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;max-width:600px;margin:0 auto;padding:20px;color:#1e293b">

  <h1 style="font-size:24px;margin-bottom:4px">📊 Weekly Social Report</h1>
  <p style="color:#64748b;margin-top:0">${date}</p>

  <table style="width:100%;border-collapse:collapse;margin:24px 0">
    <thead>
      <tr style="background:#f8fafc">
        <th style="padding:12px 16px;text-align:left;border-bottom:2px solid #e2e8f0">Account</th>
        <th style="padding:12px 16px;text-align:right;border-bottom:2px solid #e2e8f0">Followers</th>
        <th style="padding:12px 16px;text-align:right;border-bottom:2px solid #e2e8f0">Eng. Rate</th>
        <th style="padding:12px 16px;text-align:right;border-bottom:2px solid #e2e8f0">Avg Likes</th>
      </tr>
    </thead>
    <tbody>
      ${accountRows}
    </tbody>
  </table>

  <p style="color:#94a3b8;font-size:12px;margin-top:32px">
    Powered by <a href="https://sociavault.com" style="color:#3b82f6">SociaVault</a> • Data pulled from public APIs
  </p>
</body>
</html>`;
}

module.exports = { buildEmailHTML };

Step 5: Send It

// index.js
require('dotenv').config();
const cron = require('node-cron');
const { Resend } = require('resend');
const { getAccountStats } = require('./fetcher');
const { compareSnapshots } = require('./compare');
const { buildEmailHTML } = require('./email-template');
const db = require('./db');

const resend = new Resend(process.env.RESEND_API_KEY);

// Your accounts to track
const ACCOUNTS = [
  { platform: 'instagram', username: 'your_brand' },
  { platform: 'tiktok', username: 'your_brand' },
];

async function generateAndSend() {
  console.log('Generating weekly report...');

  const reports = [];

  for (const account of ACCOUNTS) {
    const current = await getAccountStats(account.platform, account.username);
    const lastWeek = db.getLastWeek(account.platform, account.username);
    const comparison = compareSnapshots(current, lastWeek);

    // Save this week's snapshot
    db.saveSnapshot(current);

    reports.push({ ...account, current, comparison });
  }

  const html = buildEmailHTML(reports);
  const recipients = process.env.REPORT_RECIPIENTS.split(',').map(e => e.trim());

  await resend.emails.send({
    from: 'reports@yourdomain.com',
    to: recipients,
    subject: `📊 Weekly Social Report — ${new Date().toLocaleDateString()}`,
    html,
  });

  console.log(`Report sent to ${recipients.length} recipients`);
}

// Every Monday at 9am
cron.schedule('0 9 * * 1', generateAndSend);

// Run manually with: node index.js --now
if (process.argv.includes('--now')) {
  generateAndSend().then(() => process.exit(0));
}

console.log('Weekly report scheduler started. Next run: Monday 9am.');

Test it:

node index.js --now

You should get a clean email with a table showing each account's followers, engagement rate, average likes — all with week-over-week arrows.

What the Email Looks Like

📊 Weekly Social Report
Monday, April 7, 2026

Account              Followers        Eng. Rate      Avg Likes
─────────────────────────────────────────────────────────────
Instagram @brand     124,500 ↑ +2.1%  3.4% ↑ +0.3%  4,230 ↑ +8.2%
TikTok @brand        89,200 ↑ +4.7%   5.1% ↓ -1.2%  12,100 ↓ -3.1%

Green arrows for growth, red for decline. Your CEO reads this in 10 seconds and knows exactly what's happening.

Extending It

Add top performing post of the week — include a thumbnail and link
Add competitor comparison — show your numbers next to theirs
Add monthly roll-up — first Monday of each month includes 4-week trend
Switch to React Email for more complex layouts if needed

Read the Full Guide

Build a Self-Emailing Social Report → SociaVault Blog

Automate your social media analytics with SociaVault — one API for TikTok, Instagram, YouTube, and 10+ platforms. Pull profiles, posts, and engagement data programmatically.

Discussion

How do you handle social media reporting for your team or clients? Still exporting CSVs from native analytics? I'd love to hear what other people have automated.

javascript #automation #email #webdev #productivity

Stop Writing Regex to Parse Social Media URLs (Build a Universal Parser)

Olamide Olaniyan — Wed, 15 Apr 2026 19:31:00 +0000

I've seen this in every codebase that deals with social media data:

// Please don't do this
if (url.includes('tiktok.com')) {
  const username = url.split('@')[1]?.split('/')[0]?.split('?')[0];
} else if (url.includes('instagram.com')) {
  const username = url.split('instagram.com/')[1]?.split('/')[0]?.split('?')[0];
}

Fragile. Breaks on edge cases. Doesn't handle mobile URLs, short links, embedded URLs, or the 15 different formats each platform uses.

I wrote a proper parser once and never had to touch URL parsing code again. Here it is.

The Problem

Social media URLs are chaos. For a single TikTok video, users might paste any of these:

https://www.tiktok.com/@username/video/7234567890
https://tiktok.com/@username/video/7234567890
https://vm.tiktok.com/ZMrKxYz/     (short link)
https://www.tiktok.com/t/ZMrKxYz/  (another short format)
tiktok.com/@username                (no protocol)
@username                           (just the handle)

For Instagram, you have:

https://www.instagram.com/username/
https://instagram.com/p/CxYz123/
https://www.instagram.com/reel/CxYz123/
https://www.instagram.com/stories/username/12345/
https://instagr.am/p/CxYz123/     (short domain)

A real parser needs to handle all of these without breaking.

The Parser

// social-url-parser.js

const PLATFORM_PATTERNS = {
  tiktok: {
    domains: ['tiktok.com', 'vm.tiktok.com'],
    patterns: [
      // Video: tiktok.com/@user/video/12345
      {
        regex: /tiktok\.com\/@([^/?#]+)\/video\/(\d+)/i,
        extract: (m) => ({ type: 'video', username: m[1], videoId: m[2] }),
      },
      // Profile: tiktok.com/@user
      {
        regex: /tiktok\.com\/@([^/?#]+)/i,
        extract: (m) => ({ type: 'profile', username: m[1] }),
      },
      // Short link: vm.tiktok.com/ZMrKxYz  or tiktok.com/t/ZMrKxYz
      {
        regex: /(?:vm\.tiktok\.com|tiktok\.com\/t)\/([A-Za-z0-9]+)/i,
        extract: (m) => ({ type: 'shortlink', shortCode: m[1] }),
      },
      // Music: tiktok.com/music/song-name-12345
      {
        regex: /tiktok\.com\/music\/([^/?#]+)-(\d+)/i,
        extract: (m) => ({ type: 'music', slug: m[1], musicId: m[2] }),
      },
      // Tag: tiktok.com/tag/hashtag
      {
        regex: /tiktok\.com\/tag\/([^/?#]+)/i,
        extract: (m) => ({ type: 'hashtag', tag: m[1] }),
      },
    ],
  },

  instagram: {
    domains: ['instagram.com', 'instagr.am'],
    patterns: [
      // Post: instagram.com/p/CODE
      {
        regex: /instagram\.com\/p\/([A-Za-z0-9_-]+)/i,
        extract: (m) => ({ type: 'post', shortcode: m[1] }),
      },
      // Reel: instagram.com/reel/CODE
      {
        regex: /instagram\.com\/reel\/([A-Za-z0-9_-]+)/i,
        extract: (m) => ({ type: 'reel', shortcode: m[1] }),
      },
      // Story: instagram.com/stories/username/12345
      {
        regex: /instagram\.com\/stories\/([^/?#]+)\/(\d+)/i,
        extract: (m) => ({ type: 'story', username: m[1], storyId: m[2] }),
      },
      // Profile: instagram.com/username (must come last — it's the catch-all)
      {
        regex: /instagram\.com\/([A-Za-z0-9_.]+)\/?(?:\?|#|$)/i,
        extract: (m) => {
          const reserved = ['p', 'reel', 'stories', 'explore', 'accounts', 'direct', 'reels'];
          if (reserved.includes(m[1].toLowerCase())) return null;
          return { type: 'profile', username: m[1] };
        },
      },
    ],
  },

  youtube: {
    domains: ['youtube.com', 'youtu.be', 'youtube.com'],
    patterns: [
      // Video: youtube.com/watch?v=ID or youtu.be/ID
      {
        regex: /(?:youtube\.com\/watch\?v=|youtu\.be\/)([A-Za-z0-9_-]{11})/i,
        extract: (m) => ({ type: 'video', videoId: m[1] }),
      },
      // Shorts: youtube.com/shorts/ID
      {
        regex: /youtube\.com\/shorts\/([A-Za-z0-9_-]{11})/i,
        extract: (m) => ({ type: 'short', videoId: m[1] }),
      },
      // Channel: youtube.com/@handle or /channel/ID
      {
        regex: /youtube\.com\/@([^/?#]+)/i,
        extract: (m) => ({ type: 'channel', handle: m[1] }),
      },
      {
        regex: /youtube\.com\/channel\/([A-Za-z0-9_-]+)/i,
        extract: (m) => ({ type: 'channel', channelId: m[1] }),
      },
    ],
  },

  twitter: {
    domains: ['twitter.com', 'x.com'],
    patterns: [
      // Tweet: twitter.com/user/status/12345
      {
        regex: /(?:twitter|x)\.com\/([^/?#]+)\/status\/(\d+)/i,
        extract: (m) => ({ type: 'tweet', username: m[1], tweetId: m[2] }),
      },
      // Profile: twitter.com/user
      {
        regex: /(?:twitter|x)\.com\/([A-Za-z0-9_]+)\/?(?:\?|#|$)/i,
        extract: (m) => {
          const reserved = ['home', 'explore', 'notifications', 'messages', 'settings', 'i', 'search'];
          if (reserved.includes(m[1].toLowerCase())) return null;
          return { type: 'profile', username: m[1] };
        },
      },
    ],
  },

  linkedin: {
    domains: ['linkedin.com'],
    patterns: [
      // Post: linkedin.com/posts/user_activity-id
      {
        regex: /linkedin\.com\/posts\/([^/?#]+)/i,
        extract: (m) => ({ type: 'post', slug: m[1] }),
      },
      // Profile: linkedin.com/in/username
      {
        regex: /linkedin\.com\/in\/([^/?#]+)/i,
        extract: (m) => ({ type: 'profile', username: m[1] }),
      },
      // Company: linkedin.com/company/name
      {
        regex: /linkedin\.com\/company\/([^/?#]+)/i,
        extract: (m) => ({ type: 'company', slug: m[1] }),
      },
    ],
  },
};

function parseHandle(input) {
  // Handle bare @username or username inputs
  const cleaned = input.trim().replace(/^@/, '');
  if (/^[A-Za-z0-9_.]+$/.test(cleaned) && cleaned.length <= 30) {
    return { platform: null, type: 'handle', username: cleaned };
  }
  return null;
}

function parseSocialUrl(input) {
  if (!input || typeof input !== 'string') return null;

  const trimmed = input.trim();

  // Try as bare handle first
  if (!trimmed.includes('/') && !trimmed.includes('.')) {
    return parseHandle(trimmed);
  }

  // Normalize: add protocol if missing
  let url = trimmed;
  if (!url.startsWith('http')) {
    url = 'https://' + url;
  }

  // Try each platform
  for (const [platform, config] of Object.entries(PLATFORM_PATTERNS)) {
    // Check if the URL matches any known domain
    const matchesDomain = config.domains.some(d => url.includes(d));
    if (!matchesDomain) continue;

    // Try each pattern for this platform
    for (const pattern of config.patterns) {
      const match = url.match(pattern.regex);
      if (match) {
        const extracted = pattern.extract(match);
        if (extracted) {
          return { platform, ...extracted, originalUrl: trimmed };
        }
      }
    }
  }

  return null; // Unrecognized
}

module.exports = { parseSocialUrl };

Usage

const { parseSocialUrl } = require('./social-url-parser');

// TikTok
parseSocialUrl('https://www.tiktok.com/@charlidamelio/video/7234567890');
// { platform: 'tiktok', type: 'video', username: 'charlidamelio', videoId: '7234567890' }

parseSocialUrl('https://vm.tiktok.com/ZMrKxYz/');
// { platform: 'tiktok', type: 'shortlink', shortCode: 'ZMrKxYz' }

parseSocialUrl('tiktok.com/@charlidamelio');
// { platform: 'tiktok', type: 'profile', username: 'charlidamelio' }

// Instagram
parseSocialUrl('https://instagram.com/p/CxYz123/');
// { platform: 'instagram', type: 'post', shortcode: 'CxYz123' }

parseSocialUrl('instagram.com/therock');
// { platform: 'instagram', type: 'profile', username: 'therock' }

// YouTube
parseSocialUrl('https://youtu.be/dQw4w9WgXcQ');
// { platform: 'youtube', type: 'video', videoId: 'dQw4w9WgXcQ' }

// Twitter/X — handles both domains
parseSocialUrl('https://x.com/elonmusk/status/1234567890');
// { platform: 'twitter', type: 'tweet', username: 'elonmusk', tweetId: '1234567890' }

// Bare handle
parseSocialUrl('@charlidamelio');
// { platform: null, type: 'handle', username: 'charlidamelio' }

Resolving Short Links

TikTok short links (vm.tiktok.com/xxx) redirect to the full URL. Here's how to resolve them:

const axios = require('axios');

async function resolveShortLink(shortUrl) {
  try {
    // Follow redirects and grab the final URL
    const response = await axios.get(shortUrl, {
      maxRedirects: 5,
      validateStatus: () => true,
      headers: { 'User-Agent': 'Mozilla/5.0' },
    });

    const finalUrl = response.request?.res?.responseUrl || response.headers?.location || shortUrl;
    return parseSocialUrl(finalUrl);
  } catch {
    return null;
  }
}

// Usage
const result = await resolveShortLink('https://vm.tiktok.com/ZMrKxYz/');
// Now you have the full username + video ID

Integrating with SociaVault API

Once you've parsed the URL, fetching the actual data is one API call:

const axios = require('axios');
const { parseSocialUrl } = require('./social-url-parser');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function getDataFromUrl(input) {
  const parsed = parseSocialUrl(input);
  if (!parsed) throw new Error('Unrecognized URL format');

  switch (`${parsed.platform}:${parsed.type}`) {
    case 'tiktok:profile':
      return api.get(`/tiktok/profile?username=${parsed.username}`);
    case 'tiktok:video':
      return api.get(`/tiktok/video-info?videoId=${parsed.videoId}`);
    case 'instagram:profile':
      return api.get(`/instagram/profile?username=${parsed.username}`);
    case 'instagram:post':
    case 'instagram:reel':
      return api.get(`/instagram/post-info?shortcode=${parsed.shortcode}`);
    default:
      throw new Error(`Unsupported: ${parsed.platform}:${parsed.type}`);
  }
}

// User pastes any URL → you get structured data
const data = await getDataFromUrl('https://www.tiktok.com/@charlidamelio');

Your users paste whatever garbage URL format they have. You parse it, identify the platform and content type, and fetch the right data. No more "please enter a valid URL" errors.

Testing

// test.js
const { parseSocialUrl } = require('./social-url-parser');

const testCases = [
  ['https://www.tiktok.com/@user/video/123', 'tiktok', 'video'],
  ['https://vm.tiktok.com/ZMrKxYz/', 'tiktok', 'shortlink'],
  ['tiktok.com/@user', 'tiktok', 'profile'],
  ['https://instagram.com/p/ABC123/', 'instagram', 'post'],
  ['https://www.instagram.com/reel/ABC123/', 'instagram', 'reel'],
  ['instagram.com/username', 'instagram', 'profile'],
  ['https://youtu.be/dQw4w9WgXcQ', 'youtube', 'video'],
  ['https://x.com/user/status/123', 'twitter', 'tweet'],
  ['@username', null, 'handle'],
];

let passed = 0;
for (const [input, expectedPlatform, expectedType] of testCases) {
  const result = parseSocialUrl(input);
  const ok = result?.platform === expectedPlatform && result?.type === expectedType;
  console.log(`${ok ? '✅' : '❌'} ${input} → ${result?.platform}:${result?.type}`);
  if (ok) passed++;
}

console.log(`\n${passed}/${testCases.length} passed`);

npm Package It

This is useful enough to be a standalone package. Throw it on npm:

npm init --scope=@yourname
# Add the parser as index.js
npm publish --access public

Now every project that deals with social URLs can npm install @yourname/social-url-parser instead of writing their own regex spaghetti.

Read the Full Guide

Universal Social Media URL Parser → SociaVault Blog

Parse social media URLs and fetch the data behind them with SociaVault — one API for TikTok, Instagram, YouTube, Twitter, LinkedIn, Reddit, and more.

Discussion

What's the worst URL parsing code you've seen in a codebase? I once found a 400-line switch statement that handled 3 platforms. Share your horror stories.

javascript #webdev #opensource #api #tutorial

Turn Any TikTok Video into a Blog Post (Automated Content Repurposing)

Olamide Olaniyan — Tue, 14 Apr 2026 19:30:00 +0000

You spent 2 hours making a TikTok video. It did well. 50K views, solid comments.

Now that same insight is trapped in a 60-second video that the algorithm'll bury in 48 hours.

What if you could turn every TikTok into a blog post automatically? Same message, different format, different audience, permanent SEO value.

That's what we're building.

The Pipeline

TikTok Video URL
  → Extract transcript (SociaVault API)
  → Extract video metadata (title, stats, hashtags)
  → Feed to GPT-4 with a structured prompt
  → Get back a formatted blog post
  → Save as Markdown

One command. Video URL in, blog post out.

The Stack

Node.js – runtime
SociaVault API – extract TikTok transcripts and video metadata
OpenAI API – transform transcript into structured blog content
Markdown – output format (works with any CMS)

Setup

mkdir tiktok-to-blog && cd tiktok-to-blog
npm init -y
npm install axios dotenv slugify

# .env
SOCIAVAULT_API_KEY=your_key
OPENAI_API_KEY=your_openai_key
OUTPUT_DIR=./posts

Step 1: Extract the Transcript

TikTok videos have auto-generated captions. SociaVault can pull them:

// extract.js
const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function extractTikTokData(videoUrl) {
  // Get video info (title, stats, hashtags)
  const { data: videoInfo } = await api.get(`/tiktok/video-info?url=${encodeURIComponent(videoUrl)}`);
  const video = videoInfo.data || videoInfo;

  // Get transcript
  let transcript = '';
  try {
    const { data: transcriptData } = await api.get(`/tiktok/transcript?url=${encodeURIComponent(videoUrl)}`);
    const segments = transcriptData.data || transcriptData.segments || [];

    // Combine segments into readable text
    transcript = segments
      .map(s => s.text)
      .join(' ')
      .replace(/\s+/g, ' ')
      .trim();
  } catch (err) {
    console.warn('No transcript available — video may not have captions');
  }

  return {
    title: video.desc || video.title || '',
    transcript,
    author: video.author?.uniqueId || video.author?.nickname || 'unknown',
    likes: video.diggCount || video.likesCount || 0,
    views: video.playCount || video.viewCount || 0,
    comments: video.commentCount || video.commentsCount || 0,
    shares: video.shareCount || 0,
    hashtags: (video.challenges || []).map(c => c.title),
    url: videoUrl,
    coverUrl: video.coverUrl || video.cover || '',
    duration: video.duration || 0,
  };
}

module.exports = { extractTikTokData };

Step 2: The Prompt Engineering

This is where quality comes from. A bad prompt gives you generic AI slop. A good prompt produces something that reads like a person wrote it.

// transform.js
const axios = require('axios');

async function transformToPost(videoData) {
  const prompt = `You are a content writer converting a TikTok video into a blog post. 

Here's the source material:

VIDEO TITLE/CAPTION: ${videoData.title}
TRANSCRIPT: ${videoData.transcript || '(no transcript available — use the title and hashtags to infer the topic)'}
HASHTAGS: ${videoData.hashtags.join(', ') || 'none'}
ENGAGEMENT: ${videoData.views.toLocaleString()} views, ${videoData.likes.toLocaleString()} likes, ${videoData.comments.toLocaleString()} comments

RULES:
1. Write a 600-900 word blog post based on the video content
2. Use a conversational, direct tone — like you're explaining to a friend
3. Start with a hook that grabs attention (not "In this article..." or "Today we're going to...")
4. Break it into clear sections with H2 headers
5. Add practical takeaways or action items
6. Include specific numbers or examples where the transcript mentions them
7. End with a brief conclusion or call-to-action
8. Do NOT mention that this was originally a TikTok video
9. Do NOT start with "Have you ever..." 
10. Output as Markdown

FORMAT:
---
title: "[SEO-friendly title, 50-60 characters]"
description: "[Meta description, 150-160 characters]"
tags: [3-5 relevant tags as comma-separated list]
---

[Blog post content in Markdown]`;

  const { data } = await axios.post(
    'https://api.openai.com/v1/chat/completions',
    {
      model: 'gpt-4o',
      messages: [
        { role: 'system', content: 'You are an expert content writer who turns video transcripts into engaging blog posts.' },
        { role: 'user', content: prompt },
      ],
      max_tokens: 2000,
      temperature: 0.7,
    },
    { headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` } }
  );

  return data.choices[0].message.content;
}

module.exports = { transformToPost };

Step 3: Save as Markdown

// save.js
const fs = require('fs');
const path = require('path');
const slugify = require('slugify');

function savePost(markdownContent, videoData, outputDir) {
  // Extract title from frontmatter
  const titleMatch = markdownContent.match(/title:\s*(.+)/);
  const title = titleMatch ? titleMatch[1].trim().replace(/['"]/g, '') : 'untitled';

  const slug = slugify(title, { lower: true, strict: true });
  const filename = `${slug}.md`;
  const filepath = path.join(outputDir, filename);

  // Append source attribution at the bottom
  const attribution = `\n\n---\n\n*Originally inspired by content from [@${videoData.author}](${videoData.url}). ${videoData.views.toLocaleString()} views on TikTok.*\n`;

  const fullContent = markdownContent + attribution;

  // Create output directory if it doesn't exist
  fs.mkdirSync(outputDir, { recursive: true });
  fs.writeFileSync(filepath, fullContent, 'utf-8');

  return { filepath, slug, title };
}

module.exports = { savePost };

Step 4: Wire It All Together

// index.js
require('dotenv').config();
const { extractTikTokData } = require('./extract');
const { transformToPost } = require('./transform');
const { savePost } = require('./save');

async function convert(videoUrl) {
  console.log('Extracting video data...');
  const videoData = await extractTikTokData(videoUrl);

  if (!videoData.transcript && !videoData.title) {
    console.error('No transcript or title found. Cannot convert.');
    process.exit(1);
  }

  console.log(`Video: "${videoData.title.slice(0, 60)}..."`);
  console.log(`Transcript: ${videoData.transcript ? videoData.transcript.length + ' chars' : 'none (using title + hashtags)'}`);
  console.log(`Stats: ${videoData.views.toLocaleString()} views, ${videoData.likes.toLocaleString()} likes`);
  console.log('\nGenerating blog post...');

  const markdown = await transformToPost(videoData);

  const outputDir = process.env.OUTPUT_DIR || './posts';
  const result = savePost(markdown, videoData, outputDir);

  console.log(`\n✅ Blog post saved to: ${result.filepath}`);
  console.log(`   Title: ${result.title}`);
  console.log(`   Slug: ${result.slug}`);
}

const url = process.argv[2];
if (!url) {
  console.error('Usage: node index.js <tiktok-video-url>');
  process.exit(1);
}

convert(url);

Usage

node index.js "https://www.tiktok.com/@creator/video/7234567890"

Output:

Extracting video data...
Video: "3 things I wish I knew before starting a SaaS..."
Transcript: 847 chars
Stats: 52,000 views, 4,200 likes

Generating blog post...

✅ Blog post saved to: ./posts/3-things-i-wish-i-knew-before-starting-a-saas.md
   Title: 3 Things I Wish I Knew Before Starting a SaaS
   Slug: 3-things-i-wish-i-knew-before-starting-a-saas

Batch Mode

Got a whole channel of TikToks? Convert them all:

// batch.js
require('dotenv').config();
const axios = require('axios');
const { extractTikTokData } = require('./extract');
const { transformToPost } = require('./transform');
const { savePost } = require('./save');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function batchConvert(username, count = 10) {
  // Fetch recent videos
  const { data } = await api.get(`/tiktok/profile-videos?username=${username}&limit=${count}`);
  const videos = data.data || data.posts || [];

  console.log(`Found ${videos.length} videos from @${username}\n`);

  for (let i = 0; i < videos.length; i++) {
    const video = videos[i];
    const url = video.webVideoUrl || `https://www.tiktok.com/@${username}/video/${video.id}`;

    console.log(`[${i + 1}/${videos.length}] Converting: ${(video.desc || '').slice(0, 50)}...`);

    try {
      const videoData = await extractTikTokData(url);
      const markdown = await transformToPost(videoData);
      const result = savePost(markdown, videoData, process.env.OUTPUT_DIR || './posts');
      console.log(`  ✅ Saved: ${result.filepath}`);
    } catch (err) {
      console.error(`  ❌ Failed: ${err.message}`);
    }

    // Rate limit: one conversion every 5 seconds
    await new Promise(r => setTimeout(r, 5000));
  }

  console.log('\nBatch conversion complete.');
}

const username = process.argv[2];
const count = parseInt(process.argv[3]) || 10;

if (!username) {
  console.error('Usage: node batch.js <username> [count]');
  process.exit(1);
}

batchConvert(username, count);

# Convert last 20 TikToks from a creator
node batch.js creator_username 20

That gives you 20 blog posts in about 2 minutes. Each one is unique, SEO-ready, and based on content that already proved it resonates (the video performed well for a reason).

Quality Control

The output isn't publish-ready — it's a solid first draft. You should:

Read it once — fix any weird AI phrasing (5 minutes per post)
Add internal links — to your other content
Add images — screenshot from the video or relevant stock photos
Check the title — make sure it's click-worthy and SEO-friendly

A 60-second TikTok becomes a 700-word blog post in under a minute of compute time and 5 minutes of editing. That's 10x more efficient than writing from scratch.

The ROI

One TikTok video = 48 hours of algorithmic reach.

One blog post = years of organic search traffic.

Same insight, two formats, completely different lifespan.

Read the Full Guide

TikTok to Blog Post Automation → SociaVault Blog

Extract transcripts, metadata, and analytics from TikTok videos with SociaVault — one API for TikTok, Instagram, YouTube, and more. No login required.

Discussion

Are you repurposing your video content into other formats? What's your workflow? I find that the video → text pipeline is the most underutilized content strategy.

javascript #contentcreation #automation #webdev #ai

Build a Social Media Event Bus: React to Posts, Comments, and Follows in Real-Time

Olamide Olaniyan — Mon, 13 Apr 2026 19:29:00 +0000

Social media platforms don't give you webhooks. Instagram won't ping your server when someone comments. TikTok won't notify you when a creator posts.

So you build your own.

I built an event bus that polls social media APIs and converts changes into events. New post? Event. New comment? Event. Follower count changed by more than 5%? Event. Then any downstream system can subscribe — Discord bots, email senders, dashboards, CRMs.

It turned 10 separate "check social media" scripts into one system.

Architecture

Poller (cron jobs)
  │
  ├── Check profiles every 30 minutes
  ├── Check posts every 15 minutes
  ├── Check comments every hour
  │
  ↓ Detect changes (diff against last known state)
  │
Event Bus (in-process EventEmitter or Redis Pub/Sub)
  │
  ├── → Discord notifier
  ├── → Email sender
  ├── → Database logger
  ├── → Slack alerter
  └── → Webhook forwarder (POST to any URL)

The pollers detect changes. The event bus routes them. The handlers do whatever you want. Completely decoupled.

The Stack

Node.js – runtime
SociaVault API – data source
EventEmitter (built-in) – event bus for single-process; Redis Pub/Sub for multi-process
better-sqlite3 – state tracking
node-cron – polling schedule

Setup

mkdir social-event-bus && cd social-event-bus
npm init -y
npm install axios better-sqlite3 node-cron dotenv

Step 1: The State Store

To detect changes, you need to know what things looked like last time you checked.

// state.js
const Database = require('better-sqlite3');
const db = new Database('./state.db');

db.exec(`
  CREATE TABLE IF NOT EXISTS known_state (
    key TEXT PRIMARY KEY,
    value TEXT NOT NULL,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );
`);

const getState = db.prepare('SELECT value FROM known_state WHERE key = ?');
const setState = db.prepare(`
  INSERT INTO known_state (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)
  ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP
`);

module.exports = {
  get: (key) => {
    const row = getState.get(key);
    return row ? JSON.parse(row.value) : null;
  },
  set: (key, value) => {
    setState.run(key, JSON.stringify(value));
  },
};

Step 2: The Event Bus

// bus.js
const { EventEmitter } = require('events');

class SocialEventBus extends EventEmitter {
  emit(eventType, payload) {
    const event = {
      type: eventType,
      timestamp: new Date().toISOString(),
      ...payload,
    };

    // Log every event
    console.log(`[EVENT] ${eventType} — ${payload.platform}/@${payload.username || 'unknown'}`);

    // Emit both the specific event and a wildcard
    super.emit(eventType, event);
    super.emit('*', event);

    return true;
  }
}

// Singleton
const bus = new SocialEventBus();
module.exports = bus;

Event types we'll generate:

Event	Trigger
`new_post`	Creator published a new post/video
`post_milestone`	A post crossed a view/like threshold
`follower_change`	Follower count changed significantly (±5%)
`new_comment`	New comment on a tracked post
`engagement_spike`	Post engagement rate is 3x+ above creator's average
`profile_updated`	Bio, name, or profile pic changed

Step 3: The Pollers

Each poller fetches current data, diffs against stored state, and emits events for any changes.

// pollers/profile-poller.js
const axios = require('axios');
const state = require('../state');
const bus = require('../bus');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function pollProfile(platform, username) {
  const endpoint = platform === 'instagram'
    ? `/instagram/profile?username=${username}`
    : `/tiktok/profile?username=${username}`;

  try {
    const { data: res } = await api.get(endpoint);
    const profile = res.data || res;

    const key = `profile:${platform}:${username}`;
    const previous = state.get(key);

    const current = {
      followers: profile.followersCount || profile.followerCount || 0,
      following: profile.followingCount || 0,
      posts: profile.postsCount || profile.videoCount || 0,
      bio: profile.bio || profile.signature || '',
      displayName: profile.fullName || profile.nickname || '',
    };

    if (previous) {
      // Check for follower changes (±5% or ±1000)
      const followerDelta = current.followers - previous.followers;
      const followerPercent = previous.followers > 0
        ? Math.abs(followerDelta / previous.followers) * 100
        : 0;

      if (followerPercent >= 5 || Math.abs(followerDelta) >= 1000) {
        bus.emit('follower_change', {
          platform,
          username,
          previous: previous.followers,
          current: current.followers,
          delta: followerDelta,
          percentChange: parseFloat(followerPercent.toFixed(1)),
        });
      }

      // Check for new posts
      if (current.posts > previous.posts) {
        bus.emit('new_post', {
          platform,
          username,
          previousCount: previous.posts,
          currentCount: current.posts,
          newPosts: current.posts - previous.posts,
        });
      }

      // Check for bio changes
      if (current.bio !== previous.bio) {
        bus.emit('profile_updated', {
          platform,
          username,
          field: 'bio',
          old: previous.bio,
          new: current.bio,
        });
      }
    }

    state.set(key, current);
  } catch (err) {
    console.error(`Poll failed for ${platform}/@${username}: ${err.message}`);
  }
}

module.exports = { pollProfile };

// pollers/post-poller.js
const axios = require('axios');
const state = require('../state');
const bus = require('../bus');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function pollPosts(platform, username) {
  const endpoint = platform === 'instagram'
    ? `/instagram/posts?username=${username}&limit=5`
    : `/tiktok/profile-videos?username=${username}&limit=5`;

  try {
    const { data: res } = await api.get(endpoint);
    const posts = res.data || res.posts || [];

    for (const post of posts) {
      const postId = post.id || post.shortcode || post.videoId;
      if (!postId) continue;

      const key = `post:${platform}:${postId}`;
      const previous = state.get(key);

      const current = {
        likes: post.likesCount || post.diggCount || 0,
        comments: post.commentsCount || post.commentCount || 0,
        views: post.viewCount || post.playCount || null,
        shares: post.shareCount || null,
      };

      if (previous) {
        // Check for engagement spike
        const likeGrowth = previous.likes > 0
          ? current.likes / previous.likes
          : 0;

        if (likeGrowth >= 3) {
          bus.emit('engagement_spike', {
            platform,
            username,
            postId,
            metric: 'likes',
            previous: previous.likes,
            current: current.likes,
            multiplier: parseFloat(likeGrowth.toFixed(1)),
          });
        }

        // Check for view milestones (10K, 100K, 1M)
        const milestones = [10000, 100000, 1000000, 10000000];
        if (current.views) {
          for (const milestone of milestones) {
            if (previous.views < milestone && current.views >= milestone) {
              bus.emit('post_milestone', {
                platform,
                username,
                postId,
                milestone,
                currentViews: current.views,
              });
            }
          }
        }
      }

      state.set(key, current);
    }
  } catch (err) {
    console.error(`Post poll failed for ${platform}/@${username}: ${err.message}`);
  }
}

module.exports = { pollPosts };

Step 4: The Handlers

This is where you plug in whatever actions you want:

// handlers/discord.js
const axios = require('axios');
const bus = require('../bus');

const DISCORD_WEBHOOK = process.env.DISCORD_WEBHOOK_URL;

bus.on('new_post', async (event) => {
  if (!DISCORD_WEBHOOK) return;

  await axios.post(DISCORD_WEBHOOK, {
    content: `🆕 **@${event.username}** posted ${event.newPosts} new ${event.newPosts === 1 ? 'post' : 'posts'} on ${event.platform}!`,
  });
});

bus.on('engagement_spike', async (event) => {
  if (!DISCORD_WEBHOOK) return;

  await axios.post(DISCORD_WEBHOOK, {
    content: `🔥 **Engagement spike!** @${event.username}'s post is getting ${event.multiplier}x normal likes on ${event.platform}`,
  });
});

bus.on('follower_change', async (event) => {
  if (!DISCORD_WEBHOOK) return;

  const direction = event.delta > 0 ? '📈' : '📉';
  const sign = event.delta > 0 ? '+' : '';
  await axios.post(DISCORD_WEBHOOK, {
    content: `${direction} **@${event.username}** ${sign}${event.delta.toLocaleString()} followers (${event.percentChange}%) on ${event.platform}`,
  });
});

// handlers/webhook-forwarder.js
const axios = require('axios');
const bus = require('../bus');

// Forward all events to an external URL (your own API, Zapier, n8n, etc.)
const WEBHOOK_URL = process.env.FORWARD_WEBHOOK_URL;

bus.on('*', async (event) => {
  if (!WEBHOOK_URL) return;

  try {
    await axios.post(WEBHOOK_URL, event, {
      headers: { 'Content-Type': 'application/json' },
      timeout: 5000,
    });
  } catch (err) {
    console.error(`Webhook forward failed: ${err.message}`);
  }
});

Step 5: Main Entry Point

// index.js
require('dotenv').config();
const cron = require('node-cron');
const { pollProfile } = require('./pollers/profile-poller');
const { pollPosts } = require('./pollers/post-poller');

// Load handlers (they self-register on the bus)
require('./handlers/discord');
require('./handlers/webhook-forwarder');

// Accounts to monitor
const WATCHED = [
  { platform: 'instagram', username: 'competitor_1' },
  { platform: 'instagram', username: 'competitor_2' },
  { platform: 'tiktok', username: 'competitor_3' },
  { platform: 'tiktok', username: 'your_own_account' },
];

async function runProfilePolls() {
  console.log(`[${new Date().toISOString()}] Polling profiles...`);
  for (const account of WATCHED) {
    await pollProfile(account.platform, account.username);
    await new Promise(r => setTimeout(r, 500));
  }
}

async function runPostPolls() {
  console.log(`[${new Date().toISOString()}] Polling posts...`);
  for (const account of WATCHED) {
    await pollPosts(account.platform, account.username);
    await new Promise(r => setTimeout(r, 500));
  }
}

// Initial run
runProfilePolls();
runPostPolls();

// Schedule
cron.schedule('*/30 * * * *', runProfilePolls);  // Profiles every 30 min
cron.schedule('*/15 * * * *', runPostPolls);      // Posts every 15 min

console.log(`Social event bus started. Watching ${WATCHED.length} accounts.`);
console.log('Profile polls: every 30 minutes');
console.log('Post polls: every 15 minutes');

Why This Pattern?

Because polling scripts always start simple and end up as spaghetti. You start with one script that checks competitors and sends a Discord message. Then your boss wants Slack too. Then email. Then someone wants to log it to a spreadsheet. Then you need to check comments too, not just posts.

The event bus pattern means:

Adding a new data source = write one poller function
Adding a new action = write one handler function
They don't know about each other — the poller doesn't care if Discord or Slack or email is listening

I've run this pattern for 6 months. Added 4 handlers and 2 pollers without touching existing code once.

Scaling Up

When you outgrow a single Node.js process:

Replace EventEmitter with Redis Pub/Sub — pollers publish, handlers subscribe, can run on different machines
Move pollers to separate workers — one per platform
Add a dead letter queue for failed handler deliveries
Add a simple web UI to see recent events (Express + SSE)

But honestly, a single Node process on a $5 VPS handles 50+ accounts with room to spare.

Read the Full Guide

Build a Social Media Event Bus → SociaVault Blog

Turn social media data into real-time events with SociaVault — one API for TikTok, Instagram, YouTube, and 10+ platforms. Profiles, posts, comments, followers — all endpoints, one key.

Discussion

What's your approach to "real-time" social media monitoring when the platforms don't offer webhooks? Poll and diff like this, or a different strategy entirely?

javascript #nodejs #architecture #webdev #api

Build a Slack Bot That Monitors Social Media Mentions in Real-Time

Olamide Olaniyan — Fri, 10 Apr 2026 11:27:00 +0000

Every brand has the same problem: someone mentions you on TikTok, tags you in an Instagram comment, or drops your name in a Reddit thread — and you find out 3 days later.

By then the viral complaint already has 50K views and your PR team is scrambling.

I fixed this with a Slack bot that monitors social mentions across platforms and drops them into the right channel within minutes. Here's how to build it yourself.

What We're Building

A lightweight service that:

Searches for your brand name (and common misspellings) across TikTok, Instagram, Twitter, and Reddit
Classifies mentions as positive, negative, or neutral
Routes them to the right Slack channel (#praise for positive, #urgent for negative)
Runs every 15 minutes on a cron job

No Slack app store submission required. We're using incoming webhooks — the simplest approach.

The Stack

Node.js – runtime
SociaVault API – search across platforms
Slack Incoming Webhooks – send formatted messages
OpenAI API (optional) – sentiment classification
node-cron – scheduling

Setup

mkdir social-monitor && cd social-monitor
npm init -y
npm install axios node-cron dotenv

# .env
SOCIAVAULT_API_KEY=your_key
SLACK_WEBHOOK_GENERAL=https://hooks.slack.com/services/xxx/yyy/zzz
SLACK_WEBHOOK_URGENT=https://hooks.slack.com/services/xxx/yyy/aaa
OPENAI_API_KEY=your_openai_key  # optional, for sentiment

Setting Up Slack Webhooks

Go to api.slack.com/apps → Create New App
Incoming Webhooks → Activate
Add New Webhook → Pick channel → Copy URL
Repeat for each channel you want to route to

Step 1: Search for Mentions

// search.js
const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

// Your brand terms — include common misspellings and variations
const BRAND_TERMS = [
  'yourbrand',
  'your_brand',
  'your brand',
  '@yourbrand',
];

async function searchTikTok(query) {
  try {
    const { data } = await api.get(`/tiktok/search?query=${encodeURIComponent(query)}&limit=10`);
    return (data.data || []).map(item => ({
      platform: 'TikTok',
      text: item.desc || item.title || '',
      author: item.author?.uniqueId || 'unknown',
      url: item.webVideoUrl || '',
      likes: item.diggCount || 0,
      timestamp: item.createTime ? new Date(item.createTime * 1000) : new Date(),
    }));
  } catch (err) {
    console.error(`TikTok search failed: ${err.message}`);
    return [];
  }
}

async function searchAllPlatforms() {
  const allMentions = [];

  for (const term of BRAND_TERMS) {
    const results = await searchTikTok(term);
    allMentions.push(...results);

    // Add a delay between searches
    await new Promise(r => setTimeout(r, 500));
  }

  // Deduplicate by URL
  const seen = new Set();
  return allMentions.filter(m => {
    if (seen.has(m.url)) return false;
    seen.add(m.url);
    return true;
  });
}

module.exports = { searchAllPlatforms };

Step 2: Classify Sentiment (Optional but Powerful)

You can do this with simple keyword matching or with OpenAI. Here's both:

// sentiment.js
const axios = require('axios');

// Option A: Simple keyword matching (free, no API needed)
const NEGATIVE_WORDS = ['scam', 'trash', 'worst', 'terrible', 'broken', 'hate', 'avoid', 'refund', 'lawsuit', 'fake'];
const POSITIVE_WORDS = ['love', 'amazing', 'best', 'incredible', 'recommend', 'awesome', 'great', 'perfect'];

function classifySimple(text) {
  const lower = text.toLowerCase();
  const negScore = NEGATIVE_WORDS.filter(w => lower.includes(w)).length;
  const posScore = POSITIVE_WORDS.filter(w => lower.includes(w)).length;

  if (negScore > posScore) return 'negative';
  if (posScore > negScore) return 'positive';
  return 'neutral';
}

// Option B: OpenAI (more accurate, costs ~$0.001 per classification)
async function classifyWithAI(text) {
  if (!process.env.OPENAI_API_KEY) return classifySimple(text);

  try {
    const { data } = await axios.post(
      'https://api.openai.com/v1/chat/completions',
      {
        model: 'gpt-4o-mini',
        messages: [
          {
            role: 'system',
            content: 'Classify the sentiment of this social media post about a brand. Respond with exactly one word: positive, negative, or neutral.',
          },
          { role: 'user', content: text.slice(0, 500) },
        ],
        max_tokens: 10,
      },
      { headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` } }
    );

    const result = data.choices[0].message.content.trim().toLowerCase();
    return ['positive', 'negative', 'neutral'].includes(result) ? result : 'neutral';
  } catch {
    return classifySimple(text);
  }
}

module.exports = { classify: classifyWithAI };

Step 3: Send to Slack

// slack.js
const axios = require('axios');

const WEBHOOKS = {
  general: process.env.SLACK_WEBHOOK_GENERAL,
  urgent: process.env.SLACK_WEBHOOK_URGENT,
};

function getEmoji(sentiment) {
  if (sentiment === 'positive') return '💚';
  if (sentiment === 'negative') return '🔴';
  return '⚪';
}

async function sendToSlack(mention, sentiment) {
  const webhook = sentiment === 'negative' ? WEBHOOKS.urgent : WEBHOOKS.general;

  const payload = {
    blocks: [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `${getEmoji(sentiment)} *New ${mention.platform} mention* (${sentiment})\n\n>${mention.text.slice(0, 280)}`,
        },
      },
      {
        type: 'context',
        elements: [
          {
            type: 'mrkdwn',
            text: `👤 *${mention.author}* • ❤️ ${mention.likes.toLocaleString()} likes • <${mention.url}|View Post>`,
          },
        ],
      },
    ],
  };

  try {
    await axios.post(webhook, payload);
  } catch (err) {
    console.error(`Slack send failed: ${err.message}`);
  }
}

module.exports = { sendToSlack };

Step 4: The Main Loop

// index.js
require('dotenv').config();
const cron = require('node-cron');
const { searchAllPlatforms } = require('./search');
const { classify } = require('./sentiment');
const { sendToSlack } = require('./slack');

// Track what we've already sent (in-memory, resets on restart)
// For production, use SQLite like in the Discord bot article
const sentMentions = new Set();

async function monitor() {
  console.log(`[${new Date().toISOString()}] Scanning for mentions...`);

  const mentions = await searchAllPlatforms();
  let newCount = 0;

  for (const mention of mentions) {
    // Skip if we've already sent this one
    if (sentMentions.has(mention.url)) continue;

    const sentiment = await classify(mention.text);
    await sendToSlack(mention, sentiment);
    sentMentions.add(mention.url);
    newCount++;

    // Small delay between Slack messages to avoid rate limits
    await new Promise(r => setTimeout(r, 300));
  }

  console.log(`Found ${mentions.length} mentions, ${newCount} new`);
}

// Run immediately, then every 15 minutes
monitor();
cron.schedule('*/15 * * * *', monitor);

console.log('Social mention monitor started. Checking every 15 minutes.');

The Result

Your Slack now looks like this:

#social-mentions
💚 New TikTok mention (positive)
> "just discovered @yourbrand and honestly this is incredible, been looking for this for months"
👤 sarah_creates • ❤️ 12,400 likes • View Post

⚪ New TikTok mention (neutral)
> "comparing @yourbrand vs competitor for my workflow, will report back"
👤 tech_reviewer • ❤️ 890 likes • View Post

#social-urgent
🔴 New TikTok mention (negative)
> "@yourbrand charged me twice and support won't respond, this is basically a scam at this point"
👤 angry_customer_42 • ❤️ 5,200 likes • View Post ← your team sees this FAST

The negative mention routes to #social-urgent where someone can respond before it snowballs.

Cost

4 search queries × 96 runs/day = 384 credits/day (~11,500/month)
With deduplication, actual unique queries are lower
Fits SociaVault growth plan

Compare that to Brandwatch ($800/month) or Mention ($83/month) doing the same thing.

Read the Full Guide

Build a Slack Social Monitoring Bot → SociaVault Blog

Monitor social media mentions programmatically with SociaVault — one API for TikTok, Instagram, YouTube, Twitter, Reddit, and more.

Discussion

What's your current social monitoring setup? Are you still checking manually, using an expensive tool, or have you built something custom?

javascript #slack #automation #webdev #api

Ship a Micro-SaaS in a Weekend: Influencer Vetting Tool (Full Stack)

Olamide Olaniyan — Thu, 09 Apr 2026 09:26:00 +0000

I keep seeing "build a SaaS in a weekend" posts that end with a login page and a Stripe checkout. Cool. What about the actual product?

Here's a real one. An influencer vetting tool that agencies and brands actually pay for. The whole thing — frontend, backend, Stripe, the works — in under 400 lines of meaningful code.

The Product

A simple tool: paste a creator's Instagram or TikTok handle, get a one-page report that tells you if this creator is worth partnering with.

The report shows:

Real engagement rate (calculated from actual posts, not estimated)
Audience quality signals (fake follower indicators)
Posting consistency
Growth trajectory
A simple Go / Caution / Avoid recommendation

Free tier: 3 reports/month. Paid: $19/month for unlimited.

Why This Makes Money

Agencies vet 50-100 creators per campaign. They currently do it manually — checking profiles, calculating engagement rates in spreadsheets, gut-feeling whether followers look real.

Charge $19/month. Get 100 agencies. That's $1,900/month from a weekend project.

The Stack

Next.js 14 (App Router) – frontend + API routes
SociaVault API – all the social data
Stripe – payments
Clerk – auth (or roll your own, but why)
Vercel – deploy

Project Structure

influencer-vetter/
├── app/
│   ├── page.tsx              # Landing + search
│   ├── report/[handle]/page.tsx  # The report page
│   ├── api/
│   │   ├── vet/route.ts         # Generate report
│   │   └── webhook/route.ts     # Stripe webhook
│   └── layout.tsx
├── lib/
│   ├── scoring.ts            # The scoring engine
│   ├── stripe.ts             # Stripe helpers
│   └── rate-limit.ts         # Usage tracking
└── package.json

The Scoring Engine

This is the brain. Everything else is plumbing.

// lib/scoring.ts

interface CreatorReport {
  handle: string;
  platform: string;
  followers: number;
  engagementRate: number;
  avgLikes: number;
  avgComments: number;
  likeCommentRatio: number;
  postingFrequency: number; // posts per week
  consistencyScore: number; // 0-100
  authenticityScore: number; // 0-100
  overallScore: number; // 0-100
  verdict: 'go' | 'caution' | 'avoid';
  flags: string[];
}

export function analyzeCreator(profile: any, posts: any[]): CreatorReport {
  const followers = profile.followersCount || profile.followerCount || 0;
  const flags: string[] = [];

  // --- Engagement Rate ---
  const totalLikes = posts.reduce((s, p) => s + (p.likesCount || p.diggCount || 0), 0);
  const totalComments = posts.reduce((s, p) => s + (p.commentsCount || p.commentCount || 0), 0);
  const avgLikes = posts.length > 0 ? totalLikes / posts.length : 0;
  const avgComments = posts.length > 0 ? totalComments / posts.length : 0;
  const engagementRate = followers > 0 ? ((avgLikes + avgComments) / followers) * 100 : 0;

  // --- Like-to-Comment Ratio ---
  // Healthy: 10:1 to 50:1. Above 100:1 = likely bought likes
  const likeCommentRatio = avgComments > 0 ? avgLikes / avgComments : 0;
  if (likeCommentRatio > 100) flags.push('Suspiciously high like-to-comment ratio');
  if (likeCommentRatio > 200) flags.push('Likely purchased likes or bot engagement');

  // --- Posting Frequency ---
  const timestamps = posts
    .map(p => new Date(p.timestamp || p.createTime * 1000).getTime())
    .filter(t => !isNaN(t))
    .sort((a, b) => b - a);

  let postsPerWeek = 0;
  if (timestamps.length >= 2) {
    const spanDays = (timestamps[0] - timestamps[timestamps.length - 1]) / 86400000;
    postsPerWeek = spanDays > 0 ? (posts.length / spanDays) * 7 : 0;
  }

  // --- Consistency Score ---
  // Measures how regular their posting cadence is
  let consistencyScore = 50;
  if (timestamps.length >= 3) {
    const gaps = [];
    for (let i = 0; i < timestamps.length - 1; i++) {
      gaps.push(timestamps[i] - timestamps[i + 1]);
    }
    const avgGap = gaps.reduce((s, g) => s + g, 0) / gaps.length;
    const variance = gaps.reduce((s, g) => s + Math.pow(g - avgGap, 2), 0) / gaps.length;
    const stdDev = Math.sqrt(variance);
    const cv = avgGap > 0 ? stdDev / avgGap : 1; // Coefficient of variation

    // Lower CV = more consistent. CV of 0.3 = very consistent, 1.0+ = chaotic
    consistencyScore = Math.max(0, Math.min(100, Math.round((1 - Math.min(cv, 1)) * 100)));
  }

  if (postsPerWeek < 1) flags.push('Posts less than once per week');
  if (consistencyScore < 30) flags.push('Very inconsistent posting schedule');

  // --- Authenticity Score ---
  let authenticityScore = 100;

  // Follower/following ratio
  const following = profile.followingCount || 0;
  const ffRatio = following > 0 ? followers / following : followers;
  if (ffRatio < 1 && followers > 1000) {
    authenticityScore -= 20;
    flags.push('Following more people than followers (follow-for-follow pattern)');
  }

  // Engagement vs follower count sanity check
  if (followers > 100000 && engagementRate < 0.5) {
    authenticityScore -= 25;
    flags.push('Very low engagement for follower count — possible ghost followers');
  }

  // Like-comment ratio penalty
  if (likeCommentRatio > 100) authenticityScore -= 15;
  if (likeCommentRatio > 200) authenticityScore -= 20;

  authenticityScore = Math.max(0, authenticityScore);

  // --- Overall Score ---
  // Weighted: engagement quality matters most
  const overallScore = Math.round(
    authenticityScore * 0.4 +
    consistencyScore * 0.2 +
    Math.min(engagementRate * 10, 100) * 0.3 + // Cap at 10% ER = 100 points
    Math.min(postsPerWeek * 15, 100) * 0.1      // Cap at ~7 posts/week = 100 points
  );

  // --- Verdict ---
  let verdict: 'go' | 'caution' | 'avoid';
  if (overallScore >= 70 && flags.length <= 1) verdict = 'go';
  else if (overallScore >= 40 || flags.length <= 2) verdict = 'caution';
  else verdict = 'avoid';

  return {
    handle: profile.username || profile.uniqueId,
    platform: profile.platform || 'unknown',
    followers,
    engagementRate: parseFloat(engagementRate.toFixed(2)),
    avgLikes: Math.round(avgLikes),
    avgComments: Math.round(avgComments),
    likeCommentRatio: parseFloat(likeCommentRatio.toFixed(1)),
    postingFrequency: parseFloat(postsPerWeek.toFixed(1)),
    consistencyScore,
    authenticityScore,
    overallScore,
    verdict,
    flags,
  };
}

That's the entire scoring engine. ~100 lines. No AI, no machine learning. Just math that makes sense.

The API Route

// app/api/vet/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { analyzeCreator } from '@/lib/scoring';

const SOCIAVAULT_API = 'https://api.sociavault.com/v1/scrape';
const API_KEY = process.env.SOCIAVAULT_API_KEY!;

async function fetchFromSociaVault(endpoint: string) {
  const res = await fetch(`${SOCIAVAULT_API}${endpoint}`, {
    headers: { 'x-api-key': API_KEY },
  });
  if (!res.ok) throw new Error(`API error: ${res.status}`);
  return res.json();
}

export async function GET(req: NextRequest) {
  const handle = req.nextUrl.searchParams.get('handle');
  const platform = req.nextUrl.searchParams.get('platform') || 'instagram';

  if (!handle) {
    return NextResponse.json({ error: 'Missing handle' }, { status: 400 });
  }

  try {
    let profile, posts;

    if (platform === 'instagram') {
      [profile, posts] = await Promise.all([
        fetchFromSociaVault(`/instagram/profile?username=${handle}`),
        fetchFromSociaVault(`/instagram/posts?username=${handle}&limit=12`),
      ]);
    } else {
      [profile, posts] = await Promise.all([
        fetchFromSociaVault(`/tiktok/profile?username=${handle}`),
        fetchFromSociaVault(`/tiktok/profile-videos?username=${handle}&limit=12`),
      ]);
    }

    const profileData = profile.data || profile;
    const postsData = posts.data || posts.posts || [];

    const report = analyzeCreator(
      { ...profileData, platform },
      postsData
    );

    return NextResponse.json(report);
  } catch (err: any) {
    return NextResponse.json({ error: err.message }, { status: 500 });
  }
}

The Frontend (Simplified)

I'm not going to paste an entire React frontend — you've seen search bars before. The key parts:

// app/page.tsx — the search
'use client';

import { useState } from 'react';
import { useRouter } from 'next/navigation';

export default function Home() {
  const [handle, setHandle] = useState('');
  const [platform, setPlatform] = useState('instagram');
  const router = useRouter();

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    if (handle.trim()) {
      router.push(`/report/${handle.trim().replace('@', '')}?platform=${platform}`);
    }
  };

  return (
    <main className="min-h-screen flex items-center justify-center">
      <form onSubmit={handleSubmit} className="w-full max-w-md">
        <h1 className="text-3xl font-bold mb-8 text-center">
          Should you partner with this creator?
        </h1>
        <div className="flex gap-2 mb-4">
          <button
            type="button"
            onClick={() => setPlatform('instagram')}
            className={platform === 'instagram' ? 'bg-pink-500 text-white px-4 py-2 rounded' : 'bg-gray-200 px-4 py-2 rounded'}
          >
            Instagram
          </button>
          <button
            type="button"
            onClick={() => setPlatform('tiktok')}
            className={platform === 'tiktok' ? 'bg-black text-white px-4 py-2 rounded' : 'bg-gray-200 px-4 py-2 rounded'}
          >
            TikTok
          </button>
        </div>
        <input
          type="text"
          value={handle}
          onChange={(e) => setHandle(e.target.value)}
          placeholder="Enter username..."
          className="w-full px-4 py-3 border rounded-lg text-lg"
        />
        <button type="submit" className="w-full mt-4 bg-blue-600 text-white py-3 rounded-lg text-lg font-medium">
          Analyze Creator
        </button>
      </form>
    </main>
  );
}

The report page calls /api/vet?handle=xxx&platform=yyy and renders the result. Show the overall score big. Color code the verdict. List the flags as warnings. Done.

Monetization with Stripe

// lib/rate-limit.ts
// Track usage per user per month using a simple in-memory map
// (For production, use Redis or your database)

const usage = new Map<string, { count: number; resetAt: number }>();

export function checkUsage(userId: string, isPaid: boolean): boolean {
  const limit = isPaid ? Infinity : 3;
  const now = Date.now();
  const key = userId;

  const record = usage.get(key);
  if (!record || record.resetAt < now) {
    // New month
    usage.set(key, { count: 1, resetAt: now + 30 * 86400000 });
    return true;
  }

  if (record.count >= limit) return false;

  record.count++;
  return true;
}

Deploy

# Push to GitHub, connect to Vercel, done
git init && git add -A && git commit -m "initial"
vercel

Total cost:

Vercel: $0 (free tier)
SociaVault API: $29/month (Starter plan, 5K credits)
Stripe: 2.9% + $0.30 per transaction
Clerk: $0 (free tier up to 10K users)

At 10 paying users ($19/month each), you're making $190/month and spending ~$30. That's a 6:1 return from a weekend project.

What Makes This Win

It's not the code. It's the positioning.

HypeAuditor charges $299/month for this. CreatorIQ won't even talk to you without a demo call. You're offering the same core value for $19/month with zero friction.

The scoring engine above does 80% of what the expensive tools do. The other 20% is pretty charts and PDF exports — which you can add later.

Read the Full Guide

Build an Influencer Vetting Micro-SaaS → SociaVault Blog

Power your SaaS with social media data from SociaVault — one API for TikTok, Instagram, YouTube, and 10+ platforms. Profiles, posts, engagement, followers — all endpoints, one API key.

Discussion

Have you shipped a micro-SaaS in a weekend? What was it, and how did it go? I'm always curious about the gap between "launched" and "first paying customer."

javascript #saas #webdev #startup #indiehackers

Build a Discord Bot That Alerts Your Team When Competitors Post

Olamide Olaniyan — Wed, 08 Apr 2026 07:25:00 +0000

My team used to manually check competitor accounts every morning. Five people, ten minutes each, scrolling through Instagram and TikTok at 9am.

That's 250 minutes per week of human time spent doing what a bot can do in 3 seconds.

So I built one. A Discord bot that watches competitor accounts and drops a notification the moment they post something new. Here's exactly how.

What We're Building

A Node.js bot that:

Polls competitor profiles every 30 minutes
Detects new posts since the last check
Sends a rich Discord embed with the post details
Tracks what's already been seen so you never get duplicate alerts

No AI, no fancy ML. Just polling + diffing + Discord webhooks.

The Stack

Node.js – runtime
SociaVault API – fetch competitor posts across Instagram and TikTok
Discord.js – send rich embeds to your server
node-cron – schedule polling intervals
SQLite (better-sqlite3) – track seen posts (no external DB needed)

Setup

mkdir competitor-alerts && cd competitor-alerts
npm init -y
npm install discord.js node-cron better-sqlite3 axios dotenv

# .env
DISCORD_BOT_TOKEN=your_discord_bot_token
DISCORD_CHANNEL_ID=your_channel_id
SOCIAVAULT_API_KEY=your_api_key

Step 1: The Database (Tracking What We've Seen)

We need to remember which posts we've already alerted on. SQLite is perfect for this — zero setup, single file, no external dependencies.

// db.js
const Database = require('better-sqlite3');
const db = new Database('./seen_posts.db');

// Create table if it doesn't exist
db.exec(`
  CREATE TABLE IF NOT EXISTS seen_posts (
    post_id TEXT PRIMARY KEY,
    platform TEXT NOT NULL,
    username TEXT NOT NULL,
    seen_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )
`);

// Clean up posts older than 30 days to keep the DB small
db.exec(`
  DELETE FROM seen_posts WHERE seen_at < datetime('now', '-30 days')
`);

const isPostSeen = db.prepare('SELECT 1 FROM seen_posts WHERE post_id = ?');
const markPostSeen = db.prepare(
  'INSERT OR IGNORE INTO seen_posts (post_id, platform, username) VALUES (?, ?, ?)'
);

module.exports = {
  hasBeenSeen: (postId) => !!isPostSeen.get(postId),
  markSeen: (postId, platform, username) => markPostSeen.run(postId, platform, username),
};

Step 2: Fetch Competitor Posts

// fetcher.js
const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function getRecentPosts(platform, username) {
  try {
    let endpoint;

    if (platform === 'instagram') {
      endpoint = `/instagram/posts?username=${username}&limit=5`;
    } else if (platform === 'tiktok') {
      endpoint = `/tiktok/profile-videos?username=${username}&limit=5`;
    } else {
      throw new Error(`Unsupported platform: ${platform}`);
    }

    const { data } = await api.get(endpoint);
    return data.data || data.posts || [];

  } catch (err) {
    console.error(`Failed to fetch ${platform}/@${username}: ${err.message}`);
    return [];
  }
}

module.exports = { getRecentPosts };

The limit=5 is intentional. We only care about the most recent posts. No point fetching 50 posts every 30 minutes when we're checking frequently enough.

Step 3: Build the Discord Embed

Discord embeds are what make this actually useful. Raw text notifications suck. Rich embeds with thumbnails, stats, and links — that's what gets people to actually look.

// embed.js
const { EmbedBuilder } = require('discord.js');

function buildPostEmbed(post, platform, username) {
  const embed = new EmbedBuilder()
    .setColor(platform === 'instagram' ? 0xE1306C : 0x000000)
    .setAuthor({
      name: `@${username} posted on ${platform}`,
      url: platform === 'instagram'
        ? `https://instagram.com/${username}`
        : `https://tiktok.com/@${username}`,
    })
    .setTimestamp(new Date(post.timestamp || post.createTime * 1000));

  // Caption/description
  const caption = post.caption || post.desc || post.text || 'No caption';
  embed.setDescription(caption.slice(0, 300) + (caption.length > 300 ? '...' : ''));

  // Thumbnail
  const thumbnail = post.thumbnailUrl || post.coverUrl || post.imageUrl;
  if (thumbnail) {
    embed.setThumbnail(thumbnail);
  }

  // Stats
  const likes = post.likesCount ?? post.diggCount ?? 0;
  const comments = post.commentsCount ?? post.commentCount ?? 0;
  const views = post.viewCount ?? post.playCount ?? null;

  let statsLine = `❤️ ${likes.toLocaleString()}  💬 ${comments.toLocaleString()}`;
  if (views) statsLine += `  👁️ ${views.toLocaleString()}`;

  embed.addFields({ name: 'Stats', value: statsLine, inline: true });

  // Link to original post
  const postUrl = post.url || post.webVideoUrl || post.shortcode
    ? `https://instagram.com/p/${post.shortcode}`
    : null;

  if (postUrl) {
    embed.addFields({ name: 'Link', value: `[View Post](${postUrl})`, inline: true });
  }

  return embed;
}

module.exports = { buildPostEmbed };

Step 4: Wire It All Together

// index.js
require('dotenv').config();
const { Client, GatewayIntentBits } = require('discord.js');
const cron = require('node-cron');
const { getRecentPosts } = require('./fetcher');
const { buildPostEmbed } = require('./embed');
const db = require('./db');

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

// Your competitors — add as many as you want
const COMPETITORS = [
  { platform: 'instagram', username: 'competitor_one' },
  { platform: 'instagram', username: 'competitor_two' },
  { platform: 'tiktok', username: 'competitor_three' },
  { platform: 'tiktok', username: 'competitor_four' },
];

async function checkForNewPosts() {
  const channel = await client.channels.fetch(process.env.DISCORD_CHANNEL_ID);
  if (!channel) {
    console.error('Channel not found');
    return;
  }

  for (const competitor of COMPETITORS) {
    const posts = await getRecentPosts(competitor.platform, competitor.username);

    for (const post of posts) {
      const postId = post.id || post.shortcode || post.videoId;
      if (!postId) continue;

      // Skip if we've already seen this post
      if (db.hasBeenSeen(postId)) continue;

      // New post! Send alert and mark as seen
      const embed = buildPostEmbed(post, competitor.platform, competitor.username);
      await channel.send({ embeds: [embed] });
      db.markSeen(postId, competitor.platform, competitor.username);

      console.log(`[NEW] ${competitor.platform}/@${competitor.username}: ${postId}`);
    }

    // Small delay between competitors to avoid rate limits
    await new Promise(r => setTimeout(r, 1000));
  }
}

client.once('ready', () => {
  console.log(`Logged in as ${client.user.tag}`);
  console.log(`Watching ${COMPETITORS.length} competitors`);

  // Run immediately on startup
  checkForNewPosts();

  // Then every 30 minutes
  cron.schedule('*/30 * * * *', () => {
    console.log(`[${new Date().toISOString()}] Checking for new posts...`);
    checkForNewPosts();
  });
});

client.login(process.env.DISCORD_BOT_TOKEN);

Step 5: Optional — Add Summary Commands

Let your team ask the bot questions:

// Add to index.js after the client.once('ready') block

client.on('interactionCreate', async (interaction) => {
  if (!interaction.isChatInputCommand()) return;

  if (interaction.commandName === 'latest') {
    const platform = interaction.options.getString('platform');
    const username = interaction.options.getString('username');

    await interaction.deferReply();
    const posts = await getRecentPosts(platform, username);

    if (posts.length === 0) {
      await interaction.editReply('No posts found.');
      return;
    }

    const embed = buildPostEmbed(posts[0], platform, username);
    await interaction.editReply({ embeds: [embed] });
  }
});

Now anyone on your team can type /latest platform:instagram username:competitor_one and get their most recent post instantly.

Running It

# Development
node index.js

# Production (PM2)
npm install -g pm2
pm2 start index.js --name "competitor-alerts"
pm2 save

Runs 24/7 on any cheap VPS. I run mine alongside other bots on a $5 Hetzner box.

Cost Breakdown

Each check fetches the 5 most recent posts per competitor. With 4 competitors checked every 30 minutes:

4 API calls × 48 checks/day = 192 credits/day
~5,760 credits/month
With caching (same posts won't trigger new calls): ~2,000-3,000 credits/month in practice

That fits comfortably in a SociaVault growth plan.

What I'd Add Next

Engagement spike alerts — "This post is getting 5x their average likes"
Weekly summary — every Friday, bot posts a digest of what competitors published that week
Multi-channel routing — Instagram alerts to #instagram, TikTok to #tiktok
Reaction tracking — team reacts with 👀 on posts worth studying deeper

Read the Full Guide

Build a Discord Competitor Alert Bot → SociaVault Blog

Need social media data for your bots and tools? SociaVault provides a unified API for TikTok, Instagram, YouTube, and 10+ platforms. One API key, all the data.

Discussion

What automated alerts have you built for your team? I'm curious what other people are monitoring beyond competitor posts.

javascript #discord #automation #webdev #api

Build a Searchable Creator Database with PostgreSQL and Node.js

Olamide Olaniyan — Tue, 07 Apr 2026 19:24:00 +0000

Every influencer marketing platform charges $300+/month. The core feature? A searchable database of creators.

But here's their secret: it's just a PostgreSQL table with a good search index. The data comes from public APIs. The "AI-powered discovery" is a WHERE clause with some filters.

Let's build the same thing.

What We're Building

A creator database that:

Ingests creator profiles from Instagram and TikTok
Stores them in PostgreSQL with full-text search
Lets you search by niche, follower range, engagement rate, location, and keywords
Auto-enriches new profiles when they're looked up
Exposes a simple REST API for querying

This is the backend that powers tools like Modash, Heepsy, and Upfluence. You'll have a working version by the end of this article.

The Stack

Node.js + Express – API server
PostgreSQL – storage + full-text search
Prisma – database ORM
SociaVault API – fetch creator profiles and posts
node-cron – background enrichment jobs

Database Schema

// schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model Creator {
  id              String    @id @default(cuid())
  platform        String    // instagram, tiktok
  username        String
  displayName     String?
  bio             String?
  followers       Int       @default(0)
  following       Int       @default(0)
  postsCount      Int       @default(0)
  avgLikes        Int       @default(0)
  avgComments     Int       @default(0)
  engagementRate  Float     @default(0)
  profilePicUrl   String?
  isVerified      Boolean   @default(false)
  category        String?   // detected niche
  country         String?
  language        String?
  lastUpdated     DateTime  @default(now())
  createdAt       DateTime  @default(now())

  @@unique([platform, username])
  @@index([platform, followers])
  @@index([category])
  @@index([engagementRate])
}

Run the migration:

npx prisma migrate dev --name init

The Key Trick: Full-Text Search

PostgreSQL has built-in full-text search. No Elasticsearch needed.

-- Add a generated tsvector column for search
ALTER TABLE "Creator" ADD COLUMN search_vector tsvector
  GENERATED ALWAYS AS (
    setweight(to_tsvector('english', coalesce(username, '')), 'A') ||
    setweight(to_tsvector('english', coalesce("displayName", '')), 'A') ||
    setweight(to_tsvector('english', coalesce(bio, '')), 'B') ||
    setweight(to_tsvector('english', coalesce(category, '')), 'C')
  ) STORED;

-- Index it
CREATE INDEX creator_search_idx ON "Creator" USING GIN (search_vector);

Username and display name get weight A (highest priority). Bio gets B. Category gets C. When you search "fitness coach LA", it'll match creators whose username contains "fitness", bio mentions "coach", and location includes "LA" — ranked by relevance.

Step 1: The Ingestion Pipeline

// ingest.js
const axios = require('axios');
const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();
const api = axios.create({
  baseURL: 'https://api.sociavault.com/v1/scrape',
  headers: { 'x-api-key': process.env.SOCIAVAULT_API_KEY },
});

async function ingestCreator(platform, username) {
  // Check if we already have fresh data (< 7 days old)
  const existing = await prisma.creator.findUnique({
    where: { platform_username: { platform, username } },
  });

  if (existing) {
    const daysSinceUpdate = (Date.now() - existing.lastUpdated.getTime()) / 86400000;
    if (daysSinceUpdate < 7) return existing; // Still fresh
  }

  // Fetch profile
  const profileEndpoint = platform === 'instagram'
    ? `/instagram/profile?username=${username}`
    : `/tiktok/profile?username=${username}`;

  const { data: profileRes } = await api.get(profileEndpoint);
  const profile = profileRes.data || profileRes;

  // Fetch recent posts for engagement calculation
  const postsEndpoint = platform === 'instagram'
    ? `/instagram/posts?username=${username}&limit=12`
    : `/tiktok/profile-videos?username=${username}&limit=12`;

  const { data: postsRes } = await api.get(postsEndpoint);
  const posts = postsRes.data || postsRes.posts || [];

  // Calculate engagement metrics
  const totalLikes = posts.reduce((s, p) => s + (p.likesCount || p.diggCount || 0), 0);
  const totalComments = posts.reduce((s, p) => s + (p.commentsCount || p.commentCount || 0), 0);
  const avgLikes = posts.length > 0 ? Math.round(totalLikes / posts.length) : 0;
  const avgComments = posts.length > 0 ? Math.round(totalComments / posts.length) : 0;

  const followers = profile.followersCount || profile.followerCount || 0;
  const engagementRate = followers > 0
    ? parseFloat((((avgLikes + avgComments) / followers) * 100).toFixed(2))
    : 0;

  // Detect category from bio (simple keyword matching)
  const category = detectCategory(profile.bio || profile.signature || '');

  // Upsert into database
  return prisma.creator.upsert({
    where: { platform_username: { platform, username } },
    create: {
      platform,
      username,
      displayName: profile.fullName || profile.nickname || username,
      bio: profile.bio || profile.signature || '',
      followers,
      following: profile.followingCount || 0,
      postsCount: profile.postsCount || profile.videoCount || 0,
      avgLikes,
      avgComments,
      engagementRate,
      profilePicUrl: profile.profilePicUrl || profile.avatarUrl || null,
      isVerified: profile.isVerified || false,
      category,
    },
    update: {
      displayName: profile.fullName || profile.nickname || username,
      bio: profile.bio || profile.signature || '',
      followers,
      following: profile.followingCount || 0,
      postsCount: profile.postsCount || profile.videoCount || 0,
      avgLikes,
      avgComments,
      engagementRate,
      profilePicUrl: profile.profilePicUrl || profile.avatarUrl || null,
      isVerified: profile.isVerified || false,
      category,
      lastUpdated: new Date(),
    },
  });
}

function detectCategory(bio) {
  const lower = bio.toLowerCase();
  const categories = {
    'fitness': ['fitness', 'gym', 'workout', 'personal trainer', 'health coach'],
    'beauty': ['beauty', 'makeup', 'skincare', 'cosmetics', 'hair'],
    'food': ['food', 'recipe', 'cooking', 'chef', 'restaurant', 'baking'],
    'travel': ['travel', 'wanderlust', 'adventure', 'explore', 'backpack'],
    'tech': ['tech', 'developer', 'coding', 'software', 'startup', 'saas'],
    'fashion': ['fashion', 'style', 'outfit', 'clothing', 'designer'],
    'gaming': ['gaming', 'gamer', 'twitch', 'esports', 'streamer'],
    'music': ['music', 'musician', 'singer', 'producer', 'dj'],
    'education': ['teacher', 'education', 'learn', 'tutor', 'professor'],
    'business': ['entrepreneur', 'ceo', 'founder', 'business', 'marketing'],
  };

  for (const [category, keywords] of Object.entries(categories)) {
    if (keywords.some(kw => lower.includes(kw))) return category;
  }
  return 'other';
}

module.exports = { ingestCreator };

Step 2: The Search API

// server.js
const express = require('express');
const { PrismaClient } = require('@prisma/client');
const { ingestCreator } = require('./ingest');

const app = express();
const prisma = new PrismaClient();

// Search creators
app.get('/api/creators/search', async (req, res) => {
  const {
    q,                // text search query
    platform,         // instagram or tiktok
    category,         // fitness, beauty, tech, etc.
    minFollowers,
    maxFollowers,
    minEngagement,
    sort = 'followers',
    order = 'desc',
    page = 1,
    limit = 20,
  } = req.query;

  const where = {};
  const AND = [];

  if (platform) AND.push({ platform });
  if (category) AND.push({ category });
  if (minFollowers) AND.push({ followers: { gte: parseInt(minFollowers) } });
  if (maxFollowers) AND.push({ followers: { lte: parseInt(maxFollowers) } });
  if (minEngagement) AND.push({ engagementRate: { gte: parseFloat(minEngagement) } });

  if (AND.length > 0) where.AND = AND;

  // Full-text search using raw SQL for the tsvector
  let creators;
  const offset = (parseInt(page) - 1) * parseInt(limit);

  if (q) {
    // Use PostgreSQL full-text search
    const searchQuery = q.split(' ').join(' & '); // AND between terms
    creators = await prisma.$queryRaw`
      SELECT *, ts_rank(search_vector, to_tsquery('english', ${searchQuery})) as rank
      FROM "Creator"
      WHERE search_vector @@ to_tsquery('english', ${searchQuery})
        ${platform ? prisma.$queryRaw`AND platform = ${platform}` : prisma.$queryRaw``}
        ${category ? prisma.$queryRaw`AND category = ${category}` : prisma.$queryRaw``}
        ${minFollowers ? prisma.$queryRaw`AND followers >= ${parseInt(minFollowers)}` : prisma.$queryRaw``}
        ${maxFollowers ? prisma.$queryRaw`AND followers <= ${parseInt(maxFollowers)}` : prisma.$queryRaw``}
      ORDER BY rank DESC
      LIMIT ${parseInt(limit)} OFFSET ${offset}
    `;
  } else {
    creators = await prisma.creator.findMany({
      where,
      orderBy: { [sort]: order },
      skip: offset,
      take: parseInt(limit),
    });
  }

  const total = await prisma.creator.count({ where: q ? undefined : where });

  res.json({
    creators,
    pagination: {
      page: parseInt(page),
      limit: parseInt(limit),
      total,
      pages: Math.ceil(total / parseInt(limit)),
    },
  });
});

// Lookup + auto-ingest a specific creator
app.get('/api/creators/:platform/:username', async (req, res) => {
  const { platform, username } = req.params;

  try {
    const creator = await ingestCreator(platform, username);
    res.json(creator);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000, () => console.log('Creator DB API running on :3000'));

Step 3: Seed the Database

You need initial data. Here's a script that ingests a list of known creators:

// seed.js
const { ingestCreator } = require('./ingest');

const SEED_CREATORS = [
  { platform: 'instagram', username: 'therock' },
  { platform: 'instagram', username: 'cristiano' },
  { platform: 'tiktok', username: 'charlidamelio' },
  { platform: 'tiktok', username: 'khaby.lame' },
  // Add more from your niche...
];

async function seed() {
  for (const creator of SEED_CREATORS) {
    try {
      console.log(`Ingesting ${creator.platform}/@${creator.username}...`);
      await ingestCreator(creator.platform, creator.username);
      await new Promise(r => setTimeout(r, 1000)); // Rate limit
    } catch (err) {
      console.error(`Failed: ${creator.username} — ${err.message}`);
    }
  }
  console.log('Seeding complete.');
}

seed();

Usage Examples

# Search for fitness creators on Instagram with 10K-100K followers
curl "localhost:3000/api/creators/search?q=fitness&platform=instagram&minFollowers=10000&maxFollowers=100000"

# Find beauty creators with 3%+ engagement rate
curl "localhost:3000/api/creators/search?category=beauty&minEngagement=3&sort=engagementRate"

# Look up a specific creator (auto-fetches if not in DB)
curl "localhost:3000/api/creators/instagram/some_creator"

Why This Beats Spreadsheets

The moment you have 500+ creators in the database, spreadsheets become useless. You can't full-text search a CSV. You can't filter by engagement rate AND follower count AND niche in Google Sheets without losing your mind.

With this setup, queries like "find me fitness creators on TikTok with 50K-200K followers and 4%+ engagement" take 3 milliseconds.

What I'd Add Next

Background refresh job — cron that re-fetches the oldest profiles daily
Duplicate detection — same creator on Instagram and TikTok, link them
Export to CSV — for people who still need spreadsheets
Simple frontend — a search bar + filter sidebar + results grid

Read the Full Guide

Build a Creator Database → SociaVault Blog

Build influencer databases with SociaVault — one API for profiles, posts, and engagement data across TikTok, Instagram, YouTube, and 10+ platforms.

Discussion

If you've built a creator/influencer database before, what was your biggest pain point? Schema design? Keeping data fresh? Handling duplicates across platforms?

javascript #postgresql #api #webdev #database

Build a Link-in-Bio Page That Updates Itself with Your Latest Content

Olamide Olaniyan — Mon, 06 Apr 2026 19:23:00 +0000

Linktree charges $24/month for a page with links on it. Let's build one that's better in 45 minutes.

Not just a static page — a link-in-bio that automatically pulls your latest Instagram posts, TikTok videos, and YouTube uploads. You update your page by posting content. No manual link swapping.

The Concept

Instead of:

🔗 My latest video → (manually updated every time you post)
🔗 My second latest → (always stale)
🔗 Watch my podcast → (from 3 months ago)

You get:

@yourbrand
[auto-pulled profile pic + bio]

📱 Latest TikTok
  [thumbnail] [title] [views] → auto-linked

📸 Latest Instagram
  [grid of 6 recent posts] → each linked

🎬 Latest YouTube
  [thumbnail] [title] → auto-linked

[your permanent links below]

Every time a visitor loads the page, they see your actual latest content. Zero maintenance.

The Stack

Next.js with App Router
SociaVault API — fetch latest content from each platform
Vercel — deploy for free
ISR (Incremental Static Regeneration) — cache the page, regenerate every hour

The Core: Server Component That Fetches Latest Content

// app/[username]/page.tsx

const SOCIAVAULT_API = 'https://api.sociavault.com/v1/scrape';
const API_KEY = process.env.SOCIAVAULT_API_KEY!;

interface LinkInBioConfig {
  name: string;
  bio: string;
  avatar: string;
  platforms: {
    instagram?: string;
    tiktok?: string;
    youtube?: string;
  };
  links: { title: string; url: string; emoji?: string }[];
}

// Define your config (this could come from a database in a multi-user setup)
const USERS: Record<string, LinkInBioConfig> = {
  yourusername: {
    name: 'Your Name',
    bio: 'Creator • Developer • Building cool stuff',
    avatar: '/avatar.jpg',
    platforms: {
      instagram: 'your_instagram',
      tiktok: 'your_tiktok',
    },
    links: [
      { title: 'My Newsletter', url: 'https://your-newsletter.com', emoji: '📧' },
      { title: 'My Course', url: 'https://your-course.com', emoji: '🎓' },
      { title: 'Work With Me', url: 'https://your-site.com/contact', emoji: '🤝' },
    ],
  },
};

async function fetchAPI(endpoint: string) {
  try {
    const res = await fetch(`${SOCIAVAULT_API}${endpoint}`, {
      headers: { 'x-api-key': API_KEY },
      next: { revalidate: 3600 }, // Cache for 1 hour
    });
    if (!res.ok) return null;
    return res.json();
  } catch {
    return null;
  }
}

async function getLatestContent(platforms: LinkInBioConfig['platforms']) {
  const content: any = {};

  if (platforms.instagram) {
    const data = await fetchAPI(`/instagram/posts?username=${platforms.instagram}&limit=6`);
    content.instagram = (data?.data || data?.posts || []).slice(0, 6);
  }

  if (platforms.tiktok) {
    const data = await fetchAPI(`/tiktok/profile-videos?username=${platforms.tiktok}&limit=3`);
    content.tiktok = (data?.data || data?.posts || []).slice(0, 3);
  }

  return content;
}

export async function generateMetadata({ params }: { params: { username: string } }) {
  const config = USERS[params.username];
  if (!config) return { title: 'Not Found' };
  return {
    title: `${config.name} — Links`,
    description: config.bio,
  };
}

// Regenerate every hour
export const revalidate = 3600;

export default async function LinkInBioPage({ params }: { params: { username: string } }) {
  const config = USERS[params.username];
  if (!config) return <div>Not found</div>;

  const content = await getLatestContent(config.platforms);

  return (
    <main className="min-h-screen bg-gradient-to-b from-gray-900 to-black text-white">
      <div className="max-w-md mx-auto px-4 py-12">
        {/* Profile */}
        <div className="text-center mb-8">
          <img
            src={config.avatar}
            alt={config.name}
            className="w-24 h-24 rounded-full mx-auto mb-4 border-2 border-white/20"
          />
          <h1 className="text-xl font-bold">{config.name}</h1>
          <p className="text-gray-400 text-sm mt-1">{config.bio}</p>
        </div>

        {/* Latest TikTok */}
        {content.tiktok?.length > 0 && (
          <section className="mb-8">
            <h2 className="text-xs uppercase tracking-wider text-gray-500 mb-3">Latest on TikTok</h2>
            <div className="space-y-2">
              {content.tiktok.map((video: any, i: number) => (
                <a
                  key={i}
                  href={video.webVideoUrl || '#'}
                  target="_blank"
                  rel="noopener noreferrer"
                  className="flex items-center gap-3 bg-white/5 hover:bg-white/10 rounded-xl p-3 transition"
                >
                  {video.coverUrl && (
                    <img src={video.coverUrl} alt="" className="w-12 h-16 rounded object-cover" />
                  )}
                  <div className="flex-1 min-w-0">
                    <p className="text-sm truncate">{video.desc || 'TikTok video'}</p>
                    <p className="text-xs text-gray-500 mt-1">
                      {(video.playCount || 0).toLocaleString()} views
                    </p>
                  </div>
                </a>
              ))}
            </div>
          </section>
        )}

        {/* Latest Instagram */}
        {content.instagram?.length > 0 && (
          <section className="mb-8">
            <h2 className="text-xs uppercase tracking-wider text-gray-500 mb-3">Latest on Instagram</h2>
            <div className="grid grid-cols-3 gap-1 rounded-xl overflow-hidden">
              {content.instagram.map((post: any, i: number) => (
                <a
                  key={i}
                  href={post.url || `https://instagram.com/p/${post.shortcode}`}
                  target="_blank"
                  rel="noopener noreferrer"
                  className="aspect-square relative group"
                >
                  <img
                    src={post.imageUrl || post.thumbnailUrl || ''}
                    alt=""
                    className="w-full h-full object-cover"
                  />
                  <div className="absolute inset-0 bg-black/50 opacity-0 group-hover:opacity-100 transition flex items-center justify-center">
                    <span className="text-xs">
                      ❤️ {(post.likesCount || 0).toLocaleString()}
                    </span>
                  </div>
                </a>
              ))}
            </div>
          </section>
        )}

        {/* Permanent Links */}
        <section className="space-y-3">
          {config.links.map((link, i) => (
            <a
              key={i}
              href={link.url}
              target="_blank"
              rel="noopener noreferrer"
              className="block w-full text-center bg-white/10 hover:bg-white/20 rounded-xl py-3 px-4 transition font-medium"
            >
              {link.emoji && <span className="mr-2">{link.emoji}</span>}
              {link.title}
            </a>
          ))}
        </section>

        {/* Footer */}
        <p className="text-center text-gray-600 text-xs mt-12">
          Powered by <a href="https://sociavault.com" className="text-gray-500 hover:text-white">SociaVault</a>
        </p>
      </div>
    </main>
  );
}

How ISR Makes This Work

The revalidate = 3600 line is doing the heavy lifting. It means:

First visitor → page is generated server-side, API calls happen, result is cached
Next 3,599 visitors → served from cache instantly, no API calls
After 1 hour → next visitor triggers a background regeneration, still gets the cached version while the new one builds

Your latest TikTok video shows up within an hour of posting. With zero manual work. And the page loads in under 100ms for every visitor after the first.

Cost

Vercel: Free tier (100K page views/month)
SociaVault API: One API call per platform per hour = ~48 credits/day = 1,440 credits/month
Domain: $12/year

Total: effectively $0/month for a personal link-in-bio page.

Making It Multi-User (SaaS Mode)

If you want to turn this into a Linktree competitor:

Replace the hardcoded USERS config with a database (Prisma + PostgreSQL)
Add a setup wizard where users connect their social handles
Add Stripe for a $5/month plan
Add custom themes (the easiest upsell — CSS variables)

The SociaVault API calls scale linearly: 10 users = 10x the credits, but with ISR caching it's still cheap. 100 users with hourly revalidation = ~144,000 credits/month.

Why This Beats Linktree

Feature	Linktree ($24/mo)	This (free)
Latest content auto-pulls	❌ Manual links	✅ Automatic
Custom domain	✅ (paid)	✅ (Vercel)
Analytics	✅	Add Plausible ($0)
SEO	Weak (shared domain)	✅ Your own domain
Load speed	~2-3s	~100ms (ISR)
Customization	Limited themes	Full CSS control

Read the Full Guide

Build an Auto-Updating Link-in-Bio → SociaVault Blog

Pull latest posts and profiles from any platform with SociaVault — one API for TikTok, Instagram, YouTube, and 10+ social platforms.

Discussion

What's on your link-in-bio page? Do you actually remember to update the links, or is it pointing to content from 6 months ago? (Be honest.)

nextjs #webdev #react #javascript #saas

Build an Engagement Decay Analyzer: How Fast Do Posts Die?

Olamide Olaniyan — Wed, 25 Mar 2026 19:18:00 +0000

You post a TikTok. It gets 10K views in the first hour. You celebrate.

24 hours later: 12K views. 48 hours: 12.1K. It's dead.

Meanwhile, your competitor posted at the same time. First hour: 8K views. Seems worse. But 48 hours later: 45K. A week later: 200K. Their content has legs. Yours doesn't.

The difference isn't luck. It's engagement decay rate — and almost nobody tracks it.

I built a tool that measures exactly how fast posts lose momentum and which content types have the longest shelf life. Here's the whole thing.

The Stack

Node.js – runtime
SociaVault API – fetch post data over time
Math – decay curve fitting

Why Decay Rate Matters More Than Total Engagement

Two posts, same creator, same niche:

Metric	Post A	Post B
Views at 1 hour	10,000	5,000
Views at 24 hours	12,000	20,000
Views at 7 days	13,000	80,000
Decay rate	Fast (dies in hours)	Slow (grows for days)

Post B wins by 6x despite starting slower. If you only measured "first hour performance," you'd double down on Post A's style. That's the trap.

Slow-decay content gets picked up by the algorithm, appears in search results, and compounds. Fast-decay content spikes and vanishes.

Step 1: Collect Time-Series Data

You need engagement snapshots at multiple time points. Fetch the same post's data repeatedly.

const axios = require('axios');

const API_BASE = 'https://api.sociavault.com/v1';
const API_KEY = process.env.SOCIAVAULT_API_KEY;

const api = axios.create({
  baseURL: API_BASE,
  headers: { 'x-api-key': API_KEY },
});

async function getPostInfo(platform, postId) {
  const { data } = await api.get(`/${platform}/post/${postId}`);
  return data;
}

async function getPosts(platform, username, limit = 30) {
  const { data } = await api.get(`/${platform}/posts/${username}`, {
    params: { limit },
  });
  return data.posts;
}

For decay analysis, we snapshot posts at known intervals after posting:

async function collectDecayData(platform, postId, postDate) {
  const post = await getPostInfo(platform, postId);
  const hoursOld = (Date.now() - new Date(postDate).getTime()) / (1000 * 60 * 60);

  return {
    postId,
    hoursOld: Math.round(hoursOld),
    views: post.viewCount || 0,
    likes: post.likeCount || 0,
    comments: post.commentCount || 0,
    shares: post.shareCount || 0,
    timestamp: new Date().toISOString(),
  };
}

Step 2: Calculate Decay Curves

With multiple snapshots (or by comparing posts of different ages), calculate engagement velocity — how much engagement each post gains per hour.

function calculateDecayCurve(snapshots) {
  // Sort by hours old
  const sorted = snapshots.sort((a, b) => a.hoursOld - b.hoursOld);

  const curve = [];

  for (let i = 1; i < sorted.length; i++) {
    const prev = sorted[i - 1];
    const curr = sorted[i];

    const hoursDiff = curr.hoursOld - prev.hoursOld;
    if (hoursDiff <= 0) continue;

    const viewsGained = curr.views - prev.views;
    const likesGained = curr.likes - prev.likes;

    curve.push({
      fromHour: prev.hoursOld,
      toHour: curr.hoursOld,
      viewsPerHour: Math.round(viewsGained / hoursDiff),
      likesPerHour: parseFloat((likesGained / hoursDiff).toFixed(1)),
      velocityDrop: prev.hoursOld === 0 ? 0 :
        parseFloat(((viewsGained / hoursDiff) / (curve[0]?.viewsPerHour || 1) * 100).toFixed(1)),
    });
  }

  return curve;
}

Step 3: Estimate Decay Without Snapshots

Don't have historical snapshots? You can estimate decay from a batch of recent posts by comparing age vs. total engagement.

function estimateDecayFromBatch(posts) {
  // Group posts by age buckets
  const buckets = {
    '0-6h': [], '6-24h': [], '1-3d': [], '3-7d': [], '7-14d': [], '14-30d': [],
  };

  for (const post of posts) {
    const hoursOld = (Date.now() - new Date(post.createdAt).getTime()) / (1000 * 60 * 60);

    if (hoursOld <= 6) buckets['0-6h'].push(post);
    else if (hoursOld <= 24) buckets['6-24h'].push(post);
    else if (hoursOld <= 72) buckets['1-3d'].push(post);
    else if (hoursOld <= 168) buckets['3-7d'].push(post);
    else if (hoursOld <= 336) buckets['7-14d'].push(post);
    else buckets['14-30d'].push(post);
  }

  // Calculate average engagement per hour for each bucket
  const rates = {};
  for (const [bucket, bucketPosts] of Object.entries(buckets)) {
    if (bucketPosts.length === 0) continue;

    const avgViews = bucketPosts.reduce((s, p) => s + (p.viewCount || 0), 0) / bucketPosts.length;
    const avgHours = bucketPosts.reduce((s, p) => {
      return s + (Date.now() - new Date(p.createdAt).getTime()) / (1000 * 60 * 60);
    }, 0) / bucketPosts.length;

    rates[bucket] = {
      avgViewsPerHour: parseFloat((avgViews / avgHours).toFixed(1)),
      sampleSize: bucketPosts.length,
    };
  }

  return rates;
}

Step 4: Compute Half-Life

The "half-life" of a post = how many hours until it's getting 50% of its peak engagement velocity. This is the single best metric for content longevity.

function calculateHalfLife(decayCurve) {
  if (decayCurve.length < 2) return null;

  const peakVelocity = decayCurve[0].viewsPerHour;
  const halfPeak = peakVelocity * 0.5;

  // Find when velocity drops below 50% of peak
  for (const point of decayCurve) {
    if (point.viewsPerHour <= halfPeak) {
      return point.fromHour;
    }
  }

  // Still above 50% — long-lived content
  return decayCurve[decayCurve.length - 1].toHour;
}

function classifyDecay(halfLifeHours) {
  if (halfLifeHours <= 2) return { type: 'Flash', emoji: '⚡', description: 'Dies within hours' };
  if (halfLifeHours <= 12) return { type: 'Standard', emoji: '📊', description: 'Normal decay' };
  if (halfLifeHours <= 48) return { type: 'Sustained', emoji: '🔥', description: 'Multi-day momentum' };
  if (halfLifeHours <= 168) return { type: 'Evergreen', emoji: '🌲', description: 'Week-long legs' };
  return { type: 'Viral', emoji: '🚀', description: 'Algorithm-boosted longevity' };
}

Platform benchmarks (approximate):

TikTok: Average half-life ~4-8 hours. Viral posts: 48-72 hours.
Instagram Reels: Average ~6-12 hours. Explore-boosted: 24-48 hours.
Instagram Feed: Average ~2-4 hours. Very fast decay.
YouTube: Average ~48-168 hours. Evergreen content: months.
Twitter/X: Average ~0.5-2 hours. Fastest decay of any platform.

Step 5: Analyze Content Types

Which types of content decay slowest? Find the pattern.

function analyzeContentTypes(posts, decayData) {
  const categories = {};

  for (const post of posts) {
    const type = categorizePost(post);

    if (!categories[type]) {
      categories[type] = { posts: [], halfLives: [] };
    }

    categories[type].posts.push(post);

    if (decayData[post.id]) {
      const curve = calculateDecayCurve(decayData[post.id]);
      const halfLife = calculateHalfLife(curve);
      if (halfLife) categories[type].halfLives.push(halfLife);
    }
  }

  // Summarize each category
  const summary = {};
  for (const [type, data] of Object.entries(categories)) {
    if (data.halfLives.length === 0) continue;

    const avgHalfLife = data.halfLives.reduce((a, b) => a + b, 0) / data.halfLives.length;

    summary[type] = {
      postCount: data.posts.length,
      avgHalfLife: parseFloat(avgHalfLife.toFixed(1)),
      decay: classifyDecay(avgHalfLife),
      avgViews: Math.round(
        data.posts.reduce((s, p) => s + (p.viewCount || 0), 0) / data.posts.length
      ),
    };
  }

  return summary;
}

function categorizePost(post) {
  const caption = (post.caption || '').toLowerCase();
  const hasQuestion = caption.includes('?');
  const hasList = /\d\.\s|•|→/.test(caption);
  const isShort = caption.length < 50;

  if (post.type === 'carousel' || post.mediaCount > 1) return 'Carousel';
  if (post.type === 'reel' || post.duration) return 'Video/Reel';
  if (hasQuestion) return 'Question/Poll';
  if (hasList) return 'List/Tips';
  if (isShort) return 'Short Caption';
  return 'Long Caption';
}

Step 6: Compare Creators

async function compareCreatorDecay(platform, usernames) {
  const results = [];

  for (const username of usernames) {
    const posts = await getPosts(platform, username, 30);
    const decayRates = estimateDecayFromBatch(posts);

    // Estimate overall content longevity
    const avgViews = posts.reduce((s, p) => s + (p.viewCount || 0), 0) / posts.length;
    const avgAge = posts.reduce((s, p) => {
      return s + (Date.now() - new Date(p.createdAt).getTime()) / (1000 * 60 * 60);
    }, 0) / posts.length;

    results.push({
      username,
      postCount: posts.length,
      avgViews: Math.round(avgViews),
      avgPostAgeHours: Math.round(avgAge),
      viewsPerHour: parseFloat((avgViews / avgAge).toFixed(1)),
      decayRates,
    });
  }

  // Rank by views per hour (proxy for content longevity)
  return results.sort((a, b) => b.viewsPerHour - a.viewsPerHour);
}

Putting It All Together

async function runDecayAnalysis(platform, username) {
  console.log(`\n=== ENGAGEMENT DECAY ANALYSIS: @${username} ===\n`);

  const posts = await getPosts(platform, username, 50);
  const decayRates = estimateDecayFromBatch(posts);

  console.log('📉 Engagement Velocity by Post Age:');
  for (const [bucket, rate] of Object.entries(decayRates)) {
    console.log(`  ${bucket}: ${rate.avgViewsPerHour} views/hour (n=${rate.sampleSize})`);
  }

  // Content type breakdown
  console.log('\n📊 Content Type Longevity:');
  const typeAnalysis = analyzeContentTypes(posts, {});
  for (const [type, data] of Object.entries(typeAnalysis)) {
    console.log(
      `  ${data.decay.emoji} ${type}: ~${data.avgHalfLife}h half-life ` +
      `(${data.decay.type}) — avg ${data.avgViews.toLocaleString()} views`
    );
  }

  // Recommendations
  console.log('\n💡 Recommendations:');
  const sorted = Object.entries(typeAnalysis).sort((a, b) => b[1].avgHalfLife - a[1].avgHalfLife);
  if (sorted.length >= 2) {
    console.log(`  Best longevity: ${sorted[0][0]} (~${sorted[0][1].avgHalfLife}h half-life)`);
    console.log(`  Worst longevity: ${sorted[sorted.length - 1][0]} (~${sorted[sorted.length - 1][1].avgHalfLife}h half-life)`);
    console.log(`  → Post more ${sorted[0][0]} content, less ${sorted[sorted.length - 1][0]}`);
  }
}

runDecayAnalysis('tiktok', 'target_creator');

Sample Output

=== ENGAGEMENT DECAY ANALYSIS: @target_creator ===

📉 Engagement Velocity by Post Age:
  0-6h: 2,340 views/hour (n=3)
  6-24h: 890 views/hour (n=5)
  1-3d: 210 views/hour (n=8)
  3-7d: 45 views/hour (n=7)
  7-14d: 8 views/hour (n=4)

📊 Content Type Longevity:
  🔥 Carousel: ~36h half-life (Sustained) — avg 47,200 views
  📊 List/Tips: ~14h half-life (Standard) — avg 31,800 views
  📊 Video/Reel: ~8h half-life (Standard) — avg 22,100 views
  ⚡ Short Caption: ~1.5h half-life (Flash) — avg 5,400 views

💡 Recommendations:
  Best longevity: Carousel (~36h half-life)
  Worst longevity: Short Caption (~1.5h half-life)
  → Post more Carousel content, less Short Caption

Carousels last 24x longer than short-caption posts. That's not a small difference — it's the difference between content that compounds and content that disappears.

Read the Full Guide

This is a condensed version. The full guide includes:

Automated snapshot scheduling for precision decay curves
Platform-specific decay benchmarks from 10,000+ posts
Correlation between posting time and decay rate
Visualization with Charts.js

Read the complete guide on SociaVault →

Building content analytics tools? SociaVault provides social media data APIs for TikTok, Instagram, YouTube, and 10+ platforms. Track posts over time, compare creators, and analyze content performance through one unified API.

Discussion

Do you track how long your content stays alive? Or do you only look at total engagement? Curious what metrics you optimize for 👇

webdev #api #nodejs #analytics #javascript

Build a Cross-Platform Profile Matcher: Find the Same Creator Everywhere

Olamide Olaniyan — Tue, 24 Mar 2026 19:17:00 +0000

A brand wants to work with @sarah_creates on TikTok. She has 150K followers. Great.

But does she have an Instagram? A YouTube? A Twitter? What's her total reach?

You could ask her. Or you could search manually. Open 5 tabs. Try different username variations. Scroll through results. Hope you got the right person.

Or you could build a tool that does it in seconds. Search every platform, match by username similarity + bio + profile picture + display name, and output a unified cross-platform profile.

Here's the full build.

The Stack

Node.js – runtime
SociaVault API – search users and fetch profiles across platforms
String similarity – fuzzy matching for username variations

Why Cross-Platform Matters

Creator	TikTok Only	All Platforms
Followers	150,000	312,400
Avg Engagement	5.8%	4.2% (weighted)
Content Types	Short video only	Video + Photo + Long-form
CPM Potential	$150	$312

Knowing the full picture changes the deal. And it gives brands confidence they're investing in someone with a real, diversified presence — not a one-platform wonder.

Step 1: Search Across Platforms

const axios = require('axios');

const API_BASE = 'https://api.sociavault.com/v1';
const API_KEY = process.env.SOCIAVAULT_API_KEY;

const api = axios.create({
  baseURL: API_BASE,
  headers: { 'x-api-key': API_KEY },
});

const PLATFORMS = ['tiktok', 'instagram', 'youtube', 'twitter', 'threads', 'linkedin'];

async function searchAllPlatforms(query, limit = 10) {
  const results = {};

  for (const platform of PLATFORMS) {
    try {
      const { data } = await api.get(`/${platform}/search/users`, {
        params: { keyword: query, limit },
      });
      results[platform] = data.users || [];
    } catch (err) {
      console.error(`Search failed on ${platform}: ${err.message}`);
      results[platform] = [];
    }
  }

  return results;
}

async function getProfile(platform, username) {
  const { data } = await api.get(`/${platform}/profile/${username}`);
  return data;
}

Step 2: Generate Username Variations

Creators rarely use the exact same handle everywhere. Generate smart variations.

function generateUsernameVariations(username) {
  const clean = username.replace(/^@/, '').toLowerCase();
  const variations = new Set([clean]);

  // Remove common separators
  variations.add(clean.replace(/[._-]/g, ''));

  // Swap separators
  variations.add(clean.replace(/[._-]/g, '_'));
  variations.add(clean.replace(/[._-]/g, '.'));
  variations.add(clean.replace(/[._-]/g, ''));

  // Remove trailing numbers
  variations.add(clean.replace(/\d+$/, ''));

  // Remove common suffixes
  const suffixes = ['official', 'real', 'tv', 'hq', 'yt', 'ig'];
  for (const suffix of suffixes) {
    if (clean.endsWith(suffix)) {
      variations.add(clean.slice(0, -suffix.length));
    }
    variations.add(clean + suffix);
  }

  // Remove common prefixes
  const prefixes = ['the', 'real', 'official', 'its', 'im'];
  for (const prefix of prefixes) {
    if (clean.startsWith(prefix)) {
      variations.add(clean.slice(prefix.length));
    }
  }

  return [...variations].filter(v => v.length >= 3);
}

Example: sarah_creates generates:
sarah_creates, sarahcreates, sarah.creates, sarah_createstv, sarah_createsofficial, etc.

Step 3: Score Profile Matches

Not every "sarahcreates" is the same person. Score match confidence using multiple signals.

function stringSimilarity(a, b) {
  const longer = a.length > b.length ? a : b;
  const shorter = a.length > b.length ? b : a;

  if (longer.length === 0) return 1.0;

  // Levenshtein distance
  const matrix = Array.from({ length: shorter.length + 1 }, (_, i) =>
    Array.from({ length: longer.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0))
  );

  for (let i = 1; i <= shorter.length; i++) {
    for (let j = 1; j <= longer.length; j++) {
      const cost = shorter[i - 1] === longer[j - 1] ? 0 : 1;
      matrix[i][j] = Math.min(
        matrix[i - 1][j] + 1,
        matrix[i][j - 1] + 1,
        matrix[i - 1][j - 1] + cost
      );
    }
  }

  return (longer.length - matrix[shorter.length][longer.length]) / longer.length;
}

function scoreMatch(sourceProfile, candidateProfile) {
  let score = 0;
  let signals = [];

  // Username similarity (0-30 points)
  const usernameSim = stringSimilarity(
    sourceProfile.username.toLowerCase().replace(/[._-]/g, ''),
    candidateProfile.username.toLowerCase().replace(/[._-]/g, '')
  );
  const usernameScore = Math.round(usernameSim * 30);
  score += usernameScore;
  if (usernameScore > 20) signals.push(`username match (${Math.round(usernameSim * 100)}%)`);

  // Display name similarity (0-25 points)
  const sourceName = (sourceProfile.fullName || sourceProfile.displayName || '').toLowerCase();
  const candidateName = (candidateProfile.fullName || candidateProfile.displayName || '').toLowerCase();
  if (sourceName && candidateName) {
    const nameSim = stringSimilarity(sourceName, candidateName);
    const nameScore = Math.round(nameSim * 25);
    score += nameScore;
    if (nameScore > 15) signals.push(`display name match (${Math.round(nameSim * 100)}%)`);
  }

  // Bio keyword overlap (0-20 points)
  const sourceBioWords = new Set((sourceProfile.biography || '').toLowerCase().split(/\s+/).filter(w => w.length > 3));
  const candidateBioWords = new Set((candidateProfile.biography || '').toLowerCase().split(/\s+/).filter(w => w.length > 3));
  let bioOverlap = 0;
  for (const word of sourceBioWords) {
    if (candidateBioWords.has(word)) bioOverlap++;
  }
  const bioScore = Math.min(20, Math.round((bioOverlap / Math.max(sourceBioWords.size, 1)) * 20));
  score += bioScore;
  if (bioScore > 10) signals.push(`bio overlap (${bioOverlap} keywords)`);

  // Verified status match (0-10 points)
  if (sourceProfile.isVerified && candidateProfile.isVerified) {
    score += 10;
    signals.push('both verified');
  }

  // Follower count sanity check (0-15 points)
  // Same person should have roughly correlated follower counts
  const ratio = Math.min(sourceProfile.followerCount, candidateProfile.followerCount) /
    Math.max(sourceProfile.followerCount, candidateProfile.followerCount);
  if (ratio > 0.05) { // At least 5% ratio — not a nobody vs. mega-star mismatch
    score += Math.round(ratio * 15);
    if (ratio > 0.2) signals.push(`follower ratio plausible (${Math.round(ratio * 100)}%)`);
  }

  return {
    score: Math.min(100, score),
    confidence: score >= 70 ? 'high' : score >= 45 ? 'medium' : 'low',
    signals,
  };
}

Step 4: Find Matches

async function findCrossPlatformProfiles(platform, username) {
  // Get source profile
  const sourceProfile = await getProfile(platform, username);
  console.log(`\nSource: @${username} on ${platform} (${sourceProfile.followerCount.toLocaleString()} followers)`);

  // Generate username variations to search
  const variations = generateUsernameVariations(username);
  console.log(`Searching ${variations.length} variations across ${PLATFORMS.length} platforms...`);

  // Search other platforms
  const candidates = {};

  for (const targetPlatform of PLATFORMS) {
    if (targetPlatform === platform) continue; // Skip source platform

    candidates[targetPlatform] = [];

    for (const variation of variations.slice(0, 5)) { // Limit to top 5 variations
      try {
        const { data } = await api.get(`/${targetPlatform}/search/users`, {
          params: { keyword: variation, limit: 5 },
        });

        for (const user of (data.users || [])) {
          // Fetch full profile for scoring
          try {
            const profile = await getProfile(targetPlatform, user.username);
            const match = scoreMatch(sourceProfile, profile);

            if (match.score >= 30) { // Minimum threshold
              candidates[targetPlatform].push({
                platform: targetPlatform,
                username: profile.username,
                displayName: profile.fullName || profile.displayName,
                followers: profile.followerCount,
                bio: (profile.biography || '').slice(0, 100),
                ...match,
              });
            }
          } catch (e) {
            // Profile fetch failed, skip
          }
        }
      } catch (e) {
        // Search failed, skip
      }
    }

    // Deduplicate and keep best score per username
    const seen = new Map();
    for (const c of candidates[targetPlatform]) {
      if (!seen.has(c.username) || seen.get(c.username).score < c.score) {
        seen.set(c.username, c);
      }
    }
    candidates[targetPlatform] = [...seen.values()].sort((a, b) => b.score - a.score);
  }

  return { sourceProfile, candidates };
}

Step 5: Generate Unified Profile

function buildUnifiedProfile(sourceProfile, sourcePlatform, matches) {
  const profiles = [{
    platform: sourcePlatform,
    username: sourceProfile.username,
    followers: sourceProfile.followerCount,
    confidence: 'source',
  }];

  for (const [platform, candidates] of Object.entries(matches)) {
    if (candidates.length > 0 && candidates[0].confidence !== 'low') {
      profiles.push({
        platform,
        username: candidates[0].username,
        followers: candidates[0].followers,
        confidence: candidates[0].confidence,
        matchScore: candidates[0].score,
      });
    }
  }

  const totalFollowers = profiles.reduce((sum, p) => sum + p.followers, 0);

  return {
    primaryUsername: sourceProfile.username,
    displayName: sourceProfile.fullName || sourceProfile.displayName,
    totalFollowers,
    platformCount: profiles.length,
    profiles,
  };
}

Step 6: Print the Report

async function matchAndReport(platform, username) {
  const { sourceProfile, candidates } = await findCrossPlatformProfiles(platform, username);

  console.log('\n═══ CROSS-PLATFORM PROFILE MATCH ═══\n');

  const unified = buildUnifiedProfile(sourceProfile, platform, candidates);

  console.log(`Creator: ${unified.displayName || unified.primaryUsername}`);
  console.log(`Total Reach: ${unified.totalFollowers.toLocaleString()} across ${unified.platformCount} platforms\n`);

  for (const p of unified.profiles) {
    const conf = p.confidence === 'source' ? '(source)' :
      p.confidence === 'high' ? '✅ high confidence' :
      '⚠️ medium confidence';

    console.log(`  ${p.platform.padEnd(12)} @${p.username.padEnd(25)} ${p.followers.toLocaleString().padStart(10)} followers  ${conf}`);
  }

  // Show uncertain matches
  for (const [plat, cands] of Object.entries(candidates)) {
    const lowConf = cands.filter(c => c.confidence === 'low' && c.score >= 30);
    if (lowConf.length > 0) {
      console.log(`\n  ❓ Possible ${plat} matches (low confidence):`);
      lowConf.slice(0, 3).forEach(c => {
        console.log(`     @${c.username} (${c.followers.toLocaleString()} followers, score: ${c.score}) — ${c.signals.join(', ')}`);
      });
    }
  }

  return unified;
}

matchAndReport('tiktok', 'sarah_creates');

Sample Output

═══ CROSS-PLATFORM PROFILE MATCH ═══

Creator: Sarah Chen
Total Reach: 312,400 across 4 platforms

  tiktok       @sarah_creates                   148,200 followers  (source)
  instagram    @sarah.creates                    97,800 followers  ✅ high confidence
  youtube      @SarahCreates                     66,400 followers  ✅ high confidence
  twitter      @sarahcreates_                    12,300 followers  ⚠️ medium confidence

  ❓ Possible threads matches (low confidence):
     @sarah_creates (2,100 followers, score: 38) — username match (92%), bio overlap (3 keywords)

4 platforms confirmed. 312K total reach vs. the 148K you'd see looking only at TikTok.

Read the Full Guide

This is a condensed version. The full guide includes:

Profile picture similarity using image hashing
Link-in-bio cross-referencing
Batch matching for lists of 100+ creators
Caching matched profiles in a database

Read the complete guide on SociaVault →

Building influencer analytics tools? SociaVault provides social media data APIs for TikTok, Instagram, YouTube, and 10+ platforms. Search users, fetch profiles, and build cross-platform views with one unified API.

Discussion

How do you handle cross-platform creator identification today? Manual? Platforms? Have you found any creative signals that help confirm matches? 👇

webdev #api #nodejs #socialmedia #javascript