DEV Community: Hugues Ishema

How to scrape any public Telegram channel without the API (no phone number, no login)

Hugues Ishema — Fri, 02 Oct 2026 12:37:05 +0000

There are two usual ways to read a Telegram channel from code, and both are annoying:

Bot API: a bot only sees posts from channels where it's an admin, so it can't read someone else's channel.
MTProto (Telethon / Pyrogram): works, but needs an api_id/api_hash from my.telegram.org, which is tied to your phone number. You also manage a logged-in session, and risk your account if you scrape hard.

There's a third way that most people miss: every public channel has a web preview at https://t.me/s/<channel>. It's plain HTML, needs no login or account, and contains the full post text, date, view count, reactions, photos, videos and link previews.

Here's how it works, a 30-line Python scraper, and the gotchas I ran into.

How the preview works

https://t.me/s/durov returns the 20 newest posts, ordered oldest-first on the page.
Each post is a div.tgme_widget_message with data-post="durov/548" (channel/ID).
Paging back: https://t.me/s/durov?before=528 returns the 20 posts before ID 528.
Search inside the channel: https://t.me/s/durov?q=privacy (it combines with before).
Channel stats: the right column (.tgme_channel_info) has the title, description, subscriber count ("10.5M subscribers") and photo/video/link counts.
Private channels, groups, bots and users have no preview. The request redirects to t.me/<name> instead of returning posts.

Useful selectors inside a post:

Field	Selector
Text	`.tgme_widget_message_text` (keep the `<br>` as newlines)
Date	`.tgme_widget_message_date time[datetime]`
Views	`.tgme_widget_message_views` ("1.9M")
Reactions	`.tgme_reaction` (emoji or custom-emoji ID plus count)
Photos	`.tgme_widget_message_photo_wrap` (URL in `background-image`)
Videos	`.tgme_widget_message_video_player video[src]`
Link preview	`.tgme_widget_message_link_preview` (title, description, image)
Forwarded from	`.tgme_widget_message_forwarded_from_name`

A minimal scraper (Python)

import time
import requests
from bs4 import BeautifulSoup

def channel_posts(channel, limit=50):
    """Newest-first posts from a public Telegram channel's web preview (t.me/s/<channel>)."""
    posts, before = [], None
    while len(posts) < limit:
        url = f"https://t.me/s/{channel}" + (f"?before={before}" if before else "")
        html = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=30).text
        soup = BeautifulSoup(html, "html.parser")
        page = soup.select(".tgme_widget_message[data-post]")
        if not page:
            break
        for m in reversed(page):  # the page is oldest-first
            text = m.select_one(".tgme_widget_message_text")
            views = m.select_one(".tgme_widget_message_views")
            posts.append({
                "id": int(m["data-post"].split("/")[1]),
                "date": m.select_one(".tgme_widget_message_date time")["datetime"],
                "text": text.get_text("\n", strip=True) if text else "",
                "views": views.get_text(strip=True) if views else None,
            })
        before = min(p["id"] for p in posts)
        time.sleep(1)  # be polite
    return posts[:limit]

for p in channel_posts("durov", limit=25)[:3]:
    print(p["id"], p["date"], p["views"], p["text"][:60].replace("\n", " "))

Output today:

548 2026-09-11T16:04:02+00:00 1.9M 🤝 Telegram has become the sponsor of Codeforces — the larges
547 2026-09-06T17:40:39+00:00 2.81M 💸 In just one month, Telegram has awarded over $2,222,000 to
546 2026-08-31T16:30:15+00:00 3.18M 🏳️ Gram Wallet in Telegram is ready and is now accessible to

Gotchas

Use the right <time>. Video posts contain other <time> tags (durations), so a bare select_one("time")["datetime"] crashes. Use .tgme_widget_message_date time.
Views are rounded strings ("1.9M", "14.3K"). Convert them before you sort or sum.
Reactions can be custom emoji. These have an emoji-id instead of a Unicode character. Store the ID.
Message IDs have gaps where posts were deleted. Page with before=<smallest ID you have>, not before=id-20.
Media URLs expire. Photo and video links point to Telegram's CDN with tokens, so download during the run if you need them later.
Some media isn't rendered in the web preview (certain polls and stickers). The post still has its date, views and usually the text.
Stop by date, not by count, when you only need recent posts. Check each post's date and break as soon as you pass your cutoff, instead of paging the whole history.

If you don't want to maintain it

Disclosure: I built this. The Telegram Channel Scraper on Apify does all of the above and returns clean JSON or CSV:

views as numbers, reactions, photos, videos, documents, link previews, forwards, replies, polls, hashtags and mentions;
channel stats;
search inside channels, date filters, and a monitoring mode that returns only new posts since the last run.

It costs $0.50 per 1,000 posts, with no login and no proxy needed.

{
  "channels": ["durov", "https://t.me/telegram"],
  "maxMessagesPerChannel": 500,
  "dateFrom": "2026-01-01",
  "onlyNewMessages": false
}

Happy to answer questions about edge cases in the comments.

Booking.com ran ~40x more Google ads than Expedia last month. I pulled the ad counts for 8 travel brands.

Hugues Ishema — Fri, 02 Oct 2026 12:33:42 +0000

TL;DR: I pulled Google's own ad counts for 8 travel brands from the Google Ads Transparency Center: every ad shown in the US over the last 30 days (2 Sep – 2 Oct 2026), split by platform and format.

Booking.com showed ~300k–400k distinct ads, about 40× Expedia (8k–9k). Tripadvisor and Priceline were at 100k–200k each, and Kayak at 50k–60k.
Booking.com is almost entirely Search text ads. It ran just 29 video ads. Expedia ran 2k–3k, about 90× more, and Priceline ran none.
Booking.com also ran 20k–30k ads on Google Maps. Kayak ran 0 there.
Expedia Group refreshes its ads; Booking.com and Kayak barely do. Among the first 400 ads Google lists for each brand, the number launched in the last 30 days was 84 for Vrbo, 71 for Hotels.com, 58 for Expedia, 1 for Booking.com and 0 for Kayak.

The numbers

Brand	All ads (US, 30 days)	Google Search	YouTube*	Google Maps	Video format
Booking.com	300k–400k	300k–400k	90k–100k	20k–30k	29
Tripadvisor	100k–200k	100k–200k	10k–20k	4k–5k	100–200
Priceline	100k–200k	100k–200k	30k–40k	8k–9k	0
Kayak	50k–60k	50k–60k	10k–20k	0	36
Airbnb	30k–40k	30k–40k	10k–20k	100–200	500–600
Vrbo	9k–10k	8k–9k	700–800	2	600–700
Expedia	8k–9k	5k–6k	3k–4k	800–900	2k–3k
Hotels.com	1k–2k	900–1k	400–500	200–300	400–500

* "YouTube" counts every ad shown on YouTube, including text ads in YouTube search. That's why it's much bigger than the video column.

Google Shopping was small for everyone (25 ads or fewer per brand), and none of the 8 ran Google Play ads in the US in this window.

What stands out

1. Booking.com plays a Search-volume game. Hundreds of thousands of distinct text ads usually means programmatic ads: one per destination, hotel or search phrase. The few headlines I could read look templated, for example "Book Now, Change Later" and "Book for Tonight".

2. Expedia plays a video game. Expedia had about 90× more video ads than Booking.com, and its sister brands Vrbo and Hotels.com lean on video too. Airbnb is the only other brand with hundreds of videos.

3. Ads that never die. Among the first 400 ads Google lists for Booking.com, half were first shown in January 2022 or earlier, and they were still running on 2 Oct 2026. The archive's earliest "first shown" dates are in October 2021, so many are probably older still. For Expedia, the median listed ad was about 7 months old.

4. Maps is a real channel for some brands and ignored by others. Booking.com (20k–30k), Priceline (8k–9k) and Tripadvisor (4k–5k) advertise heavily on Google Maps. Kayak and Vrbo almost don't.

5. Pricing hooks are everywhere. Priceline: "$39+ Room Deals - Last Minute Rooms". Tripadvisor: "The 10 Best Hotels (2026) - … Special Offer: Now From $58".

How I did it

Source: the Google Ads Transparency Center, Google's public database of every ad from verified advertisers.
Filters: country United States, ads shown from 2 Sep to 2 Oct 2026, one website at a time (booking.com, expedia.com, …). I repeated the query for each platform (Search, YouTube, Maps, Shopping, Play) and each format (text, image, video).
Counts: these are the ad counts Google itself reports for each filter, which come as ranges (e.g. "300000–400000"). They count distinct ads (creatives), not impressions or spend.
Ad-level sample: the first 400 ads Google lists per brand (3,200 in total), used for "first shown" dates and the new-ad counts. This sample follows Google's order, so it isn't random.
Open data: both CSVs (counts per brand × platform/format, plus the 3,200 ad records) are in github.com/ISHEMAH/travel-price-studies, under CC BY 4.0.

Caveats

Counts are not spend. A brand with 300k programmatic text ads may spend less than one with 3k videos.
A website search returns every advertiser that ran ads for that domain. That's mostly the brand itself, plus a few resellers or partners (e.g. 13 different advertisers for airbnb.com, 386 of the 400 sampled ads from Airbnb, Inc.).
One country, one 30-day window, one collection day.
Ad text is only partly available. Google archives many text ads as images, so only some ads expose readable copy.

Reproduce it (or watch your own competitors)

Disclosure: I built the tool I used. It's the Google Ads Transparency Scraper on Apify. Give it advertiser names, IDs or websites, and it returns every ad with format, first and last shown, preview, link, and (optionally) the ad text, landing pages and YouTube video. It costs $1 per 1,000 ads.

{
  "searchTargets": ["booking.com", "expedia.com", "airbnb.com"],
  "country": "US",
  "platform": "youtube",
  "lastDays": 30,
  "maxAdsPerTarget": 200,
  "includeAdDetails": true
}

# pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("kuezi/google-ads-transparency-scraper").call(run_input={
    "searchTargets": ["your-competitor.com"], "country": "US", "lastDays": 7, "onlyNewAds": True,
})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["format"], ad["firstShown"][:10], ad["adUrl"])

Run it daily with onlyNewAds: true and you get a feed of every new ad your competitors launch.

More open travel data from the same tools: 24 booking sites compared on 47 hotels · the cheapest day to fly

I priced 150 flights across November. Tuesday was the cheapest day to fly, Friday cost 20% more.

Hugues Ishema — Fri, 02 Oct 2026 11:00:48 +0000

TL;DR: 5 routes × every departure day in November 2026, cheapest one-way economy fare from Google Flights. Prices were seen on 2 Oct 2026.

Tuesday was the cheapest day to depart, −5% vs the route's typical price. Monday and Wednesday were close behind (−3%, −2%).
Friday was the most expensive, +20%. Saturday and Sunday were both about +13%.
Picking the wrong day cost up to 2.7×: San Francisco → Honolulu was $163 on the cheapest day and $444 on the priciest.
The Sunday after Thanksgiving (29 Nov) was the most expensive day of the month on New York → LA ($489 vs $184 at best) and on Chicago → Miami ($195 vs $113).

The routes

Route	Cheapest day	Priciest day	Spread	Google's "price level" on most days
New York JFK → Los Angeles	$184 (Fri 6, Mon 16, Thu 19)	$489 (Sun 29)	+166%	typical
London LHR → New York JFK	$399 (14 different days from 11 Nov)	$641 (Sun 1)	+61%	low on 21 of 30 days
Chicago ORD → Miami	$113 (Sat 14)	$195 (Sun 29)	+73%	typical / high
San Francisco → Honolulu	$163 (12 different days, every one a Sun–Wed)	$444 (Fri 20)	+172%	low / typical
Los Angeles → Tokyo NRT	$329 (Wed 25)	$823 (Fri 20)	+150%	typical

How I did it

For each route I searched every departure date from 1 to 30 November: 150 searches in total, one-way, economy, 1 adult, USD, US point of sale. I took the cheapest itinerary per search.

The weekday numbers compare each day's cheapest fare with that route's median over the month, then average across the 5 routes. A $300 route and a $100 route count equally.

Google also labels prices as low, typical or high against its own history. I recorded that label too: London → New York was "low" on 21 of 30 days.

All the data and the analysis script are open: github.com/ISHEMAH/travel-price-studies (CSV, CC BY 4.0). python3 analysis.py reproduces every number in this post.

Caveats

Five routes and one month, and November includes US Thanksgiving. Read it as a strong hint, not a law.
Prices were seen on one day (2 Oct). Fares change as departure gets closer.
Cheapest fares are often basic economy, so check bags and seat rules.

Practical takeaway

Be flexible by a day or two. Use a date grid, because the difference can be bigger than any coupon.
Avoid Friday and Sunday departures when you can, especially around holidays.
Watch Google's price level. When it says low, that's usually your moment.

Reproduce it (or scan your own route)

Disclosure: I built the scraper I used. It's the Google Flights Scraper on Apify. Set scanDepartureUntil and it searches every day in the range, then reports the cheapest day per route in SUMMARY.

{
  "routes": ["JFK-LAX", "LHR-JFK", "ORD-MIA", "SFO-HNL", "LAX-NRT"],
  "departureDate": "2026-11-01",
  "scanDepartureUntil": "2026-11-30",
  "maxFlightsPerSearch": 3,
  "currency": "USD"
}

# pip install apify-client
from apify_client import ApifyClient

run_input = {"routes": ["JFK-LAX"], "departureDate": "2026-11-01", "scanDepartureUntil": "2026-11-30", "maxFlightsPerSearch": 3}
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("kuezi/google-flights-scraper").call(run_input=run_input)
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
for r in summary["cheapestByRoute"]:
    print(r["route"], r["cheapestPrice"], "on", r["departureDate"])

Schedule it weekly and you have a fare-drop alert for your own trips.

Same method, hotels: I compared 24 booking sites on 47 hotels. Booking.com, Expedia and Hotels.com were ~26% above the cheapest.

Update: robustness check (thanks to a reader)

A reader pointed out that November has only four Fridays, and two of them sit in the Thanksgiving window. Rerunning the same method on 1–19 Nov only: Mon −5.2%, Tue −2.8%, Wed +2.1%, Thu +10.2%, Fri +13.9%, Sat +7.6%, Sun +5.2%.

The holiday inflated the headline: Friday falls from +19.7% to +13.9%, and Sunday from +12.7% to +5.2%.
Monday edges out Tuesday as the cheapest day.
Friday is still the priciest, but that rests on just 2 Fridays × 5 routes. Treat it as a hint, not a rule. A non-holiday month is the next run.

I compared 24 booking sites on 47 hotels. Booking.com, Expedia and Hotels.com were ~26% above the cheapest.

Hugues Ishema — Fri, 02 Oct 2026 09:37:38 +0000

TL;DR: 47 hotels in 5 cities, 24 booking sites per hotel on average, same dates for all (12–15 Nov 2026, 3 nights, 2 adults, USD).

The big names were a median 26–27% more expensive than the cheapest site for the same hotel: Booking.com +27%, Priceline +27%, Expedia +26%, Hotels.com +26%.
The cheapest offer usually came from smaller sites: Super.com, Vio.com and Traveluro were cheapest on 9 hotels each.
Checking Expedia, Hotels.com, Orbitz, Travelocity and CheapTickets is one check, not five. They showed the exact same price on 37 of 45 hotels (all Expedia Group).
The hotel's own website was the cheapest on only 4 of 34 hotels where I could identify it.
Google's headline price matched the cheapest site 42 times out of 47. It's a good reference if you only look at one number.

How I did it

Google Hotels shows a "Prices" list for each hotel: every booking site it has a rate from. I pulled that list for the top 10 hotels Google returned in Paris, London, New York, Barcelona and Bangkok, all for the same stay. Then for each hotel I compared every site's total price for the stay with the cheapest one.

Point of sale: US (gl=us), currency USD, collected on 2 Oct 2026.
50 hotels requested. 47 had at least two sites listed, which gives 24.4 sites per hotel on average.
"Premium" = (site's total − cheapest total) / cheapest total, for the same hotel. The median is taken across hotels.
All the data and the analysis script are open: github.com/ISHEMAH/travel-price-studies (CSV, CC BY 4.0). python3 analysis.py reproduces every number in this post.

What I found

Site	Hotels it was listed on	Median premium vs cheapest	Times it was the cheapest
Super.com	36	+8.5%	9
Kiwi.com	33	+12.7%	3
Trip.com	36	+21.9%	0
Hotels.com	45	+25.8%	1
Expedia	45	+26.4%	1
Priceline	43	+26.8%	1
Booking.com	43	+27.2%	0
eDreams	33	+27.7%	0

The gap between the cheapest and the priciest site for the same room was big: median 67%, ranging from New York (41%) to London (98%) and Bangkok (116%).

Caveats (read these before you book the cheapest one)

Cheapest isn't always best. Smaller sites can mean stricter cancellation rules, member-only rates, or fees added at checkout. Check the refund policy and the final price before paying.
This is one stay window, five cities, one day of prices. Rates move hourly, and other dates or countries can look different.
I compared the prices exactly as Google listed them. I didn't book anything.
"The hotel's own site" was matched by name, so a few may be missed.

Practical takeaway

Open the hotel on Google Hotels and look at the whole price list, not the first logo.
Skip comparing Expedia vs Hotels.com vs Orbitz vs Travelocity: they're almost always the same price.
If a smaller site is much cheaper, check its reviews and refund policy, then decide whether the saving is worth it.

Reproduce it (or track your own hotels)

Disclosure: I built the scraper I used. It's the Google Hotels Scraper on Apify. With includeVendorPrices turned on, it returns every booking site's price for your dates.

{
  "queries": ["Paris", "London", "New York", "Barcelona", "Bangkok"],
  "checkInDate": "2026-11-12",
  "checkOutDate": "2026-11-15",
  "adults": 2,
  "currency": "USD",
  "maxResultsPerQuery": 10,
  "includeVendorPrices": true
}

# pip install apify-client
from apify_client import ApifyClient

run_input = {
    "queries": ["Lisbon"], "checkInDate": "2026-11-12", "checkOutDate": "2026-11-15",
    "adults": 2, "currency": "USD", "maxResultsPerQuery": 10, "includeVendorPrices": True,
}
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("kuezi/google-hotels-scraper").call(run_input=run_input)
for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    prices = {v["vendor"]: v["totalPrice"] for v in hotel.get("vendorPrices", [])}
    if len(prices) > 1:
        low = min(prices.values())
        print(hotel["name"], {k: f"+{(p - low) / low:.0%}" for k, p in prices.items()})

Schedule it daily and you have a rate-shopping tracker.