# Telegram Channel Content Scraper (`akula.marketing/telegram-get-channel-content-media`) Actor

Scrape Telegram channel posts — text, reactions, hashtags, mentions, forwards, replies, and downloadable media — straight to your dataset, no webhook needed. Multi-session pool means no queue wait and no 10-channel cap: up to 25 channels, 1,000 posts each. Pay only for posts scraped.

- **URL**: https://apify.com/akula.marketing/telegram-get-channel-content-media.md
- **Developed by:** [akula.marketing](https://apify.com/akula.marketing) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.50 / 1,000 post scrapeds

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/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 Post & Media Scraper

Scrape Telegram channel posts — text, reactions, hashtags, mentions, forwards, replies, and downloadable media — for research, content archiving, and OSINT. Results return **directly in the Apify dataset**: no webhook to configure, no Excel export to download.

**No shared-session queue.** Other Telegram content scrapers route every run through one login, so you wait in line and get capped around 10 channels/run. This Actor runs on a multi-session pool — no queue wait, and up to **25 channels / 1,000 posts each** in a single job.

This Actor uses your channel's public post history via the [channels.getHistory](https://core.telegram.org/method/channels.getHistory) API and works on any public channel without requiring bot admin access.

To get more functionality use [akula.marketing](https://akula.marketing/en)

### 📥 Input

The Actor accepts the following input fields:

#### 📋 Input Schema

| Field                 | Type    | Description                                                        | Required | Default |
|------------------------|---------|----------------------------------------------------------------------|----------|---------|
| `channels`             | Array   | Telegram channel usernames or t.me links to scrape (max 25 per run). | Yes      | —       |
| `maxPostsPerChannel`   | Integer | Maximum posts to fetch per channel across the whole run (1–1000).    | No       | `100`   |
| `daysRange`            | Integer | Only fetch posts published within the last N days (1–90).            | No       | `30`    |
| `includeText`          | Boolean | Include the post text in the results.                                | No       | `true`  |
| `mediaOnly`            | Boolean | Only return posts that contain media.                                | No       | `false` |
| `downloadMedia`        | Boolean | Download and re-host media, returning stable presigned URLs.         | No       | `false` |

Channels can be provided as `@channelname`, `channelname`, or a Telegram URL like `https://t.me/channelname`.

### 📤 Output

Results are pushed directly to the Actor's default dataset — one row per scraped post. If a channel can't be scraped (private, not found, or rate-limited), a single row with an `error` field is added for that channel instead of failing the whole run.

#### Post fields

| Field | Description |
|-------|-------------|
| `channel`, `channelLink`, `channelTitle`, `channelDescription`, `subscribers` | Channel metadata, repeated on every post row |
| `postId`, `postUrl`, `date`, `views`, `text` | Core post data |
| `reactions`, `totalReactions` | List of `{emoji, count}` and their sum |
| `hashtags`, `mentions`, `links` | Extracted from post text and entities |
| `hasMedia`, `mediaUrls`, `mediaTypes` | Media presence, presigned download URLs (7-day expiry), and file types |
| `isForward`, `forwardFromType`, `forwardFromId`, `forwardFromName`, `forwardChannelPost`, `forwardPostAuthor`, `forwardDate` | Forward chain details, when the post is forwarded |
| `replyToMsgId`, `replyToPostUrl` | Set when the post is a reply within the channel |
| `editDate` | Set when the post was edited after publishing |
| `error`, `rateLimitSeconds` | Set on channel-level failures instead of post data |

#### Example Output

```json
{
  "channel": "@telegram",
  "postId": 454,
  "postUrl": "https://t.me/telegram/454",
  "date": "2026-07-19T17:58:20+00:00",
  "views": 1057413,
  "text": "For all the details on these new features, check out our blog...",
  "reactions": [{"emoji": "👍", "count": 120}],
  "totalReactions": 120,
  "hashtags": [],
  "mentions": [],
  "links": ["https://telegram.org/blog/..."],
  "hasMedia": true,
  "mediaUrls": ["https://.../channel-content/telegram/454_0.jpg?..."],
  "mediaTypes": ["jpg"],
  "isForward": false,
  "error": null
}
```

### Usage

1. **Input channels**: Provide one or more channel usernames (e.g. `telegram`, `@telegram`, or `https://t.me/telegram`).
2. **Run the Actor**: Execute to fetch posts.
3. **Read the dataset**: Results appear directly in the run's dataset — no webhook or polling required.

### Pricing

This Actor uses **pay-per-event pricing** — you're charged per post scraped (`post-scraped` event), not per Actor run. Media downloads, hashtag/mention/reaction extraction, and forward/reply metadata are all included at no extra cost.

### 🔌 Automate with Zapier & Make

No code needed — trigger this Actor from your existing tools.

- **Zapier**: search for the "Apify" app → action **Run Actor** → select `akula.marketing/telegram-get-channel-content-media` → since this Actor returns results directly in the dataset, use the **Get Dataset Items** action after the run completes to pull the scraped posts into your Zap. [Docs](https://docs.apify.com/platform/integrations/zapier)
- **Make**: add the **Apify → Run an Actor** module, then the **Apify → Get Dataset Items** module to fetch the results once the run finishes. [Docs](https://docs.apify.com/platform/integrations/make)

#### Support

Support 24/7 - [@KoteamSupport](https://t.me/KoteamSupport).
We also offer specialized solutions for Telegram-related tasks — contact us to learn more

🏷️ Find This Tool When You Search For
"telegram channel content scraper" - Extract post text, media, and metadata from any public channel
"telegram media downloader" - Bulk download photos, videos, and documents from channel posts
"telegram post reactions scraper" - Track engagement, reactions, and view counts over time
"telegram hashtag and mention extractor" - Mine channel posts for hashtags, mentions, and links
"telegram forward tracking tool" - Trace forward chains and original post sources
"telegram content archiving" - Preserve channel posts and media for research or compliance
"telegram osint" - Open source intelligence from Telegram channel content
🎯 Turn a channel's post history into structured, exportable data with media included
🛡️ Archive channel content and engagement for research and compliance
💰 Mine channel posts for leads, trends, and market signals

# Actor input Schema

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

Telegram channel usernames or t.me links to scrape (max 25 per run).

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

Maximum number of posts to fetch per channel across the whole run.

## `daysRange` (type: `integer`):

Only fetch posts published within the last N days.

## `includeText` (type: `boolean`):

Include the post text in the results.

## `mediaOnly` (type: `boolean`):

Only return posts that contain media.

## `downloadMedia` (type: `boolean`):

Download photos, videos, and documents and return stable download URLs. Turn on if you need media files — off by default to keep runs fast and cheap.

## Actor input object example

```json
{
  "channels": [
    "telegram"
  ],
  "maxPostsPerChannel": 100,
  "daysRange": 30,
  "includeText": true,
  "mediaOnly": false,
  "downloadMedia": false
}
```

# Actor output Schema

## `channelContent` (type: `string`):

Dataset with one row per post scraped, including media download URLs and full engagement metadata.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("akula.marketing/telegram-get-channel-content-media").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"] }

# Run the Actor and wait for it to finish
run = client.actor("akula.marketing/telegram-get-channel-content-media").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"
  ]
}' |
apify call akula.marketing/telegram-get-channel-content-media --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,akula.marketing/telegram-get-channel-content-media"
        }
    }
}

```

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/qxR5eDzuMjaz8CROG/builds/qySb5oxymxmAe5d1b/openapi.json