# Engagement Rate & Fake Follower Checker: Instagram, TikTok & YT (`nerolabs/engagement-rate-checker`) Actor

Engagement rate, fake follower warning signs, creator score, grade and a shortlist/check/skip verdict for Instagram, TikTok and YouTube creators from any scraper dataset, CSV or Sheet. No scraping or login. Follower, engagement and niche filters. Charged per creator scored. Agent-ready: MCP, x402.

- **URL**: https://apify.com/nerolabs/engagement-rate-checker.md
- **Developed by:** [Adam Pearce](https://apify.com/nerolabs) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 creator scoreds

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

## Engagement Rate & Fake Follower Checker: Instagram, TikTok & YouTube

**You scraped 500 creators. Which ones are worth paying?** Feed this Actor the rows your Instagram, TikTok or YouTube scraper already gave you and get back, for every creator: engagement rate, how it compares with accounts the same size, warning signs of bought followers, a 0 to 100 score, a grade and a plain **shortlist / check / skip** verdict. Best creators first.

No scraping, no login, nothing to break. It reads the data you already have, so it is fast and cheap: **$0.003 per creator scored**.

### Who it is for

- **Brands and agencies** building influencer shortlists for a launch, Black Friday or a seasonal campaign.
- **Influencer platforms and lead-gen builders** who scrape creators in bulk and need to rank them automatically.
- **AI agents** that find creators and need a quick, explainable "is this one real?" answer per account.

### What goes in

Any mix of these, all at once. Posts and profiles of the same creator are merged on platform + username.

| Source | Works with |
|---|---|
| Instagram profile scraper rows | `apify/instagram-profile-scraper` (followers, following and the latest 12 posts per profile) |
| Instagram post rows | `apify/instagram-scraper` in posts mode (add the profile run too for follower counts) |
| TikTok video rows | `clockworks/tiktok-scraper` and look-alikes (`authorMeta` with fans, plus plays, likes, comments, shares) |
| YouTube video rows | `streamers/youtube-scraper` and look-alikes (subscribers, views, likes) |
| Your own sheet | A CSV, Excel file or Google Sheet with `username`, `platform`, `followers` and either posts or `avgLikes` / `avgComments` / `engagementRate` |

Pass **Datasets** (pick one or more scraper runs), a **File or Google Sheet URL**, or **Creator rows** as JSON.

### What comes out (one row per creator)

| Field | Meaning |
|---|---|
| `engagementRate` | (likes + comments, + shares on TikTok) per post, as a % of followers |
| `engagementRateByViews` | (likes + comments + shares) per video, as a % of views. TikTok and YouTube are judged on this |
| `medianEngagementRate` | Same, using the median post, so one viral post cannot flatter the number |
| `tier`, `benchmarkEngagementRate`, `engagementLevel` | Size band (nano, micro, mid, macro, mega), the typical rate for that band and platform, and very low / low / typical / high / unusually high |
| `riskSignals` | Warning signs, each with a plain sentence: low engagement for the size, likes without comments, views without likes, low views, follow-for-follow, uneven likes, unusually high engagement, inactive, mostly sponsored, few posts |
| `authenticityScore` | 100 minus points for each warning sign |
| `creatorScore`, `grade` | 0 to 100 from engagement vs typical (45%), authenticity (35%) and posting rhythm (20%); A to F |
| `verdict`, `verdictReason` | `shortlist`, `check` or `skip`, with the reason |
| `avgLikes`, `avgComments`, `avgViews`, `avgShares`, `avgSaves`, `medianLikes` | The averages behind it |
| `postsPerWeek`, `daysSinceLastPost`, `sponsoredPostShare`, `topHashtags` | Rhythm and content |
| `nicheMatch`, `nicheWordsFound` | Whether your niche words appear in the bio, captions or hashtags |
| `confidence` | high (8+ posts and a follower count), medium, low |

Example row (shortened):

```json
{
  "handle": "nasa", "platform": "tiktok", "followers": 2200000, "postsAnalyzed": 7,
  "avgLikes": 13584, "avgComments": 377, "avgViews": 228043,
  "engagementRate": 0.66, "engagementRateByViews": 6.35, "tier": "mega",
  "benchmarkEngagementRate": 5, "engagementLevel": "typical",
  "riskSignals": [], "authenticityScore": 100, "creatorScore": 84, "grade": "A",
  "verdict": "shortlist", "verdictReason": "Shortlist: typical engagement for a mega account and no serious warning signs."
}
```

The creator's own columns from your scraper (profile fields, not every post) are kept next to the new ones. Turn **Keep original columns** off for a compact table. A run summary with verdict, grade and warning-sign counts is saved as `OUTPUT` in the key-value store, and you can also save a CSV or Excel file.

### Filters

Set **Minimum / Maximum followers**, **Minimum engagement rate** or **Niche words** (fitness, vegan, skincare...). Creators that do not pass are left out and **not charged**. **Rows to keep** can write only the shortlist.

### Pricing

- **$0.003 per creator scored** (a creator that comes back with an engagement rate and a verdict).
- $0.01 per CSV or Excel file, only if you ask for one.
- Not charged: private accounts, creators with no follower count, rows with no username, and anyone your filters leave out.

Scoring 1,000 creators costs about **$3**. You also pay your scraper as normal; this Actor adds no scraping cost of its own.

### Use it after your scraper (no code)

On your scraper's **Integrations** tab, add this Actor and keep **Datasets** as `["{{resource.defaultDatasetId}}"]`. Every scraper run is scored the moment it finishes.

For AI agents: the Actor is on Apify's MCP server (`mcp.apify.com/?tools=nerolabs/engagement-rate-checker`) and can be paid per call with x402.

### How honest is it?

- Every number comes from your rows. Nothing is guessed or looked up elsewhere.
- Benchmarks are typical industry ranges per platform and size: a rough guide, not a law.
- **A warning sign is a reason to look closer, not proof that followers are fake.** Some real creators have quiet comment sections or one viral post. The reason for every sign is written on the row so you can judge it.
- Some YouTube scrapers write 0 comments when they did not collect them; when every video shows 0, comments are treated as unknown rather than as a warning.

### FAQ

**My Instagram post rows say "needs_followers".** The posts scraper does not include follower counts. Add the Instagram profile scraper's run for the same accounts to **Datasets** and the two are merged.

**Which engagement rate formula is used?** Instagram: (likes + comments) / followers. TikTok: (likes + comments + shares) / views, with the per-follower rate also given. YouTube: (likes + comments) / views. The formula used is written in `engagementBasis` on every row.

**Pinned posts?** Left out when there are at least 4 other posts, because they are often old hits.

**Can it check a creator's followers one by one?** No. It judges the audience from engagement patterns, which is faster and works on any scraper's output. For a follower-by-follower audit you need a tool that scrapes each follower.

If this saved you from paying the wrong creator, a review on the Apify Store helps a lot.

# Actor input Schema

## `datasetIds` (type: `array`):

One or more scraper datasets: Instagram profile or post scrapers, TikTok scrapers, YouTube scrapers. Posts and profiles of the same creator are merged, so add the profile run and the posts run together. Every creator-level column is kept. In an integration set it to \["{{resource.defaultDatasetId}}"].

## `fileUrl` (type: `string`):

A public link to a CSV, Excel, JSON or JSON Lines file: scraper rows, or your own creator list with a username and followers column (plus avgLikes, avgComments or engagementRate if you have them). A normal Google Sheets link works when shared as 'Anyone with the link can view'.

## `fileFormat` (type: `string`):

Leave on 'Detect automatically' unless the link has no file extension.

## `sheetName` (type: `string`):

Which sheet to read from an Excel workbook. Defaults to the first sheet.

## `data` (type: `array`):

Rows as JSON objects, for a quick run or an AI agent call, e.g. \[{"username": "...", "platform": "instagram", "followers": 25000, "avgLikes": 600, "avgComments": 25}] or raw scraper rows.

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

Leave out creators below this follower count (not charged). 0 = no minimum.

## `maxFollowers` (type: `integer`):

Leave out creators above this follower count (not charged). 0 = no maximum.

## `minEngagementRate` (type: `number`):

Leave out creators whose engagement rate is below this (not charged). 0 = no minimum.

## `nicheKeywords` (type: `array`):

Keep only creators whose bio, captions or hashtags contain at least one of these words, e.g. fitness, vegan, skincare. Others are left out and not charged.

## `lookbackDays` (type: `integer`):

Judge creators on posts from this many days back (used when at least 3 posts fall inside it). 0 = all posts given.

## `maxPostsPerCreator` (type: `integer`):

The most recent posts used per creator. Pinned posts are left out when there are enough others.

## `keep` (type: `string`):

Which creators to write. 'All' also writes creators that could not be scored (private, no follower count) with the reason.

## `keepOriginalFields` (type: `boolean`):

Keep the creator's own columns from your scraper (profile fields, not every post) next to the new ones.

## `exportFormats` (type: `array`):

Also save the results as CSV or Excel in the run's key-value store (charged once per file).

## `outputDatasetName` (type: `string`):

Name of a dataset to append the results to, to keep a running creator list across runs.

## `maxItems` (type: `integer`):

Stop reading after this many input rows.

## Actor input object example

```json
{
  "fileUrl": "https://nerolabs-samples.nerolabs.workers.dev/sample-creators.json",
  "fileFormat": "auto",
  "minFollowers": 0,
  "maxFollowers": 0,
  "minEngagementRate": 0,
  "lookbackDays": 120,
  "maxPostsPerCreator": 30,
  "keep": "all",
  "keepOriginalFields": true,
  "maxItems": 200000
}
```

# Actor output Schema

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

One row per creator with engagement rate, warning signs, score, grade and verdict.

## `summary` (type: `string`):

Verdict, grade and warning sign counts, settings used, export links and warnings.

# 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 = {
    "fileUrl": "https://nerolabs-samples.nerolabs.workers.dev/sample-creators.json"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nerolabs/engagement-rate-checker").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 = { "fileUrl": "https://nerolabs-samples.nerolabs.workers.dev/sample-creators.json" }

# Run the Actor and wait for it to finish
run = client.actor("nerolabs/engagement-rate-checker").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 '{
  "fileUrl": "https://nerolabs-samples.nerolabs.workers.dev/sample-creators.json"
}' |
apify call nerolabs/engagement-rate-checker --silent --output-dataset

```

## MCP server setup

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

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/dgteerLoZDmnxeuKD/builds/cxeJCWkIUteDXIpzy/openapi.json