# Telegram Channel Benchmark — which channels are actually read (`entrogix_works/telegram-channel-benchmark`) Actor

Compare public Telegram channels side by side. One row per channel: median views, reach concentration, posting cadence, how much is forwarded rather than original, ranked. Unofficial; not affiliated with Telegram.

- **URL**: https://apify.com/entrogix\_works/telegram-channel-benchmark.md
- **Developed by:** [Entrogix Works](https://apify.com/entrogix_works) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 channel benchmarkeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Telegram Channel Benchmark — which channels are actually read

Put several public Telegram channels side by side and get **one row per channel**, ranked by how many people actually read a typical post.

Subscriber counts and post volume both flatter channels that are not being read. A channel posting twenty times a day to a quiet audience looks busy and is worthless to monitor. Median views per post is what separates the two, and that only means something when channels are measured the same way.

### What you get per channel

| Field | Example |
|---|---|
| `reachRank` | `1` |
| `channel`, `posts`, `postsWithViews` | `durov`, `30`, `30` |
| **`medianViews`** | `412000` |
| `maxViews`, `topShare` | `1900000`, `0.28` |
| **`postIntervalHours`** | `18.5` |
| **`forwardedShare`** | `0.13` |
| `latestPostAt`, `hoursSinceLastPost` | ISO 8601, `6.2` |

**`reachRank`** is ordered by `medianViews`, not post count. Channels with no readable view counts get `null` rather than a rank, so they sink instead of pretending to be last.

**`topShare`** is the share of all views held by the top 10% of sampled posts. Near 1 means one post went wide and the rest were ignored; low means the audience reads consistently.

**`postIntervalHours`** is the *median* gap between posts. Median, not mean: one quiet week destroys a mean and makes a daily channel look weekly.

**`forwardedShare`** is the proportion of posts forwarded from elsewhere rather than written by the channel. High values mark aggregators — useful to know before treating a channel as a primary source.

**`hoursSinceLastPost`** lets you drop dormant channels rather than reading them as low-reach.

### Summary (key-value store, `BENCHMARK_SUMMARY`)

`channels`, `channelsWithPosts`, `medianOfMedianViews`, `mostRead`, and `stale` — channels with no post in over 7 days.

### Input

```json
{
  "channels": ["durov", "telegram"]
}
```

Public channel usernames, without the `@`.

**Two or more channels are required.** One channel is not a comparison, and the run is rejected rather than returning a single row that answers nothing. If you want the post list for one channel, use **Telegram Channel Scraper** instead.

### Scope and limits — please read

This Actor reads Telegram's **public web preview** for each channel — the same pages anyone can open without an account. Private channels, groups, and anything requiring membership are out of reach and will simply come back empty.

Channels that return no posts are still returned as a row with `posts: 0` and `reachRank: null`, so "private or misspelled" is distinguishable from "quiet".

Each channel is measured on a recent sample of the same size. That makes the comparison fair; it is not a complete history and should not be read as one.

View counts that Telegram does not display are returned as `null`, never `0`, so a missing figure cannot drag a median down.

**No subscriber data.** This Actor reports what a channel publishes and how widely those posts are read. It does not enumerate members, and it does not collect anything about individual subscribers.

### Pricing

Charged **per channel**, not per post — one request covers a whole channel, and the price reflects that.

### Disclaimer

**This is an unofficial tool and is not affiliated with, endorsed by, or sponsored by Telegram.** "Telegram" is a trademark of its respective owner and is used here only to describe what this Actor reads. You are responsible for ensuring your use of the collected data complies with applicable law and with Telegram's terms.

# Actor input Schema

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

Public channel usernames, without the @. One channel is not a comparison and is rejected.

## `samplePerChannel` (type: `integer`):

How many recent posts to base each channel's numbers on. All channels are sampled the same way so the comparison stays fair.

## `minIntervalMs` (type: `integer`):

Pacing between channel fetches.

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

Off by default. Telegram's public preview pages are served without a proxy, and residential bandwidth costs about 34x direct.

## `proxyType` (type: `string`):

Only used when the proxy is enabled. Datacenter is far cheaper on bandwidth than residential.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "samplePerChannel": 30,
  "minIntervalMs": 2000,
  "useProxy": false,
  "proxyType": "DATACENTER"
}
```

# 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": [
        "durov",
        "telegram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("entrogix_works/telegram-channel-benchmark").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": [
        "durov",
        "telegram",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("entrogix_works/telegram-channel-benchmark").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": [
    "durov",
    "telegram"
  ]
}' |
apify call entrogix_works/telegram-channel-benchmark --silent --output-dataset

```

## MCP server setup

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

```

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/gTF2jzg7zHeLfSRKE/builds/z4yPmSD9yfo8rOzie/openapi.json