# Creator Stats (`s-r/creator-stats`) Actor

Creator and influencer stats across 19 platforms from one handle list. Followers, engagement, growth, earnings estimates and contact emails, merged field by field from every source that answers. No API keys required.

- **URL**: https://apify.com/s-r/creator-stats.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$7.00 / 1,000 creator rows

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/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

## Creator Stats: multi-platform influencer stats from one handle list

Get followers, engagement, growth, earnings estimates and contact emails for
creators across 19 platforms in a single run. Creator stats and influencer
analytics come back as one tidy row per platform and handle, merged field by
field from every source that answers, so you can rank, vet and outreach without
opening twenty tabs.

### What you get

- One dataset row per `(platform, handle)` with `platform`, `handle`,
  `display_name`, `followers`, `following`, `posts_count`, `videos_count`,
  `engagement_rate`, `growth`, `earnings_estimate`, `audience_quality`,
  `contact_email`, `source_name`, `sources`, `fetched_at` and `status`
- Coverage across YouTube, Instagram, TikTok, Twitch, X, Kick, Telegram, Reddit,
  Snapchat, Bluesky, Mastodon, Discord, Substack, Medium, Gab and VK
- Field-level merge: when several sources answer, the strongest source wins each
  field and the row lists every source that ran
- Second-index corroboration from public stats providers, so a single thin
  profile is not your only signal
- Contact emails pulled from bios and profile pages when the creator published
  one
- Earnings or income bands and audience-quality grades where a source carries
  them
- A clear `status` on every row (`ok`, `partial`, `blocked`, `not_configured`,
  `not_found`, `error`) so a quiet platform never looks like a zero
- Per-source notes on the row, including missing API keys and upstream limits

No API keys are required for the core run. Optional keys unlock a few official
APIs and are skipped cleanly when absent.

### Why scrape creator stats

Influencer platforms sell seat licences and metered lookups. If you vet fifty
creators a week across six networks, you are paying enterprise money for what
is, at heart, a public profile read. The numbers also disagree: a TikTok
follower count on the profile page, on a stats site and inside a media kit can
all differ, and you only find out when the campaign report lands.

Pulling creator stats yourself fixes both problems. You choose the handles, you
keep the raw fields, and you can line up several sources on the same profile to
see where the story is consistent. That is the difference between "she has about
a million followers" and "she has 1.02M on the profile, 1.09M on the stats
index, engagement around 8%, income band mid-five figures, contact email on the
bio".

Agencies run this before a pitch. Brands run it to qualify inbound. Analysts
run it to build a market map of a niche. In every case the job is the same:
turn a list of handles into a comparable table, fast, without a login wall on
your time.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `handles` | array | one of `handles` / `handle` | List of `{platform, handle}` objects. A bare string is resolved on every known platform. |
| `handle` | string | one of `handles` / `handle` | Single handle, resolved on `platforms` or on every known platform. |
| `platforms` | array | no | Platform keys for the single-handle form. |
| `include_stubs` | boolean | no | Also emit stub rows for platforms that need a real browser. Default `false`. |
| `sources` | array | no | Source-name filter (for example `socialblade`, `speakrj`, `reddit_web`). Empty runs every source that covers the platform. |

Platform keys: `youtube`, `instagram`, `facebook`, `tiktok`, `twitch`, `x`,
`telegram`, `threads`, `reddit`, `kick`, `snapchat`, `truth_social`, `bluesky`,
`mastodon`, `rumble`, `substack`, `medium`, `gettr`, `gab`, `discord`, `vk`,
`lemon8`, `pinterest`, `linkedin`.

Handles are normalised for you: a leading `@`, a full profile URL or a channel
URL all resolve to the same handle.

```json
{
  "handles": [
    { "platform": "youtube", "handle": "@LinusTechTips" },
    { "platform": "instagram", "handle": "pewdiepie" },
    { "platform": "tiktok", "handle": "khaby.lame" },
    { "platform": "telegram", "handle": "durov" }
  ]
}
```

### Output

One row per platform and handle. Fields a source did not publish stay `null`
rather than becoming `0`.

```json
{
  "platform": "instagram",
  "handle": "pewdiepie",
  "display_name": "PewDiePie",
  "followers": 19300000,
  "following": 560,
  "posts_count": 1800,
  "videos_count": null,
  "engagement_rate": 8.65,
  "growth": null,
  "earnings_estimate": { "band": "mid-five figures", "source": "speakrj" },
  "audience_quality": { "source": "socialblade", "grade": "B+" },
  "contact_email": null,
  "source_name": "imginn",
  "sources": ["imginn", "socialblade", "speakrj"],
  "fetched_at": "2026-09-24T15:16:11+00:00",
  "status": "ok",
  "notes": ["socialblade: social blade letter grade, not a fraud score"]
}
```

The run also writes `OUTPUT`, `summary` and `errors` to the default key-value
store. `OUTPUT` carries `itemCount`, `errorCount`, `targetCount`, `statusCounts`
and `free_tier_remaining`.

### Use cases

**Agency shortlisting.** Paste fifty handles from a campaign brief, pull the
table, sort on engagement rate and contact email presence. The shortlist for a
client call takes minutes and every number is one you can re-run next week to
see what moved.

**Inbound qualification.** A creator emails a media kit. Run the handle across
their claimed platforms before you answer. Follower counts that do not line up
with the kit, or a missing profile on a claimed network, change the conversation.

**Market mapping.** List the top voices in a niche on one platform, then fan
each handle out across the others. The overlap shows who is actually
multi-platform and who is a one-network specialist, which is the input your
pricing model needs.

**Monitoring and CRM enrichment.** Schedule a weekly run over a fixed handle
list and diff the follower and engagement columns into your CRM. Trend direction
matters more than a single snapshot, and the `growth` field carries history
where a source publishes it.

### How it compares

| | This actor | Single-platform profile scrapers | Influencer SaaS seats |
|---|---|---|---|
| Platforms per run | 19 keys, one row each | 1 | varies, usually capped |
| API keys needed | none for the core run | none to several | account |
| Multi-source merge | yes, field level | no | yes, closed |
| Contact email | when published on the profile | rarely | yes, often gated |
| Pricing | pay per row | pay per row or free | $250-500/mo |
| Raw dataset | yes | yes | export, sometimes metered |

Single-platform scrapers are cheaper per row and deeper on their one network.
They do not reconcile a creator across the other eighteen. Influencer SaaS gives
you a polished UI and a database; you pay for the seat and for every lookups
quota they set. This actor sits in between: a wide, comparable table, priced per
row, with the raw JSON in your dataset.

### Pricing

$0.007 per `creator` row delivered to the dataset. All pricing is pay-per-event:
you only pay for results you receive. No actor-start fee, no per-compute-unit
charges.

### Limits and gotchas

- Free-plan runs receive at most 10 rows per run. Split large lists across runs,
  or upgrade, to get past the cap.
- A row with `status: blocked` or `not_found` is still a row: the platform was
  checked and did not answer or does not have that handle. It is not a zero.
- Official-API sources (YouTube Data API, Twitch Helix, SparkToro and similar)
  return `not_configured` until you attach their keys as actor environment
  variables. The rest of the run is unaffected.
- `include_stubs: true` adds rows for platforms that need a real browser. Those
  rows come back `blocked` with the reason named. Leave the flag off unless you
  want the coverage map.
- Some public stats sources rate-limit under burst. If `notes` mentions a limit,
  lower concurrency by splitting the input.
- Lifetime post and comment counts are not published on every platform. Those
  fields stay `null` where the number is not public.
- Medium support depends on an optional extra being present in the run
  environment. When it is missing, only that one source degrades; the other
  sources still run.
- Cold start is a few seconds. A 20-handle fan-out typically finishes well
  inside two minutes.

### FAQ

**Can I get creator stats without an API key?**
Yes. The core of this actor is keyless. A handful of official-API sources skip
themselves when their keys are missing and say so in `notes`, and the row still
fills from the other sources.

**How do I scrape influencer stats across several platforms at once?**
Pass a list of `{platform, handle}` objects, or one handle and let it fan out.
One row comes back per platform and handle, so the output is already in the
shape of a comparison table.

**Does this return engagement rate and earnings estimates?**
It returns `engagement_rate` and `earnings_estimate` whenever a source publishes
them. Not every platform exposes both publicly; the fields stay `null` when they
do not, and `raw_sources` shows which source said what.

**Where does the contact email come from?**
From the profile or bio when the creator published one. This actor does not
bypass a login wall or a private field, so a hidden email stays hidden.

**What happens when a platform blocks the lookup?**
The row comes back with `status: "blocked"` and a note. The run still succeeds,
and the rest of the rows are unaffected. Raise this with us if one platform is
consistently blocked for you.

### Related Actors

- [Reddit Scraper](https://apify.com/s-r/reddit-scraper) for posts, comment
  trees and search, including author karma and account age
- [Free Spotify Artist Analytics](https://apify.com/s-r/free-spotify-artist-analytics)
  for artist-level listeners, popularity and related artists
- [Backlinks Checker](https://apify.com/s-r/backlinks-checker) for domain
  authority, referring domains and backlink rows

# Actor input Schema

## `handles` (type: `array`):

List of {platform, handle} objects. Platform keys: youtube, instagram, facebook, tiktok, twitch, x, telegram, threads, reddit, kick, snapchat, truth\_social, bluesky, mastodon, rumble, substack, medium, gettr, gab, discord, vk, lemon8, pinterest, linkedin. A bare string is resolved on every known platform.

## `handle` (type: `string`):

Alternative to Creators: one handle, resolved on Platforms below (or on every known platform when Platforms is empty).

## `platforms` (type: `array`):

Optional platform keys for Single handle. Leave empty to try every known platform.

## `include_stubs` (type: `boolean`):

Also emit stub rows for platforms that need a real browser (truth\_social, rumble, gettr and similar). Off by default so runs stay clean.

## `sources` (type: `array`):

Optional source-name filter (for example twitchtracker, kick\_api, socialblade, speakrj, reddit\_web). Empty runs every source that covers the platform.

## Actor input object example

```json
{
  "handles": [
    {
      "platform": "youtube",
      "handle": "@LinusTechTips"
    },
    {
      "platform": "instagram",
      "handle": "pewdiepie"
    },
    {
      "platform": "tiktok",
      "handle": "khaby.lame"
    }
  ],
  "handle": "xqc",
  "platforms": [
    "kick",
    "twitch"
  ],
  "include_stubs": false,
  "sources": [
    "socialblade",
    "speakrj"
  ]
}
```

# Actor output Schema

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

One row per platform and handle, with followers, engagement and contact fields merged across sources.

## `output` (type: `string`):

OUTPUT record with counts, status breakdown and free\_tier\_remaining.

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

Counts by status for the run.

## `errors` (type: `string`):

Rows that came back blocked, not found or in error, with a code and a redacted message.

# 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 = {
    "handles": [
        {
            "platform": "telegram",
            "handle": "durov"
        },
        {
            "platform": "bluesky",
            "handle": "bsky.app"
        }
    ],
    "handle": "",
    "platforms": [],
    "sources": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/creator-stats").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 = {
    "handles": [
        {
            "platform": "telegram",
            "handle": "durov",
        },
        {
            "platform": "bluesky",
            "handle": "bsky.app",
        },
    ],
    "handle": "",
    "platforms": [],
    "sources": [],
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/creator-stats").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 '{
  "handles": [
    {
      "platform": "telegram",
      "handle": "durov"
    },
    {
      "platform": "bluesky",
      "handle": "bsky.app"
    }
  ],
  "handle": "",
  "platforms": [],
  "sources": []
}' |
apify call s-r/creator-stats --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/creator-stats"
        }
    }
}
```

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/G93wYRmFTM3LyPhvy/builds/SjELO9PeNIFQnkzne/openapi.json