# Telegram Channel Analytics: Growth and Reach (`datagrit/telegram-channel-growth-analytics`) Actor

One row per public Telegram channel: subscribers and growth since your last run, median views, view rate, posting cadence, reactions and forward sources.

- **URL**: https://apify.com/datagrit/telegram-channel-growth-analytics.md
- **Developed by:** [datagrit](https://apify.com/datagrit) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Telegram Channel Analytics: Growth and Reach do?

Telegram Channel Analytics: Growth and Reach turns a list of public Telegram channels into one analytics row per channel: subscribers, how many of them actually see a post (view rate), how often the channel posts, how people react, how much of it is forwarded from other channels, and how the audience changed since your last run.
It reads the public web preview of each channel, so there is no login, no API key and no Telegram account involved. Export the rows as JSON, CSV or Excel, call the Actor through the Apify API, or connect it to n8n, Make and AI agents through MCP.

### Why use Telegram channel analytics?

What sets this Actor apart is memory: it stores the subscriber count and median views of every channel it delivers, so each scheduled run adds the change since the previous run (`subscribersChange`, `subscribersChangePerDay`, `medianViewsChangePct`, `previousCheckedAt`, `observations`) to the row, with nothing to set up. It also lists the channels each one forwards from most (`topForwardSources`) and screens a shortlist by subscriber range.

- **Vet channels before you buy an ad.** Compare median views, view rate and reactions per 1,000 views across a shortlist instead of trusting the subscriber number.
- **Track growth of your own and competing channels.** Schedule the Actor daily or weekly; from the second run every row carries the subscriber change, the change per day and the change in median views.
- **Find the channels worth a partnership.** Filter by minimum and maximum subscribers, then rank by view rate, posting cadence and the days since the last post to drop dead channels.
- **Map who a channel amplifies.** Each row lists the channels it forwards from most often, which shows content sources and network clusters.
- **Feed dashboards and agents.** One flat row per channel, stable field names, no message dumps to post-process.

### Example output

| channel | subscribers | medianViews | viewRatePct | postsPerDay | forwardedSharePct | subscribersChange | isFirstObservation |
|---|---|---|---|---|---|---|---|
| durov | 1100000 | 412000 | 37.5 | 0.4 | 5.0 | 12000 | false |
| bloomberg | 410000 | 38000 | 9.3 | 31.2 | 0 | -800 | false |

```json
{
  "channel": "durov",
  "channelUrl": "https://t.me/durov",
  "title": "Pavel Durov",
  "verified": true,
  "subscribers": 1100000,
  "subscribersApproximate": true,
  "postsAnalyzed": 40,
  "lastPostAt": "2026-10-05T14:20:11.000Z",
  "daysSinceLastPost": 1.4,
  "postsPerDay": 0.4,
  "medianViews": 412000,
  "viewRatePct": 37.5,
  "medianReactions": 9400,
  "reactionsPer1kViews": 23.1,
  "forwardedSharePct": 5,
  "topForwardSources": [{ "channel": "telegram", "posts": 2 }],
  "isFirstObservation": false,
  "previousSubscribers": 1088000,
  "subscribersChange": 12000,
  "subscribersChangePct": 1.1,
  "subscribersChangePerDay": 1714.3,
  "subscribersChangeApproximate": true,
  "found": true,
  "scrapedAt": "2026-10-07T08:00:00.000Z"
}
```

### How much does it cost?

You pay for each channel row that is delivered, with a lower price on paid Apify plans. Channels that cannot be read (no public preview, wrong username) come back as status rows that are not charged. Set a maximum spend on the run and the Actor stops when it is reached.
The Actor uses plain HTTP requests, so a run of ten channels takes seconds and uses very little memory.

### Input

- **Channels** – usernames (`telegram`), with an at sign (`@durov`) or links (`https://t.me/bloomberg`), one per line. Duplicates are merged.
- **Posts per channel** – how many recent posts feed the metrics, 20 to 400. Telegram serves about 20 posts per request.
- **Maximum post age (days)** – ignore older posts, so a channel is not judged on viral posts from years ago. 0 means no limit.
- **Minimum / maximum subscribers** – skip channels outside the range; skipped channels are not charged.
- **Maximum channels** – total limit of channel rows per run.
- **Proxy configuration** – optional; use it if Telegram throttles your region.

### Output fields

Each row has the channel identity (`channel`, `title`, `verified`, `description`), size (`subscribers`, `photosTotal`, `videosTotal`, `linksTotal`), cadence (`postsPerDay`, `lastPostAt`, `daysSinceLastPost`), reach (`medianViews`, `averageViews`, `maxViews`, `viewRatePct`), engagement (`medianReactions`, `reactionsPer1kViews`), content mix (`forwardedSharePct`, `topForwardSources`, `mediaPostsSharePct`, `linkPostsSharePct`) and growth since the previous run (`subscribersChange`, `subscribersChangePct`, `subscribersChangePerDay`, `medianViewsChangePct`).
When a channel cannot be read you get one row with `found: false`, a `reason` and a `message`: `notFound` (no such username on Telegram), `notAChannel` (the username belongs to a user, a bot or a group), `previewUnavailable` (the channel exists but its owner disabled the public preview) or `fetchFailed` (Telegram did not answer).

### How growth tracking works

The Actor remembers the subscriber count and median views of every delivered channel in a store tied to your account. The first run for a channel has no comparison, so growth columns are empty and `isFirstObservation` is `true`; from the second run on they are filled. Run it on a schedule to build a series.
Telegram rounds large subscriber counts (for example 1.1M), so for channels above roughly 10,000 subscribers the change is approximate and `subscribersChangeApproximate` says so.

### Is it legal to scrape Telegram channels?

The Actor reads only the public preview page that Telegram serves to anyone without logging in. It does not read private channels, groups or messages, and it does not bypass access controls. You are responsible for using the data in line with applicable laws, including data protection rules, and Telegram's terms. If you find an issue, open it in the Issues tab; problems are answered within one business day.

### FAQ

**Why is the view rate above 100%?** Views can exceed subscribers when posts are shared widely. If the sample contains old viral posts, set Maximum post age to 30 or 60 days for a current picture.

**Why does a channel come back without data?** The row says why: the username does not exist (`notFound`), belongs to a user, bot or group (`notAChannel`), or the channel owner disabled the public preview (`previewUnavailable`). Such rows are not charged.

**How fresh is the data?** Every run reads the preview live. Views of posts younger than 24 hours are still growing, so the median uses settled posts when at least five exist.

**Can I schedule runs?** Yes, use Apify schedules; the growth columns rely on repeated runs.

**Something looks wrong.** Open an issue with the input you used; layout changes at Telegram are fixed quickly.

### Related Actors

See other data Actors from the same publisher on the Store profile.

# Changelog

This Actor's version history is a separate document: https://apify.com/datagrit/telegram-channel-growth-analytics/changelog.md

# Actor input Schema

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

Public Telegram channels to analyse, one per line: usernames (telegram), with an at sign (@durov) or as links (https://t.me/bloomberg). Channels without a public web preview cannot be read and come back as status rows.

## `postsPerChannel` (type: `integer`):

How many of the latest posts feed the view, cadence, reaction and forward metrics. Telegram serves about 20 posts per request, so 40 posts cost two requests per channel.

## `maxPostAgeDays` (type: `integer`):

Ignore posts older than this many days, so rarely posting channels are not judged on years-old posts. 0 means no age limit; the latest post time is reported either way.

## `minSubscribers` (type: `integer`):

Skip channels with fewer subscribers than this. 0 disables the filter. Skipped channels are not charged and not recorded for growth tracking.

## `maxSubscribers` (type: `integer`):

Skip channels with more subscribers than this, for example to find mid-size channels. 0 disables the filter.

## `maxItems` (type: `integer`):

Stop after this many channel rows in total. Status rows do not count.

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

Optional proxy. Leave disabled unless Telegram blocks the platform IP range; residential proxy raises the platform cost of the run.

## Actor input object example

```json
{
  "channels": [
    "telegram",
    "durov",
    "bloomberg"
  ],
  "postsPerChannel": 40,
  "maxPostAgeDays": 0,
  "minSubscribers": 0,
  "maxSubscribers": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All extracted records as a dataset.

# 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": [
        "telegram",
        "durov",
        "bloomberg"
    ],
    "postsPerChannel": 40,
    "maxPostAgeDays": 0,
    "minSubscribers": 0,
    "maxSubscribers": 0,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagrit/telegram-channel-growth-analytics").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": [
        "telegram",
        "durov",
        "bloomberg",
    ],
    "postsPerChannel": 40,
    "maxPostAgeDays": 0,
    "minSubscribers": 0,
    "maxSubscribers": 0,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("datagrit/telegram-channel-growth-analytics").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": [
    "telegram",
    "durov",
    "bloomberg"
  ],
  "postsPerChannel": 40,
  "maxPostAgeDays": 0,
  "minSubscribers": 0,
  "maxSubscribers": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call datagrit/telegram-channel-growth-analytics --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagrit/telegram-channel-growth-analytics"
        }
    }
}
```

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/CwbrzHv7GokfFbYKX/builds/qPhccbcOjOuqu9LlF/openapi.json