How to Check If an Influencer Has Fake Followers (Free Methods + Data)

You're about to sign a $5,000 deal with an influencer. They have 200K followers, decent-looking comments, and a polished feed. Everything looks legit.

But here's the problem: our 100K-account study found that 37.2% of influencer followers are fake or suspicious. In the macro tier (100K–500K), that number jumps to 48.3%. And in the beauty niche? 52.1%.

That $5,000 could be reaching 100K real people — or 50K bots and 50K humans. You'd never know from looking at the profile.

This guide gives you 5 concrete methods to check, from free manual techniques anyone can use, to API-based programmatic checks for teams running campaigns at scale.

The 5-Second Red Flag Check

Before you do anything else, run through these quick signals. They won't catch sophisticated fraud, but they'll flag the obvious cases:

Instant red flags:

❌ 200K followers, 50 likes per post (engagement rate under 0.05%)
❌ Follower count way higher than following count (10:1+ ratio for non-celebrities)
❌ Comments are all generic: "Nice!" "🔥" "Great post!" "Love this ❤️"
❌ Rapid follower growth with no viral content to explain it
❌ Large number of followers with no profile pictures or zero posts

If any of these show up, dig deeper. If multiple show up, save your money.

Method 1: Check the Engagement Rate (Free, Manual)

This is the simplest check, and it catches most fraud.

How to do it manually:

Go to the influencer's profile
Pick 10 recent posts (not Reels — feed posts)
For each post, add likes + comments
Divide by their follower count
Multiply by 100
Average the 10 results

What the numbers mean:

Follower Tier	Normal ER	Suspicious	Likely Fake
1K – 10K	3.0% – 6.0%	1.5% – 3.0%	Below 1.5%
10K – 50K	2.0% – 4.0%	1.0% – 2.0%	Below 1.0%
50K – 100K	1.5% – 3.0%	0.8% – 1.5%	Below 0.8%
100K – 500K	1.0% – 2.5%	0.5% – 1.0%	Below 0.5%
500K+	0.7% – 1.8%	0.3% – 0.7%	Below 0.3%

These benchmarks are from our 2026 engagement rate study based on clean, verified accounts. If an account is significantly below the "Normal" range for their tier, something is off.

The catch: Engagement rate alone isn't conclusive. Some creators have bad content but real followers. Some have bought both followers AND engagement (like-bots). You need to check more signals.

Method 2: Audit the Comment Quality (Free, Manual)

This is the most reliable single indicator of fake followers. In our study, comment quality analysis had an 87.3% accuracy rate for detecting fraud.

What to look for:

Open 5-10 posts. Read the comments. Ask yourself:

Signs of real engagement:

✅ Comments reference specific content in the post ("That shade of lipstick is stunning")
✅ Questions about the product/topic ("Where did you buy that?")
✅ Multi-sentence responses
✅ Back-and-forth conversations in replies
✅ Comments from accounts with real profiles, posts, and followers

Signs of bot/fake engagement:

❌ One or two word comments: "Nice!" "Beautiful!" "Amazing post!"
❌ Emoji-only comments: "🔥🔥🔥" "❤️❤️" "👏👏"
❌ Generic praise that could apply to any post
❌ Comments from accounts with 0 posts, no profile photo, or random usernames
❌ Same commenters appearing on every single post
❌ Comments in a language different from the creator's content/audience

Real example: An account with 300K followers where every post has 100+ comments, but 80% of them are "👏" "❤️" "Nice pic!" from accounts named user839274621. That's bot engagement. Run.

Method 3: Check the Follower/Following Ratio (Free, Manual)

The math here is simple:

Account Type	Normal Ratio	Suspicious
Celebrities / Mega creators	50:1 to 500:1	N/A (they just don't follow many people)
Macro creators (100K+)	10:1 to 50:1	Following more than 2,000 people
Micro creators (10K-50K)	2:1 to 10:1	Following count close to or exceeding followers
Nano creators (1K-10K)	1:1 to 3:1	Totally normal if ratio is near 1:1

What matters: If an account has 200K followers and follows 7,500 people, they likely used follow/unfollow automation. They followed thousands of accounts (many followed back), then unfollowed. The followers who didn't notice are still there — but they're low-quality, disengaged followers.

Method 4: Analyze the Growth Pattern (API-Based)

This is where you move beyond manual checks. Organic growth is gradual. Purchased followers appear in spikes.

You can detect this by tracking follower counts over time, or by analyzing the posting timeline vs. engagement patterns. If someone has 200K followers but their last 50 posts average 300 likes, the math doesn't add up — those followers didn't come from the content.

Here's how to build a quick follower audit:

const axios = require('axios');

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

async function auditInfluencer(platform, handle) {
  if (platform === 'instagram') {
    return await auditInstagram(handle);
  } else if (platform === 'tiktok') {
    return await auditTikTok(handle);
  }
}

async function auditInstagram(handle) {
  // Get profile data
  const profile = await axios.get(`${BASE_URL}/v1/scrape/instagram/profile`, {
    params: { handle, trim: true },
    headers: { 'X-API-Key': API_KEY }
  });

  const user = profile.data.data.data.user;
  const followers = user.edge_followed_by.count;
  const following = user.edge_follow.count;
  const postCount = user.edge_owner_to_timeline_media.count;

  // Get recent posts for engagement analysis
  const posts = await axios.get(`${BASE_URL}/v1/scrape/instagram/posts`, {
    params: { handle, trim: true },
    headers: { 'X-API-Key': API_KEY }
  });

  const edges = posts.data.data.data.user.edge_owner_to_timeline_media.edges;

  // Calculate engagement metrics
  const engagements = edges.map(e => {
    const likes = e.node.edge_liked_by?.count || 0;
    const comments = e.node.edge_media_to_comment?.count || 0;
    return { likes, comments, total: likes + comments };
  });

  const avgEngagement = engagements.reduce((s, e) => s + e.total, 0) / engagements.length;
  const engagementRate = (avgEngagement / followers) * 100;

  // Flag suspicious patterns
  const flags = [];

  // Flag 1: Low engagement rate for follower tier
  if (followers > 100000 && engagementRate < 0.5) {
    flags.push(`Very low ER (${engagementRate.toFixed(2)}%) for ${followers.toLocaleString()} followers`);
  } else if (followers > 10000 && engagementRate < 1.0) {
    flags.push(`Low ER (${engagementRate.toFixed(2)}%) for ${followers.toLocaleString()} followers`);
  }

  // Flag 2: Suspicious follower/following ratio
  if (following > 2000 && followers / following < 5) {
    flags.push(`High following count (${following.toLocaleString()}) suggests follow/unfollow growth`);
  }

  // Flag 3: Engagement variance (consistent engagement = possible pods/bots)
  const erValues = engagements.map(e => (e.total / followers) * 100);
  const variance = calculateVariance(erValues);
  if (variance < 0.1 && engagements.length > 5) {
    flags.push('Suspiciously consistent engagement across posts (possible engagement pods)');
  }

  // Flag 4: Like/comment ratio
  const avgLikes = engagements.reduce((s, e) => s + e.likes, 0) / engagements.length;
  const avgComments = engagements.reduce((s, e) => s + e.comments, 0) / engagements.length;
  const likeCommentRatio = avgLikes / (avgComments || 1);
  if (likeCommentRatio > 200) {
    flags.push(`Extremely high like-to-comment ratio (${likeCommentRatio.toFixed(0)}:1) — typical of purchased likes`);
  }

  const result = {
    platform: 'instagram',
    handle,
    followers,
    following,
    postCount,
    avgLikes: Math.round(avgLikes),
    avgComments: Math.round(avgComments),
    engagementRate: engagementRate.toFixed(2) + '%',
    likeCommentRatio: likeCommentRatio.toFixed(0) + ':1',
    flags,
    riskLevel: flags.length === 0 ? 'LOW' : flags.length <= 2 ? 'MEDIUM' : 'HIGH'
  };

  console.log('\n--- INFLUENCER AUDIT REPORT ---');
  console.log(`Account: @${handle} (Instagram)`);
  console.log(`Followers: ${followers.toLocaleString()}`);
  console.log(`Following: ${following.toLocaleString()}`);
  console.log(`Avg Engagement Rate: ${result.engagementRate}`);
  console.log(`Like:Comment Ratio: ${result.likeCommentRatio}`);
  console.log(`Risk Level: ${result.riskLevel}`);
  if (flags.length > 0) {
    console.log(`\nRed Flags:`);
    flags.forEach(f => console.log(`  ⚠️ ${f}`));
  } else {
    console.log(`\n✅ No red flags detected`);
  }

  return result;
}

function calculateVariance(values) {
  const mean = values.reduce((a, b) => a + b, 0) / values.length;
  return values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length;
}

// Audit an influencer
await auditInfluencer('instagram', 'garyvee');

TikTok version:

async function auditTikTok(handle) {
  const profile = await axios.get(`${BASE_URL}/v1/scrape/tiktok/profile`, {
    params: { handle },
    headers: { 'X-API-Key': API_KEY }
  });

  const { user, stats } = profile.data.data;
  const followers = stats.followerCount;
  const following = stats.followingCount;
  const totalLikes = stats.heart;
  const videoCount = stats.videoCount;

  // Get recent videos
  const videos = await axios.get(`${BASE_URL}/v1/scrape/tiktok/profile-videos`, {
    params: { handle, sort_by: 'latest', trim: true },
    headers: { 'X-API-Key': API_KEY }
  });

  const videoList = videos.data.data.aweme_list || [];

  const engagements = videoList.map(v => ({
    views: v.statistics?.play_count || 0,
    likes: v.statistics?.digg_count || 0,
    comments: v.statistics?.comment_count || 0,
    shares: v.statistics?.share_count || 0
  }));

  const avgViews = engagements.reduce((s, e) => s + e.views, 0) / engagements.length;
  const avgLikes = engagements.reduce((s, e) => s + e.likes, 0) / engagements.length;
  const avgComments = engagements.reduce((s, e) => s + e.comments, 0) / engagements.length;
  const engagementRate = ((avgLikes + avgComments) / followers) * 100;

  const flags = [];

  // TikTok-specific: views-to-followers ratio
  const viewRatio = avgViews / followers;
  if (viewRatio < 0.02) {
    flags.push(`Very low view ratio (${(viewRatio * 100).toFixed(1)}% of followers see content)`);
  }

  // Low engagement
  if (followers > 50000 && engagementRate < 1.0) {
    flags.push(`Low engagement rate (${engagementRate.toFixed(2)}%) for ${followers.toLocaleString()} followers`);
  }

  // High following count
  if (following > 3000) {
    flags.push(`Following ${following.toLocaleString()} accounts — possible mass-follow growth`);
  }

  console.log('\n--- TIKTOK AUDIT ---');
  console.log(`@${handle}: ${followers.toLocaleString()} followers`);
  console.log(`Avg views: ${Math.round(avgViews).toLocaleString()}`);
  console.log(`Avg likes: ${Math.round(avgLikes).toLocaleString()}`);
  console.log(`ER: ${engagementRate.toFixed(2)}%`);
  console.log(`Flags: ${flags.length === 0 ? 'None ✅' : flags.join(', ')}`);

  return { handle, followers, engagementRate: engagementRate.toFixed(2), flags };
}

await auditInfluencer('tiktok', 'khaby.lame');

Cost: 2 credits per Instagram audit (profile + posts). 2 credits per TikTok audit (profile + videos).

Method 5: Batch-Check Comment Quality (API-Based)

This is the most powerful method. Instead of manually reading comments, pull them programmatically and analyze the quality:

import requests
import os
import re

API_KEY = os.getenv('SOCIAVAULT_API_KEY')
BASE_URL = 'https://api.sociavault.com'
headers = {'X-API-Key': API_KEY}

def analyze_comment_quality(platform, post_url, sample_size=50):
    """Pull comments from a post and analyze for bot signals"""

    if platform == 'instagram':
        endpoint = f'{BASE_URL}/v1/scrape/instagram/comments'
        params = {'url': post_url, 'amount': sample_size}
    elif platform == 'tiktok':
        endpoint = f'{BASE_URL}/v1/scrape/tiktok/comments'
        params = {'url': post_url}

    response = requests.get(endpoint, params=params, headers=headers)
    data = response.json()

    # Get comments array (structure varies by platform)
    comments = data.get('data', {}).get('comments', [])

    if not comments:
        print("No comments found")
        return None

    bot_signals = 0
    total = len(comments)

    for comment in comments[:sample_size]:
        text = comment.get('text', '') or comment.get('comment', '')
        is_suspicious = False

        # Signal 1: Very short comment (under 5 chars)
        if len(text.strip()) < 5:
            is_suspicious = True

        # Signal 2: Emoji-only
        emoji_pattern = re.compile(
            r'^[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF'
            r'\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF'
            r'\U00002702-\U000027B0\U0000FE00-\U0000FE0F'
            r'\U0000200D\s]+$'
        )
        if emoji_pattern.match(text.strip()):
            is_suspicious = True

        # Signal 3: Generic bot phrases
        generic_phrases = [
            'nice', 'great', 'awesome', 'amazing', 'love it',
            'beautiful', 'cool', 'wow', 'perfect', 'wonderful',
            'follow me', 'check my', 'dm me', 'link in bio'
        ]
        if text.strip().lower() in generic_phrases:
            is_suspicious = True

        if is_suspicious:
            bot_signals += 1

    bot_percentage = (bot_signals / total) * 100

    print(f"\nComment Quality Analysis ({total} comments)")
    print(f"Suspicious comments: {bot_signals}/{total} ({bot_percentage:.1f}%)")

    if bot_percentage > 60:
        print("⚠️ HIGH RISK: Majority of comments appear bot-generated")
    elif bot_percentage > 30:
        print("⚠️ MEDIUM RISK: Significant bot comment activity")
    else:
        print("✅ LOW RISK: Comments appear mostly genuine")

    return {'total': total, 'suspicious': bot_signals, 'percentage': bot_percentage}

# Check a specific post
analyze_comment_quality(
    'instagram',
    'https://www.instagram.com/p/EXAMPLE_POST_ID/'
)

Cost: 1 credit per post comment check.

The "3-Indicator Quick Check"

From our study, if three signals are all flagged simultaneously, the account is fraudulent 93% of the time:

Comment quality — Over 60% generic/emoji comments
Engagement rate — Below the "Suspicious" threshold for their tier
Like-to-comment ratio — Over 200:1

If you have limited time or budget, check these three things. That's it. You'll catch the vast majority of fake accounts.

Free Tools vs. API: Which Should You Use?

Approach	Best For	Limitations
Manual checks (Methods 1-3)	One-off brand deals, small budgets	Slow, subjective, can't scale
Free third-party tools (HypeAuditor free tier, Social Blade)	Quick sanity checks	Limited data, often outdated, paywalled features
API-based checks (Methods 4-5)	Agencies, platforms, bulk vetting	Requires development, costs per lookup

Be honest about the free tools: HypeAuditor's free tier gives you a basic score but hides the details behind a paywall. Social Blade shows follower trends but doesn't analyze engagement quality. NotJustAnalytics (formerly Ninjalitics) is decent for basic Instagram stats.

None of them give you raw data. If you want to build custom fraud detection — or integrate vetting into your workflow — you need the underlying data from an API like SociaVault.

Real-World Vetting Checklist

Before signing any influencer deal, run through this:

Engagement rate within normal range for their tier? (Benchmark reference)
Comments reference actual content, not just "🔥🔥🔥"?
Following count under 2,000 for macro+ accounts?
Like-to-comment ratio under 200:1?
Audience location matches your target market? (Check who's commenting)
Growth is gradual, not sudden spikes with no viral content?
Recent posts have consistent engagement, not huge drops?
Sponsored posts perform similarly to organic posts? (Big drops = disengaged audience)

An account that passes all 8 checks is almost certainly legitimate.

The Cost of Not Checking

Here's the math:

Average brand deal (macro tier): $5,000
Fraud rate in macro tier: 48.3%
Expected waste per unvetted deal: ~$2,415

If you're an agency running 20 influencer partnerships per quarter, that's $48,300/quarter in potential waste. A few API credits for vetting is the cheapest insurance you'll ever buy.

Full research: 37.2% of Influencer Followers Are Fake — Key Findings

Get Started

The manual methods in this guide are free and work today. Open Instagram, start checking.

For programmatic vetting at scale, sign up for SociaVault — 100 free credits gets you 50 influencer audits across Instagram and TikTok.

Full API docs: docs.sociavault.com

How to Check If an Influencer Has Fake Followers (Free Methods + Data)

How to Check If an Influencer Has Fake Followers (Free Methods + Data)

The 5-Second Red Flag Check

Method 1: Check the Engagement Rate (Free, Manual)

Method 2: Audit the Comment Quality (Free, Manual)

Signs of real engagement:

Signs of bot/fake engagement:

Method 3: Check the Follower/Following Ratio (Free, Manual)

Method 4: Analyze the Growth Pattern (API-Based)

Method 5: Batch-Check Comment Quality (API-Based)

The "3-Indicator Quick Check"

Free Tools vs. API: Which Should You Use?

Real-World Vetting Checklist

The Cost of Not Checking

Get Started

Found this helpful?

Ready to Try SociaVault?

How to Check If an Influencer Has Fake Followers (Free Methods + Data)

How to Check If an Influencer Has Fake Followers (Free Methods + Data)

The 5-Second Red Flag Check

Method 1: Check the Engagement Rate (Free, Manual)

Method 2: Audit the Comment Quality (Free, Manual)

Signs of real engagement:

Signs of bot/fake engagement:

Method 3: Check the Follower/Following Ratio (Free, Manual)

Method 4: Analyze the Growth Pattern (API-Based)

Method 5: Batch-Check Comment Quality (API-Based)

The "3-Indicator Quick Check"

Free Tools vs. API: Which Should You Use?

Real-World Vetting Checklist

The Cost of Not Checking

Get Started

Related Reading

Found this helpful?

Ready to Try SociaVault?