# Creator Follower Growth Monitor: Counts Across Platforms (`accountable_eel/creator-follower-growth-monitor`) Actor

Social media follower tracker: track follower counts across YouTube, TikTok, Twitch, Bluesky and Telegram channel subscriber counts in one row: change and growth since last run. Weekly follower growth report for creators, or a competitor follower growth alert past a % change. Google Sheets or n8n.

- **URL**: https://apify.com/accountable_eel/creator-follower-growth-monitor.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 creator returneds

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

## Creator Follower Growth Monitor: Counts Across Platforms

Give it a creator's or a brand's accounts on YouTube, TikTok, Twitch, Bluesky and Telegram and get
one row back: the follower count on each platform now, the count at your last run, how many were
gained or lost, and the growth rate. Run the same list again tomorrow or next week and the row
shows **what moved since last time**, per platform and in total. No API key, no login, no account
on any of the platforms.

### Who it's for

- **Influencer and talent agencies** who report follower growth for a roster every week and do not
  want to open fifty profiles to do it.
- **Brand and social media managers** tracking their own channels next to three or four
  competitors, in one sheet.
- **Sponsorship and partnerships teams** who want to know which creators on a shortlist are
  actually growing before they sign.
- **Creators** who want one number for "how did I do this week" across every platform they post on.
- **Analysts and investors** following the audience of a media brand, a game or a product over time.

### What you get

One flat row per creator:

| What | Columns |
| --- | --- |
| The verdict | `monitorStatus`, `hasChanges`, `changeSummary`, `previousCheckedAt`, `daysSincePrevious` |
| The total | `totalFollowers`, `totalFollowersChange`, `totalGrowthPct`, `followersPerDay`, `platformsFound`, `platformsCompared`, `fastestGrowingPlatform` |
| Each platform (`youtube`, `tiktok`, `twitch`, `bluesky`, `telegram`) | `…Handle`, `…Url`, `…Followers`, `…FollowersPrevious`, `…FollowersChange`, `…GrowthPct`, `…Status` |
| Provenance | `creator`, `sourceUrl`, `unreadEntries`, `scrapedAt` |

Two example rows from a weekly run, shortened:

| creator | monitorStatus | changeSummary | totalFollowers | totalFollowersChange | totalGrowthPct | followersPerDay |
| --- | --- | --- | --- | --- | --- | --- |
| youtube:@NASA, twitch:nasa, tiktok:@nasa | CHANGED | YouTube +100,000 (+0.66%), Twitch +1,204 (+0.06%), TikTok +8,310 (+0.41%) since 2026-10-04. | 19,157,223 | 109,514 | 0.57 | 15,644.9 |
| https://t.me/telegram | CHANGED | Telegram -2,118 (-0.02%) since 2026-10-04. | 9,357,774 | -2,118 | -0.02 | -302.6 |

A value that is not known is empty, never 0. `youtubeFollowersChange: 0` means the count was read in
both runs and did not move; an empty cell means there was nothing to compare with.

### How growth tracking works

- **Every run remembers the counts it returned.** The first run of a creator is its `BASELINE`: the
  counts are there, the change columns are empty. From the second run on, every row carries the
  previous count, the change and the growth percentage.
- **By default every creator is returned on every run**, `NO_CHANGE` rows included, which is what a
  weekly report wants.
- **Turn on "Only return creators whose counts changed"** for an alert. A creator whose counts did
  not move is not returned and not charged.
- **Set "Minimum change to report (%)"** to hear only about real moves, for example 5. Smaller moves
  are not lost: the comparison stays against the last row you received, so slow growth adds up
  until it crosses your threshold and the row then shows the whole move.
- **Give the watchlist a name** to keep two schedules apart, for example a daily one and a monthly
  one over the same creators. Each name keeps its own previous counts.

Four rules keep the numbers honest:

1. **An outage is not a loss.** If a platform does not answer on one run, its remembered count is
   left as it was and no change is reported for it. The next run that does get an answer compares
   against the last count actually seen.
2. **A new platform is not growth.** Add an account to a platform later and it is recorded first and
   compared from the run after.
3. **Totals compare like with like.** `totalFollowersChange` is summed only over the platforms read
   in both runs, listed in `platformsCompared`.
4. **Nothing is guessed.** A bare name such as "nasa" is not searched for. You say which account on
   which platform, so the numbers tracked over months always belong to the same account.

### How to use Creator Follower Growth Monitor

1. **In the Apify Console.** Open the actor page and click **Start** — the `creators` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~creator-follower-growth-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"creators":["https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa","https://t.me/telegram","https://bsky.app/profile/bsky.app"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "creators": [
    "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
    "https://t.me/telegram",
    "https://bsky.app/profile/bsky.app"
  ]
}
```

One creator or brand per line. Put all of its accounts on the same line, separated by commas: profile URLs, or platform:handle pairs such as youtube:@NASA, twitch:nasa. Works with YouTube, TikTok, Twitch, Bluesky and Telegram channels. Run the same list again and every row shows how the follower counts moved since the last run. Accepted formats: https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, youtube:@NASA, tiktok:@nasa, twitch:nasa, https://t.me/telegram, bluesky:bsky.app.

All of one creator's accounts go on one line. Each entry is a profile URL or a `platform:handle`
pair; `yt`, `tt`, `bsky` and `tg` work as short names. An entry that is not an account on one of the
five platforms is listed in `unreadEntries` and skipped.

### Output

One row per creator, for example:

| query | found | status | creator | sourceUrl | monitorStatus | hasChanges | changeSummary | previousCheckedAt | daysSincePrevious | totalFollowers | totalFollowersChange | totalGrowthPct | followersPerDay | platformsFound | platformsCompared | fastestGrowingPlatform | youtubeHandle | youtubeUrl | youtubeFollowers | youtubeFollowersPrevious | youtubeFollowersChange | youtubeGrowthPct | youtubeStatus | tiktokHandle | tiktokUrl | tiktokFollowers | tiktokFollowersPrevious | tiktokFollowersChange | tiktokGrowthPct | tiktokStatus | twitchHandle | twitchUrl | twitchFollowers | twitchFollowersPrevious | twitchFollowersChange | twitchGrowthPct | twitchStatus | blueskyHandle | blueskyUrl | blueskyFollowers | blueskyFollowersPrevious | blueskyFollowersChange | blueskyGrowthPct | blueskyStatus | telegramHandle | telegramUrl | telegramFollowers | telegramFollowersPrevious | telegramFollowersChange | telegramGrowthPct | telegramStatus | unreadEntries | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa | true | OK | \<creator (as entered)> | <source url> | <monitoring status> | <changed since last run> | <change in plain words> | <previous run> | <days since previous run> | <total followers now> | <total change> | \<total growth (%)> | <followers per day> | <platforms found> | <platforms compared> | <fastest growing platform> | <youtube handle> | <youtube url> | <youtube subscribers> | \<youtube subscribers, previous run> | <youtube change> | \<youtube growth (%)> | <youtube check> | <tiktok handle> | <tiktok url> | <tiktok followers> | \<tiktok followers, previous run> | <tiktok change> | \<tiktok growth (%)> | <tiktok check> | <twitch handle> | <twitch url> | <twitch followers> | \<twitch followers, previous run> | <twitch change> | \<twitch growth (%)> | <twitch check> | <bluesky handle> | <bluesky url> | <bluesky followers> | \<bluesky followers, previous run> | <bluesky change> | \<bluesky growth (%)> | <bluesky check> | <telegram handle> | <telegram url> | <telegram subscribers> | \<telegram subscribers, previous run> | <telegram change> | \<telegram growth (%)> | <telegram check> | <entries not read> | 1970-01-01T00:00:00.000Z |

A line none of whose accounts returned a count comes back as a row with `"found": false` and a
`message` that says why, platform by platform. It is never charged.

### Example runs

Three inputs that need no credentials of any kind and return rows as they stand. Paste one into the
Input tab and press Start.

**1. Where do these creators stand today, and since my last run?**

```json
{
  "creators": [
    "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
    "https://t.me/telegram",
    "https://bsky.app/profile/bsky.app"
  ]
}
```

**2. A weekly growth report with its own memory**

Save this as a task and put it on a weekly schedule. Every run returns every creator, with the
change since the week before.

```json
{
  "creators": [
    "youtube:@NASA, twitch:nasa, tiktok:@nasa",
    "twitch:twitch"
  ],
  "deltaName": "weekly-report"
}
```

**3. A daily alert when a channel moves by 2% or more**

The first run returns each creator once as the baseline. After that a creator is returned, and
charged, only on a day when one of its counts has moved 2% since the last row you received.

```json
{
  "creators": [
    "https://t.me/telegram",
    "bluesky:bsky.app"
  ],
  "onlyNewSinceLastRun": true,
  "minChangePct": 2,
  "deltaName": "daily-alert"
}
```

### Pricing

Pay-per-event. A flat per-run fee covers session/proxy warmup; each independent
source is billed under its own event, only when that source actually returns
data — see `.actor/pay_per_event.json` for exact prices. A miss is never
charged.

You pay once per creator row returned, and nothing else. One row covers every platform on the line,
so five platforms cost the same as one.

- A line with no account on it, or whose accounts returned no count, is free.
- With "Only return creators whose counts changed" on, a creator whose counts did not move is not
  returned and is free.
- A row hidden by a keyword filter is free.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~creator-follower-growth-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"creators":["https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa","https://t.me/telegram","https://bsky.app/profile/bsky.app"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~creator-follower-growth-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"creators":["https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa","https://t.me/telegram","https://bsky.app/profile/bsky.app"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~creator-follower-growth-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"creators":["{{creator}}"]}`, mapping the row's creator into the `creators` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "social media follower tracker" — the agent will find and run this actor.

### Where the data comes from

Each count is the one the platform publishes on the account's own public page, read at the moment
of the run:

| Platform | Count | Precision |
| --- | --- | --- |
| YouTube | subscribers | as displayed, three digits (15.1M) |
| TikTok | followers | exact |
| Twitch | followers | exact |
| Bluesky | followers | exact |
| Telegram | subscribers of a public channel, members of a public group | exact |

### Limits, stated plainly

- **YouTube rounds.** YouTube shows three digits and publishes no exact figure, so a channel with
  15.1M subscribers moves in steps of 100,000 and one with 8,120 in steps of 10. Short intervals on
  large channels read `NO_CHANGE` until the displayed figure ticks over.
- **Five platforms.** Instagram, X, Threads and Facebook are not read by this actor.
- **Public accounts only.** A private TikTok account is reported as `PRIVATE` with no count. A
  YouTube channel that hides its subscriber count is reported as `COUNT_HIDDEN`. Telegram invite
  links and personal Telegram accounts are not read.
- **Growth is measured between your runs.** There is no history from before your first run, and a
  spike that rose and fell between two runs is not seen. Run more often if that matters.
- **Editing a line starts it over.** The memory belongs to the exact set of accounts on a line. Add
  or remove an account and that creator's next row is a new `BASELINE`.
- **Counts only.** No follower lists, no posts, no engagement figures.

### Data & privacy

The actor returns the handle, the profile URL and the follower count an account publishes to every
visitor. It reads no follower lists, no posts, no bios and nothing behind a sign-in. The counts it
remembers between runs are stored in a key-value store in your own Apify account, under the
watchlist name you chose. You are responsible for how you use the output, including when an account
belongs to a private person.

### FAQ

**Why are the change columns empty on my first run?**
The first run of a creator is the baseline. There is nothing to compare with yet. Run it again and
they fill in.

**Can I see growth over the last 30 days today?**
Not on day one. The actor measures from your first run onward. Schedule it and the history builds
up in your datasets, one row per run.

**Why does my YouTube channel show no change?**
YouTube's displayed count is rounded to three digits. Until it ticks over, the count is the same.

**One platform says `BLOCKED` or `ERROR`. Did I pay for it?**
You pay per creator row, not per platform. The row is returned if at least one platform gave a
count, and the platform that did not answer keeps its remembered count for next time.

**Can two schedules track the same creators?**
Yes. Give each a different watchlist name so one does not move the other's baseline.

**Do I need a proxy?**
No. The default setting works.

### Related actors

- [Creator Profile Lookup: TikTok, Instagram, YouTube, X, Threads](https://apify.com/accountable_eel/creator-profile-unified-lookup): a full profile snapshot (bio, posts, verified badge) per creator across TikTok, Instagram, YouTube, X and Threads.

- **Creator Profile Unified Lookup** for a creator's full public profile on several platforms at once.

- **YouTube Channel Lookup**, **Twitch Channel Lookup**, **TikTok Profile Lookup** and
  **Telegram Channel Lookup** for everything one platform publishes about one account.

# Actor input Schema

## `creators` (type: `array`):

One creator or brand per line. Put all of its accounts on the same line, separated by commas: profile URLs, or platform:handle pairs such as youtube:@NASA, twitch:nasa. Works with YouTube, TikTok, Twitch, Bluesky and Telegram channels. Run the same list again and every row shows how the follower counts moved since the last run. Accepted formats: https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, youtube:@NASA, tiktok:@nasa, twitch:nasa, https://t.me/telegram, bluesky:bsky.app. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on for a scheduled run that feeds an alert. A creator whose follower counts did not move since the last row you received is not returned and not charged. The first run of a creator is always returned, so you can see which counts were recorded.

## `minChangePct` (type: `integer`):

Only used with the checkbox above. A creator is returned once the count on at least one platform has moved by this percentage, up or down, since the last row you received. Smaller moves are not lost: they add up until they cross it. 0 means any change.

## `deltaName` (type: `string`):

Optional. Counts are remembered between runs under this name, for example "competitors-weekly". Give two schedules different names and each keeps its own previous counts. Left empty, all your runs share one memory.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "creators": [
    "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
    "https://t.me/telegram",
    "https://bsky.app/profile/bsky.app"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "onlyNewSinceLastRun": false,
  "minChangePct": 0,
  "deltaName": "",
  "columns": [
    "creator",
    "sourceUrl",
    "monitorStatus",
    "hasChanges",
    "changeSummary",
    "previousCheckedAt",
    "daysSincePrevious",
    "totalFollowers",
    "totalFollowersChange",
    "totalGrowthPct",
    "followersPerDay",
    "platformsFound",
    "platformsCompared",
    "fastestGrowingPlatform",
    "youtubeHandle",
    "youtubeUrl",
    "youtubeFollowers",
    "youtubeFollowersPrevious",
    "youtubeFollowersChange",
    "youtubeGrowthPct",
    "youtubeStatus",
    "tiktokHandle",
    "tiktokUrl",
    "tiktokFollowers",
    "tiktokFollowersPrevious",
    "tiktokFollowersChange",
    "tiktokGrowthPct",
    "tiktokStatus",
    "twitchHandle",
    "twitchUrl",
    "twitchFollowers",
    "twitchFollowersPrevious",
    "twitchFollowersChange",
    "twitchGrowthPct",
    "twitchStatus",
    "blueskyHandle",
    "blueskyUrl",
    "blueskyFollowers",
    "blueskyFollowersPrevious",
    "blueskyFollowersChange",
    "blueskyGrowthPct",
    "blueskyStatus",
    "telegramHandle",
    "telegramUrl",
    "telegramFollowers",
    "telegramFollowersPrevious",
    "telegramFollowersChange",
    "telegramGrowthPct",
    "telegramStatus",
    "unreadEntries"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "creators": [
        "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
        "https://t.me/telegram",
        "https://bsky.app/profile/bsky.app"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/creator-follower-growth-monitor").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 = {
    "creators": [
        "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
        "https://t.me/telegram",
        "https://bsky.app/profile/bsky.app",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/creator-follower-growth-monitor").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 '{
  "creators": [
    "https://www.youtube.com/@NASA, https://www.twitch.tv/nasa, https://www.tiktok.com/@nasa",
    "https://t.me/telegram",
    "https://bsky.app/profile/bsky.app"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/creator-follower-growth-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/creator-follower-growth-monitor"
        }
    }
}
```

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/7ItJsHTaUSlbOMyVo/builds/LGiiOviJx9GeWxr84/openapi.json
