# WhatsApp Channel Follower Count Tracker & Change Monitor (`neverempty/whatsapp-channel-follower-tracker`) Actor

Follower count, name, description and verified badge of any public WhatsApp channel. Counts under 1M are the exact number, larger ones are read to the nearest 10,000 up to 100M. Monitoring mode returns a channel only when its followers, name, description or badge change.

- **URL**: https://apify.com/neverempty/whatsapp-channel-follower-tracker.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, For creators, Automation
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## WhatsApp Channel Follower Count Tracker & Change Monitor

Follower count, name, description and verified badge for any public WhatsApp channel. **Channels under 1 million followers come back with the exact number** (110,176, not "110K"). **Larger channels come back to the nearest 10,000 up to 100 million** (3,330,000, not "3.3M"). Each row says how precise its figure is.

With monitoring on, **a channel is returned only when its followers, name, description or verified badge have changed**. The row carries the previous count and the difference. The first check of a channel is free.

Paste channel links (`https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M`) or invite codes (`0029Va4K0PZ5a245NkngBA2M`), mixed in one list.

### Input

| Field | What it does |
|---|---|
| `channels` | Channel links or invite codes, one per line |
| `maxChannels` | Stop after this many channels (default 100) |
| `monitoringMode` | Return only channels that changed since the previous run |
| `monitorMode` | What counts as a change: `any-change` (followers, name, description, verified badge) or `followers-change` |
| `resetMonitoringState` | Forget the remembered figures and start over with a free first check |
| `useProxy` | Move to fresh Apify datacenter proxy addresses if WhatsApp refuses requests (default on) |

### What you get

One row per channel:

| Column | Meaning |
|---|---|
| `channelName` | The channel's name as WhatsApp shows it |
| `followers` | The follower count WhatsApp shows, as an integer, rounded down by WhatsApp (see below) |
| `followersIsExact` | `true` when `followers` is the exact count (channels under 1 million) |
| `followersRoundedTo` | How finely WhatsApp shows the count: `1` (exact), `10000`, `100000` or `1000000` |
| `followersMax` | The highest count consistent with what WhatsApp shows: the real count is between `followers` and `followersMax` |
| `isVerified` | Whether the channel has WhatsApp's verified badge |
| `description` | The channel description, with line breaks kept; `null` when the channel has none |
| `descriptionLinks` | The links written in the description, in page order |
| `avatarUrl` | The channel picture; `null` when the channel uses the default picture |
| `channelId`, `channelUrl` | The invite code and the channel link |
| `followersPageText` | The follower line exactly as WhatsApp showed it, for your own checks |
| `input`, `scrapedAt`, `status` | What you typed, when it was read, `ok` for a channel row |

Monitoring columns (filled in monitoring mode): `change`, `isFirstCheck`, `changedFields` (for example `["followers"]` or `["channelName"]`), `previousFollowers`, `followersChange`, `followersChangeIsExact`, `previousChannelName`, `previousCheckedAt`.

Measured on 2026-10-23:

| Channel | followers | followersRoundedTo | followersMax | isVerified |
|---|---|---|---|---|
| PUNCH Newspaper | 110176 | 1 | 110176 | false |
| The Tribune | 31333 | 1 | 31333 | true |
| The Hindu News | 3330000 | 10000 | 3339999 | true |
| Katrina Kaif | 9670000 | 10000 | 9679999 | true |
| FC Barcelona | 50770000 | 10000 | 50779999 | true |
| WhatsApp | 234000000 | 1000000 | 234999999 | true |

### How precise the follower count is

WhatsApp shows the count on the public channel page, and **it always rounds down**. How much it rounds depends on the size of the channel, and this Actor reads the most precise figure WhatsApp shows:

| Channel size | What you get | `followersRoundedTo` |
|---|---|---|
| Under 1 million | The exact count | `1` |
| 1 million to 100 million | The count to the nearest 10,000 below | `10000` |
| 100 million and above | The count to the nearest 1,000,000 below | `1000000` |

`followers` is therefore the figure WhatsApp shows, not a guess. The real count is never below it and never above `followersMax`. If the finer figure cannot be read for a channel in one run, that row falls back to the 100,000-step figure and says so in `followersRoundedTo`.

### Monitoring mode

Turn on **Monitoring mode** and run the same list on a schedule:

1. **First run of a channel**: its figures are remembered as the starting point. You get a `first-check` row without figures, and nothing is charged.
2. **Later runs**: each channel is read and compared with what was remembered.
   - **Something changed**: you get the channel row with `previousFollowers`, `followersChange` and `changedFields`, charged as one channel row.
   - **Nothing changed**: no channel row; the channel is charged as one check. When no channel in the run changed, you get one `no-change` row so an empty result is never ambiguous.

`followersChange` is the difference between two figures of the same precision. `followersChangeIsExact` is `true` when both figures are exact (channels under 1 million). For a large channel, `followersChange` is the difference between two rounded-down figures: a change of 10,000 means the shown figure moved by one step. If the two figures have different precision, `followersChange` is `null` instead of an invented number. The channel then counts as changed only when the two ranges no longer overlap.

**What counts as a change**: any of followers, name, description and verified badge (default), or the follower count only. A large channel whose shown figure has not moved is not reported as changed.

Figures are remembered per channel, so adding a channel to your list does not reset the others. **Forget the remembered figures and start over** clears them, and the next run is a free first check again. A change that could not be delivered because the run's maximum total charge was reached is not remembered, so the next run returns it.

### What is charged

- **channel-returned**: one per channel row with `status: ok`.
- **channel-checked**: monitoring mode only. One per channel that was compared and had not changed. A channel that changed is charged as a row only, not as a check.
- Not charged: `first-check`, `no-such-channel`, `invalid-input`, `duplicate-input`, `unreadable`, `blocked`, `no-change`, `not-read` and `budget-reached` rows. There is no start fee and no monthly fee.

If you set a maximum total charge, the run stops before it, lists the lines it did not read in a `not-read` row, and charges nothing for them.

### Rows that explain instead of failing

| status | When |
|---|---|
| `first-check` | Monitoring: the first time a channel is seen, its starting point was remembered |
| `no-such-channel` | WhatsApp shows its "invite link is invalid" page for the code: the channel was deleted, or the code is wrong (codes are case-sensitive) |
| `invalid-input` | The line is not a channel link or invite code, for example a group invite link (`chat.whatsapp.com`) - or no channel was given |
| `duplicate-input` | The same channel appeared earlier in the list |
| `unreadable` | The page came back without the channel name or follower line. No figure is guessed |
| `blocked` | WhatsApp kept refusing the request (HTTP 403/429) |
| `not-read` | Lines that were not requested: after a `blocked` row or three unreadable pages in a row, or when `maxChannels` or the charge limit was reached |
| `no-change` | Monitoring: every channel was compared and none had changed |
| `budget-reached` | A changed channel was ready but did not fit inside the run's maximum total charge |

### Good to know

- **Large channels are not exact**: WhatsApp does not show an exact count above 1 million on its public page, so no tool reading that page can return one. This Actor returns the most precise figure shown and tells you its precision in `followersRoundedTo` and `followersMax`.
- **Channel names are not searched**: give the channel link from the channel's Share menu in WhatsApp, or its invite code.
- **Picture links expire**: `avatarUrl` is a signed WhatsApp link that stops opening after a while. Download the picture if you need to keep it.
- **Posts are not read**: the public channel page does not list the channel's messages, so this Actor returns the channel's profile and follower figures only.
- Only the public channel page (`whatsapp.com/channel/<code>`) is requested, with a pause between requests and a User-Agent that identifies this Actor. Channels of 1 to 100 million followers need a second request for the finer figure. No login and no WhatsApp account are used. If WhatsApp refuses requests from one address, the run moves to fresh Apify datacenter proxy addresses (you can turn this off).
- This Actor is not affiliated with, endorsed by or sponsored by WhatsApp or Meta. WhatsApp's terms restrict automated collection; decide for yourself whether your use is permitted before you run it.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

Channel links (https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M, with or without www) or just the invite code (0029Va4K0PZ5a245NkngBA2M). Invite codes are case-sensitive, so paste them as they are. A code WhatsApp has no channel for comes back as a "no-such-channel" row that is not charged. Group invite links (chat.whatsapp.com) are private groups, not channels, and are rejected. Channel names are not searched: use the link from the channel's Share menu in WhatsApp.

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

With monitoring off, the run stops after this many channel rows and lists the lines it did not read in a row that is not charged. Monitoring mode ignores this and checks every channel you listed.

## `monitoringMode` (type: `boolean`):

Off = return every channel you listed, charged per channel row (channel-returned). On = the follower count, name, description and verified badge are remembered, and later runs return a channel only when one of them differs, with the previous follower count and the difference. The first monitoring run of a channel only remembers its starting point: it is free and returns a first-check row without figures. After that, a channel that changed is charged as one channel row, and a channel that was compared and had not changed is charged as one check (channel-checked). Figures are remembered per channel, not per list, so adding a channel does not reset the others. Do not put the same channel in two schedules that run at the same moment.

## `monitorMode` (type: `string`):

Any change = the channel is returned when its follower count, name, description or verified badge differs from what was remembered. Follower count only = name, description and badge changes are ignored. A follower count that WhatsApp shows rounded (1M and above) counts as changed only when the shown figure moves.

## `resetMonitoringState` (type: `boolean`):

Clears every remembered channel for this Actor on your account, so the next monitoring run takes a free first check of each channel again. This affects all your monitoring runs, because figures are remembered per channel rather than per list.

## `useProxy` (type: `boolean`):

Requests go directly to WhatsApp with a pause between them. WhatsApp refuses (HTTP 429) after about 50 quick requests from one address; when that happens, the run continues from fresh Apify datacenter proxy addresses. Turn this off to never use a proxy: a refusal is then waited out once and, if it repeats, the run stops and lists what it did not read.

## Actor input object example

```json
{
  "channels": [
    "https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M",
    "0029Va5M78l35fLt7xvmGQ2z"
  ],
  "maxChannels": 100,
  "monitoringMode": false,
  "monitorMode": "any-change",
  "resetMonitoringState": false,
  "useProxy": true
}
```

# Actor output Schema

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

One row per WhatsApp channel: name, follower count (exact under 1M, otherwise the rounded-down figure WhatsApp shows with its rounding step and upper bound), verified badge, description, links in the description, avatar URL, invite code and link and, in monitoring mode, the previous follower count, the difference and which fields changed. Invite codes WhatsApp has no channel for, lines that are not channel links, pages that could not be read, first monitoring checks and runs where nothing changed come back as their own rows and are not charged.

# 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": [
        "https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M",
        "0029Va5M78l35fLt7xvmGQ2z"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/whatsapp-channel-follower-tracker").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": [
        "https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M",
        "0029Va5M78l35fLt7xvmGQ2z",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/whatsapp-channel-follower-tracker").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": [
    "https://whatsapp.com/channel/0029Va4K0PZ5a245NkngBA2M",
    "0029Va5M78l35fLt7xvmGQ2z"
  ]
}' |
apify call neverempty/whatsapp-channel-follower-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/whatsapp-channel-follower-tracker"
        }
    }
}
```

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/v9gOrkuZaDDHlvY5v/builds/ldlxpGmK3CEv7scgL/openapi.json
