DEV Community: Hugues Ishema

Google's Trends API is still invite-only. I tested what the alternatives return

Hugues Ishema — Tue, 13 Oct 2026 07:39:09 +0000

TL;DR: Google announced an official Trends API in July 2025 "only to a very limited number of testers". Fifteen months later the page is still titled "Alpha" and still ends in an application form. pytrends, the library most tutorials use, was archived in April 2025, and its last maintainer left a note saying Google gives bots "slightly altered data". I tested that claim on 13 October 2026: five keywords, one hour, three ways to ask Google. Interest over time and interest by region came back the same from all three, give or take 3 points. Related queries are unstable for everyone, including the website. Related topics are the one thing Google withholds from anything it tags as a scraper, and it tags sessions openly, in its own JSON.

What you can't get from any route below: absolute search volumes. Google Trends only ever gives relative interest on a 0 to 100 scale, API or not.

Status table (checked 13 October 2026)

Source	State today
Official Google Trends API	Alpha. "As we can't open the API for everyone yet, we're prioritizing developers that know what they want to do", with an application form (API page). Announced 24 July 2025 (blog). An April 2026 Ask HN asking who got in has one reply, from someone who didn't
pytrends (Python)	Archived on GitHub 17 April 2025. Last release 4.9.2, April 2023. Still 908,810 PyPI downloads in the last 30 days (pypistats). 63 issues and PRs in the repo mention HTTP 429
trendspy (Python)	The fork the pytrends maintainer pointed to. Last commit 25 December 2024, v0.1.6
google-trends-api (npm)	Last push November 2022. 569,469 downloads in the last 30 days, 54 open issues
trends.google.com	Works. Compare a handful of terms, download a CSV by hand
Scrapers (self-built or hosted)	Work, with the caveats measured below

The pytrends note is worth reading in full (issue #636, 8 February 2025). The maintainer's claim is that when Google detects a bot it returns "slightly altered data" compared with the website. That's a strong claim, and nobody I could find had checked it. So I did.

The test

Same five keywords (python, javascript, rust, typescript, golang), United States, past 12 months, web search. All pulled between 07:19 and 07:31 UTC on 13 October 2026, three ways:

	Who asks Google	Where from
A. Website	trends.google.com in a normal browser. I read the JSON the page itself loads	My IP (Rwanda)
B. Plain fetch	`fetch()` typed into the console of that same tab. Same cookies, same IP, same minute	My IP (Rwanda)
C. Scraper	My Apify Actor (residential proxy, no cookies)	Apify's servers

The raw responses, the Actor's output and the overlap script are in the public repo.

1. Google labels every session, and tells you

The first request on a Trends page is POST /trends/api/explore. Its response contains the request object for every widget, and inside each one is this:

"userConfig": {"userType": "USER_TYPE_LEGIT_USER"}

That is what the page got (A). The fetch() from the console of the same tab (B) got, every time:

"userConfig": {"userType": "USER_TYPE_SCRAPER"}

Same browser, same cookies, same IP, seconds apart. The widget tokens are signed against this label, so you can't edit it. Whatever the website's JavaScript sends that my fetch() didn't, Google uses it to sort requests into two bins before any data is returned. The question is what differs between the bins.

2. Interest over time: the same, within 3 points

A and B returned identical numbers. I compared python on all 53 weeks and the other four terms on 48 weeks, and found no difference. The scraper label alone does not change the time series.

The Actor (C) got a slightly different sample. Google's help pages say Trends data is a sample, and the Actor asked from a different IP ten minutes earlier. Per keyword, 53 weekly points on the shared 0 to 100 scale:

Keyword	Points identical	Mean abs. difference	Max difference	Correlation
python	16 of 53	1.08	3	0.997
javascript	42 of 53	0.21	1	0.994
rust	25 of 53	0.66	3	0.985
typescript	48 of 53	0.09	1	0.987
golang	52 of 53	0.02	1	0.995

The Actor's share-of-search ranking (python 57%, rust 28%, javascript 9%, typescript 3%, golang 2%) is the same ranking the website chart shows. For a trend line, a seasonality check or a "did interest double" question, 3 points on a 0 to 100 scale is noise.

3. Interest by region: the same, within 1 point

Website (A) versus Actor (C) for python, US states, top of the list:

State	Website	Actor
Wyoming	100	100
Kansas	35	35
District of Columbia	28	27
Massachusetts	24	24
Maryland	23	22
Washington	23	22
California	23	24
Virginia	22	22

All 51 regions are within 1 point. (Yes, Wyoming. Google's regional score is a share of all searches in that state, not a count.)

4. Related queries: unstable for everyone

This is where "altered data" would hide, so I pulled the top 25 related queries for python five times: the website twice (two page loads, ten minutes apart), the plain fetch twice, and the Actor once. Overlap of the 25:

Pair	Shared queries (of 25)	Shared in the top 10
Website load 1 vs website load 2	15	5
Website load 1 vs plain fetch	18	7
Website load 2 vs plain fetch	17	7
Website load 1 vs Actor	15	5
Website load 2 vs Actor	15	6

The website disagrees with itself as much as it disagrees with the scrapers. Two loads of the same page, ten minutes apart, shared 15 of 25 queries. "python list", "python documentation", "python news" and "python class" were in load 1 and gone in load 2. Rising queries were worse: 6 of 25 shared between the two website loads.

The head of the list is stable everywhere: "what is python" at 100, "python code" at 69 to 72, "ball python" at 40 or 41 in every pull but one. Even the wording moves: the website said "install python" on one load and "python install" on the next.

Conclusion: take the top handful of related queries from any source. Don't build anything on the tail, and don't diff two pulls and call the difference a trend.

5. Related topics: withheld from scrapers

Related topics (Google's entity list, with Freebase-style ids like /m/05z1_) are the one hard difference.

Website (A), python, past 12 months: 20 top topics and 13 rising. Python the programming language at 100, then Data 7, Python the snake 7, Documentation 6, Computer file 5, API 5, and so on.
Plain fetch (B), same tab, seconds later: rankedList present, both lists empty.
Actor (C): {"top": [], "rising": []}.

The topics widget appears only on single-keyword pages, by the way. On a compare page the website itself shows related queries only.

So the maintainer was right that scrapers get something different, and the something is this: no related topics. On the numbers people actually chart, I found no alteration.

What this means if you need Trends data in code

You need	Where to get it
Interest over time, interest by region, share of search between terms	Any route. The website, a scraper, or the official API if you're in the alpha
Related queries	Any route, head of the list only
Related topics	The website, or the official API if it ever ships them. Not a scraper
Absolute volumes	Nowhere in Trends

Hosted version

Google Trends Scraper on Apify is source C above. One record per keyword: the time series with a trend direction and recent change, the region table, related queries with breakouts flagged, and a share-of-search ranking when you compare terms. It also chains batches so you can compare more than five keywords on one scale. It can't return related topics, for the reason in section 5, and it says so in the README.

Disclosure: I built this. It costs $4 per 1,000 keyword reports and $0.50 per 1,000 Trending Now items. Keywords Google has no data for aren't charged. Apify's free plan includes $5 of credit a month.

With apify-client 3.x (pip install apify-client):

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("kuezi/google-trends-scraper").call(logger=None, run_input={
    "keywords": ["python"],
    "geo": "US",
    "timeRange": "today 12-m",
    "includeInterestOverTime": True,
    "includeInterestByRegion": True,
    "includeRelatedQueries": True,
    "includeRelatedTopics": True,
})

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["keyword"], item["status"], "avg", item["average"], "latest", item["latestValue"], item["direction"])
    print("  top region:", item["topRegion"])
    print("  top queries:", [q["query"] for q in item["relatedQueries"]["top"][:5]])
    print("  rising:", [q["query"] for q in item["relatedQueries"]["rising"][:3]])
    print("  related topics:", item.get("relatedTopics"))

print(run.status_message)

Output from the real run on 13 October 2026 (25 seconds, $0.004):

python ok avg 62.5 latest 37 falling
  top region: Wyoming
  top queries: ['what is python', 'python code', 'ball python', 'install python', 'python online']
  rising: ['walmart near me', 'python swallowing deer india', 'singapore reticulated python sighting']
  related topics: {'top': [], 'rising': []}
Done: 1/1 keywords.

The empty topics are the honest output, not a bug. A TIMELINE_WIDE.csv with one column per keyword lands in the run's key-value store for Sheets or pandas.

What this doesn't give you

Search volumes. 100 means the peak for that term, place and period. Nothing more.
Related topics. See section 5.
A guarantee the sample matches the website to the point. Expect a 1 to 3 point spread on the time series.

If you've compared Trends output across sources in a different way, or you're in the API alpha and can say what it returns, post it in the comments and I'll add it to the tables.

AI disclosure: I wrote this with AI assistance. Every quote, number and output above was checked or run on 13 October 2026.

There's no Google Hotels API, and the free fallbacks closed

Hugues Ishema — Mon, 12 Oct 2026 07:06:39 +0000

TL;DR: Google has no public API for the prices you see on Google Hotels. In 2026 the two fallbacks most tutorials pointed to also closed for small developers: Amadeus Self-Service (including Hotel Search) shut on 17 July, and Booking.com's Demand API is for contracted partners only. If you need hotel prices in code without a partnership, what's left is reading the public results page, yourself or through a paid scraper. Code and a real run are below.

What this post can't fix: booking. Everything here is price data. If you need to sell rooms, you need a supplier contract (Expedia Rapid, Booking.com, a bedbank), and no scraper replaces that.

Status table (checked 12 October 2026)

Source	Can a solo developer get hotel prices from it today?
Google Travel Partner API	No. It's for Hotel Center accounts: your own feed, reports and price accuracy. No method returns other providers' prices
Amadeus Self-Service Hotel Search / Hotel List	No. The portal "has been decommissioned on July 17th", per the Amadeus for Developers homepage
Booking.com Demand API	Only as a "Managed Affiliate Partner" with Partner Centre access given by your account manager after a contract
Expedia Rapid API	Only as an approved Expedia partner. The key stays in development mode until a site review
Google Hotels results page	Yes. It's public. You parse it or pay someone who does

Google: the API exists, but not for you

Search "Google Hotels API" and you land on the Travel Partner API. It's real, and it's for hotels and booking sites that send prices to Google. You authenticate with OAuth2 against your own Hotel Center account and read your own price views and reports. There is no endpoint that returns what Booking.com or Expedia charge for a hotel you don't manage.

Amadeus: the free door closed on 17 July

For years the standard answer was Amadeus Self-Service: free test keys, then shopping.hotel_offers_search and reference_data.locations.hotels.by_city in the Python SDK.

The Amadeus for Developers homepage now reads: "self-service portal has been decommissioned on July 17th, this website is for Amadeus Enterprise API Portal only".
The old Hotel Search docs URL redirects to that homepage.
The official amadeus-python repo was archived on 17 July 2026 at 10:04 UTC.

Only Self-Service closed. Amadeus's Enterprise APIs continue, under contract.

If you had flight code on Amadeus too, I wrote a call-by-call replacement for the flight endpoints.

Booking.com: contract first, API second

The Demand API prerequisites list two things before any key:

"Registered as a Booking.com Managed Affiliate Partner."
"Access to Partner Centre (provided by your Booking.com Account Manager after signing the agreed contract)."

Booking.com also ended its direct affiliate programme in 2025 and moved affiliates to networks such as CJ and Awin (Skift, May 2025). One developer documented in September 2026 that applying through CJ is separate from Demand API access. Their Partner Centre login said they had "no access rights".

Expedia Rapid: partner, approval, site review

Rapid's getting-started page is clear: "To integrate with Rapid API, you need to be an Expedia partner." After approval you get a key, but it stays in development mode. You "ask your business development manager for a site review", and only then is the key enabled for production.

That's a sensible process for a booking business. It's a wall for a side project, a price tracker or a research script.

What's left: the public page

Google Hotels already shows what you want: for each hotel, the nightly and total price for your dates, plus a list of booking sites and what each one charges. The page is public. You have three ways to get it into code:

Option	Cost	Who maintains the parser
Write your own scraper	Proxies and your time	You, every time Google changes the page
SerpApi Google Hotels	Free 250 searches a month, then from $25 per 1,000 searches (pricing)	SerpApi
Apify Actors, including mine	Pay per result	The Actor's developer

Even paid APIs struggle with this page. SerpApi's own public roadmap has open issues titled "Some prices are missing in the search results" (14 comments) and "Some regional results don't show up" (16 comments). Whichever route you pick, check for gaps before you trust a number.

Hosted version

Google Hotels Scraper on Apify takes a city or a search, your dates, guests and currency, and returns one JSON record per hotel. Turn on includeVendorPrices and each hotel also gets every booking site Google lists, cheapest first.

Disclosure: I built this. It costs $1.50 per 1,000 hotels, plus $0.006 per hotel for the booking-site price list. Hotels removed by your filters and failed searches aren't charged. Apify's free plan includes $5 of credit a month.

With apify-client 3.x (pip install apify-client):

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("kuezi/google-hotels-scraper").call(logger=None, run_input={
    "queries": ["Lisbon"],
    "checkInDate": "2026-11-20",
    "checkOutDate": "2026-11-22",
    "adults": 2,
    "currency": "USD",
    "maxResultsPerQuery": 3,
    "includeVendorPrices": True,
    "maxVendorsPerHotel": 20,
})

for h in client.dataset(run.default_dataset_id).iterate_items():
    print(f'{h["name"]} | {h["rating"]} | ${h["pricePerNight"]}/night on Google, {h["vendorCount"]} sites')
    for v in h["vendorPrices"][:3]:  # cheapest first
        print(f'    {v["vendor"]:<14} ${v["pricePerNight"]}')

print(run.status_message)

Output from a real run on 12 October 2026:

Brown's | Avenue Hotel | 4.6 | $180/night on Google, 20 sites
    Brown's Avenue $180
    Vio.com        $185
    Etrip.net      $185
Iberostar Selection Lisboa | 4.7 | $118/night on Google, 20 sites
    Evendo         $118
    goseek.com     $123
    dealbase.com   $123
Patio São Vicente Guest Houses | 4.9 | $112/night on Google, 11 sites
    Hotels.com     $112
    Expedia.com    $119
    Travelocity.com $119
Saved 3 hotels from 1/1 searches (2026-11-20 → 2026-11-22, 2 adults, prices per night). "hotels in Lisbon" (3 hotels): cheapest Patio São Vicente Guest Houses 112 USD (Hotels.com), Iberostar Selection Lisboa 118 USD (Evendo), Brown's | Avenue Hotel 180 USD (Brown's Avenue); median 118 USD/night; best rated Patio São Vicente Guest Houses 4.9★ at 112.

That run took 12 seconds and cost $0.0225: three hotels plus three booking-site lists. maxVendorsPerHotel keeps the 20 cheapest sites, so "20 sites" means "at least 20".

The full lists show why the per-site data matters. For the same two nights:

Hotel	Cheapest site	Booking.com	Gap
Brown's Avenue Hotel	$180 (the hotel's own site)	$221	+23%
Patio São Vicente	$112 (Hotels.com)	$140	+25%

Two hotels prove nothing on their own. I ran the same comparison on 47 hotels in an earlier study, with the data and code public.

Other inputs worth knowing:

minRating, maxPricePerNight and minHotelClass filter before saving, so you don't pay for hotels you drop.
country sets Google's region, which changes which booking sites appear. Prices above are from a US point of sale.
Schedule the run daily to build a price history for your dates.

There's a ready-made task to compare one hotel's price across booking sites.

What this doesn't give you

Booking or availability guarantees. These are the prices Google shows at the moment of the run. Rooms, taxes and cancellation terms differ by site.
Room-level rate plans. You get the headline price per site, not every room type.
Official status. This is public-page data, not a partner feed. If you need a contract and an SLA, the partner programmes above are the way.

If you found another legitimate route to hotel prices that's open to small developers in 2026, post it in the comments and I'll add it to the table.

AI disclosure: I wrote this with AI assistance. Every quote, number and output above was checked or run on 12 October 2026.

my.telegram.org says ERROR? For public channels you may not need an api_id

Hugues Ishema — Sat, 03 Oct 2026 17:19:10 +0000

You filled in the form at my.telegram.org/apps, clicked Create application, and got a box that says "ERROR". No code, no reason. You tried again. Same box.

You're in large company:

The Stack Overflow question "my.telegram.org sends an ERROR when I want to create an API id/hash" has almost 96,000 views.
tdlib/telegram-bot-api #597 has 52 comments. The latest one is from 16 September 2026.
Telethon's maintainer answered the same report with "I don't have any control over that page".

Nobody outside Telegram knows exactly why the form fails. Before you spend another evening on it, check whether you need an api_id at all.

Do you actually need an api_id?

What you want to do	api_id?	Use instead
Read posts from a public channel	No	The web preview at `t.me/s/<channel>`
Search inside a public channel	No	`t.me/s/<channel>?q=<word>`
Get new posts from a public channel every hour	No	Poll the web preview
Send messages or run a bot	No	A bot token from @botfather
Read a private channel, a group, your own chats, member lists	Yes	MTProto (Telethon, Kurigram)

If your project is in the first three rows, you can skip my.telegram.org entirely. If it's in the last row, there's no way around it, and the fixes people report are further down.

Why a bot token doesn't solve it

Another common answer is "just ask BotFather for a token". That works for sending messages. It doesn't work for reading someone else's channel:

Telegram's Bots FAQ says bots receive "all messages from channels where they are a member". The channel's admin has to add your bot.
The Bot API has no method to fetch a chat's past messages. A bot only sees what arrives after it joins.
Updates wait on Telegram's server for "not longer than 24 hours". If your bot is down for a day, those posts are gone from its queue.

If you do need MTProto: library status

Library	Status (checked 3 Oct 2026)
Pyrogram	Archived on GitHub on 23 Dec 2024. Last release April 2023, yet still 275,823 PyPI downloads last month
pyrofork	Archived on 14 Sep 2026. Last release December 2025
Telethon	Active. The GitHub repo was archived in February 2026 because the project moved to Codeberg. v1.45.0 shipped on 10 Sep 2026
Kurigram (a Pyrogram fork)	Active. v2.2.26 on 12 Sep 2026

All four need an api_id and a phone login. If you only look at GitHub, Telethon looks dead. It isn't.

Telegram's own api_id page adds two rules worth knowing:

"Each number can only have one api_id connected to it."
"All accounts that log in using unofficial Telegram API clients are automatically put under observation."

So a scraper built on your personal number puts your personal account on the line.

What people report fixes the ERROR

None of these is official, and none works for everyone. They come from the Stack Overflow thread and tdlib #597:

Disable ad blockers and VPN browser extensions. This is the top Stack Overflow answer.
Try another browser or an incognito window.
Switch from Wi-Fi to mobile data, or submit from your phone.
Use an IP address in the same country as your phone number. Several people report this; one commenter disputes it.
Wait 5 to 10 minutes and submit again. One user got through "after about 2 months" with no other change.

One warning. The tdlib thread also has posts from accounts offering to "apply for you" for a fee. That means giving a stranger a login code for your Telegram account. Don't.

The route that needs nothing: t.me/s/

Every public channel has a web preview at https://t.me/s/<channel>. It's plain HTML. It shows the newest 20 posts with text, date, views, reactions and media. You page back with ?before=<id> and search with ?q=<word>. No account, no phone number, no api_id.

Private channels, groups, bots and users have no preview. For them, t.me/s/<name> redirects to t.me/<name>. That redirect is a quick test of whether this route works for your target.

I wrote up the selectors, a 30-line Python scraper and the gotchas in an earlier post. If you'd rather not maintain a parser, there's a hosted version.

Hosted version

Telegram Channel Scraper on Apify reads the same public preview and returns JSON.

Disclosure: I built this. It costs $0.50 per 1,000 posts plus $0.001 per channel per run, and failed channels aren't charged. Apify's free plan includes $5 of credit a month.

With apify-client 3.x (pip install apify-client):

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("kuezi/telegram-channel-scraper").call(logger=None, run_input={
    "channels": ["telegram", "BotFather"],
    "searchQuery": "passkey",
    "maxMessagesPerChannel": 5,
})

for post in client.dataset(run.default_dataset_id).iterate_items():
    print(post["messageId"], post["date"][:10], post["views"], post["text"][:60].replace("\n", " "))

print(run.status_message)
failed = client.key_value_store(run.default_key_value_store_id).get_record("FAILED")
print(failed["value"] if failed else None)

Output from a real run on 3 October 2026:

423 2026-01-07 2720000 Happy New Year! Telegram released 13 major updates in 2025 –
420 2025-12-15 3020000 For all the details about creating passkeys and making offer
417 2025-12-15 2020000 Passkeys. You can now create a passkey to instantly log in t
Saved 3 messages from 2 channel(s). telegram (9.4M subscribers): 3 posts from 2025-12-15 to 2026-01-07; most viewed 3M views https://t.me/telegram/420. BotFather: failed (no public preview).
[{'channel': 'BotFather', 'error': '"BotFather" has no public web preview (it may be private, a group, a user or a bot, or it doesn\'t exist).'}]

That run cost $0.0025: three posts plus one channel. BotFather is a bot, so it has no preview. The run reports it in FAILED and doesn't charge for it.

Other inputs:

dateFrom and dateTo stop paging once a run passes your date range, so you don't pay for old posts.
onlyNewMessages turns on monitoring. Schedule the run, and each one returns only posts published since the previous run.

There's also a ready-made task to search a Telegram channel for keywords.

What you can't do without an api_id

Private channels, groups and DMs. There's no preview. You need MTProto and an account that's a member.
Exact view counts. The preview rounds them ("1.6M" becomes 1600000).
Some media. Certain polls and stickers aren't rendered in the preview. The post still has its date, views and usually its text.
Posting. Use a bot token for that.

If you hit the ERROR and found a fix that isn't listed here, add it in the comments. I'll update the list.

AI disclosure: I wrote this with AI assistance. Every number and output above was checked or run on 3 October 2026.

Amadeus Self-Service shut down on July 17. Here's a drop-in replacement for flight prices

Hugues Ishema — Sat, 03 Oct 2026 11:30:51 +0000

If your fare tracker, travel bot or class project suddenly can't reach test.api.amadeus.com or gets auth errors, it's not your code. Amadeus decommissioned its Self-Service APIs on 17 July 2026.

The developer portal now says the self-service portal "has been decommissioned on July 17th".
PhocusWire reported the plan on 9 February: new registrations paused, then keys disabled from 17 July. Enterprise APIs continue.
The official SDKs (amadeus-python, amadeus-node, amadeus-java, Ruby, .NET) were archived on GitHub the same day.
On 2 October, test.api.amadeus.com, the SDK's default host, had no DNS A record at Google or Cloudflare DNS.

GitHub is full of projects hitting this. More than 190 issues and PRs mention Amadeus Self-Service since February. Some remove their Amadeus adapter (anythingmcp #713). Others swap in another API (multi-flight-search #1). Many are student projects that started an Amadeus integration after registrations closed.

I needed the same three calls for my own projects, so I built a replacement with the same parameter names and the same JSON shape. This post covers the options, the migration code, and what you can't replace.

The free options are mostly closed

Option	Status (checked 2 Oct 2026)
Amadeus Self-Service	Decommissioned 17 July 2026. Enterprise only, via a commercial agreement
Google QPX Express	Ended 10 April 2018
Kiwi.com Tequila	New partnerships "on an invitation only basis" since May 2024
Skyscanner Travel API	"Commercial use only". Not for students, start-ups without a product, or sites under 100K monthly users
SerpApi Google Flights	Works. 250 free searches a month, then $25 per 1,000 to $275 per 30,000 ($0.025–$0.009 per search). Return legs need a second request
`fast-flights` (Python)	Alive and popular, but the maintainer says it can break whenever Google changes something (#92)

If you need booking (Flight Create Orders, ticketing), none of these help. You need a booking API from an airline, a consolidator or Amadeus Enterprise. The rest of this post is about the read-only price calls, which is what most hobby and research projects used.

A drop-in for the three price calls

I published Flight Offers API on Apify. It takes the Amadeus Self-Service parameter names, fetches live prices from Google Flights, and returns Amadeus-shaped JSON:

Amadeus Self-Service	Replacement	Status
Flight Offers Search `GET /v2/shopping/flight-offers`	`endpoint: "flight-offers"`	Same parameters, `flight-offer` objects
Flight Cheapest Date Search `GET /v1/shopping/flight-dates`	`endpoint: "cheapest-date"`	Scans every day in a range, up to 90 days
Flight Price Analysis `GET /v1/analytics/itinerary-price-metrics`	`endpoint: "price-metrics"`	Quartiles from Google's recent price history for that date
Flight Offers Price, Create Orders, Seat Maps	✘	Not replaced

Disclosure: I built and sell this. It's pay per use: $0.003 per search plus $0.0005 per saved offer. A Flight Offers Search with 10 offers costs $0.008. Apify's free plan includes $5 of monthly credit, which covers about 600 such searches.

Migrating Flight Offers Search (Python)

Before, with the archived SDK:

from amadeus import Client

amadeus = Client(client_id="...", client_secret="...")
response = amadeus.shopping.flight_offers_search.get(
    originLocationCode="JFK", destinationLocationCode="LAX",
    departureDate="2026-11-12", adults=1, max=5)

for offer in response.data:
    seg = offer["itineraries"][0]["segments"][0]
    print(offer["price"]["total"], seg["carrierCode"], seg["number"], seg["departure"]["at"])

After (pip install apify-client, version 3.x):

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

def amadeus_call(endpoint, **params):
    """Runs the replacement and returns an Amadeus-style {meta, data, dictionaries} dict."""
    run = client.actor("kuezi/flight-offers-api").call(logger=None, run_input={"endpoint": endpoint, **params})
    return client.key_value_store(run.default_key_value_store_id).get_record("RESPONSE")["value"]

response = amadeus_call("flight-offers",
    originLocationCode="JFK", destinationLocationCode="LAX",
    departureDate="2026-11-12", adults=1, max=5)

for offer in response["data"]:
    seg = offer["itineraries"][0]["segments"][0]
    print(offer["price"]["total"], seg["carrierCode"], seg["number"], seg["departure"]["at"])

The loop is unchanged. Only response.data becomes response["data"]. Output from a real run on 2 October:

204.00 DL 1788 2026-11-12T12:00:00
204.00 B6 1023 2026-11-12T12:00:00
204.00 B6 623 2026-11-12T15:29:00
204.00 B6 123 2026-11-12T05:45:00
204.00 DL 742 2026-11-12T07:00:00

The run took 5 seconds. Its status message is a one-line answer, handy for logs and AI agents:

5 flight offers JFK-LAX on 2026-11-12. Cheapest 204.00 USD: DL 1788, departs 2026-11-12T12:00:00, PT6H8M.
Google says prices are typical (typical 144-240).

Cheapest Date Search

Amadeus took a date range in departureDate. So does this:

response = amadeus_call("cheapest-date",
    origin="SFO", destination="HNL", departureDate="2026-11-01,2026-11-30")

for d in response["data"][:3]:      # sorted cheapest first
    print(d["departureDate"], d["price"]["total"], d["priceLevel"])

Real run: 30 dates priced in 18 seconds. Cheapest was $163 on 1 November, with 11 more dates at the same price. The priciest was $444 on 20 November. For round trips, pass duration=7 (one trip length; Amadeus-style ranges like 1,15 aren't supported).

Price Analysis

response = amadeus_call("price-metrics",
    originIataCode="JFK", destinationIataCode="LAX", departureDate="2026-11-12")
m = response["data"][0]
print({x["quartileRanking"]: x["amount"] for x in m["priceMetrics"]})

{'MINIMUM': '167.00', 'FIRST': '178.00', 'MEDIUM': '178.00', 'THIRD': '204.00', 'MAXIMUM': '215.00'}

Amadeus built these quartiles from its booking data. This version builds them from Google Flights' price history for that exact date, 61 days in this case, and also returns Google's own verdict (typical) and typical range ($144–240). The idea is the same, but the source isn't, so don't compare the numbers one to one.

What's different from Amadeus

Be aware of these before you switch:

Prices are what Google Flights shows a shopper in the chosen country (country: "us" by default). That includes low-cost and airline-direct fares that Amadeus often didn't have. They're shopping prices, not bookable fares.
Some fields are null because Google doesn't publish them: numberOfBookableSeats, lastTicketingDate, price.base, and aircraft.code (the aircraft name is in aircraft.name instead).
Round-trip offers carry the total trip price but only the outbound itinerary. Google shows return options after you pick an outbound flight.
Use IATA airport codes. There's no airport or city search endpoint yet.
Extras Amadeus never had are under googleFlights in each offer: CO₂, legroom, layovers, Google's price level and a link to the search.

Plain HTTP, no SDK

curl -X POST "https://api.apify.com/v2/acts/kuezi~flight-offers-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"endpoint":"flight-offers","originLocationCode":"LHR","destinationLocationCode":"JFK","departureDate":"2026-12-01","max":5}'

That returns the data array directly.

If you were using another Amadeus Self-Service endpoint and want it replaced, tell me which one in the comments. I'll prioritize by demand.

AI disclosure: this post and the tool were produced with an AI agent (Claude) working for me. Every number above comes from real runs on 2 October 2026.

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.default_dataset_id).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.default_key_value_store_id).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.

Update 2 (17 Oct): same flights, three pull dates

Another point from the same reader: all 150 fares were pulled on one day, so the early-November dates were also the closest to departure. I pulled the same searches again on 9 and 17 Oct and compared weekdays at the same lead time (route + weekday + 7-day lead-time bucket).

Friday is still the priciest day, at about 8–12% above the average weekday: +12.0% for all of November, +8.1% for 1–19 Nov. That's smaller than the headline +19.7%, which mixed in lead time and Thanksgiving.
Sunday is also pricier, at about +7%.
Monday and Tuesday are both 7–10% below average. The difference between them is noise, so "Tuesday is cheapest" really means "early in the week is cheapest".
Fares held, then rose. From 2 to 9 Oct the median fare didn't change. From 9 to 17 Oct it rose 5.2%, with 84 of 150 fares up and 41 down.

Data and script (lead_time.py): travel-price-studies on GitHub.

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.default_dataset_id).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.

Update (17 Oct): does the same cheap site keep winning?

I re-ran the same 50 searches on 9 and 17 Oct. With a rule fixed before the new data, I tested whether three small sites (Super.com, Traveluro, Vio.com) keep most of the saving against the cheapest big brand.

9 Oct: they captured 75% of the gap (95% CI 56–90%). Pass.
17 Oct: 65% (95% CI 48–82%). Inconclusive.
Verdict: inconclusive. A fixed shortlist of "cheap sites" isn't reliable enough to recommend. Compare every site, or start from Google's headline price.
The cheapest site for a hotel repeats from week to week far more often than chance: 63% of hotels from 2 to 9 Oct, 56% from 9 to 17 Oct. Over longer gaps it repeats less: 40% from 2 to 17 Oct.
On the same hotels, the gap between the cheapest big brand and the cheapest small site fell from about 18% on 2 Oct to 13.5% on 17 Oct.

Full method, data and scripts: travel-price-studies on GitHub.