Telegram Public Channels Scraper: 245 of 245 Runs Succeeded (2026)

Public Telegram channel data arrives in 12 channel metadata fields and 11 post record fields, including post text, media attachments, view counts, and forwarded-from attribution. Extracting 1,000 results costs $5.00 on Apify's free plan, which provides $5.00 of monthly usage with no credit card required. No Telegram login, app installation, or custom proxies are required because data is scraped directly from web previews. This Actor is designed for OSINT researchers, newsrooms, and market analysts tracking public communication channels. It is not for teams needing access to private channels or invite-only groups, which public web previews do not render.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open Telegram Public Channels Scraper on Apify and run the prefilled example.

How reliable is Telegram Public Channels Scraper in production?

Across the last 30 days of public runs on the Apify platform, Telegram Public Channels Scraper recorded 245 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	245	100.0%
Failed	0	0.0%
Aborted by the user	0	0.0%
Timed out	0	0.0%
Total	245	100.0%

Over the last 30 days, all 245 public runs finished successfully with zero failures and zero timeouts. When running on a automated schedule, you can rely on this stability without building complex fallback wrappers. Since no run failed or timed out in this period, standard automated triggers will operate smoothly.

What does it cost to run Telegram Public Channels Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.005	$5.00
BRONZE	$0.00433	$4.33
SILVER	$0.00367	$3.67
GOLD	$0.003	$3.00
PLATINUM	$0.003	$3.00
DIAMOND	$0.003	$3.00

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The maxPostsPerChannel and maxItems controls determine your dataset size and drive total charges. Because billing is based strictly on dataset item output, adding filters like minViews does not increase result fees. Run an initial test with maxItems set to 10 to verify record structure before running broad historical sweeps.

How do you run Telegram Public Channels Scraper from the API?

None of its 12 controls is strictly required, so the defaults below produce a valid run on their own. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Telegram Public Channels Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~telegram-public-channels-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"channels","channels":["durov"],"maxPostsPerChannel":50,"includeChannelMeta":true,"mediaOnly":false,"excludeForwarded":false,"maxItems":100}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "channels",
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 50,
  "includeChannelMeta": True,
  "mediaOnly": False,
  "excludeForwarded": False,
  "maxItems": 100
}

run = client.actor("crawlerbros~telegram-public-channels-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "channels",
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 50,
  "includeChannelMeta": true,
  "mediaOnly": false,
  "excludeForwarded": false,
  "maxItems": 100
}

const run = await client.actor('crawlerbros~telegram-public-channels-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Telegram Public Channels Scraper inputs matter, and which can you skip?

The mode parameter toggles between fetching channel histories with channels or retrieving specific items with postUrls. Specify channel handles without the leading @ symbol and set maxPostsPerChannel to bound pagination depth. Leave searchQuery and date controls clear on your first run until you verify basic dataset output.

mode (string): What to fetch. Default: "channels".
channels (array): Channel handles (without @) or t.me/{channel} URLs. Examples: durov, telegram, breakingnews. Handles must be 5-32 chars, start with a letter, contain only A-Z/a-z/0-9/underscore. Default: ["durov"].
postUrls (array): Public Telegram post URLs to fetch individually, e.g. https://t.me/durov/100. Used when mode=singlePost.
searchQuery (string): Keyword to search within each channel's post history. Uses Telegram's built-in t.me/s/<channel>?q=<query> preview search.
since (string): Earliest post date as YYYY-MM-DD or ISO 8601. Pagination stops once the oldest post on a page is older than this bound.
until (string): Latest post date as YYYY-MM-DD or ISO 8601. Posts published after this date are dropped.
maxPostsPerChannel (integer): Hard cap on posts emitted per channel. The web preview returns ~16-20 posts per page; pagination reaches further back via the ?before=N cursor. Default: 50.
includeChannelMeta (boolean): Emit a separate recordType=channel record per channel with title, description, subscriber count, etc. Default: true.
mediaOnly (boolean): Drop posts that don't have any image / video / document attached. Default: false.
minViews (integer): Drop posts with fewer than this many views (Telegram's published view count).
excludeForwarded (boolean): Drop posts that are forwards from another channel. Default: false.
maxItems (integer): Hard cap on total emitted records across all channels. Default: 100.

Fixed-choice controls: mode accepts channels (channel metadata + recent posts (with optional keyword + date filters)), singlePost (fetch one post by t.me/<channel>/<post_id> URL).

What does Telegram Public Channels Scraper return?

Output records supply structured post content, media attachment arrays, public view counts, and channel metadata suitable for archival pipelines. They do not contain user comments, post reactions, or channel subscriber lists, as Telegram does not publish these on public web preview pages.

Channel records (recordType=channel)

channel: Channel handle (without @)
id: Same as channel (handle is canonical ID)
url: Public Telegram URL (https://t.me/{channel})
title: Channel display name
description: Channel bio
avatarUrl: Channel avatar URL
subscribersCount: Subscriber count (parsed from 1.2M / 12K short form)
photosCount: Total photo count
videosCount: Total video count
filesCount: Total file/document count
linksCount: Total external-link count
verified: true for verified channels

Post records (recordType=post)

id: Post message ID (channel-relative)
channel: Source channel handle
url: Direct post URL (https://t.me/{channel}/{id})
publishedAt: ISO 8601 timestamp
text: Plain-text post body (newlines preserved)
viewCount: View count (parsed from 1.2K / 99M short form)
mediaAttachments: Array of {type, url, [thumbnailUrl, title]} for photo / video / document
isForwarded: true if the post was forwarded from another channel
forwardedFrom: Source channel handle (when isForwarded=true)
inReplyToUrl: Permalink of the post being replied to
scrapedAt: ISO 8601 UTC timestamp

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Telegram Public Channels Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Set mode to channels and pass a single handle into channels, such as durov, to test initial connection.
Keep includeChannelMeta set to true and set maxPostsPerChannel to 10 to limit output on your test run.
Execute the run and verify the first record contains recordType equal to channel with a non-null title and subscribersCount.
Confirm that subsequent records contain recordType equal to post with valid publishedAt ISO timestamps and populated text or mediaAttachments.
Set since and until using YYYY-MM-DD format if your collection requires a strict publication window.
Apply minViews or excludeForwarded to filter low-engagement posts or secondary forwards before writing to the dataset.
Increase maxPostsPerChannel up to 1000 and adjust maxItems to enforce your desired total result cap across all channels.

How do you apply it? Three worked playbooks

These are Telegram Public Channels Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: OSINT / intelligence research

Outcome: Snapshot public Telegram channels of interest (geopolitical, journalism, dissident communities).

Configure: Set mode to channels, channels to ["durov", "telegram"], includeChannelMeta to true, and maxPostsPerChannel to 50.

Working method: Start with a single target handle in channels to verify output structure. Check that the first record returns recordType channel with valid subscribersCount, followed by records with recordType post. Expand the channels array once the initial output schema is confirmed.

Deliverable: A dataset containing channel metadata records and post records with text, ISO 8601 publishedAt timestamps, and viewCount fields.

Stop condition: Stop if a target channel returns zero post records while its corresponding channel record reports non-zero post counts.

Use case 2: Crypto / market monitoring

Outcome: Many trading communities publish first on Telegram; monitor for signals.

Configure: Set mode to channels, channels to ["breakingnews"], minViews to 5000, excludeForwarded to true, and maxPostsPerChannel to 100.

Working method: Execute a targeted query run across monitor channels. Verify that returned records carry a viewCount at or above your threshold and confirm that excludeForwarded successfully filtered out secondary shares before merging records into your analysis pipeline.

Deliverable: A dataset of high-engagement post records filtered for original post content with view counts.

Stop condition: Stop if returned post records contain viewCount values below the minViews setting.

Use case 3: News monitoring

Outcome: Track breaking-news channels for headlines as they post.

Configure: Set mode to channels, channels to ["breakingnews"], since to "2026-05-01", includeChannelMeta to false, and maxPostsPerChannel to 200.

Working method: Schedule recurring runs passing since set to the timestamp of your last execution. Confirm that returned records have recordType set to post and that all publishedAt dates fall within the target timeframe before appending to historical store.

Deliverable: A chronological record collection of recent breaking news posts.

Stop condition: Stop if the oldest publishedAt value in a batch is newer than your configured since parameter.

What breaks, and how do you design around it?

Comments, reactions, and detailed engagement metrics aren't on the web preview (Telegram exposes those only in-app or via the Bot API with admin auth).
Voice/video notes don't have direct download URLs in the web preview.
Some country-blocked channels may not render outside their target region.
Telegram's t.me/s/ only shows the latest few thousand messages; very old archives are not paginatable indefinitely.

Public web previews cap historical pagination, preventing indefinite retrieval of multi-year archives. If you hit pagination caps on large channels, refine your collection window using since and until. Direct video and voice note stream downloads are omitted by the web preview interface.

When should you not use Telegram Public Channels Scraper?

Do not use this Actor if you require private group content, channel member lists, reaction details, or post comment threads. Telegram restricts those items to authenticated app clients, hiding them from web previews. If your goal is discovering platform profiles across networks rather than scraping post feeds, use Social Media Finder. If you require video performance metrics from video hosting platforms instead of chat channels, use YouTube Channel Scraper or Vimeo Scraper.

What should you check before trusting the output?

Flag any record where recordType is post and both text and mediaAttachments are empty or missing.
Stop execution if publishedAt fails standard ISO 8601 timestamp parsing.
Alert if includeChannelMeta is true but no record with recordType channel appears in the dataset.
Check that viewCount is a non-negative integer across all post records.
Verify that forwardedFrom is present whenever isForwarded evaluates to true.

None of this proves a record is correct. It gives a scheduled Telegram Public Channels Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Do I need a Telegram account or proxies to run this?

No account or proxy is needed. The Actor accesses public web preview pages at t.me/s/{channel}, which are accessible without authentication or special proxy routing.

Can this Actor extract private Telegram channels or groups?

No. It only scrapes public channels with accessible t.me URLs. Private channels that require invite links or user logins cannot be accessed.

How much does it cost to scrape 1,000 Telegram results?

It costs $5.00 per 1,000 results on Apify's free plan. Higher paid plan tiers offer lower per-result pricing.

Does this Actor scrape post comments or emoji reactions?

No. Telegram does not expose comments or reaction counts on its public web preview pages, so these fields are omitted from output records.

How reliable has this Actor been in recent usage?

In the last 30 days, 245 of 245 public runs succeeded, achieving a 100.0% success rate with zero failures and zero timeouts.

Where to go next

When you are ready to run it, open Telegram Public Channels Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Telegram Public Channels Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

Review scrapers covers 193 Actors in this family.

Readers running Telegram Public Channels Scraper commonly pair it with:

Kick Channel Scraper: Scrape Kick.com streamer channels - profile info, follower counts, live status, VODs, clips, gift leaderboards, custom emotes, and the full category/subcategory taxonomy.
YouTube Channel Scraper: Scrape YouTube channel info and video listings.
Social Media Finder: Find social media profiles across 400+ platforms by username.
Dailymotion Scraper: Scrape Dailymotion - search videos by keyword, browse trending videos, get videos from a specific user/channel, or browse by topic.
Mixkit Stock Media Scraper: Scrape free stock videos, background music, and sound effects from mixkit.co - no login, no watermark, no attribution required.
Dropbox App Center Scraper (n8n Workflow Templates): Scrapes the n8n workflow template library - a publicly accessible automation marketplace with 9,800+ workflow templates.
Vimeo Scraper: Scrape public videos from Vimeo - staff picks, channels, categories, user uploads, and individual video details.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-24.
Actor last updated by its maintainers on 2026-05-08.
Run outcome figures cover the 30 day public window ending 2026-09-24.
Telegram Public Channels Scraper on Apify