Telegram Scraper: Channels, Messages, Comments & Profiles

Telegram Scraper exports messages, comments, view counts, reactions, media URLs, links and exact subscriber counts from any public Telegram channel — without an API key, Telegram account, or login. Filter by keyword, date or media type, monitor channels for new posts, or look up profiles of channels, groups, bots and users. It costs $1 or less per 1,000 messages.

How to scrape Telegram without an API key

Most Telegram scrapers require developer API credentials (api_id and api_hash from my.telegram.org). This actor needs zero credentials — it scrapes Telegram's public web preview pages (t.me/s/) directly, the same pages anyone can visit in a browser. Just enter a channel username or link like durov or https://t.me/telegram and the actor handles everything: pagination, retries when Telegram rate-limits, and data extraction.

What does Telegram Channel & Profile Scraper do?

This actor scrapes public Telegram channels and channel profiles via their web preview pages (t.me/s/). It extracts:

• Messages with full text, HTML formatting, timestamps, and permalink URLs, newest first
• Comments — public comments under each post, with author, date and text (optional)
• View counts parsed as integers (not raw strings like "5.29M")
• Reactions with emoji identifiers and counts (including paid Telegram Stars)
• Media — every photo of an album, video CDN URLs and thumbnails with duration, voice messages, document names and sizes, polls
• Text extras — web links, hashtags, @mentions and email addresses found in the text
• Link previews — URL, site name, title, description, preview image
• Telegram profile / channel metadata — title, description, exact subscriber count, avatar URL, photo/video/link counts, verified badge, for channels, groups, bots and users
• Message context — edited flag, forwarded-from source, reply-to message ID, author signature
• Incremental monitoring — resume after the last processed messageId without downloading or paying for duplicate messages

Why use this scraper instead of others?

• Zero credentials — no Telegram API key, no api_id/api_hash, no phone number, no login. Just enter a channel username and go. Most competing scrapers require Telegram developer credentials.
• Reactions data — reaction emoji and counts, including paid Telegram Stars, plus a total per message.
• Comments and filters in one Actor — add public comments, keep only messages with your keywords, or limit to a date range or media type. You only pay for what passes the filters.
• Monitoring that works across channels — give each channel its own "after this ID" cursor, so scheduled runs return only new posts.
• Parsed view counts — views returned as integers (5290000), not raw strings ("5.29M"). Ready for analysis without post-processing.
• Media URLs — actual photo and video CDN URLs, not just text content.
• Rich message context — edited flag, forwarded-from, reply-to chains, author signatures, link previews with images.
• Pay per result — transparent per-message pricing. No monthly subscription.

Who is it for

Marketing and brand teams

• Brand monitoring — track mentions and discussions in public Telegram channels
• Competitive research — analyze competitor Telegram channels for content strategy and engagement
• Community insights — understand what your audience discusses in public Telegram communities

Finance and crypto teams

• Crypto/DeFi intelligence — monitor token announcements, pump channels, and project updates
• Market sentiment — track discussions in trading and investment channels for sentiment signals

Research and intelligence

• Media monitoring — scrape news channels for breaking stories and sentiment analysis
• Academic research — collect public discourse data from Telegram communities for social studies
• OSINT — gather open-source intelligence from public channels for investigative work

What data can you extract?

Channel metadata

Field	Example
title	Pavel Durov
description	Founder of Telegram.
subscribers	10109734
subscriberCount	10.1M
entityType	channel
verified	true
avatarUrl	https://cdn4.telesco.pe/...

Messages (40+ fields per message)

Field	Example
messageId	455
text	Someone made a game about me...
date	2025-10-31T14:12:20+00:00
views	5290000
author	Paul Du Rove
mediaType	video
videoUrl	https://cdn4.telesco.pe/...
reactions	[{emoji: "⭐", count: "39.3K", isPaid: true}]
isEdited	true
isForwarded	false
replyToMessageId	442
url	https://t.me/durov/455
rowType	message
photoUrls	[https://cdn4.telesco.pe/...]
mediaCount	3
totalReactions	125300
links	[https://example.com/article]
hashtags	[#news]
mentions	[@durov]
emails	[press@example.com]
commentCount	10 (with comments on)

Comment rows have rowType: "comment", the post's ID in parentMessageId, and the commenter's display name in author. Profile rows have rowType: "profile".

How much does it cost to scrape Telegram?

This actor uses pay-per-event pricing — you only pay for what you scrape. No monthly subscription.

Event	Cost
Actor start	$0.005
Per channel info	$0.002
Per message or comment	$0.001

From 2026-11-22 the price will be: per message or comment $0.00087 on the Free and Starter plans, $0.000783 on Scale and $0.000696 on Business and above; per channel info $0.00174, $0.001566 and $0.001392. Actor start stays $0.005.

A run that reads a channel and finds nothing, for example when no message passes your filters or a cursor has no new posts, pays only the $0.005 start fee. You pay nothing when a run fails or when a few names you gave don't exist.

Real-world cost examples:

Query	Messages	Cost
1 channel, 20 messages	20	$0.005 + $0.002 + 20 × $0.001 = $0.027
1 channel, 100 messages	100	$0.005 + $0.002 + 100 × $0.001 = $0.107
5 channels, 50 messages each	250	$0.005 + 5 × $0.002 + 250 × $0.001 = $0.265

With the Apify Free plan, you get $5 of free usage per month — enough to scrape ~4,900 messages.

How to scrape a Telegram channel or profile

1. Go to the actor's input page.
2. Enter one or more channels as usernames or links (e.g., durov, https://t.me/telegram).
3. For a profile lookup, enable Profile only to return channel, group, bot or user metadata without scraping messages.
4. For message history, leave Profile only disabled and set max messages per channel (default: 100, prefill: 20).
5. To narrow results, set Keywords, Media types, or a date range with Oldest message date, Newest message date or Last N days. Turn on Include comments for public comments.
6. For recurring runs on one channel, set Only messages after ID to the highest messageId saved from the previous run. For several channels, use Only messages after ID, per channel, because IDs differ per channel. The cursor is exclusive.
7. Optionally toggle Include channel info to get metadata alongside messages.
8. Click Start and wait for the run to finish.
9. Download your data in JSON, CSV, Excel, or connect via API.

Input parameters

Field	Type	Description	Default
channels	string[]	Public Telegram channels as usernames or t.me links	—
maxMessages	integer	Max messages per channel, newest first (1–100,000)	100
oldestMessageDate	string	Optional UTC date (YYYY-MM-DD); return messages on or after it and stop paginating after older messages	—
newestMessageDate	string	Optional UTC date (YYYY-MM-DD); return messages on or before it	—
lastNDays	integer	Optional; return only messages from the last N days	—
afterMessageId	integer	Optional exclusive cursor; return only messages whose messageId is greater and stop paginating when the cursor is reached	—
afterMessageIds	object	Optional cursor per channel, e.g. {"durov": 455, "telegram": 460}	—
keywords	string[]	Optional; keep messages whose text contains any of these (case-insensitive)	—
excludeKeywords	string[]	Optional; skip messages whose text contains any of these	—
mediaTypes	string[]	Optional; keep text, photo, video, document, poll, sticker, voice, location	—
includeComments	boolean	Add public comments as separate rows, charged as messages	false
maxCommentsPerMessage	integer	Max comments per message (1–200)	20
includeChannelInfo	boolean	Include channel/profile metadata as separate item	true
profileOnly	boolean	Return only Telegram channel/profile metadata and skip message scraping	false

Finding channel usernames

A channel username is the part after t.me/ in the channel URL:

• https://t.me/durov → username is durov
• https://t.me/telegram → username is telegram

You can paste the username, @username, or the whole link: https://t.me/durov, https://t.me/s/durov and https://t.me/durov/455 all work. Private invite links (t.me/+...) are not supported.

Output example

{
    "messageId": 455,
    "channelUsername": "durov",
    "channelTitle": "Pavel Durov",
    "url": "https://t.me/durov/455",
    "date": "2025-10-31T14:12:20+00:00",
    "text": "Someone made a game about me escaping a French prison...",
    "views": 5290000,
    "viewsRaw": "5.29M",
    "author": "Paul Du Rove",
    "isEdited": true,
    "isForwarded": false,
    "mediaType": "video",
    "videoUrl": "https://cdn4.telesco.pe/file/...",
    "videoDuration": "0:18",
    "reactions": [
        {"emoji": "⭐", "count": "39.3K", "isPaid": true},
        {"emoji": "", "emojiId": "5265077361648368841", "count": "86K", "isPaid": false}
    ],
    "totalReactions": 125300,
    "rowType": "message",
    "scrapedAt": "2026-03-05T21:00:39.599Z"
}

Tips for best results

• Start small — use maxMessages: 20 to preview data before large runs.
• Resume scheduled monitoring — save the highest returned messageId for each channel, then pass them as afterMessageIds on the next run. The boundary message is excluded, so only new posts are returned and charged. Message IDs differ per channel, so don't share one afterMessageId across channels.
• Bound monitoring windows — set oldestMessageDate for date-based limits. You can combine it with afterMessageId; both filters apply and maxMessages remains the upper result cap.
• Public channels only — messages come from t.me/s/ public preview pages. Private channels are not accessible. For a name without a preview, such as a bot, user or private-preview group, you get its profile row and the run status says it has no public messages.
• Keyword filters scan history — Telegram's own web search returns only a few results, so keywords are matched while paging through the channel. A run reads about 80 pages (about 1,600 messages) plus 8 more for every row it returns, so a rare keyword or a date window far back may stop early, and the run status tells you.
• Posts with no content — Telegram's preview hides a few post types and shows "open Telegram to view". Those rows have a date, views and URL, with text and mediaType null.
• Read the status — the run's final status says how many messages you got against what you asked for, and why it stopped.
• Run time — channels and their history pages are processed sequentially. Large multi-channel inputs can take tens of minutes. The default run timeout is 60 minutes; API clients, saved tasks and schedules that explicitly set a shorter timeout must increase it in their own run options. Messages already saved remain in the dataset if a run times out; later channels may not have been reached. Use afterMessageId or oldestMessageDate for incremental collection where appropriate.
• Reactions availability — reactions appear in the HTML for recent messages. Very old messages may not include reaction data.
• Media URLs — video and photo CDN URLs are temporary. Download media promptly if you need to archive it.

How to export Telegram chat history to CSV

Telegram's built-in export only works for your own chats and requires the desktop app. To export any public channel's message history to CSV — including channels you don't belong to — use Telegram Scraper:

1. Open Telegram Scraper on Apify Store.
2. Enter the channel username (e.g., durov, telegram, cointelegraph).
3. Set Max messages to the number of messages you want to export (up to 100,000 per channel).
4. Enable Include channel info if you want subscriber count and metadata.
5. Click Start and wait for the run to finish (usually under a minute).
6. Open the Dataset tab and click Export → CSV.
7. Open the downloaded .csv in Excel, Google Sheets, or any data tool.

Each row in the CSV represents one message with columns for: messageId, date, text, views, author, mediaType, reactions, isForwarded, url, and more.

Tips for large exports:

• Very long exports take time: expect about 13 messages per second at the default 512 MB, and faster with more memory. In the default 60-minute timeout that is about 45,000 messages; for more, raise Timeout and Memory in the run options.
• Use the JSON export instead of CSV if you need nested reaction data (CSV flattens arrays).
• Schedule recurring daily scrapes to build a running archive of channel activity over time.

Integrations

Connect Telegram Scraper to your workflow using Apify integrations:

• Google Sheets — export messages directly to a spreadsheet for tracking channel activity over time
• Slack / Discord — get notifications when scraping finishes, or forward key messages to your team channels
• Zapier / Make — automate workflows, e.g., alert on crypto announcements, archive news channel content, or trigger analysis when new messages arrive
• Webhooks — send results to your own API endpoint for custom processing pipelines
• Scheduled runs — set up hourly or daily scrapes to continuously monitor channels
• Data warehouses — pipe messages to BigQuery, Snowflake, or PostgreSQL for large-scale analysis
• AI/LLM pipelines — feed messages into sentiment analysis, translation, or summarization workflows

API usage

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/telegram-scraper').call({
    channels: ['durov', 'telegram'],
    maxMessages: 50,
});

// Profile-only lookup (Telegram Profile Scraper mode):
const profileRun = await client.actor('automation-lab/telegram-scraper').call({
    channels: ['durov'],
    profileOnly: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

// On the next scheduled run, resume each channel after its own highest saved ID:
const afterMessageIds = {};
for (const item of items.filter((row) => row.rowType === 'message')) {
    afterMessageIds[item.channelUsername] = Math.max(afterMessageIds[item.channelUsername] ?? 0, item.messageId);
}
await client.actor('automation-lab/telegram-scraper').call({
    channels: ['durov', 'telegram'],
    maxMessages: 50,
    afterMessageIds,
});

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/telegram-scraper").call(run_input={
    "channels": ["durov"],
    "maxMessages": 100,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    if item.get("rowType") == "message":
        print(f"[{item['date']}] {item['views']} views: {item['text'][:80]}")

cURL

curl "https://api.apify.com/v2/acts/automation-lab~telegram-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"channels":["durov"],"maxMessages":50}'

Diagnostic privacy

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private, company-operated GlitchTip service for repair. Secret fields and URL query strings are removed, and reports are retained for 30 days. Telemetry costs are covered by the provider; no customer credentials are needed for it.

This Actor uses no AI or model provider. It processes public channel metadata and messages and stores results in your Apify run storage; storage retention and deletion follow your Apify account settings. Delete datasets and run storage in Apify when no longer needed. The Actor does not download media files or maintain a separate results database. Only submit public channel identifiers, not private credentials.

This is an independent Automation Lab tool, not affiliated with or endorsed by Telegram. For help, open an issue on the Actor's Apify Store page.

Legality: is it legal to scrape Telegram?

This actor only accesses publicly available data from Telegram's own public web preview pages (t.me/s/). It does not:

• Access private channels or groups
• Require authentication or user credentials
• Extract personal data like phone numbers
• Bypass any access controls

Always review Telegram's Terms of Service and comply with applicable data protection laws (GDPR, CCPA) when processing scraped data.

Use with AI agents via MCP

Telegram Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP). This lets you use natural language to scrape data — just ask your AI assistant and it will configure and run the scraper for you.

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/telegram-scraper"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/telegram-scraper"
        }
    }
}

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts

Once connected, try asking your AI assistant:

• "Scrape the last 500 messages from this Telegram channel"
• "Get channel info and recent posts from @durov"
• "Use Telegram Profile Scraper mode to get @durov profile metadata only"
• "Find messages about bitcoin from the last 7 days in this Telegram channel"
• "Get the latest posts and their comments from this Telegram channel"

Learn more in the Apify MCP documentation.

What is a Telegram channel vs. a Telegram group?

A Telegram channel is a broadcast tool where only admins post messages to unlimited subscribers. Channels are one-to-many: subscribers read messages but typically cannot reply. Examples include news outlets (BBC, CNN), crypto projects, brand announcements, and influencer updates. Channels display view counts on every message.

A Telegram group is a many-to-many chat where all members can send messages. Groups support up to 200,000 members and are used for discussions, communities, and team communication.

Messages come from public channels that have a web preview at t.me/s/CHANNEL_NAME. Private channels, and groups without a preview, need authentication, so only their profile is available. Comments under channel posts are public and available when the channel has comments on.

FAQ

Q: Do I need a Telegram account or API key? No. This actor scrapes public web pages — no Telegram credentials needed.

Q: Can I scrape private channels or groups? No. Only public channels with a t.me/s/ preview page are supported.

Q: How many messages can I get? Up to 100,000 per channel per run. The actor paginates automatically through the channel history, newest first.

Q: Why are some reaction emojis empty? Custom Telegram emojis are identified by emojiId rather than a Unicode character. The standard emojis (thumbs up, heart, etc.) show the Unicode emoji.

Q: Can I get comments? Yes. Turn on Include comments. Each comment is a separate row charged as one message, and it doesn't count toward Max messages. Channels with comments off return no comment rows and commentCount: null. Telegram doesn't show a comment's reply target here, so comments are a flat list per post.

Q: Can I search all of Telegram by keyword? No. Keywords filter the channels you list. This Actor doesn't search across every Telegram channel.

Q: The scraper returns no messages for a channel — what's wrong? Read the run's status message: it names each channel that was not found, has no public messages, or failed. Then check that the channel has a public web preview at t.me/s/CHANNEL_NAME. If visiting that URL in a browser shows a "You can view and join" message instead of posts, the channel doesn't have public preview enabled. Only channels with public web previews can be scraped.

Q: Media URLs are broken or return 404 — how do I fix this? Telegram CDN URLs are temporary and expire after some time. If you need to archive media, download the files immediately after scraping. The scraper extracts the URLs as they appear at scraping time, but Telegram may rotate CDN links.

Related actors

• Threads Scraper — scrape Meta Threads posts, profiles, and search results
• TikTok Scraper — scrape TikTok profiles and video details
• Instagram Scraper — scrape Instagram posts, profiles, and reels
• Twitter/X Scraper — scrape tweets and user profiles
• Reddit Scraper — scrape Reddit posts and comments
• Bluesky Scraper — scrape Bluesky posts and profiles
• YouTube Scraper — scrape YouTube videos, channels, and comments