Influencer Vetting: Detect Fake Followers Before You Pay

You find an influencer with 200K followers. Their engagement looks solid. You pay them $3,000 for a sponsored post.

The post goes live. You get 50 website visits and zero sales.

What happened? 70% of their followers were bots. The engagement was fake. You just threw away $3,000.

I have made this mistake. Multiple times. Paid influencers who looked legit but delivered nothing. Their follower counts were inflated. Their engagement was purchased. Their "influence" was manufactured.

Now I vet every influencer with data before paying them. I can spot fake followers in 5 minutes. I verify authentic engagement. I know their real reach.

Let me show you how to vet influencers properly so you never waste money on fake accounts again.

Why Influencer Fraud Is Everywhere

The influencer marketing industry is full of fraud.

A study found that 49% of influencers have purchased fake followers. Another study showed that brands waste $1.3 billion per year on influencer fraud.

Why is it so common? Because it is easy and profitable.

How Influencers Fake It:

1. Buy followers - Services sell 10K followers for $50
2. Buy engagement - Services sell likes and comments in bulk
3. Use engagement pods - Groups that like and comment on each other's posts
4. Bot comments - Automated generic comments to inflate numbers

Most brands never check. They see the follower count and assume it is real.

Red Flag 1: Suspicious Follower Count

Real follower growth is gradual. Fake growth shows obvious spikes.

Check Engagement Rate

Here is what normal engagement rates look like:

Under 10K followers: 5% to 8% engagement 10K to 100K followers: 3% to 5% engagement 100K to 1M followers: 1% to 3% engagement Over 1M followers: Under 2% engagement

If someone has 500K followers but only gets 500 likes per post, that is 0.1% engagement. Way too low. Most followers are fake.

const axios = require('axios');

async function checkEngagementRate(handle, platform = 'instagram') {
  try {
    // Get profile data
    const profileResponse = await axios.get(
      `https://api.sociavault.com/${platform}/profile`,
      {
        params: { handle: handle },
        headers: {
          'X-API-Key': process.env.SOCIAVAULT_API_KEY
        }
      }
    );
    
    const profile = profileResponse.data.profile;
    const followers = profile.followersCount;
    
    // Get recent posts
    const postsResponse = await axios.get(
      `https://api.sociavault.com/${platform}/posts`,
      {
        params: { handle: handle, amount: 12 },
        headers: {
          'X-API-Key': process.env.SOCIAVAULT_API_KEY
        }
      }
    );
    
    const posts = platform === 'instagram' ? postsResponse.data.posts : postsResponse.data.videos;
    
    // Calculate average engagement
    let totalEngagement = 0;
    posts.forEach(post => {
      if (platform === 'instagram') {
        totalEngagement += post.likesCount + post.commentsCount;
      } else {
        totalEngagement += post.diggCount + post.commentCount;
      }
    });
    
    const avgEngagement = totalEngagement / posts.length;
    const engagementRate = ((avgEngagement / followers) * 100).toFixed(2);
    
    // Determine expected range
    let expectedMin, expectedMax;
    if (followers < 10000) {
      expectedMin = 5;
      expectedMax = 8;
    } else if (followers < 100000) {
      expectedMin = 3;
      expectedMax = 5;
    } else if (followers < 1000000) {
      expectedMin = 1;
      expectedMax = 3;
    } else {
      expectedMin = 0.5;
      expectedMax = 2;
    }
    
    const isSuspicious = parseFloat(engagementRate) < expectedMin / 2;
    
    console.log(`\n=== ENGAGEMENT ANALYSIS: @${handle} ===`);
    console.log(`Followers: ${followers.toLocaleString()}`);
    console.log(`Avg Engagement per Post: ${avgEngagement.toFixed(0)}`);
    console.log(`Engagement Rate: ${engagementRate}%`);
    console.log(`Expected Range: ${expectedMin}% to ${expectedMax}%`);
    
    if (isSuspicious) {
      console.log(`\n⚠️ WARNING: Engagement rate is suspiciously low`);
      console.log(`Likely has fake followers`);
    } else if (parseFloat(engagementRate) >= expectedMin) {
      console.log(`\n✅ Engagement rate looks normal`);
    } else {
      console.log(`\n⚠️ Engagement rate is below average`);
    }
    
    return {
      followers,
      avgEngagement,
      engagementRate: parseFloat(engagementRate),
      isSuspicious,
      expectedRange: `${expectedMin}%-${expectedMax}%`
    };
  } catch (error) {
    console.error('Failed to check engagement rate:', error.message);
    return null;
  }
}

// Check an influencer
const analysis = await checkEngagementRate('influencer_handle', 'instagram');

Example Results

Legit Influencer:

• Followers: 85,000
• Avg engagement: 3,400
• Engagement rate: 4%
• Status: Normal (expected 3% to 5%)

Fake Influencer:

• Followers: 250,000
• Avg engagement: 800
• Engagement rate: 0.32%
• Status: Suspicious (expected 1% to 3%)

The fake influencer has 3x more followers but worse engagement. Clear sign of purchased followers.

Red Flag 2: Low-Quality Followers

Check if followers are real people or empty bot accounts.

async function analyzeFollowers(handle, platform = 'instagram', sampleSize = 100) {
  try {
    const response = await axios.get(
      `https://api.sociavault.com/${platform}/followers`,
      {
        params: {
          handle: handle,
          amount: sampleSize
        },
        headers: {
          'X-API-Key': process.env.SOCIAVAULT_API_KEY
        }
      }
    );
    
    const followers = response.data.followers;
    
    const analysis = {
      total: followers.length,
      noProfilePic: 0,
      noPosts: 0,
      suspiciousUsername: 0,
      lowFollowers: 0,
      suspicious: 0
    };
    
    followers.forEach(follower => {
      let redFlags = 0;
      
      // Check for profile picture
      if (!follower.profilePicUrl || follower.profilePicUrl.includes('default')) {
        analysis.noProfilePic++;
        redFlags++;
      }
      
      // Check post count
      if (follower.postsCount === 0) {
        analysis.noPosts++;
        redFlags++;
      }
      
      // Check username (bots often have random numbers)
      const username = follower.username || '';
      const numberCount = (username.match(/\d/g) || []).length;
      const numberRatio = numberCount / username.length;
      
      if (numberRatio > 0.4) {
        analysis.suspiciousUsername++;
        redFlags++;
      }
      
      // Check follower count (bots have very few followers)
      if (follower.followersCount && follower.followersCount < 50) {
        analysis.lowFollowers++;
        redFlags++;
      }
      
      // Mark as suspicious if multiple red flags
      if (redFlags >= 2) {
        analysis.suspicious++;
      }
    });
    
    const suspiciousPercent = ((analysis.suspicious / analysis.total) * 100).toFixed(1);
    
    console.log(`\n=== FOLLOWER QUALITY ANALYSIS ===`);
    console.log(`Sample Size: ${analysis.total} followers\n`);
    console.log(`Red Flags:`);
    console.log(`- No profile pic: ${analysis.noProfilePic} (${(analysis.noProfilePic/analysis.total*100).toFixed(1)}%)`);
    console.log(`- No posts: ${analysis.noPosts} (${(analysis.noPosts/analysis.total*100).toFixed(1)}%)`);
    console.log(`- Suspicious username: ${analysis.suspiciousUsername} (${(analysis.suspiciousUsername/analysis.total*100).toFixed(1)}%)`);
    console.log(`- Low follower count: ${analysis.lowFollowers} (${(analysis.lowFollowers/analysis.total*100).toFixed(1)}%)`);
    console.log(`\nSuspicious Followers: ${analysis.suspicious} (${suspiciousPercent}%)\n`);
    
    let verdict;
    const suspPercent = parseFloat(suspiciousPercent);
    
    if (suspPercent < 10) {
      verdict = '✅ HIGH QUALITY - Most followers are real';
    } else if (suspPercent < 30) {
      verdict = '⚠️ MEDIUM QUALITY - Some fake followers present';
    } else {
      verdict = '🚫 LOW QUALITY - Majority are fake followers. DO NOT WORK WITH THIS ACCOUNT';
    }
    
    console.log(`Verdict: ${verdict}`);
    
    return {
      ...analysis,
      suspiciousPercent: parseFloat(suspiciousPercent),
      verdict
    };
  } catch (error) {
    console.error('Failed to analyze followers:', error.message);
    return null;
  }
}

const followerAnalysis = await analyzeFollowers('influencer_handle', 'instagram', 100);

What to Look For

Real followers have:

• Profile pictures (not default avatars)
• Posts on their account (at least 5-10)
• Normal usernames (not random numbers)
• Followers themselves (at least 100)

Bot accounts have:

• No profile picture or generic stock photo
• Zero posts
• Username like "user_8472639"
• Under 10 followers

If more than 30% of sampled followers show these bot characteristics, the influencer has purchased followers.

Red Flag 3: Fake Comments

Bot comments are generic and repetitive.

async function analyzeComments(postId, platform = 'instagram') {
  try {
    const response = await axios.get(
      `https://api.sociavault.com/${platform}/comments`,
      {
        params: {
          postId: postId,
          amount: 100
        },
        headers: {
          'X-API-Key': process.env.SOCIAVAULT_API_KEY
        }
      }
    );
    
    const comments = response.data.comments;
    
    const analysis = {
      total: comments.length,
      generic: 0,
      tooShort: 0,
      onlyEmojis: 0,
      likelyBots: 0,
      likelyReal: 0
    };
    
    const genericPhrases = [
      'great post',
      'nice post',
      'love this',
      'amazing',
      'awesome',
      'cool',
      'nice',
      'great',
      'love it',
      'beautiful',
      'wonderful'
    ];
    
    comments.forEach(comment => {
      const text = (comment.text || '').toLowerCase().trim();
      let botScore = 0;
      
      // Check for generic phrases
      const isGeneric = genericPhrases.some(phrase => 
        text === phrase || text === phrase + '!' || text === phrase + ' ❤️'
      );
      
      if (isGeneric) {
        analysis.generic++;
        botScore += 2;
      }
      
      // Check length
      if (text.length < 10) {
        analysis.tooShort++;
        botScore += 1;
      }
      
      // Check if only emojis
      const hasLetters = /[a-zA-Z]/.test(text);
      if (!hasLetters && text.length > 0) {
        analysis.onlyEmojis++;
        botScore += 2;
      }
      
      // Classify
      if (botScore >= 2) {
        analysis.likelyBots++;
      } else {
        analysis.likelyReal++;
      }
    });
    
    const botPercent = ((analysis.likelyBots / analysis.total) * 100).toFixed(1);
    
    console.log(`\n=== COMMENT ANALYSIS ===`);
    console.log(`Total Comments: ${analysis.total}\n`);
    console.log(`Generic phrases: ${analysis.generic} (${(analysis.generic/analysis.total*100).toFixed(1)}%)`);
    console.log(`Too short: ${analysis.tooShort} (${(analysis.tooShort/analysis.total*100).toFixed(1)}%)`);
    console.log(`Only emojis: ${analysis.onlyEmojis} (${(analysis.onlyEmojis/analysis.total*100).toFixed(1)}%)`);
    console.log(`\nLikely bot comments: ${analysis.likelyBots} (${botPercent}%)`);
    console.log(`Likely real comments: ${analysis.likelyReal}\n`);
    
    let verdict;
    const botPct = parseFloat(botPercent);
    
    if (botPct < 15) {
      verdict = '✅ Comments look mostly authentic';
    } else if (botPct < 35) {
      verdict = '⚠️ Moderate bot activity detected';
    } else {
      verdict = '🚫 High bot activity - likely purchased engagement';
    }
    
    console.log(`Verdict: ${verdict}`);
    
    return {
      ...analysis,
      botPercent: parseFloat(botPercent),
      verdict
    };
  } catch (error) {
    console.error('Failed to analyze comments:', error.message);
    return null;
  }
}

const commentAnalysis = await analyzeComments('POST_ID', 'instagram');

Real vs Fake Comments

Real comments:

• "This workout helped me so much! What weight do you recommend for beginners?"
• "I tried this yesterday and my legs are so sore today haha"
• "Could you make a video for shoulder exercises? Love your content"

Fake comments:

• "Great post!"
• "Nice ❤️"
• "Amazing content 👍"
• "Love this!"

Real comments are specific, ask questions, and reference the actual content. Fake comments are generic and could apply to any post.

Red Flag 4: Audience Mismatch

Check if their followers match your target audience.

async function analyzeAudienceMatch(influencerHandle, yourTargetAudience, platform = 'instagram') {
  console.log(`\n=== AUDIENCE MATCH ANALYSIS ===`);
  console.log(`Influencer: @${influencerHandle}`);
  console.log(`Your target audience: ${JSON.stringify(yourTargetAudience)}\n`);
  
  try {
    // Get influencer's followers sample
    const followersResponse = await axios.get(
      `https://api.sociavault.com/${platform}/followers`,
      {
        params: {
          handle: influencerHandle,
          amount: 100
        },
        headers: {
          'X-API-Key': process.env.SOCIAVAULT_API_KEY
        }
      }
    );
    
    const followers = followersResponse.data.followers;
    
    // Analyze follower characteristics
    const analysis = {
      totalSampled: followers.length,
      hasProfileInfo: 0,
      activeAccounts: 0,
      engagedUsers: 0
    };
    
    followers.forEach(follower => {
      // Check if they have bio (indicates real person)
      if (follower.biography && follower.biography.length > 10) {
        analysis.hasProfileInfo++;
      }
      
      // Check if active (has recent posts)
      if (follower.postsCount && follower.postsCount > 10) {
        analysis.activeAccounts++;
      }
      
      // Check if engaged (has followers and following)
      if (follower.followersCount > 50 && follower.followingCount > 20) {
        analysis.engagedUsers++;
      }
    });
    
    console.log('Follower Sample Analysis:');
    console.log(`- Has profile info: ${analysis.hasProfileInfo} (${(analysis.hasProfileInfo/analysis.totalSampled*100).toFixed(1)}%)`);
    console.log(`- Active accounts: ${analysis.activeAccounts} (${(analysis.activeAccounts/analysis.totalSampled*100).toFixed(1)}%)`);
    console.log(`- Engaged users: ${analysis.engagedUsers} (${(analysis.engagedUsers/analysis.totalSampled*100).toFixed(1)}%)`);
    
    const qualityScore = (
      (analysis.hasProfileInfo / analysis.totalSampled * 0.3) +
      (analysis.activeAccounts / analysis.totalSampled * 0.4) +
      (analysis.engagedUsers / analysis.totalSampled * 0.3)
    ) * 100;
    
    console.log(`\nAudience Quality Score: ${qualityScore.toFixed(1)}%`);
    
    if (qualityScore >= 70) {
      console.log('✅ High quality, engaged audience');
    } else if (qualityScore >= 50) {
      console.log('⚠️ Moderate quality audience');
    } else {
      console.log('🚫 Low quality audience - likely many inactive/fake accounts');
    }
    
    return {
      ...analysis,
      qualityScore: qualityScore.toFixed(1)
    };
  } catch (error) {
    console.error('Failed to analyze audience:', error.message);
    return null;
  }
}

const audienceMatch = await analyzeAudienceMatch('influencer_handle', {
  niche: 'fitness',
  ageRange: '25-40',
  interests: ['health', 'wellness', 'workout']
}, 'instagram');

Comprehensive Influencer Vetting Checklist

Put it all together:

async function vetInfluencer(handle, platform = 'instagram') {
  console.log(`\n${'='.repeat(60)}`);
  console.log(`COMPREHENSIVE INFLUENCER VETTING: @${handle}`);
  console.log(`${'='.repeat(60)}`);
  
  const report = {
    handle,
    platform,
    passed: true,
    issues: [],
    recommendation: ''
  };
  
  try {
    // Test 1: Engagement Rate
    console.log('\nTest 1: Checking engagement rate...');
    const engagementCheck = await checkEngagementRate(handle, platform);
    
    if (engagementCheck.isSuspicious) {
      report.passed = false;
      report.issues.push('Suspiciously low engagement rate');
    }
    
    // Test 2: Follower Quality
    console.log('\nTest 2: Analyzing follower quality...');
    const followerCheck = await analyzeFollowers(handle, platform, 100);
    
    if (followerCheck.suspiciousPercent > 30) {
      report.passed = false;
      report.issues.push('High percentage of fake followers');
    } else if (followerCheck.suspiciousPercent > 15) {
      report.issues.push('Moderate fake follower presence');
    }
    
    // Test 3: Comment Quality
    // Would need a recent post ID - simplified for example
    console.log('\nTest 3: Would analyze comment quality on recent posts...');
    
    // Generate recommendation
    console.log(`\n${'='.repeat(60)}`);
    console.log('FINAL RECOMMENDATION');
    console.log(`${'='.repeat(60)}\n`);
    
    if (report.passed && report.issues.length === 0) {
      report.recommendation = '✅ APPROVED - Safe to work with this influencer';
      console.log(report.recommendation);
    } else if (report.passed && report.issues.length > 0) {
      report.recommendation = '⚠️ PROCEED WITH CAUTION - Minor issues detected';
      console.log(report.recommendation);
      console.log('\nIssues found:');
      report.issues.forEach(issue => console.log(`- ${issue}`));
    } else {
      report.recommendation = '🚫 DO NOT WORK WITH - Major red flags detected';
      console.log(report.recommendation);
      console.log('\nCritical issues:');
      report.issues.forEach(issue => console.log(`- ${issue}`));
    }
    
    return report;
  } catch (error) {
    console.error('Vetting failed:', error.message);
    return null;
  }
}

// Vet an influencer before paying them
const vettingReport = await vetInfluencer('potential_influencer', 'instagram');

Real Examples

Example 1: Avoided Disaster

Influencer offered collaboration:

• 180K followers
• Wanted $2,500
• Our vetting found:
  • 0.4% engagement rate (expected 1% to 3%)
  • 67% of followers were suspicious
  • 73% of comments were generic bot responses
• Decision: Did not work with them
• Money saved: $2,500

Example 2: Found a Winner

Smaller influencer:

• 25K followers
• Charged $400
• Our vetting found:
  • 6.2% engagement rate (excellent)
  • 8% suspicious followers (acceptable)
  • Authentic, thoughtful comments
  • Audience matched our target perfectly
• Decision: Worked with them
• Result: 47 sales, $3,800 revenue, $3,400 profit

The smaller influencer with real followers outperformed the fake large influencer by infinity (since we did not waste money on the fake one).

Your Vetting Action Plan

Before paying any influencer:

1. Check engagement rate - Calculate from their last 12 posts
2. Analyze follower quality - Sample 100 followers, check for bot characteristics
3. Review comments - Look for generic, repetitive, or bot-like comments
4. Verify audience match - Make sure their followers are your target customers
5. Ask for analytics - Real influencers will share their Instagram Insights

If they refuse to share analytics or you find multiple red flags, walk away.

Get your SociaVault API key and vet influencers in minutes. Know if they are real before you pay them.

Stop wasting money on fake influencers. Start verifying authenticity.