# Instagram Influencer Audit - Fake Followers & Authenticity (`centorprat/instagram-influencer-audit`) Actor

Deep creator due diligence: give Instagram handles and get engagement benchmarked to the follower tier, fake-follower / bought-engagement signals, audience quality, brand-safety flags, a rate-card estimate and authenticity + influence scores. Runs the IG scraper under the hood. Signals, not advice.

- **URL**: https://apify.com/centorprat/instagram-influencer-audit.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $42.50 / 1,000 creator auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Instagram Influencer Audit — Fake Followers, Engagement & Authenticity

Vet a creator before you pay them. Give Instagram handles and get back the full agency due-diligence brief for each: **engagement benchmarked to the creator's follower tier**, **fake-follower / bought-engagement signals**, audience & activity quality, **brand-safety flags**, a fair **rate-card estimate**, and composite **authenticity + influence scores** with a verdict. It runs Instagram's data scraper under the hood — you just pass handles. Agent-callable.

Built for influencer-marketing agencies, brand partnerships, and creator-marketplace teams who lose budget to inflated followers and bought engagement.

### Tiers (opt-in — deep layers only run when you ask)

- **Profile (default, fast):** tier-benchmarked engagement, fake-follower signals, audience/structure sanity, brand safety, rate card, authenticity + influence scores.
- **Comment forensics (`deepComments: true`):** scrapes recent-post comments and grades real engagement authenticity — % bot/spam/duplicate/emoji-only comments, script-mismatch (bot-farm signal), commenter red flags → a `commentAuthenticityScore` blended into the verdict. (Runs a second scraper; takes longer — best for scheduled/webhook use.)
- **Growth tracking (`historyStore`, optional):** pick (or create) a key-value store and each run saves a snapshot per creator and flags anomalies over time: **followers up while engagement is flat = possible purchased followers**, engagement decay, posting stall (a stateless agent can't do this). Schedule it on your roster (e.g. weekly). The Actor only gets access to the store you pick.

> Authenticity **signals** computed from public creator/business-account data for due diligence — **not a definitive accusation** that a creator is fraudulent, and estimates (rate card, benchmarks) are indicative. Verify before contracting.

### What makes it deep (vs the single-purpose tools)

Most tools do *one* thing — just a fake-follower %, or just an engagement number. This composes the whole picture:

| Dimension | What it computes |
|---|---|
| **Engagement vs tier** | ER = (avg likes+comments)/followers, scored against the *real* norm for the creator's tier (nano→global) — a 0.03% ER is a red flag for a micro creator but normal for a 100M brand |
| **Fake / bought signals** | engagement-vs-benchmark mismatch (inflated followers), like-to-comment ratio extremes (bought likes / comment pods), engagement consistency (CV — spiky = bought spikes, too-uniform = bots), video view-to-like sanity |
| **Audience & structure** | follower/following ratio, followers-vs-post-count sanity, verified/established gating (so legit big brands aren't false-flagged) |
| **Activity** | posting cadence, days since last post (dormant), sponsored-post % (ad fatigue) |
| **Brand safety & fit** | risky-content flags (adult/gambling/crypto-promo/…); optional brand-keyword fit |
| **Commercials** | estimated fair **rate card** (USD range) from tier × engagement |
| **Verdict** | `authenticityScore` + `influenceScore` + a signal (authentic-healthy / authentic-modest / inflated-followers-suspected / authenticity-concerns / brand-safety-review) + findings |

### Why not just ask an AI agent?

An agent can open a profile. It **can't** fetch a creator's recent posts, benchmark engagement to the correct follower-tier norm, run the bought-engagement forensics (ratios, variance, view-to-like), and roll it into a defensible score — deterministically, for a roster of creators. That encoded influencer-marketing expertise + scale is the product.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `usernames` | array of strings | ✅\* | Handles or profile URLs. |
| `brandKeywords` | array of strings | | Topics for a brand-fit read. |
| `datasetId` | dataset | ✅\* | …or read handles from another dataset (e.g. a discovery run). |
| `historyStore` | key-value store | | Your store for growth tracking across runs. |
| `maxCreators` | integer | | Cap per run (default 20). |
| `webhookUrl` | string | | POST the audits here as JSON. |

\* provide `usernames` or `datasetId`.

**Example input**

```json
{ "usernames": ["natgeo", "nike"], "brandKeywords": ["travel", "wildlife"] }
```

### Output

One audit per creator. **Example** (real run, trimmed):

```json
{
  "username": "natgeo",
  "verified": true,
  "tier": "global",
  "followersCount": 268351305,
  "engagementRatePct": 0.034,
  "engagementVsBenchmark": 0.28,
  "avgLikes": 92226, "avgComments": 266, "likeToCommentRatio": 347.0,
  "engagementConsistencyCv": 1.34,
  "sponsoredPostPct": 17,
  "cadence": {"avgDaysBetweenPosts": 3.4, "daysSinceLastPost": 0.1},
  "authenticityScore": 57, "influenceScore": 73,
  "estimatedRateCardUsd": {"low": 483032, "mid": 805054, "high": 1207581, "currency": "USD"},
  "signal": "authentic-modest-engagement",
  "findings": [
    {"severity": "low", "code": "below-benchmark-engagement", "detail": "Engagement 0.03% is low vs the global-tier norm (0.12%)..."}
  ]
}
```

An unverified account with followers far above its engagement returns `inflated-followers-suspected`; risky content returns `brand-safety-review`.

### Use cases

- **Pre-deal vetting** — confirm a creator's audience and engagement are real before signing.
- **Roster screening** — audit a whole shortlist (or a discovery dataset) in one run and rank by authenticity.
- **Rate negotiation** — an independent fair-price estimate.
- **Brand safety** — flag risky content and ad-fatigue before association.
- **AI agents** — a structured creator-DD verdict to gate outreach.

### Ready-made tasks

- [Instagram Fake Follower Check](https://apify.com/centorprat/instagram-influencer-audit/examples/instagram-fake-follower-check)
- [Instagram Engagement Rate Calculator by Follower Tier](https://apify.com/centorprat/instagram-influencer-audit/examples/instagram-engagement-rate-calculator)

### For AI agents / MCP

```
https://mcp.apify.com/?tools=actors,docs,centorprat/instagram-influencer-audit
```

Loads as `centorprat--instagram-influencer-audit`. Claude Code:

```
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors centorprat/instagram-influencer-audit
```

### FAQ

**Where does the data come from?** Public Instagram profiles + recent posts, via Apify's Instagram Profile Scraper (run under the hood). You don't manage any key.

**Private accounts?** Reported as `private-account` — public metrics only; posts can't be audited.

**Does it accuse creators of fraud?** No — it surfaces authenticity **signals** for your review. Legit verified/large accounts are gated so they aren't false-flagged for naturally low engagement.

**How is engagement "benchmarked"?** Against typical ranges for the creator's follower tier, because a healthy ER for a micro creator (~2.5%) is very different from a 100M brand (~0.1%).

**How are the follower/engagement forensics done?** Ratios and variance across recent posts (like-to-comment, engagement consistency, view-to-like) that diverge when followers or engagement are bought.

**Cost?** Pay-per-event per creator audited, plus the underlying scraper usage billed to your run: a fraction of a cent per profile. With `deepComments`, Apify's Instagram Comment Scraper also runs, which adds roughly $0.10-0.12 per creator on the Free plan (about 45 comments from 3 posts; less with `commentPostsSampled: 1` or on paid plans).

### Data & attribution

Public Instagram data via Apify's Instagram Profile Scraper. Signals for influencer due diligence, not accusations or guarantees; rate-card and benchmark figures are indicative.

### Related actors

- [TikTok Influencer Audit](https://apify.com/centorprat/tiktok-influencer-audit)
- [YouTube Influencer Audit](https://apify.com/centorprat/youtube-influencer-audit)
- [Google Maps Leads & Website Audit](https://apify.com/centorprat/google-maps-leads-website-audit)
- [Shopify Store Leads & App Audit](https://apify.com/centorprat/shopify-store-leads-app-audit)

# Actor input Schema

## `usernames` (type: `array`):

Creator handles or profile URLs (e.g. "natgeo", "https://instagram.com/nike"). One audit per handle.

## `brandKeywords` (type: `array`):

Topics your brand cares about (e.g. "travel", "wildlife", "camera"). The audit reports how well each creator's bio/captions match - a brand-fit read.

## `datasetId` (type: `string`):

Read handles from another dataset (e.g. an influencer-discovery run) - uses the 'username'/'handle'/'url' field.

## `deepComments` (type: `boolean`):

Also scrape recent post comments and grade engagement authenticity (bot/spam/duplicate/script-mismatch, commenter red flags). Uses the comment scraper (billed to your run) and adds time. Off by default.

## `commentPostsSampled` (type: `integer`):

When deep comment forensics is on, how many recent posts per creator to sample comments from.

## `historyStore` (type: `string`):

Pick (or create) a key-value store to keep a snapshot per creator. Each run then reports growth since the last run and flags anomalies: followers up while engagement stays flat (possible purchased followers), engagement decay, posting stall. Schedule the Actor (e.g. weekly) on your roster.

## `trackHistory` (type: `boolean`):

Kept for compatibility - growth tracking now runs whenever a history store is picked above.

## `maxCreators` (type: `integer`):

Cap how many creators to audit this run.

## `webhookUrl` (type: `string`):

If set, the finished audits are POSTed here as JSON when the run completes.

## Actor input object example

```json
{
  "usernames": [
    "natgeo"
  ],
  "deepComments": false,
  "commentPostsSampled": 3,
  "trackHistory": false,
  "maxCreators": 20
}
```

# Actor output Schema

## `audits` (type: `string`):

One audit per creator: follower tier + benchmarked engagement rate, fake-follower / bought-engagement signals (like-comment ratio, consistency, view-to-like), audience & activity quality, posting cadence, brand-safety flags, estimated rate card, and composite authenticity + influence scores with a verdict.

# 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 = {
    "usernames": [
        "natgeo"
    ],
    "maxCreators": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/instagram-influencer-audit").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 = {
    "usernames": ["natgeo"],
    "maxCreators": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/instagram-influencer-audit").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 '{
  "usernames": [
    "natgeo"
  ],
  "maxCreators": 20
}' |
apify call centorprat/instagram-influencer-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/instagram-influencer-audit"
        }
    }
}
```

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/Q8oqjJNzl9t27DgEf/builds/vW87BKXO26vHguVpj/openapi.json