# Instagram Engagement Rate & Influencer Vetting (`scrapesage/instagram-engagement-scraper`) Actor

Vet Instagram creators without login: engagement rate measured from their recent Reels, compared against a published peer band for their audience size, plus reach rate, comment-to-like ratio, consistency and named risk flags that each cite their evidence. Every formula is documented.

- **URL**: https://apify.com/scrapesage/instagram-engagement-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 creator analyseds

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

## Instagram Engagement Rate & Influencer Vetting

Score Instagram creators **without a login**: engagement rate measured from their recent Reels, compared against a **published peer band** for their audience size, plus reach rate, comment-to-like ratio, consistency, and **named risk flags that each cite their own evidence**.

### The method is the product - so here it is in full

Derived-metric tools live or die on whether you trust the number. Every figure below is either measured or computed by a formula printed here. Nothing is a black box.

**Engagement rate** = `(average likes + average comments) / followers`, measured across the creator's most recent Reels (up to 12, `reelsSampled` tells you exactly how many).

**Reach rate** = `average plays / followers` - how far content travels relative to audience size.

**Engagement per play** = `(average likes + average comments) / average plays` - how compelling content is *once seen*, which is independent of audience size.

**Peer bands.** A flat "good ER" threshold mislabels large accounts, because engagement falls as audiences grow. Each creator is judged against its own band:

| Band | Followers | Expected ER |
|---|---|---|
| nano | under 10k | 2.0% - 9.0% |
| micro | 10k - 100k | 1.5% - 6.0% |
| mid | 100k - 500k | 1.0% - 4.5% |
| macro | 500k - 1M | 0.8% - 3.5% |
| mega | 1M+ | 0.5% - 3.0% |

**Vetting score (0-100)** starts from where the creator's ER sits inside its band, then adds for healthy cadence and consistent reach, and subtracts for each risk flag (high −14, medium −7, low −3) and for a thin sample (−8 under 3 Reels). **Verdict** maps the score: `strong` 70+, `acceptable` 50+, `weak` 30+, `avoid` below, plus `low_confidence` and `insufficient_data`.

**Risk flags** - each row carries `riskFlagDetails` with a written evidence string:

| Flag | Raised when |
|---|---|
| `engagement_below_peer_band` | ER under the floor for that audience size |
| `engagement_implausibly_high` | ER more than 2.5× the band ceiling - pods or bought engagement |
| `follow_back_pattern` | 10k+ followers with a near 1:1 following ratio |
| `very_low_comment_ratio` | under 1 comment per 1,000 likes - likes without conversation |
| `erratic_reach` | reach coefficient of variation above 1.5 - a few outliers carry the average |
| `thin_posting_history` | fewer than 12 posts published |

### What this actor deliberately does NOT claim

**No "fake follower percentage."** That figure cannot be honestly derived without inspecting the follower list, and Instagram does not expose follower lists to logged-out callers at all. Tools that print one without a login are guessing. This actor gives you evidence-backed flags instead, and says so.

### Example output

```
adidas    29.6M followers   ER 1.683%   mega band   in band    score 69  acceptable   flags: none
leomessi  515M followers    ER 0.729%   mega band   in band    score 51  acceptable   flags: erratic_reach
nike      291M followers    ER 0.052%   mega band   below band score 29  avoid        flags: engagement_below_peer_band
```

### What you get per creator

`profileUrl` · `username` · `fullName` · `followersCount` · `followingCount` · `postsCount` · `isVerified` · **`vettingScore`** · **`verdict`** · **`engagementRate`** · `engagementRatePercent` · `peerBand` · `peerBandExpectedMinPercent` · `peerBandExpectedMaxPercent` · `withinPeerBand` · **`riskFlags[]`** · **`riskFlagDetails[]`** · `riskFlagCount` · `reelsSampled` · `avgPlays` · `medianPlays` · `avgLikes` · `avgComments` · `engagementPerPlay` · `commentToLikeRatio` · `reachRate` · `playsStdDev` · `playsCoefficientOfVariation` · `followerToFollowingRatio` · `recentPostsSampled` · `recentReelShare` · `biography` · `externalUrls[]` · `methodNote` · `scrapedAt`

### Input

```json
{
  "usernames": ["natgeo", "adidas", "nike"],
  "minFollowers": 10000,
  "minVettingScore": 50,
  "maxResults": 100,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

| Field | What it does |
|---|---|
| `usernames` | Creator handles - built for scoring a whole shortlist in one run |
| `minFollowers` | Audience floor, applied **before** any analysis work |
| `minVettingScore` | Return only creators scoring at least this - hands you a shortlist, not a table |
| `skipPrivate` | Skip private accounts (on by default - they publish nothing to measure) |
| `maxResults` | Cap. `0` = no limit |

### Honest limits

- **The evidence base is the creator's recent Reels** (up to 12, the logged-out ceiling). `reelsSampled` is on every row, and a sample under 3 lowers the score and returns `low_confidence`. An account with no Reels returns `insufficient_data` rather than a fabricated score.
- **Posting cadence is not measured.** The Reels tab does not carry timestamps, and fetching a date for every Reel would multiply the cost of a vetting run several times over. Rather than infer cadence from nothing, `postsPerWeek` is left out of the score. If you need per-Reel dates, use [Instagram Reels Scraper](https://apify.com/scrapesage/instagram-reels-scraper).
- **Engagement is measured on Reels, not on the whole feed.** Reels are where Instagram's reach lives, and they are the only surface exposing play counts logged-out.
- **Peer bands are a documented judgement**, not a law of nature. They are printed above and on every row so you can re-band the data yourself.

### Pricing (pay per event, no start fee)

| Event | Price | What it covers |
|---|---|---|
| `profileAnalysed` | **$0.03** | One fully vetted creator: ER, peer band, reach rate, comment-to-like ratio, consistency, risk flags with evidence, and the 0-100 score |

A single price for a complete analysis - two source requests, all the derived metrics, and the evidence behind them. Creators removed by `minFollowers` or `minVettingScore` are never billed.

### Use with AI assistants (MCP)

Works as an LLM tool via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) - ask an assistant to "vet this influencer shortlist and drop anyone below 50" and it can call this actor directly.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### Integrations

[Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://apify.com/integrations/slack), [Google Drive](https://apify.com/integrations/google-drive), [Airbyte](https://apify.com/integrations/airbyte), [GitHub](https://apify.com/integrations/github), the [Apify API](https://docs.apify.com/api/v2), [Schedules](https://docs.apify.com/platform/schedules) and [Webhooks](https://docs.apify.com/platform/integrations/webhooks).

### FAQ

**Do I need a login or cookies?** No.

**Why is a huge account scored "avoid"?** Because engagement is judged against its own peer band. A 291M-follower account posting at 0.05% ER is genuinely underperforming for its size, and that is the signal a brand is paying to see.

**Why `insufficient_data`?** That creator published no Reels this actor could sample. It returns a null score rather than inventing one.

**Can I change the bands?** Every row carries `peerBandExpectedMinPercent` / `peerBandExpectedMaxPercent` and the raw `engagementRate`, so you can re-band downstream without re-scraping.

### Related scrapers by scrapesage

- [Instagram Profile Scraper](https://apify.com/scrapesage/instagram-profile-scraper) - bulk profile stats and resolved bio links
- [Instagram Reels Scraper](https://apify.com/scrapesage/instagram-reels-scraper) - per-Reel play counts, view counts and dates
- [Instagram Leads Scraper](https://apify.com/scrapesage/instagram-leads-scraper) - turn vetted creators into contactable leads
- [Instagram Hashtag Scraper](https://apify.com/scrapesage/instagram-hashtag-scraper) - discover creators to vet

# Actor input Schema

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

Creator handles or profile URLs to vet. Any number - built for scoring a whole shortlist in one run.

## `minFollowers` (type: `integer`):

Skip creators below this audience size. Applied before the analysis work, so filtered profiles cost you nothing.

## `minVettingScore` (type: `integer`):

Only return creators scoring at least this (0-100). Use it to get back a clean shortlist instead of a full table.

## `skipPrivate` (type: `boolean`):

Private accounts publish no engagement to measure, so they are skipped by default.

## `maxResults` (type: `integer`):

Total creators to analyse. 0 means no limit (the run's time budget stops it safely).

## `concurrency` (type: `integer`):

Parallel creators. Keep at 3 or below - each creator costs two requests.

## `proxyConfiguration` (type: `object`):

RESIDENTIAL is the tested default and strongly recommended.

## Actor input object example

```json
{
  "usernames": [
    "natgeo"
  ],
  "minFollowers": 0,
  "minVettingScore": 0,
  "skipPrivate": true,
  "maxResults": 100,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Every analysed creator with engagement rate, peer band, reach rate, comment-to-like ratio, consistency, risk flags with evidence and a 0-100 vetting score as JSON items in the default dataset.

# 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",
        "nasa"
    ],
    "skipPrivate": true,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/instagram-engagement-scraper").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",
        "nasa",
    ],
    "skipPrivate": True,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/instagram-engagement-scraper").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",
    "nasa"
  ],
  "skipPrivate": true,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/instagram-engagement-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/JCu5YTq5XBZAbT7qb/builds/nob3qOAaO7C1GL9hY/openapi.json