# Instagram Fake Follower Auditor (`khadinakbar/instagram-fake-follower-auditor`) Actor

Audit public Instagram profiles for fake-follower risk using explainable public-signal scores, confidence, and risk tiers. No login or cookies. MCP-ready. $0.02 per audited profile.

- **URL**: https://apify.com/khadinakbar/instagram-fake-follower-auditor.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 profile auditeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Instagram Fake Follower Auditor

Audit public Instagram profiles for **audience quality** and likely **fake-follower risk**. The Actor reads public profile counts and recent-post engagement, then returns one dataset row per handle with an explainable risk score, confidence, risk tier, findings, and a recommended next step. It runs cookieless, with no Instagram login, and is built for humans, APIs, and AI agents on Apify.

Designed for agencies, brand teams, and CRM workflows that want a structured audience-quality score before a paid collab or influencer brief.

### Best fit

- You have public Instagram handles or profile URLs and want a fake-follower **risk score** with reasons.
- You want confidence-gated tiers (`LOW` / `MEDIUM` / `HIGH` / `VERY_HIGH` / `INCONCLUSIVE`) instead of a raw follower count.
- After a niche shortlist, start with [Instagram Niche Influencer Finder](https://apify.com/khadinakbar/instagram-niche-influencer-finder), then pass chosen handles here to compare audience quality.
- For bio, followers, and parsed contacts, continue with [Instagram Profile Scraper](https://apify.com/khadinakbar/instagram-profile-scraper) or [Instagram Contact Scraper](https://apify.com/khadinakbar/instagram-contact-scraper). This Actor stays focused on public-signal authenticity scoring.

### Workflow: from a shortlist to a collab decision

An agency starts with three public handles from a brief. It then runs this Actor with `profiles: ["creator_a", "creator_b", "creator_c"]` and `maxRecentPosts: 12`. Next it exports the overview view, compares `weightedRiskScore`, `riskTier`, and `recommendation`, and feeds HIGH-tier names to a human reviewer before spend. LOW-tier names can pass to outreach. The same flow works on a schedule for marketplace creator intake.

### How scoring works

1. Fetch the public profile (followers, following, posts, private/verified flags).
2. Sample recent public posts (likes and comments).
3. Score five public-only signals, weighted:
   - Engagement-rate vs audience-size band (35%)
   - Like/comment balance (25%)
   - Follower-to-following pattern (20%)
   - Content depth vs claimed audience (10%)
   - Engagement volatility (10%)
4. Gate the tier with **confidence**. Thin evidence is labeled `INCONCLUSIVE` so the score stays honest.

Mega accounts are compared to mega-account engagement floors, so a large publisher is scored against its own band rather than a nano-creator rate.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `profiles` | array (required) | `["natgeo"]` | Public handles, @handles, or profile URLs (up to 50 per run) |
| `maxRecentPosts` | integer | 12 | Recent posts in the engagement sample (3–24) |
| `minConfidenceToClassify` | number | 0.55 | Below this, the tier is `INCONCLUSIVE` |
| `providerOrder` | enum | `scrapecreators-first` | Public-data provider priority; fallback fires automatically |
| `includePostLevelDiagnostics` | boolean | false | Attach sampled post like/comment counts |

#### Quick start input

```json
{
  "profiles": ["natgeo"],
  "maxRecentPosts": 12,
  "minConfidenceToClassify": 0.55,
  "providerOrder": "scrapecreators-first",
  "includePostLevelDiagnostics": false
}
```

That input audits one well-known public profile so the quality run stays short and still returns a real scored row.

### Output

One dataset item is one profile audit. Download JSON, CSV, Excel, or HTML from the dataset tab. Every run also writes `OUTPUT` and `RUN_SUMMARY` with the outcome, row counts, and charged events.

```json
{
  "inputProfile": "natgeo",
  "normalizedHandle": "natgeo",
  "profileUrl": "https://www.instagram.com/natgeo/",
  "auditTimestamp": "2026-08-18T11:00:00.000Z",
  "outcome": "COMPLETE",
  "source": "scrapecreators",
  "weightedRiskScore": 18.4,
  "confidence": 0.9,
  "riskTier": "LOW",
  "engagementRatePct": 0.0746,
  "keyFindings": ["No major fake-follower anomalies in the available public signals."],
  "recommendation": "Low public fake-follower risk. Visible engagement is consistent with the reported audience size.",
  "billingEvent": "profile-audited"
}
```

| Field | What it answers |
| --- | --- |
| `normalizedHandle` + `profileUrl` | Which public profile was audited |
| `weightedRiskScore` + `riskTier` | How the public signals score on fake-follower risk |
| `confidence` | How much public evidence supported the tier |
| `engagementRatePct` | Average likes plus comments vs follower count |
| `keyFindings` + `recommendation` | Why the score looks this way, and a suggested next step |
| `outcome` | COMPLETE, PARTIAL, VALID\_EMPTY, INVALID\_INPUT, UPSTREAM\_FAILED, or CONFIG\_ERROR |

### Pricing

This Actor uses Pay per event plus Apify platform usage. Open the live Pricing tab for current event details, and use Apify's run cost controls to keep the workflow aligned with your budget.

| Event | Price | Charged when |
| --- | --- | --- |
| Actor start | $0.00005 | Once per run (scaled by memory) |
| `profile-audited` | $0.02 | Each COMPLETE or PARTIAL audit row |

| Run | Audited rows | Event cost (approx.) |
| --- | --- | --- |
| 1 public profile | 1 | ~$0.02 |
| 5-handle shortlist | 5 | ~$0.10 |

`VALID_EMPTY`, `INVALID_INPUT`, and upstream-outage rows are saved when useful and stay outside `profile-audited`. Platform usage is billed on top at Apify's rates — the live Pricing tab is the current source of truth.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~instagram-fake-follower-auditor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"profiles":["natgeo"],"maxRecentPosts":12}'
```

Then read the dataset and the `OUTPUT` record for outcome, row counts, and charged events.

### AI agent usage

> Audit public Instagram audience quality before a paid collab.
> Tool: `khadinakbar/instagram-fake-follower-auditor`
> Input: `{"profiles":["natgeo"],"maxRecentPosts":12}`
> Read the dataset row for `weightedRiskScore`, `riskTier`, `confidence`, `recommendation`, and `outcome`. Treat `INCONCLUSIVE` as a cue to gather more evidence. Cost is $0.02 per COMPLETE/PARTIAL row plus platform usage.

### Best results

- Provide currently **public** handles; public posts are the engagement sample.
- Keep `maxRecentPosts` at 12 unless you need more evidence for a borderline account.
- Read `keyFindings` together with the risk tier before a spend decision.
- Pair a LOW or MEDIUM score with a live content check, then continue outreach.

### Builder's note

I built this after live probes of native Instagram HTML and two public-data vendors. Direct `instagram.com` fetches returned empty shells, while ScrapeCreators `/v1/instagram/profile` plus `/v2/instagram/user/posts` (and SociaVault scrape equivalents) returned usable follower counts and post like/comment totals. I learned that mega-publisher engagement rates look “low” if you reuse nano-creator floors, so the scorer uses audience-size bands and confidence gates. I designed the billed unit as one public-signal audit row, because this contract scores profile and post metrics and leaves follower-identity sampling to other tools.

### Responsible use

Use this Actor on public Instagram profiles you are authorized to research for legitimate due diligence, influencer vetting, or marketplace intake. It reads **public profile and recent-post metrics only**. Follow Instagram's terms of service, GDPR, CCPA, and applicable laws. The score is a probabilistic public-signal indicator for research, not a legal finding.

### Changelog

- **0.1** — Initial private release. Provider-backed public audit, explainable scoring, PPE + usage, MCP-ready schemas.

# Actor input Schema

## `profiles` (type: `array`):

Public Instagram handles or profile URLs to audit. Accepts natgeo, @natgeo, or https://www.instagram.com/natgeo/. Each valid public profile becomes one scored dataset row. This is not a post, reel, hashtag, or follower-list input.

## `maxRecentPosts` (type: `integer`):

How many recent public posts feed the engagement sample. Accepts 3-24; default 12. More posts raise confidence and provider cost. This does not scrape commenter identities.

## `minConfidenceToClassify` (type: `number`):

Confidence below this value is marked INCONCLUSIVE even if the raw risk score is high. Range 0-1; default 0.55. Raise it when you only want high-evidence verdicts.

## `providerOrder` (type: `string`):

Order of owner-configured public data providers. Default scrapecreators-first uses SociaVault automatically if the primary fails. You never enter an API key. Pin a -only value only for diagnostics.

## `includePostLevelDiagnostics` (type: `boolean`):

When true, each row also includes the sampled post like/comment counts used for scoring. Default false keeps the agent-friendly compact row. This does not change billing.

## Actor input object example

```json
{
  "profiles": [
    "natgeo",
    "@nasa"
  ],
  "maxRecentPosts": 12,
  "minConfidenceToClassify": 0.55,
  "providerOrder": "scrapecreators-first",
  "includePostLevelDiagnostics": false
}
```

# Actor output Schema

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

Dataset of one scored audience-quality row per input profile.

## `output` (type: `string`):

OUTPUT record with outcome, row counts, and charged event totals.

## `runSummary` (type: `string`):

RUN\_SUMMARY record with timestamps, dataset IDs, and provider telemetry.

# 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 = {
    "profiles": [
        "natgeo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/instagram-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 = { "profiles": ["natgeo"] }

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

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

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

```

## CLI example

```bash
echo '{
  "profiles": [
    "natgeo"
  ]
}' |
apify call khadinakbar/instagram-fake-follower-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/instagram-fake-follower-auditor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0nfD6iZOp3HD5jrnz/builds/NCgTekTD0Z4q46u6I/openapi.json