# YouTube Influencer Audit - Fake Subscribers & Engagement (`centorprat/youtube-influencer-audit`) Actor

Deep YouTube creator due diligence: subscriber-tier benchmarks (long-form and Shorts separated), fake-subscriber and bought-view signals, reach health and momentum, recent sponsors, brand safety, a CPM rate card, and authenticity + influence scores. Keyless, no API key needed.

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

## Pricing

from $34.00 / 1,000 channel 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

## YouTube Influencer Audit — Fake Subscribers, Engagement & Sponsors

Vet a YouTube creator before you sponsor them. Give channels and get the agency due-diligence brief for each:

- **Engagement benchmarked to the subscriber tier**, with **long-form and Shorts analysed separately**.
- **Fake-subscriber and bought-view signals.**
- **Reach health and momentum.**
- **Which brands recently sponsored them.**
- **Brand-safety flags.**
- A **CPM rate card** for long-form and Shorts.
- **Authenticity, reach-health and influence scores**, with a verdict and a one-line summary.

It reads public channel data directly. **No API key and no extra scraper to pay for.** Agent-callable.

Built for influencer-marketing agencies, brand partnership and sponsorship teams, and creator marketplaces.

### Tiers (the deep layer runs only when you ask)

- **Channel audit (default, a few seconds):** subscriber-tier benchmarks, bought-subscriber / bought-view tells, reach health + momentum, upload cadence, sponsor share + recent sponsors, brand safety, rate card, three scores, verdict.
- **Comment forensics (`deepComments: true`):** reads the **newest** comments on recent uploads, where spam bots live and top-comment sorting hides them. It grades:

  - Telegram/WhatsApp/"investment" scam bots
  - generic/emoji-only comments
  - duplicates
  - commenters still on YouTube's auto-generated `@user-…` handle
  - script mismatch

  The result is a `commentAuthenticityScore` blended into the verdict.

> These are authenticity **signals** from public channel data for due diligence. They are **not an accusation** that a creator is fraudulent. Benchmarks and the rate card are indicative. Verify before contracting.

### What makes it deep

| Dimension | What it computes |
|---|---|
| **Long-form vs Shorts** | Shorts count views differently and would distort every rate, so they're analysed separately. Each format gets its own median views, like rate and rate card, and the audit flags when reach really comes from Shorts. |
| **Do subscribers watch?** | Median views ÷ subscribers vs the tier norm. Subscribers who never watch are the classic bought-subscriber pattern. |
| **Lifetime views per subscriber** | Organic channels earn 100+ lifetime views per subscriber. A large subscriber base on very few views points to bought subscribers. |
| **Engagement sanity** | Like rate (views without likes → bought views), comments per 1k likes (lopsided → bought likes), view-count uniformity. |
| **Reach health + momentum** | Recent views per upload vs the channel's own lifetime average (rising / steady / cooling / declining), plus upload activity. Price on current reach. |
| **Sponsors** | Share of uploads with sponsor or promo-code disclosures, plus the **brands that recently sponsored the creator** (competitor intel). |
| **Credibility gating** | Verified/established channels aren't flagged as fake for naturally low engagement. Their dormant subscribers show up as *low reach health* instead. |
| **Commercials** | CPM rate card on **median** views × engagement quality, long-form and Shorts. |
| **Brand safety & fit** | Risky-content flags (adult / gambling / crypto-promo / engagement-bait / profanity), YouTube's own not-family-safe flag, optional brand-keyword fit. |
| **Verdict** | `authenticityScore` + `reachHealthScore` + `influenceScore` + signal + `summary` + findings. |

**Verdicts:** `authentic-healthy-engagement` · `authentic-modest-engagement` · `inactive-audience-low-reach` · `inflated-subscribers-suspected` · `bought-engagement-suspected` · `engagement-authenticity-concerns` · `authenticity-concerns--review` · `brand-safety-review` · `subscriber-count-hidden` · `not-found`.

### Why not just ask an AI agent?

An agent can open a channel page. It **can't**, in one call and for a whole roster:

- pull exact views and likes for the latest uploads,
- split Shorts from long-form,
- read comment counts and the newest comments,
- extract who sponsored the creator,
- benchmark against the right tier,
- run the bought-subscriber forensics,
- roll it all into consistent scores.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `channels` | array of strings | ✅\* | `@handles`, channel URLs or `UC…` ids. |
| `brandKeywords` | array of strings | | Topics for a brand-fit read. |
| `datasetId` | dataset | ✅\* | …or read channels from another dataset (e.g. a YouTube channel-finder run). |
| `deepComments` | boolean | | Comment forensics add-on (default off). |
| `commentVideosSampled` | integer | | Uploads sampled for comments (default 3). |
| `maxChannels` | integer | | Cap per run (default 20). |
| `webhookUrl` | string | | POST the audits here as JSON. |

\* provide `channels` or `datasetId`.

**Example input**

```json
{ "channels": ["@mkbhd", "@veritasium", "@MrBeast"], "brandKeywords": ["tech", "science"] }
```

### Output

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

```json
{
  "handle": "@mkbhd",
  "title": "Marques Brownlee",
  "verified": true,
  "tier": "celebrity",
  "subscribersCount": 21400000,
  "analysedFormat": "long-form",
  "medianViews": 8852726,
  "viewsToSubscribersRatio": 0.414,
  "likeRatePct": 1.24,
  "commentsPer1kLikes": 69.1,
  "lifetimeViewsPerSubscriber": 270.3,
  "momentum": {"label": "rising", "recentVsLifetimeViewsRatio": 3.3},
  "cadence": {"avgDaysBetweenLongForm": 3.6, "shortsShareOfUploads": 13},
  "shorts": {"count": 2, "medianViews": 7665950, "likeRatePct": 2.37},
  "recentSponsors": [],
  "authenticityScore": 94, "reachHealthScore": 83, "influenceScore": 82,
  "estimatedRateCardUsd": {"low": 79675, "mid": 132791, "high": 212465, "currency": "USD"},
  "signal": "authentic-healthy-engagement",
  "summary": "@mkbhd - celebrity tier (21,400,000 subscribers) - median 8,852,726 long-form views (41% of subs) - like rate 1.2% - reach rising - authenticity 94, reach health 83, influence 82 -> authentic-healthy-engagement"
}
```

On a channel with sponsor disclosures, `recentSponsors` lists the brands (e.g. a real run on @MrBeast returned `["Krispy Kreme", "UPLIFT Desk", …]`). An unverified channel whose subscribers far out-number its views returns `inflated-subscribers-suspected`.

### Use cases

- **Sponsorship vetting:** confirm the audience is real and watching now before you pay.
- **Roster screening:** audit a shortlist or a channel-finder dataset in one run and rank by authenticity and reach health.
- **Rate negotiation:** an independent, views-based fair price for long-form and Shorts integrations.
- **Competitor intel:** see which brands sponsor the creators in your niche.
- **Brand safety:** risky content, not-family-safe channels, ad-fatigue.
- **AI agents:** a structured verdict + one-line `summary` to gate outreach.

### One API call, JSON back

Run it synchronously: one POST starts the run and returns the results in the same response. No run to poll, which is what an AI agent wants mid-task:

```bash
curl -X POST "https://api.apify.com/v2/acts/centorprat~youtube-influencer-audit/run-sync-get-dataset-items" -H "Authorization: Bearer <APIFY_TOKEN>" \
     -H "Content-Type: application/json" -d '{"channels": ["@mkbhd", "@veritasium"]}'
```

The body takes the same fields as the normal input. Same pay-per-event price; failed checks aren't charged.

### For AI agents / MCP

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

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

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

### FAQ

**Do I need a YouTube API key?** No. It reads public channel pages, the channel's uploads feed and public video pages.

**Why separate Shorts?** Shorts views are counted differently and run far higher per subscriber. Mixing them hides how a long-form integration will actually perform.

**How many uploads are analysed?** The channel's latest 15 uploads, with comment counts read for the most recent long-form ones. Videos under 48 h old are left out of the rates.

**What's the difference between authenticity and reach health?** Authenticity asks whether the subscribers and engagement are *real*. Reach health asks whether subscribers *watch now*. A channel that peaked years ago can be authentic and still a poor buy today.

**Does it accuse creators of fraud?** No. It surfaces **signals** for your review, and verified/established channels are gated against false flags.

**Hidden subscriber counts?** Reported as `subscriber-count-hidden`. Views-based metrics still run; subscriber benchmarks are skipped.

**Does it profile commenters?** No. Comment forensics is aggregate (percentages only). No commenter is named, and nothing is inferred about nationality.

**How fast?** A few seconds per channel, a bit more with comment forensics. Channels run in parallel.

**Cost?** Pay-per-event: one event per channel audited, plus one per channel when comment forensics runs. There's no underlying scraper bill.

### Data & attribution

Public YouTube channel and video data. These are 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)
- [Instagram Influencer Audit](https://apify.com/centorprat/instagram-influencer-audit)

# Actor input Schema

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

Channel @handles, channel URLs or channel ids (e.g. "@MrBeast", "https://www.youtube.com/@mkbhd", "UCBJycsmduvYEL83R_U4JriQ"). One audit per channel.

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

Topics your brand cares about (e.g. "tech", "fitness", "gaming"). The audit reports which appear in the channel description, keywords, titles and video descriptions.

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

Read channels from another dataset (e.g. a YouTube search/channel-finder run) - uses the 'channelUrl' / 'channelId' / 'handle' / 'url' field.

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

Also read the NEWEST comments on recent uploads and grade engagement authenticity: spam/scam bots (Telegram/WhatsApp/'investment'), generic/emoji-only, duplicates, auto-generated '@user-...' commenters, script mismatch. Adds a few seconds. Off by default.

## `commentVideosSampled` (type: `integer`):

When deep comment forensics is on, how many recent long-form uploads per channel to sample comments from (~20 newest comments each).

## `maxChannels` (type: `integer`):

Cap how many channels 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
{
  "channels": [
    "@mkbhd"
  ],
  "deepComments": false,
  "commentVideosSampled": 3,
  "maxChannels": 20
}
```

# Actor output Schema

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

One audit per channel: subscriber tier, median views (long-form and Shorts separated) vs tier norms, like and comment rates, lifetime views per subscriber, reach momentum, upload cadence, sponsor share and recent sponsors, brand-safety flags, CPM rate card, authenticity + reach-health + influence scores, a verdict, a one-line summary and findings.

# 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"
    ],
    "maxChannels": 20
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/youtube-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/D4WXl6jrqoIoAfTYj/builds/jqWRzsvTgBDzVFDHO/openapi.json