# Influencer Audit – Fake Followers & Brand Safety (`logiover/influencer-authenticity-audit`) Actor

Vet any YouTube creator before you pay for a sponsorship. One-click audit: engagement quality, suspected fake/inflated subscribers, view consistency, brand-safety scan (adult, hate, violence, gambling, scam) and a creator score with a GOOD FIT / CAUTION / AVOID verdict. No API key.

- **URL**: https://apify.com/logiover/influencer-authenticity-audit.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$0.05 / creator audit

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 🕵️ Influencer Audit – Fake Followers & Brand Safety Check

**Vet any YouTube creator BEFORE you pay for a sponsorship.**
Paste a channel → one-click audit: engagement quality, suspected **fake / inflated subscribers**, view consistency, a **brand-safety scan**, and a clear **GOOD FIT / CAUTION / AVOID** verdict. No API key, no login.

This Actor is an **influencer audit**, **fake-follower checker**, **YouTube engagement checker**, and **brand-safety screener** in one. It's built for brands, agencies, and creator-marketing teams who refuse to burn budget on a creator with bought subscribers or unsafe content.

> Need to **check an influencer before sponsoring**, **detect fake YouTube subscribers**, **calculate a creator's engagement rate**, **audit audience quality**, or run a **brand-safety check** on a channel? Drop the channels in and export clean JSON / CSV / Excel.

---

### ✅ What each audit includes

**Verdict & scores**
- `verdict` — GOOD FIT / CAUTION / AVOID
- `creatorScore` (0–100) blending engagement health, authenticity & brand safety
- `brandSafetyScore` (0–100)

**Authenticity**
- Subscribers vs **real average views** (true engagement rate)
- **View consistency** (catches spiky / bought views)
- Suspected **inflated-subscriber** flag, channel activity/inactivity, channel size

**Brand safety**
- Scans recent video **titles + descriptions** for unsafe categories: adult, hate, violence, drugs, gambling, scam, profanity
- Lists the exact `flaggedCategories` and `flaggedTerms`

**Fit & outreach**
- Topics / keywords, country, and **contact email** (when public)

---

### 🎯 Best for

- **Brands & DTC marketers** — qualify creators before sending product or money
- **Influencer-marketing agencies** — bulk-screen creator rosters and shortlists
- **Sponsorship / UGC teams** — avoid brand-safety incidents and wasted spend
- **Talent managers & MCNs** — benchmark a roster's engagement health
- **Affiliate / ambassador programs** — vet applicants at scale
- **Due diligence** — one bad creator deal costs far more than the audit

---

### ⚡ Why this one

- **One-click, key-free** — paste a channel, get the audit. No login, no cookie, no API token.
- **Decision-ready** — a single verdict + score, not raw stats you have to interpret.
- **Transparent** — every authenticity flag and unsafe term is shown, so you see *why*.
- **Real engagement, not vanity** — measures views vs subscribers, not just follower count.
- **Bulk + API** — screen a whole roster per run; export or pull via the Apify API.

---

### 🛠 How to use

1. Add YouTube **channels** (@handles, IDs, or URLs).
2. Set **Recent videos to analyze** (more = steadier signal).
3. Run and read the **verdict + flags**, or export the dataset.

#### Example input
```json
{ "channels": ["@mkbhd", "@MrBeast"], "recentVideosToAnalyze": 15 }
````

***

### 📤 Output

```json
{
  "channelTitle": "Marques Brownlee",
  "handle": "@mkbhd",
  "verdict": "GOOD FIT",
  "creatorScore": 100,
  "brandSafetyScore": 100,
  "flaggedCategories": [],
  "authenticityFlags": [],
  "subscriberCount": 21000000,
  "avgRecentViews": 3691667,
  "engagementRatePct": 17.58,
  "viewConsistencyCV": 0.42,
  "contactEmail": "business@mkbhd.com",
  "country": "US"
}
```

***

### 🧠 How the verdict works

- **Engagement health** — real average views ÷ subscribers. Big follower counts with tiny, erratic views = a classic bought-audience signal.
- **Consistency** — wildly swinging view counts suggest view-buying or one-off virality, not a reliable audience.
- **Brand safety** — recent titles/descriptions matched against unsafe-content lexicons; each hit lowers the safety score.
- **Final verdict** — GOOD FIT (clean, healthy), CAUTION (some flags / unsafe categories), AVOID (low score or unsafe).

***

### 🆚 How it compares

**vs. follower-count tools** — follower count is the easiest metric to fake. This measures *real* engagement and consistency instead.

**vs. manual vetting** — scrolling a channel for red flags doesn't scale and misses patterns. This audits a roster in one run with a repeatable score.

**vs. expensive influencer platforms** — same core vetting (engagement quality + brand safety) on pay-per-result Apify pricing, no seat fees, with API access.

***

### ❓ FAQ

**How does it detect fake / inflated subscribers?**
It compares subscriber count to **real recent view performance** and view consistency. A huge subscriber count with low, erratic views gets flagged as possible inflation.

**What does the brand-safety scan check?**
Recent video titles and the channel description against unsafe-content categories (adult, hate, violence, drugs, gambling, scam, profanity). Flagged categories and terms are listed for your team to review.

**Does it need any keys or login?**
No — it reads public YouTube data only.

**Can I audit a whole roster at once?**
Yes — pass many channels and screen them in a single run, or pull results via the API.

**Which platforms?**
YouTube (the highest-signal, key-free source for true engagement data).

***

### 💰 Pricing

Pay-per-result: charged **per creator audit**. No subscription.

***

#### Keywords

influencer audit, fake follower checker, fake subscriber detector, youtube engagement checker, engagement rate calculator youtube, brand safety check, influencer vetting tool, creator due diligence, sponsorship audit, influencer fraud detection, audience quality check, creator brand safety, vet influencer before sponsoring, youtube channel audit, influencer marketing tool, check youtube creator, bought followers detection.

# Actor input Schema

## `channels` (type: `array`):

Channel @handles, IDs (UC...), or URLs to audit.

## `recentVideosToAnalyze` (type: `integer`):

How many recent videos to use for engagement & brand-safety analysis.

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

Stop after this many audits (0 = no limit).

## Actor input object example

```json
{
  "channels": [
    "@mkbhd",
    "@MrBeast"
  ],
  "recentVideosToAnalyze": 15,
  "maxResults": 0
}
```

# Actor output Schema

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

Per-creator authenticity & brand-safety audit with verdict and score.

# 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 = {
    "channels": [
        "@mkbhd",
        "@MrBeast"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/influencer-authenticity-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 = { "channels": [
        "@mkbhd",
        "@MrBeast",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/influencer-authenticity-audit").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 '{
  "channels": [
    "@mkbhd",
    "@MrBeast"
  ]
}' |
apify call logiover/influencer-authenticity-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/influencer-authenticity-audit",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Influencer Audit – Fake Followers & Brand Safety",
        "description": "Vet any YouTube creator before you pay for a sponsorship. One-click audit: engagement quality, suspected fake/inflated subscribers, view consistency, brand-safety scan (adult, hate, violence, gambling, scam) and a creator score with a GOOD FIT / CAUTION / AVOID verdict. No API key.",
        "version": "1.0",
        "x-build-id": "4uFjlJJMJ5eNwIpT4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~influencer-authenticity-audit/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-influencer-authenticity-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~influencer-authenticity-audit/runs": {
            "post": {
                "operationId": "runs-sync-logiover-influencer-authenticity-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~influencer-authenticity-audit/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-influencer-authenticity-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "type": "array",
                        "description": "Channel @handles, IDs (UC...), or URLs to audit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recentVideosToAnalyze": {
                        "title": "Recent videos to analyze",
                        "minimum": 3,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many recent videos to use for engagement & brand-safety analysis.",
                        "default": 15
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many audits (0 = no limit).",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```