# Telegram Channel Scraper (No Login) (`octopull/telegram-channel-scraper`) Actor

Scrape posts from public Telegram channels: text, views, reactions, media, links and dates. No login, no phone number, no API keys.

- **URL**: https://apify.com/octopull/telegram-channel-scraper.md
- **Developed by:** [Yogi Wahyu Prasida](https://apify.com/octopull) (community)
- **Categories:** Social media, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

## Telegram Channel Scraper (No Login)

Scrape posts from **public Telegram channels** with no login, phone number or API keys.
Each post comes with its text, date, views, emoji reactions, paid Stars, media type, links,
link preview and forward source. Search inside a channel by keyword, or keep only recent posts.

**Built for:** OSINT researchers and journalists archiving channels, crypto and market watchers,
and brand-monitoring teams. Collect a channel's history to CSV without a phone number or a Telegram account.

It works with the default input: press **Start** and you get the latest 50 posts from the
official `@telegram` channel.

### What you can use it for

- **Brand and crypto monitoring:** track what news, project or signal channels post, and how
  many views and reactions each post gets.
- **Market research:** compare engagement across competitor channels over time.
- **Content analysis:** clean post text with dates, ready for spreadsheets or BI tools.
- **Alerts:** schedule the Actor to run hourly with `postedAfter: "1 hour"` and send new posts
  to Slack, email or a webhook through Apify integrations.

### Input

| Field | What it does | Example |
|---|---|---|
| `channels` | Channel usernames or links. Duplicates and invalid names are skipped with a warning. | `["durov", "@telegram", "https://t.me/bloomberg"]` |
| `maxPostsPerChannel` | Newest posts first, up to this many per channel (default 50). | `200` |
| `postedAfter` | Stop at older posts: a date, a timestamp, or relative. | `"2026-10-01"`, `"7 days"`, `"12 hours"` |
| `searchQuery` | Only posts matching this keyword (Telegram's own in-channel search). | `"bitcoin etf"` |
| `proxyConfiguration` | Off by default. Turn on Apify Proxy only if you scrape many channels and see rate limits. | |

### Output

One dataset item per post:

```json
{
  "channel": "durov",
  "channelTitle": "Pavel Durov",
  "channelSubscribers": 10200000,
  "postId": 535,
  "url": "https://t.me/durov/535",
  "date": "2026-07-30T16:52:37+00:00",
  "text": "Post text, with line breaks kept",
  "links": [],
  "views": 6020000,
  "reactions": [{"emoji": "🔥", "customEmojiId": null, "count": 1940}],
  "totalReactions": 291000,
  "paidStars": 16900,
  "mediaType": "photo",
  "mediaUrls": ["https://cdn1.telesco.pe/file/..."],
  "linkPreview": null,
  "forwardedFrom": null,
  "replyToPostId": null,
  "isEdited": true,
  "scrapedAt": "2026-10-30T04:35:51+00:00"
}
```

Counts such as views and subscribers are rounded the way Telegram shows them (e.g. "6.02M").
Media URLs are temporary CDN links, so download the files soon if you need them.

### Use it in n8n, Make, Zapier or Google Sheets

Use the Apify node or app, action **Run Actor** (or **Run task**), then read the dataset items. For
alerts, schedule it hourly with `postedAfter: "1 hour"` and a `searchQuery`, then send matching posts
to Slack, email or a sheet.

### Pricing

Pay per result: you are charged once per post in the dataset, with lower prices on Apify's
Bronze, Silver and Gold plans. Set a **maximum cost per run**
in the run options and the Actor stops cleanly when it reaches it, keeping everything scraped so far.

Worked example: 5 channels × 200 posts = 1,000 posts = 1,000 result events.

### Limits and good to know

- Only **public channels** that have Telegram's web preview (`t.me/s/<name>`) turned on. Private
  channels, groups and invite links (`t.me/+...`) are reported as unavailable and skipped.
- No member lists, phone numbers or personal user data. The Actor collects only what a channel
  publishes on its public page.
- Comments live in linked discussion groups and are not included.
- If every channel you entered is unavailable, the run fails with a message listing them,
  so a scheduled run won't silently return nothing.

### Is it legal?

The Actor reads only public pages that Telegram serves to any visitor without logging in.
You are responsible for using the data in line with Telegram's terms, copyright and the
data-protection laws that apply to you (e.g. GDPR). Telegram's terms forbid using its data to
train or run AI models, so don't use this Actor's output for that.

# Actor input Schema

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

Public channel usernames or links, e.g. <code>durov</code>, <code>@telegram</code> or <code>https://t.me/bloomberg</code>. Private channels and groups are skipped.

## `maxPostsPerChannel` (type: `integer`):

Newest posts first. Each page holds about 20 posts.

## `postedAfter` (type: `string`):

Stop at older posts. A date (<code>2026-10-01</code>), a timestamp (<code>2026-10-01T12:00:00Z</code>) or relative (<code>7 days</code>, <code>12 hours</code>). Leave empty for no limit.

## `searchQuery` (type: `string`):

Optional keyword. Returns only posts matching it, using Telegram's own in-channel search.

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

Not needed for most runs. Turn on Apify Proxy if you scrape many channels and hit rate limits.

## Actor input object example

```json
{
  "channels": [
    "telegram",
    "durov"
  ],
  "maxPostsPerChannel": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `posts` (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 = {
    "channels": [
        "telegram",
        "durov"
    ],
    "postedAfter": "",
    "searchQuery": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("octopull/telegram-channel-scraper").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",
    ],
    "postedAfter": "",
    "searchQuery": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("octopull/telegram-channel-scraper").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"
  ],
  "postedAfter": "",
  "searchQuery": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call octopull/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

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

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/kP0QgglWEGvKUyX5y/builds/vbbjXG5xLjjFkgpP4/openapi.json