# Telegram Channel Message (`truefetch/telegram-channel-message`) Actor

Telegram channel scraper for dependable post-history exports, returning 55 structured fields plus optional stored media. Capture text, senders, dates, views, replies, forwards, reactions, topics, service events, links, hashtags, and media from any public username.

- **URL**: https://apify.com/truefetch/telegram-channel-message.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 1,076 total users, 101 monthly users, 99.7% runs succeeded, 23 bookmarks
- **User rating**: 3.11 out of 5 stars

## Pricing

from $0.26 / 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 Message

**Telegram Channel Message is a telegram channel scraper that exports public post history as 55-field Dataset rows with optional stored media, built for developers and data teams.**

- **Public channel input:** use a bare username, `@handle`, or canonical `t.me` URL without supplying Telegram credentials.
- **Message-level context:** retain source links, sender facts, replies, threads, forwards, reactions, service events, and media metadata.
- **Three media scopes:** return metadata only, store photos, or store supported photo and document-based media.
- **Ordered persistence:** write results in small batches while channel history is read.

[**Run a one-result test**](https://apify.com/truefetch/telegram-channel-message/input) · [**View API**](https://apify.com/truefetch/telegram-channel-message/api)

A one-result text test bills one $0.01 Actor Start plus at most one $0.00035 Result at FREE event prices; source access can still produce no publishable row.

### What does Telegram Channel Message do?

Telegram Channel Message resolves one public Telegram username and converts its visible messages or service events into structured, ordered Dataset rows.

Each row can include chat identity, text, source date, sender information, views, replies, forwards, reactions, forum topics, extracted links, service actions, and media attributes. Files are stored only when the selected media scope requests them and Telegram makes them available.

The Actor is channel-focused but also accepts username-addressable public groups and forums because Telegram represents those public conversation types through related message surfaces. It is not a private-invite client, member directory, sender verification service, sentiment model, or real-time moderation bot.

### How do I run Telegram Channel Message?

Run the Actor by supplying a public Telegram username, choosing a media scope, and setting the maximum number of publishable rows.

1. Open the [input page](https://apify.com/truefetch/telegram-channel-message/input).
2. Enter `https://t.me/telegram`, select `text`, optionally add a start date, and set `max_results` to 2 for a bounded check.
3. Start the run and open the default Dataset when it reaches a terminal state.
4. Confirm the item count, `source_url`, `date`, and `processed_at` before scheduling or increasing the limit.

The shared README scenario is:

```json
{
  "telegram_url": "https://t.me/telegram",
  "download_medias": "text",
  "max_results": 2
}
```

`max_results` applies to the whole run. A smaller source history, the free-plan cap, an empty date range, unavailable source records, or a failed request can produce fewer rows.

### What data does Telegram Channel Message return?

Telegram Channel Message returns one row per publishable message or service event and documents 55 possible fields; optional source values are omitted when unavailable.

| Field group | Dataset fields |
| --- | --- |
| Chat | `chat_id`, `chat_username`, `chat_title`, `chat_type`, `chat_description`, `chat_member_count` |
| Message | `id`, `source_url`, `type`, `date`, `edit_date`, `text` |
| Sender | `sender`, `sender_id`, `sender_username`, `sender_name`, `sender_flags`, `sender_rank`, `sender_boost_count` |
| Threading | `topic_name`, `reply_to`, `thread_id`, `reply_quote`, `album_id` |
| Engagement | `view_count`, `reply_count`, `forward_count`, `reactions` |
| References | `urls`, `hashtags`, `link_preview`, `poll`, `location`, `forward_info`, `via_bot_id` |
| Media | `media_type`, `media_name`, `media_size`, `media_duration`, `media_mime_type`, `media_extension`, `media_width`, `media_height`, `media_emoji`, `media_streamable`, `media_round`, `media_has_stickers`, `media_url` |
| State and service | `restriction_reasons`, `service_type`, `service_info`, `silent`, `pinned` |
| Processing | `processor`, `processed_at` |

This abbreviated illustrative item follows the public `telegram` scenario; a real row contains only applicable fields from the 55-field contract:

```json
{
  "chat_id": 777000,
  "chat_username": "telegram",
  "chat_title": "Telegram News",
  "chat_type": "channel",
  "id": 430,
  "source_url": "https://t.me/telegram/430",
  "type": "regular",
  "date": "2026-07-21T13:20:00+00:00",
  "text": "Example public channel post",
  "view_count": 1200000,
  "media_type": "photo",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-08-12T12:00:00+00:00"
}
```

Export the Dataset as JSON, JSONL, CSV, Excel, XML, or RSS, or retrieve items through the Dataset API.

### What inputs can I configure?

You can configure four inputs in schema order, three required and one optional.

| Input | Type | Required | Behavior | Example |
| --- | --- | --- | --- | --- |
| `telegram_url` | string | Yes | Public username, `@handle`, `t.me/username`, or `t.me/s/username`; private invite links are rejected | `https://t.me/telegram` |
| `download_medias` | enum (3 values) | Yes | `text`, `image`, or `all` | `text` |
| `start_date` | string | No | UTC `YYYY-MM-DD` or relative lookback such as `7 days`, `2 weeks`, `1 month`, or `1 year` | `7 days` |
| `max_results` | integer | Yes | Minimum 1, no schema maximum for paying runs, free-plan cap of 10 | `2` |

Text mode reports media attributes but stores no files. Image mode stores photos. All mode stores supported photos, videos, GIFs, audio, voice, documents, and stickers when available. No end-date, file-size, language, country, or location input is exposed.

### What platforms and markets does Telegram Channel Message cover?

Telegram Channel Message covers public, username-addressable Telegram channels, groups, and forums without a country or language restriction in the input contract.

Telegram's [Channels FAQ](https://telegram.org/faq_channels?setln=en) explains that public channels have usernames and links, that new subscribers can see channel history, and that posts expose view counters. Availability still depends on the source, the managed account, regional conditions, target state, and Telegram policy.

The Actor does not crawl linked websites or combine data from other messaging or social platforms. Message language, username, sender label, or channel title must not be treated as proof of nationality, residence, age, profession, or affiliation.

### Why use Telegram Channel Message?

Use Telegram Channel Message when a public post stream needs to become a repeatable Apify Dataset instead of a manual copy-and-paste archive.

| Capability | Practical benefit |
| --- | --- |
| 55-field message contract | Keep identity, content, relationships, engagement, media, and processing facts in one row |
| Source URLs and IDs | Revisit a public post and deduplicate downstream by chat plus message ID |
| Topic, reply, and forward context | Preserve conversation structure for research or alert review |
| Optional file storage | Separate lightweight text analysis from file collection and storage cost |
| Batched Dataset writes | Retain completed batches from a long run that ends before the requested limit |
| API, schedules, webhooks, and MCP | Move the same input into repeatable approved workflows |

The main trade-off is source dependence: public visibility, counters, sender facts, media availability, edits, deletions, and rate limits can change between runs.

### Who is Telegram Channel Message for?

Telegram Channel Message is for developers, analysts, researchers, and data teams building bounded workflows around public channel history.

**Developers** can feed ordered rows into a search index, internal dashboard, notification workflow, or approved content pipeline while retaining source IDs and dates.

**Analysts** can compare visible views, forwards, reactions, links, and topic context across a defined historical window without interpreting those values as verified audience identity or sentiment.

**Researchers** can preserve public discussion structure through `thread_id`, `topic_name`, `reply_to`, `reply_quote`, and `forward_info` while documenting when the observation was processed.

**Media teams** can collect authorized public files only when they have malware scanning, retention limits, and access controls.

Do not choose this Actor for private invitation links, member lists, identity verification, bulk outreach, live moderation, or continuous streaming. Those require different permissions and data contracts.

### How can I use Telegram Channel Message through the API or MCP?

Use public Actor ID `TpLqaxMYSJzwVnXoj` or name form `truefetch/telegram-channel-message` through Apify's API and MCP surfaces.

#### HTTP

```bash
curl -X POST "https://api.apify.com/v2/acts/TpLqaxMYSJzwVnXoj/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"telegram_url":"https://t.me/telegram","download_medias":"text","max_results":2}'
```

#### MCP

Follow the [official Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp), connect `https://mcp.apify.com/?token=YOUR_TOKEN`, and call the Actor with:

```json
{
  "actor": "truefetch/telegram-channel-message",
  "input": {
    "telegram_url": "https://t.me/telegram",
    "download_medias": "text",
    "max_results": 2
  }
}
```

For asynchronous work, start the Actor, poll the run, and then read its `defaultDatasetId`. The [live API page](https://apify.com/truefetch/telegram-channel-message/api) provides generated SDK and endpoint examples.

### How much does Telegram Channel Message cost?

At FREE prices, each Result costs $0.00035, Actor Start costs $0.01, and the smallest one-result text run totals $0.01035.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Start (once per run) | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Result (per Dataset row) | $0.00035 | $0.00032 | $0.00028 | $0.00026 | $0.00026 | $0.00026 |
| Media (per stored file) | $0.00080 | $0.00072 | $0.00064 | $0.00060 | $0.00060 | $0.00060 |

Smallest useful test: `$0.01000 + 1 × $0.00035 = $0.01035` when text mode stores no media. Actor Start uses one event per GB with a minimum of one; the default 128 MiB run incurs the minimum. Check the [live pricing page](https://apify.com/truefetch/telegram-channel-message/pricing) because prices can change.

### How does Telegram Channel Message compare with alternatives?

Telegram Channel Message is the best fit when a public username must feed a structured Apify Dataset, API, schedule, webhook, or MCP workflow.

| Path | Best fit | Trade-off |
| --- | --- | --- |
| Manual Telegram review | A few posts that need immediate human context | No repeatable structured export |
| Telegram Desktop export | An account owner making an offline personal archive | Not designed as an Apify Dataset pipeline |
| Custom Telegram client | Teams that need full control over credentials and recovery | Requires authentication ownership, engineering, monitoring, storage, and maintenance |
| Member-focused data tool | Visible participant records | Does not replace message-history rows |

Telegram's own Desktop export is better for users who control an account and need an offline personal copy. Choose another path for private access, member enumeration, real-time event streaming, cross-platform discovery, or sentiment scoring.

### What are the limits and troubleshooting steps?

The Actor is bounded by public username access, Telegram availability, optional history boundaries, file size, execution time, and storage behavior.

- **Input rejected:** replace a private invite or unrelated URL with a bare username, `@handle`, or canonical `t.me` username URL.
- **Dataset empty:** remove `start_date`, select `text`, request 1 result, and confirm the public username is accessible in Telegram.
- **Fewer rows than requested:** check the free-plan cap, source history, date window, and returned message IDs; `max_results` is a ceiling rather than a guarantee.
- **Missing sender or topic fields:** treat them as source-absent; do not infer identity or copy the chat name into sender fields.
- **Media not stored:** confirm `image` or `all`, inspect `media_type` and the Key-Value Store, then retry a single known public media post.
- **Long run ends early:** narrow `start_date` or reduce `max_results`; completed Dataset batches remain available.

Open [Issues](https://apify.com/truefetch/telegram-channel-message/issues) with the run ID, exact sanitized input, expected rows, actual rows, and media mode. Never include API tokens, Telegram sessions, credentials, or private files.

### Frequently asked questions

The questions below address public access, export behavior, scheduling, fields, and billing.

#### How do I scrape telegram channel posts?

Use a public channel username or `t.me` URL, choose `text`, `image`, or `all`, and set `max_results`; private invitation links are rejected.

#### Can I create a telegram channel message export?

Yes. Each publishable post becomes an ordered Dataset row that can be exported as JSON, JSONL, CSV, Excel, XML, or RSS.

#### Is there a free Telegram channel API?

Apify may provide platform credits or allowances, but configured event prices still apply; the smallest FREE-price one-result text run totals $0.01035.

#### Can I schedule runs to monitor Telegram channels over time?

Yes. Use Apify schedules and a recent relative `start_date`, then deduplicate downstream by chat identity and message `id` because there is no cross-run checkpoint input.

#### Are view_count values unique viewers?

No. The Actor preserves Telegram's visible counter, and Telegram states that channel views are approximate and can count repeat views after time passes.

#### Why is sender missing on some channel posts?

Unsigned channel posts identify the channel rather than a separate person, so the Actor leaves person-level sender fields absent instead of inventing an identity.

#### Does all guarantee every file?

No. `all` requests supported media classes, but source availability, size, access, download, or storage failures can leave `media_url` absent.

### Related TrueFetch Actors

These three TrueFetch Actors extend the workflow into profile, participant, or adjacent public-post data.

- [Telegram Profile](https://apify.com/truefetch/telegram-profile) resolves public Telegram profile and chat metadata when message history is not required.
- [Telegram Group Member](https://apify.com/truefetch/telegram-group-member) targets visible participant records instead of channel posts.
- [Reddit Community Post](https://apify.com/truefetch/reddit-community-post) provides an adjacent public-community post Dataset for cross-source research.

### Support

Get product help from the [TrueFetch community](https://t.me/TrueFetch), or use the [Store page](https://apify.com/truefetch/telegram-channel-message), [API page](https://apify.com/truefetch/telegram-channel-message/api), and [Issues](https://apify.com/truefetch/telegram-channel-message/issues) for the relevant workflow.

[**Run a one-result channel test**](https://apify.com/truefetch/telegram-channel-message/input) · [**Open the Telegram Channel Message API**](https://apify.com/truefetch/telegram-channel-message/api)

**Last Updated:** August 12, 2026

# Actor input Schema

## `telegram_url` (type: `string`):

Public Telegram channel username as a bare handle, @username, or canonical t.me URL. Public groups and forums also work; private invite and join links do not.

## `download_medias` (type: `string`):

Use text for a metadata-first export, image to store photos, or all to store supported photos, videos, GIFs, audio, voice, documents, and stickers.

## `start_date` (type: `string`):

Optional UTC history boundary as YYYY-MM-DD or a relative lookback such as '7 days', '2 weeks', '1 month', or '1 year'. Posts are read from that point forward.

## `max_results` (type: `integer`):

Maximum channel posts or other public messages to return. The minimum is 1 with no schema maximum for paying runs; free-plan runs are capped at 10. Results are saved in ordered batches as history is read.

## Actor input object example

```json
{
  "telegram_url": "https://t.me/telegram",
  "download_medias": "image",
  "max_results": 2
}
```

# Actor output Schema

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

Telegram message records in the default dataset, including media URLs when files were requested and stored.

# 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 = {
    "telegram_url": "https://t.me/telegram",
    "download_medias": "image",
    "max_results": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/telegram-channel-message").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 = {
    "telegram_url": "https://t.me/telegram",
    "download_medias": "image",
    "max_results": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/telegram-channel-message").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 '{
  "telegram_url": "https://t.me/telegram",
  "download_medias": "image",
  "max_results": 2
}' |
apify call truefetch/telegram-channel-message --silent --output-dataset

```

## MCP server setup

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

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/TpLqaxMYSJzwVnXoj/builds/2bV44ycGMsnh6LB2Q/openapi.json