# X (Twitter) Fake Follower Auditor - Audience Quality Check (`seemuapps/x-fake-follower-auditor`) Actor

Audit any X (Twitter) account for fake followers and bots - per-follower bot scores, flagged signals, and an audience quality grade.

- **URL**: https://apify.com/seemuapps/x-fake-follower-auditor.md
- **Developed by:** [Andrew](https://apify.com/seemuapps) (community)
- **Categories:** Lead generation, AI, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 audit reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## X (Twitter) Fake Follower Auditor - Audience Quality Check

Audit any X (Twitter) account for fake followers and bots. The actor samples the account's most-recent followers, scores every sampled follower on proven bot signals, and returns a fake-follower percentage, an audience quality grade, and the full per-follower evidence - the same audit influencer-marketing platforms charge hundreds per month for.

### What you get

**One audit summary:**

- **Fake follower %** and **suspicious %** from a real follower sample (not an estimate)
- **Audience quality grade** (A-D)
- **Signal breakdown** - how many sampled followers had a default profile picture, zero tweets, suspicious follow ratios, spammy handles, empty bios, or brand-new accounts
- **Sample statistics** - blue-verified count, no-tweets %, default-avatar %, average follower/following counts across the sample

**Plus one record per sampled follower:**

- Bot score (0-100) with a `likely_fake` / `suspicious` / `likely_real` verdict
- The exact signals that fired, follower/following/tweet counts, account creation date, and profile URL

Export everything to JSON, CSV, Excel, or Google Sheets from the Apify console.

### Use cases

- **Influencer vetting** - check an influencer's audience authenticity before signing a sponsorship deal
- **Detecting bought followers** - a sudden wave of new, empty accounts in the recent-follower sample is the classic signature of purchased followers
- **Agency audits** - screen creator rosters and report audience quality to clients
- **Competitor audience analysis** - compare audience quality across accounts in your niche
- **Brand safety** - verify partner accounts aren't inflated with bot audiences

### How it works

The actor samples up to 5,000 of the target account's most-recent followers and scores each one on bot signals, each with a plain-language meaning:

- **Default profile picture** - the account never uploaded an avatar, the strongest low-effort-bot tell
- **Zero tweets** - the account has never posted; bots that only exist to follow rarely tweet
- **Suspicious follow ratio** - following thousands of accounts while having almost no followers is classic follow-bot behavior
- **Brand-new account** - created within the last 30 days (strong signal) or 90 days (weak signal); bot farms churn out fresh accounts
- **Spammy handle** - machine-generated username patterns like long trailing digit runs (`user48291047`)
- **Empty bio** and **no cover picture** - no effort spent making the profile look human
- **Flagged automated** - the account is publicly labeled as automated on X

Each fired signal adds its weight to the bot score (capped at 100). A score of 50+ is `likely_fake`, 25-49 is `suspicious`, below 25 is `likely_real`. The fake-follower percentage is the share of sampled followers scoring as likely fake.

### How to use

1. Enter the X **username** to audit (with or without @)
2. Choose a **Follower sample size** (200 is a good default; 1000+ for large accounts)
3. Run the actor - the summary is the first record in the **Dataset** tab, follower evidence follows

### Output format

Summary record:

```json
{
  "recordType": "summary",
  "auditedUsername": "example",
  "auditedUserId": "123456789",
  "followerCount": 152340,
  "sampleSize": 200,
  "fakeFollowerPct": 18.5,
  "suspiciousPct": 12.0,
  "qualityGrade": "B",
  "signalBreakdown": { "default_profile_picture": 31, "zero_tweets": 44, "suspicious_follow_ratio": 12, "empty_bio": 58 },
  "sampleStats": { "blueVerifiedCount": 3, "noTweetsPct": 22.0, "defaultAvatarPct": 15.5, "avgFollowers": 412, "avgFollowing": 890 },
  "sampledNewestFirst": true,
  "checkedAt": "2026-07-17T02:00:00.000Z"
}
```

Follower record:

```json
{
  "recordType": "follower",
  "auditedUsername": "example",
  "followerUsername": "user48291047",
  "followerUserId": "987654321",
  "fullName": "User 48291047",
  "botScore": 65,
  "verdict": "likely_fake",
  "flags": ["default_profile_picture", "zero_tweets", "spammy_handle", "no_cover_picture"],
  "followers": 3,
  "following": 1840,
  "tweets": 0,
  "isBlueVerified": false,
  "hasDefaultAvatar": true,
  "accountCreated": "Mon Jun 22 09:14:03 +0000 2026",
  "profileUrl": "https://x.com/user48291047"
}
```

### Free tier limits

Runs on a free Apify plan are limited to **25 followers sampled per run** (the sample size input is capped automatically). Upgrade to any paid Apify plan to remove the limit and audit with full sample sizes.

### FAQ

**Do I need to log in or provide cookies?** No. No login, no cookies, no risk to your own account.

**How accurate is it?** The sample is drawn from the account's live follower list, newest first. At 200 followers the fake percentage is typically within a few points of a full audit; increase the sample size for tighter confidence.

**Why newest first?** Bought followers arrive in bursts, so the most-recent followers are exactly where purchased or bot audiences show up first.

# Actor input Schema

## `username` (type: `string`):

The X (Twitter) account to audit (with or without @).

## `sampleSize` (type: `integer`):

How many of the account's most-recent followers to sample and score. Larger samples give more accurate fake-follower percentages. Max 5000.

## Actor input object example

```json
{
  "username": "natgeo",
  "sampleSize": 200
}
```

# Actor output Schema

## `results` (type: `string`):

One summary record (recordType 'summary': fakeFollowerPct, suspiciousPct, qualityGrade, signalBreakdown, sampleStats) followed by one record per sampled follower (recordType 'follower': followerUsername, botScore, verdict, flags, followers, following, tweets, accountCreated).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "username": "natgeo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("seemuapps/x-fake-follower-auditor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "username": "natgeo" }

# Run the Actor and wait for it to finish
run = client.actor("seemuapps/x-fake-follower-auditor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "username": "natgeo"
}' |
apify call seemuapps/x-fake-follower-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=seemuapps/x-fake-follower-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/l55tjEUGahjnyhfMR/builds/cPeGYueKtCLugVPYW/openapi.json