Multi-Platform Influencer Report: Compare Creators Across Every Network
Most influencers are on 3-5 platforms. Most analytics tools only show you one at a time. If you're evaluating a creator for a campaign, you need the full picture — not just their Instagram follower count.
Here's how to build a unified influencer report that pulls data from Instagram, TikTok, YouTube, Twitter, and Threads, normalizes the metrics, and generates a single comparison you can actually use.
Pull a Creator's Full Social Footprint
Start by collecting data from every platform a creator is on:
const API_KEY = process.env.SOCIAVAULT_API_KEY;
const BASE = 'https://api.sociavault.com/v1/scrape';
const headers = { 'X-API-Key': API_KEY };
async function getCreatorFootprint(creator) {
const report = {
name: creator.name,
platforms: {},
totalReach: 0,
totalContent: 0
};
// Instagram
if (creator.instagram) {
const res = await fetch(
`${BASE}/instagram/profile?username=${encodeURIComponent(creator.instagram)}`,
{ headers }
);
const data = (await res.json()).data;
if (data) {
report.platforms.instagram = {
username: data.username,
followers: data.follower_count || 0,
following: data.following_count || 0,
posts: data.media_count || 0,
verified: data.is_verified || false,
bio: data.biography || ''
};
report.totalReach += data.follower_count || 0;
report.totalContent += data.media_count || 0;
}
await new Promise(r => setTimeout(r, 1500));
}
// TikTok
if (creator.tiktok) {
const res = await fetch(
`${BASE}/tiktok/profile?username=${encodeURIComponent(creator.tiktok)}`,
{ headers }
);
const data = (await res.json()).data;
if (data) {
report.platforms.tiktok = {
username: data.user?.uniqueId || creator.tiktok,
followers: data.stats?.followerCount || 0,
following: data.stats?.followingCount || 0,
likes: data.stats?.heartCount || 0,
videos: data.stats?.videoCount || 0,
verified: data.user?.verified || false,
bio: data.user?.signature || ''
};
report.totalReach += data.stats?.followerCount || 0;
report.totalContent += data.stats?.videoCount || 0;
}
await new Promise(r => setTimeout(r, 1500));
}
// YouTube
if (creator.youtube) {
const res = await fetch(
`${BASE}/youtube/channel?channelId=${encodeURIComponent(creator.youtube)}`,
{ headers }
);
const data = (await res.json()).data;
if (data) {
const stats = data.statistics || {};
report.platforms.youtube = {
name: data.snippet?.title || creator.youtube,
subscribers: Number(stats.subscriberCount || 0),
totalViews: Number(stats.viewCount || 0),
videos: Number(stats.videoCount || 0),
description: (data.snippet?.description || '').substring(0, 200)
};
report.totalReach += Number(stats.subscriberCount || 0);
report.totalContent += Number(stats.videoCount || 0);
}
await new Promise(r => setTimeout(r, 1500));
}
// Twitter/X
if (creator.twitter) {
const res = await fetch(
`${BASE}/twitter/profile?username=${encodeURIComponent(creator.twitter)}`,
{ headers }
);
const data = (await res.json()).data;
if (data) {
const legacy = data.legacy || data;
report.platforms.twitter = {
username: legacy.screen_name || data.core?.screen_name || creator.twitter,
followers: legacy.followers_count || 0,
following: legacy.friends_count || 0,
tweets: legacy.statuses_count || 0,
verified: data.is_blue_verified || false,
bio: legacy.description || ''
};
report.totalReach += legacy.followers_count || 0;
report.totalContent += legacy.statuses_count || 0;
}
await new Promise(r => setTimeout(r, 1500));
}
// Threads
if (creator.threads) {
const res = await fetch(
`${BASE}/threads/profile?username=${encodeURIComponent(creator.threads)}`,
{ headers }
);
const data = (await res.json()).data;
if (data) {
report.platforms.threads = {
username: data.username || creator.threads,
followers: data.follower_count || 0,
verified: data.is_verified || false,
bio: data.biography || ''
};
report.totalReach += data.follower_count || 0;
}
await new Promise(r => setTimeout(r, 1500));
}
return report;
}
// Example usage
const report = await getCreatorFootprint({
name: 'Creator Name',
instagram: 'creator',
tiktok: 'creator',
youtube: 'UCxxxxxxxx',
twitter: 'creator',
threads: 'creator'
});
Normalize and Score
Different platforms have different metrics. Normalize them for fair comparison:
function scoreCreator(report) {
const scores = {};
let totalScore = 0;
let platformCount = 0;
// Instagram scoring
if (report.platforms.instagram) {
const ig = report.platforms.instagram;
const followerScore = Math.min(ig.followers / 100000, 1) * 25;
const contentScore = Math.min(ig.posts / 500, 1) * 15;
const ratioScore = ig.following > 0
? Math.min((ig.followers / ig.following) / 10, 1) * 10
: 5;
scores.instagram = Math.round(followerScore + contentScore + ratioScore);
totalScore += scores.instagram;
platformCount++;
}
// TikTok scoring
if (report.platforms.tiktok) {
const tk = report.platforms.tiktok;
const followerScore = Math.min(tk.followers / 100000, 1) * 20;
const likesScore = Math.min(tk.likes / 1000000, 1) * 15;
const contentScore = Math.min(tk.videos / 200, 1) * 10;
const likesPerFollower = tk.followers > 0 ? tk.likes / tk.followers : 0;
const engScore = Math.min(likesPerFollower / 20, 1) * 5;
scores.tiktok = Math.round(followerScore + likesScore + contentScore + engScore);
totalScore += scores.tiktok;
platformCount++;
}
// YouTube scoring
if (report.platforms.youtube) {
const yt = report.platforms.youtube;
const subScore = Math.min(yt.subscribers / 100000, 1) * 20;
const viewScore = Math.min(yt.totalViews / 10000000, 1) * 15;
const contentScore = Math.min(yt.videos / 100, 1) * 10;
const viewsPerSub = yt.subscribers > 0 ? yt.totalViews / yt.subscribers : 0;
const effScore = Math.min(viewsPerSub / 100, 1) * 5;
scores.youtube = Math.round(subScore + viewScore + contentScore + effScore);
totalScore += scores.youtube;
platformCount++;
}
// Twitter scoring
if (report.platforms.twitter) {
const tw = report.platforms.twitter;
const followerScore = Math.min(tw.followers / 100000, 1) * 20;
const ratioScore = tw.following > 0
? Math.min((tw.followers / tw.following) / 10, 1) * 10
: 5;
const activityScore = Math.min(tw.tweets / 5000, 1) * 10;
scores.twitter = Math.round(followerScore + ratioScore + activityScore);
totalScore += scores.twitter;
platformCount++;
}
// Cross-platform bonus
const crossPlatformBonus = Math.min(platformCount * 3, 15);
// Final score (0-100 scale)
const maxPossible = platformCount * 50;
const normalizedScore = maxPossible > 0
? Math.round((totalScore / maxPossible) * 85 + crossPlatformBonus)
: 0;
return {
platformScores: scores,
totalScore: Math.min(normalizedScore, 100),
platformCount,
totalReach: report.totalReach
};
}
Compare Multiple Creators
Run reports for several creators and rank them:
async function compareCreators(creators) {
const reports = [];
for (const creator of creators) {
console.log(`\nAnalyzing: ${creator.name}...`);
const footprint = await getCreatorFootprint(creator);
const score = scoreCreator(footprint);
reports.push({
name: creator.name,
...score,
platforms: Object.keys(footprint.platforms)
});
}
// Sort by total score
reports.sort((a, b) => b.totalScore - a.totalScore);
// Print comparison
console.log('\n' + '═'.repeat(70));
console.log(' INFLUENCER COMPARISON REPORT');
console.log('═'.repeat(70));
reports.forEach((r, i) => {
console.log(`\n #${i + 1} ${r.name}`);
console.log(` ${'─'.repeat(50)}`);
console.log(` Overall Score: ${r.totalScore}/100`);
console.log(` Total Reach: ${r.totalReach.toLocaleString()}`);
console.log(` Platforms: ${r.platforms.join(', ')} (${r.platformCount})`);
if (r.platformScores) {
console.log(` Platform scores:`);
for (const [platform, score] of Object.entries(r.platformScores)) {
console.log(` ${platform.padEnd(12)} ${score}/50`);
}
}
});
return reports;
}
// Compare creators for a campaign
await compareCreators([
{
name: 'Creator A',
instagram: 'creatora',
tiktok: 'creatora',
youtube: 'UCxxxxxxxx',
twitter: 'creatora'
},
{
name: 'Creator B',
instagram: 'creatorb',
tiktok: 'creatorb',
threads: 'creatorb'
},
{
name: 'Creator C',
instagram: 'creatorc',
tiktok: 'creatorc',
youtube: 'UCyyyyyyyy',
twitter: 'creatorc',
threads: 'creatorc'
}
]);
Full Python Report Generator
Generate a complete report with export:
import os
import json
import csv
import time
import requests
API_KEY = os.environ["SOCIAVAULT_API_KEY"]
BASE = "https://api.sociavault.com/v1/scrape"
HEADERS = {"X-API-Key": API_KEY}
def fetch_platform(endpoint, params):
try:
r = requests.get(f"{BASE}/{endpoint}", headers=HEADERS, params=params)
return r.json().get("data", {})
except Exception:
return {}
def generate_influencer_report(creators):
"""Generate a multi-platform influencer comparison report"""
reports = []
for creator in creators:
entry = {"name": creator["name"], "platforms": {}, "total_reach": 0}
# Instagram
if creator.get("instagram"):
data = fetch_platform("instagram/profile", {"username": creator["instagram"]})
if data:
entry["platforms"]["instagram"] = {
"followers": data.get("follower_count", 0),
"posts": data.get("media_count", 0),
"verified": data.get("is_verified", False),
}
entry["total_reach"] += data.get("follower_count", 0)
time.sleep(1.5)
# TikTok
if creator.get("tiktok"):
data = fetch_platform("tiktok/profile", {"username": creator["tiktok"]})
if data:
stats = data.get("stats", {})
entry["platforms"]["tiktok"] = {
"followers": stats.get("followerCount", 0),
"likes": stats.get("heartCount", 0),
"videos": stats.get("videoCount", 0),
"verified": (data.get("user", {}) or {}).get("verified", False),
}
entry["total_reach"] += stats.get("followerCount", 0)
time.sleep(1.5)
# YouTube
if creator.get("youtube"):
data = fetch_platform("youtube/channel", {"channelId": creator["youtube"]})
if data:
stats = data.get("statistics", {})
entry["platforms"]["youtube"] = {
"subscribers": int(stats.get("subscriberCount", 0)),
"total_views": int(stats.get("viewCount", 0)),
"videos": int(stats.get("videoCount", 0)),
}
entry["total_reach"] += int(stats.get("subscriberCount", 0))
time.sleep(1.5)
# Twitter
if creator.get("twitter"):
data = fetch_platform("twitter/profile", {"username": creator["twitter"]})
if data:
legacy = data.get("legacy", data)
entry["platforms"]["twitter"] = {
"followers": legacy.get("followers_count", 0),
"tweets": legacy.get("statuses_count", 0),
"verified": data.get("is_blue_verified", False),
}
entry["total_reach"] += legacy.get("followers_count", 0)
time.sleep(1.5)
# Threads
if creator.get("threads"):
data = fetch_platform("threads/profile", {"username": creator["threads"]})
if data:
entry["platforms"]["threads"] = {
"followers": data.get("follower_count", 0),
"verified": data.get("is_verified", False),
}
entry["total_reach"] += data.get("follower_count", 0)
time.sleep(1.5)
entry["platform_count"] = len(entry["platforms"])
reports.append(entry)
print(f" Collected: {creator['name']} ({entry['platform_count']} platforms)")
# Sort by reach
reports.sort(key=lambda x: x["total_reach"], reverse=True)
# Print report
print("\n" + "=" * 60)
print(" MULTI-PLATFORM INFLUENCER REPORT")
print("=" * 60)
for i, r in enumerate(reports):
print(f"\n #{i+1} {r['name']}")
print(f" Total Reach: {r['total_reach']:,}")
print(f" Platforms: {', '.join(r['platforms'].keys())}")
for platform, data in r["platforms"].items():
followers = data.get("followers") or data.get("subscribers", 0)
print(f" {platform}: {followers:,} followers")
# Export to CSV
with open("influencer-report.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerow([
"Name", "Total Reach", "Platforms",
"IG Followers", "TK Followers", "YT Subscribers",
"TW Followers", "Threads Followers"
])
for r in reports:
writer.writerow([
r["name"],
r["total_reach"],
r["platform_count"],
r["platforms"].get("instagram", {}).get("followers", ""),
r["platforms"].get("tiktok", {}).get("followers", ""),
r["platforms"].get("youtube", {}).get("subscribers", ""),
r["platforms"].get("twitter", {}).get("followers", ""),
r["platforms"].get("threads", {}).get("followers", ""),
])
# Export to JSON
with open("influencer-report.json", "w") as f:
json.dump(reports, f, indent=2)
print(f"\n Exported: influencer-report.csv + influencer-report.json")
return reports
generate_influencer_report([
{
"name": "Creator A",
"instagram": "creatora",
"tiktok": "creatora",
"youtube": "UCxxxxxxxx",
"twitter": "creatora",
"threads": "creatora",
},
{
"name": "Creator B",
"instagram": "creatorb",
"tiktok": "creatorb",
"threads": "creatorb",
},
])
Credit Cost per Report
| Platforms Checked | Credits per Creator | 10 Creators |
|---|---|---|
| 2 platforms | 2 | 20 |
| 3 platforms | 3 | 30 |
| 4 platforms | 4 | 40 |
| 5 platforms (all) | 5 | 50 |
At 1 credit per request, a full 5-platform report for 10 creators costs just 50 credits. Compare that to CreatorIQ ($2,500/month) or Grin ($1,500/month) for the same data.
What Makes a Strong Multi-Platform Creator
| Signal | Strong | Weak |
|---|---|---|
| Platform count | 3-5 active | 1 platform only |
| Follower consistency | Similar tier across platforms | 1M on one, 500 on others |
| Content frequency | Regular posting on 2+ platforms | Inactive on most |
| Verification | Verified on primary platform | Unverified everywhere |
| Follower-to-following ratio | >5:1 | <1:1 |
| Bio consistency | Same branding, links to each other | Disconnected profiles |
| Cross-promotion | Links between platforms | No cross-referencing |
Get Started
Sign up free — build comprehensive influencer reports across every social platform.
Related Reading
Found this helpful?
Share it with others who might benefit
Ready to Try SociaVault?
Start extracting social media data with our powerful API. No credit card required.