DEV Community: huynhtanan

Add Google Hotels to Claude Desktop as an MCP server (2-minute setup)

huynhtanan — Thu, 15 Oct 2026 18:27:53 +0000

If you use Claude Desktop or Claude Code, you can ask Claude in plain English to find and compare hotels for a trip. Prices are live from Google Hotels, with the rate every booking site is charging (Booking.com, Expedia, Agoda, Hotels.com, Vrbo, …), and the answer comes back as structured JSON that Claude turns into a short recommendation.

The glue is a small open-source MCP server I built: huynhtanan/google-hotels-mcp. This post is a 2-minute install plus one real example.

Disclosure: the server calls three paid Apify actors I wrote. The Apify Free plan ships $5 of credit per month — about 60 full-city searches — before you need to upgrade. No card required to sign up.

1. Get an Apify token

2. Add the MCP server to Claude Desktop

Open claude_desktop_config.json (Settings → Developer → Edit Config) and add:

{
  "mcpServers": {
    "google-hotels": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/huynhtanan/google-hotels-mcp.git",
        "google-hotels-mcp"
      ],
      "env": { "APIFY_TOKEN": "apify_api_..." }
    }
  }
}

Restart Claude Desktop. In the slash-command menu you'll now see three tools: search_hotels, hotel_price_calendar, search_vacation_rentals.

If you prefer Claude Code, one line does it:

claude mcp add google-hotels -- uvx --from "git+https://github.com/huynhtanan/google-hotels-mcp.git@v0.1.1" google-hotels-mcp

(then set APIFY_TOKEN as an env var).

3. Ask Claude a real question

"Find hotels in Lisbon from 2026-11-10 to 2026-11-13, two adults, EUR, best value under €120 per night."

Claude calls search_hotels and gets 40 live results. Below are the top 3 cheapest with the live rating from Google (one of 40 items returned, trimmed for the post — the raw JSON is 100 lines):

Patio São Vicente Guest Houses   €109/night   4.9★ (349 reviews)   4-star hotel
Home - Lisbon Hostel             €73/night    4.8★ (2,370 reviews) 2-star hotel
Magnolia Guesthouse, Lisbon      €71/night    4.7★ (139 reviews)   —

Here is the actual tool response for one item (lightly trimmed):

{
  "name": "Patio São Vicente Guest Houses",
  "rating": 4.9,
  "reviewsCount": 349,
  "ratingDistribution": {"3": 3, "4": 16, "5": 330},
  "hotelClassText": "4-star hotel",
  "pricePerNight": 109,
  "pricePerNightText": "€109",
  "totalPrice": 372.1,
  "totalBeforeTaxes": 328.48,
  "currency": "EUR",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "nights": 3,
  "checkInTime": "3:00 PM",
  "checkOutTime": "11:00 AM",
  "latitude": 38.7155846,
  "longitude": -9.1280593,
  "nearbyPlaces": [
    {"name": "National Pantheon", "travelTime": "6 min"},
    {"name": "Voz Operário",      "travelTime": "2 min"}
  ],
  "reviewTopics": [
    {"topic": "Location", "mentions": 88, "positive": 84, "positiveShare": 0.977}
  ],
  "website": "https://www.patiosaovicente.com/",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/..."
}

So Claude sees not just the price, but the rating distribution (how many 5-star reviews, how many 1-star), the review topics with sentiment, nearby places with walking time, direct website and Google Hotels URL. That is enough context to actually recommend a hotel instead of just listing names.

Two more prompts that are useful

Daily price calendar for one property. The hotel_price_calendar tool returns one row per date for ~3 months, so you can ask:

"Give me a 3-month price calendar for this Hoxton Paris URL and show the 7 cheapest dates."

Each row is { "date": "2026-12-14", "price": 189, "currency": "EUR", "available": true }.

Vacation rentals, Airbnb vs Vrbo. The search_vacation_rentals tool hits Google's rentals page:

"Compare 3-bedroom vacation rentals in Lisbon for 2026-11-15 to 2026-11-22, 4 guests, show the Airbnb rate and the Vrbo rate side-by-side."

With include_provider_prices=true, each rental comes back with a providers array containing the price Airbnb, Vrbo, Booking.com and the other 15+ OTAs are each quoting.

Pricing

Pay-as-you-go on the Apify Free plan.

Call	Cost
1 hotel in `search_hotels`	$0.002
1 hotel with per-OTA rates	$0.004
1 date in `hotel_price_calendar`	$0.0015
1 vacation rental	$0.002

A full-city search with 20 hotels and per-OTA rates is about $0.08. The $5 free monthly credit covers about 60 of those.

How it compares

A hosted MCP by HasData exists for Google Hotels. The difference:

	huynhtanan/google-hotels-mcp	HasData hosted MCP
Open source	✅ MIT	❌
Tools	3 (hotels, calendar, rentals)	1 (hotels)
Daily price calendar	✅	❌
Vacation rentals	✅ Airbnb + Vrbo + Booking.com	❌
Per-provider rates	✅ 15+ OTAs	✅
Install	`uvx` or `pip` + Apify token	hosted, their key

If you only need a one-off hotel search, HasData is fine. If you want calendars, rentals, or you want to see the raw actor code, go with this one.

Track Walmart Rollback deals with Python and SQLite

huynhtanan — Thu, 15 Oct 2026 17:28:19 +0000

If you buy a lot on Walmart.com, you've seen those orange Rollback tags — a temporary price cut that Walmart itself slaps on an item, usually a few dollars to a few tens of percent off. There's no newsletter listing every active Rollback across the catalog, and the "deals" pages are curated and partial. If you want them all in one table, you have to scrape search.

This post shows how to pull every Rollback deal from a Walmart search in Python, filter by discount percent, and track the drops day over day with a 60-line SQLite logger.

Code is in github.com/huynhtanan/walmart-deals-tracker (MIT). Disclosure: I built the Apify scraper the examples call; it's pay-per-result at $1 per 1,000 products and new Apify accounts get free monthly credit covering tens of thousands of items.

Setup

pip install "apify-client>=3"
export APIFY_TOKEN=...   # https://console.apify.com/settings/integrations (free account)

1. All Rollback items on one search page, with discount %

Walmart's search results already include the strikethrough price when there is one. The scraper exposes it as wasPrice, so computing the discount is (wasPrice - price) / wasPrice.

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/walmart-search-scraper").call(run_input={
    "queries": ["coffee maker", "headphones", "vacuum"],
    "maxItemsPerQuery": 30,
    "includeSponsored": False,
})

items = list(client.dataset(run.default_dataset_id).iterate_items())
rollbacks = [i for i in items
             if i.get("badge") == "Rollback" and i.get("wasPrice") and i.get("price")]
rollbacks.sort(key=lambda x: -(x["wasPrice"] - x["price"]) / x["wasPrice"])

for r in rollbacks[:10]:
    pct = (r["wasPrice"] - r["price"]) / r["wasPrice"] * 100
    print(f'-{pct:5.1f}%  {r["query"]:12}  {r["name"][:50]:50}  '
          f'${r["price"]:>6.2f}  (was ${r["wasPrice"]:>6.2f})')

Real output (ran today, 90 products across the three queries, 13 of them Rollbacks):

- 81.6%  headphones    2 Pack iPhone wired earbuds USB C Headphones Wired  $ 13.99  (was $ 75.99)
- 44.6%  vacuum        Eureka MaxSwivel Deluxe Upright Vacuum with Swivel  $ 49.86  (was $ 89.99)
- 34.1%  vacuum        Shark Navigator Lift-Away Upright Vacuum, Pet Frie  $118.00  (was $179.00)
- 31.8%  vacuum        BISSELL PowerForce Helix Turbo Pet, Bagless, Uprig  $ 74.97  (was $109.99)
- 28.0%  vacuum        Shark Upright Vacuum, Rotator Pet, Pet Friendly, P  $183.00  (was $254.00)
- 25.2%  headphones    Skullcandy Smokin' Buds XT True Wireless in-Ear Ea  $ 14.88  (was $ 19.88)
- 23.8%  headphones    Apple AirPods 4                                     $ 99.00  (was $129.99)
- 21.0%  headphones    Skullcandy Crusher XT Wireless Foldable over-Ear H  $ 79.00  (was $100.00)
- 15.6%  vacuum        BISSELL PowerClean FurFinder 200W Self-Standing Co  $168.00  (was $199.00)
- 15.5%  coffee maker  Keurig K-Duo Essentials Hot & Iced Single Serve K-  $109.00  (was $129.00)

A few things that are easy to miss unless you look at the data:

Not every strikethrough is a Rollback. 46 of the 90 items in the run had a wasPrice, but only 13 carried the Rollback badge. The rest are "clearance", seller-promoted "reduced price" or marketplace resets. If you only want Walmart's own Rollbacks, filter on badge == "Rollback"; if you want all discounts, filter on wasPrice is not None.
The top deal is almost always a marketplace seller, not Walmart.com. The 81% off wired earbuds at $13.99 is sold by a third-party store. That's a signal worth filtering on — seller == "Walmart.com" keeps you in Walmart-fulfilled stock.

The scraper also returns rating, reviewCount, fulfillment (SHIPPING / STORE / PICKUP), availability, sponsored, category (Walmart's own product-type leaf, e.g. Upright Vacuums) and the usItemId you need for the /ip/<usItemId> canonical URL.

2. Daily rollback tracker in SQLite

What you actually want for a watchlist is "same item, cheaper than last time". That takes a tiny SQLite table and a JOIN on usItemId.

# track_rollbacks.py — github.com/huynhtanan/walmart-deals-tracker/blob/main/track_rollbacks.py
import os, sqlite3
from datetime import date
from pathlib import Path
from apify_client import ApifyClient

QUERIES = ["coffee maker", "headphones", "vacuum", "monitor", "office chair"]
MAX_PER_QUERY = 60
DB = Path("walmart_rollbacks.sqlite3")

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/walmart-search-scraper").call(run_input={
    "queries": QUERIES,
    "maxItemsPerQuery": MAX_PER_QUERY,
    "includeSponsored": False,
})
items = list(client.dataset(run.default_dataset_id).iterate_items())
today = date.today().isoformat()

with sqlite3.connect(DB) as con:
    con.execute("""CREATE TABLE IF NOT EXISTS prices (
        run_date TEXT, us_item_id TEXT, query TEXT,
        name TEXT, price REAL, was_price REAL, badge TEXT, seller TEXT,
        rating REAL, review_count INTEGER, url TEXT,
        PRIMARY KEY (run_date, us_item_id))""")
    for it in items:
        if it.get("sponsored"):
            continue
        con.execute("INSERT OR REPLACE INTO prices VALUES (?,?,?,?,?,?,?,?,?,?,?)",
                    (today, it["usItemId"], it.get("query"), it["name"],
                     it.get("price"), it.get("wasPrice"), it.get("badge"),
                     it.get("seller"), it.get("rating"),
                     it.get("reviewCount"), it["url"]))

    print(f"Rollbacks today ({today}):")
    for row in con.execute("""
        SELECT name, price, was_price,
               ROUND(100.0 * (was_price - price) / was_price, 1) AS pct,
               seller
        FROM prices
        WHERE run_date = ? AND badge = 'Rollback' AND price < was_price
        ORDER BY pct DESC LIMIT 20""", (today,)):
        print(f"  -{row[3]:>5}%  {row[0][:60]:60}  ${row[1]:>7.2f}  (was ${row[2]:>7.2f})  {row[4]}")

3. "Deeper than yesterday" alerts

After two runs, this one SQL query gives you every item whose Rollback got deeper:

WITH deals AS (
  SELECT us_item_id, name, price, was_price, badge, run_date,
         LAG(price) OVER (PARTITION BY us_item_id ORDER BY run_date)   AS prev_price,
         LAG(badge) OVER (PARTITION BY us_item_id ORDER BY run_date)   AS prev_badge
  FROM prices)
SELECT run_date, name, prev_price, price, was_price,
       ROUND(100.0 * (was_price - price) / was_price, 1) AS pct_today,
       ROUND(100.0 * (prev_price - price) / prev_price, 1) AS dropped_today
FROM deals
WHERE badge = 'Rollback'
  AND prev_price IS NOT NULL
  AND price < prev_price
ORDER BY dropped_today DESC;

And "new Rollback today" (wasn't on sale yesterday):

WITH t AS (
  SELECT us_item_id, badge, run_date,
         LAG(badge) OVER (PARTITION BY us_item_id ORDER BY run_date) AS prev_badge
  FROM prices)
SELECT p.name, p.price, p.was_price, p.url
FROM t JOIN prices p USING (us_item_id, run_date)
WHERE t.badge = 'Rollback'
  AND (t.prev_badge IS NULL OR t.prev_badge != 'Rollback')
  AND p.run_date = DATE('now');

The repo has a one-file wrapper that does both and prints them in a terminal-friendly table.

4. Fetch a specific product by URL

If you already have the /ip/<slug>/<usItemId> URL (from an email, a share link, a competitor's page), the scraper enriches it with brand, category, shortDescription, seller, rating, reviewCount and both prices:

run = client.actor("zet46/walmart-search-scraper").call(run_input={
    "productUrls": [
        "https://www.walmart.com/ip/BISSELL-PowerForce-Helix-Bagless-Upright-Vacuum/55251527",
    ],
})

Point this at a competitor's hero product and you have a one-call price watcher.

Cost

$1 per 1,000 products returned. Watching the top 60 of five queries daily is 300 products = $0.30/day = $9/month. Running once a week is $1.20/month.

Only billed on items the scraper actually returned. Skipped items (sponsored, deduplicated by usItemId across pages, below minRating, etc.) are free.

A few things that bit me while building this

Walmart only ships prices to US IPs. From anywhere else, the __NEXT_DATA__ block arrives with price: null. The scraper pins traffic through a US Apify data-center proxy by default; you don't have to configure that unless you want residential.
priceLines is an array, not an object. The current SSR shape is priceDetails.priceLines[0].values[{lineType: "COMPARISON", key: "WAS_PRICE", price, ...}]. If you're parsing __NEXT_DATA__ yourself and following old blog posts that read .priceDetails.wasPrice.price directly, you'll get None on every row — Walmart changed this in late 2024.
Category is nested on /ip/ detail pages. Search results give you a flat category leaf name (e.g. "Laptop Computers"). The product page gives it as a breadcrumb path; the scraper walks to the deepest node and returns the same string, so you can mix search and detail data in one category column.
The Rollback badge disappears when the sale ends — the wasPrice disappears with it, not just the badge. Keep historical rows so you can tell "the sale ended" apart from "the item was replaced".

Feedback welcome

If you'd like a specific feature — Target / Costco side-by-side, Discord/Slack webhook alerts, a flat-file CSV mode, filtering by brand or price band — the repo issues are open and I ship fixes within a day.

Code and more examples: github.com/huynhtanan/walmart-deals-tracker. Scraper: apify.com/zet46/walmart-search-scraper.

Track Amazon Best Sellers in 17 country stores with Python

huynhtanan — Thu, 15 Oct 2026 16:08:22 +0000

If you're monitoring e-commerce trends, running a brand, or feeding a shopping assistant, you probably want what's selling on Amazon right now — not next week, and not just in the US.

Amazon publishes the Best Sellers and Hot New Releases charts for every category, in 17 country stores, updated every hour. Scraping those pages is cheap and doesn't need a login — this post shows how to do it from Python in three ways: today's top sellers, a cross-marketplace comparison, and a daily tracker that logs rank + price changes into SQLite.

Code is in github.com/huynhtanan/amazon-bestsellers-tracker (MIT). Disclosure: I built the Apify scraper this uses; it's pay-per-result at $1 per 1,000 products, and new Apify accounts get free monthly credit that covers tens of thousands of items.

Setup

pip install "apify-client>=3"
export APIFY_TOKEN=...   # https://console.apify.com/settings/integrations (free account)

1. Today's top sellers in one category

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/amazon-best-sellers-scraper").call(run_input={
    "marketplace": "co.uk",
    "listType": "bestsellers",         # or "new-releases"
    "categorySlugs": ["electronics"],
    "maxItemsPerCategory": 20,
})
for it in client.dataset(run.default_dataset_id).iterate_items():
    print(f'#{it["rank"]:>3}  {it["title"][:60]:60}  {it.get("priceText") or "   --":>8}  '
          f'{it["rating"]} ({it["reviewsCount"]:,})')

Real output (UK, electronics):

#  1  Amazon Basics 20-Pack AA Alkaline High-Performance Batteries     £6.32  4.6 (930,935)
#  2  DURACELL Plus 9V Alkaline Batteries (2 Pack) 6LR61 | 100% Li     £5.42  4.7 (15,730)
#  3  Amazon Basics 40-Pack AA Alkaline Industrial Batteries, 1.5      £6.62  4.5 (101,364)
#  4  DURACELL 2032 Lithium Coin Batteries (4 Pack) 3V, CR2032 | U        --  4.7 (144,677)
#  5  DURACELL Plus AA Alkaline Batteries (30 Pack) 1.5V, LR06 | D    £15.41  4.8 (1,115)
#  6  Ring Battery Video Doorbell 2K (newest gen), DIY Wireless Do        --  4.2 (3,919)
#  7  Amazon Fire TV Stick HD (newest gen), free & live TV, Alexa         --  4.1 (5,055)

For books you also get byline (author) and format (Hardcover / Paperback / Kindle Edition). Here's amazon.de's current top 5 books (fiction heavy, with an entry for the Bürgerliches Gesetzbuch — Germany's civil code):

#1  Murdoku 1: 80 Logikrätsel rund um mysteriöse Mordfälle      11,76 €   Manuel Garand        Taschenbuch
#2  Bürgerliches Gesetzbuch: mit AGG und Verjährung              8,32 €                        Taschenbuch
#3  Der Nachtzug (limitierte Auflage): Psychothriller           24,30 €   Sebastian Fitzek     Gebundene Ausgabe
#4  Murdoku 2: Auf Zeitreise                                    11,76 €   Manuel Garand        Taschenbuch
#5  Heimsuchung: Roman                                          13,08 €   Jenny Erpenbeck      Taschenbuch

2. Compare one category across many marketplaces

Pass full URLs so each marketplace returns its own prices and currency without you keeping a (country, slug) mapping:

run = client.actor("zet46/amazon-best-sellers-scraper").call(run_input={
    "categoryUrls": [
        "https://www.amazon.com/gp/bestsellers/electronics",
        "https://www.amazon.co.uk/gp/bestsellers/electronics",
        "https://www.amazon.fr/gp/bestsellers/electronics",
        "https://www.amazon.it/gp/bestsellers/electronics",
        "https://www.amazon.co.jp/gp/bestsellers/electronics",
    ],
    "maxItemsPerCategory": 5,
})

Output:

amazon.com:
  #1  blink plus plan with monthly auto-renewal                 $11.99  4.4 (281,100)
  #2  Apple EarPods Headphones with USB-C Plug                  $19.00  4.5 (19,026)
  #3  Apple AirTag (2nd Generation)                             $24.00  4.6 (11,866)

amazon.co.uk:
  #1  Amazon Basics 20-Pack AA Alkaline High-Performance B       £7.58  4.6 (930,935)
  #2  DURACELL Plus 9V Alkaline Batteries (2 Pack)               £6.50  4.7 (15,730)

amazon.fr:
  #1  DURACELL 2032 Piles Boutons au Lithium (Lot de 8)       11,99 €  4.7 (979)
  #2  TOCOL Coque pour iPhone 15, Compatible avec MagSafe,     8,57 €  4.6 (417)

amazon.it:
  #1  NEW'C Pellicola Vetro per iPhone 17/17 Pro/16 Pro        8,19 €  4.4 (306,728)
  #2  Amazon Basics, 36 batterie alcaline AAA                  8,58 €  4.6 (855,344)

amazon.co.jp:
  #3  NIMASO ガラスフィルム iPhone 17 用 保護フィルム 強化ガラス               ￥1,357  4.3
  #4  Amazonベーシック 単3形 アルカリ乾電池 20本 1.5V 保存期限10年                 ￥759  4.3

A few things the data shows that are easy to miss if you only read amazon.com:

US electronics is dominated by Apple + Amazon devices. The UK is dominated by batteries (five of the top ten are AA / 9V / coin cells).
iPhone 17 is in the top-5 of both Italy and Japan as a case/accessory, before Apple's own cheapest earbuds show up. That's a signal for third-party accessory brands.
Review counts cross one million in multiple markets — much larger than I expected, and useful if you need "popularity floor" filters.

The scraper detects the marketplace and chart type (bestsellers / new-releases) per URL, so you can mix them in one request. It also sets the right lc-main + i18n-prefs cookies and Accept-Language header per country, so Amazon serves the local language and currency even though the outbound IP is in a single Apify data center.

3. Daily rank + price tracking in ~90 lines

Save one row per ASIN per day, print climbers, fallers, newcomers and dropouts. The whole thing fits in a SQLite table with 11 columns.

# track_rank.py — see github.com/huynhtanan/amazon-bestsellers-tracker/blob/main/python/track_rank.py
import os, sqlite3
from datetime import date
from pathlib import Path
from apify_client import ApifyClient

MARKETPLACE, LIST_TYPE, CATEGORY, TOP_N = "com", "bestsellers", "electronics", 100
DB = Path("amazon_rank.sqlite3")

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/amazon-best-sellers-scraper").call(run_input={
    "marketplace": MARKETPLACE, "listType": LIST_TYPE,
    "categorySlugs": [CATEGORY], "maxItemsPerCategory": TOP_N,
    "pagesPerCategory": (TOP_N + 29) // 30,
})
items = list(client.dataset(run.default_dataset_id).iterate_items())
today = date.today().isoformat()

with sqlite3.connect(DB) as con:
    con.execute("""CREATE TABLE IF NOT EXISTS ranks (
        run_date TEXT, marketplace TEXT, list_type TEXT, category TEXT,
        rank INTEGER, asin TEXT, title TEXT, price REAL, currency TEXT,
        rating REAL, reviews INTEGER,
        PRIMARY KEY (run_date, marketplace, list_type, category, asin))""")
    for it in items:
        con.execute("INSERT OR REPLACE INTO ranks VALUES (?,?,?,?,?,?,?,?,?,?,?)",
                    (today, MARKETPLACE, LIST_TYPE, CATEGORY,
                     it["rank"], it["asin"], it["title"],
                     it.get("price"), it.get("currency"),
                     it.get("rating"), it.get("reviewsCount")))

First run on amazon.com electronics (truncated):

Amazon.com bestsellers / electronics on 2026-10-15
(60 products tracked)

  #  1  blink plus plan with monthly auto-renewal                        11.99 USD
  #  2  Apple EarPods Headphones with USB-C Plug, Wired Ear Buds with    19.00 USD
  #  3  Apple AirTag (2nd Generation): Tracker for Keychain, Wallet, a   24.00 USD
  #  4  Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancell  199.00 USD
  #  5  Apple AirPods 5 Wireless Earbuds with Active Noise Cancellatio  129.00 USD

The full script also prints "new in the chart", "climbers (3+ positions up)", "fallers (3+ positions down)" and "dropped out" on day 2 and after — see the GitHub repo.

Because the data is a plain table, you can answer things like "which ASINs lost 10+ ranks since last week" with one SQL line:

WITH last_two AS (
  SELECT asin, title, rank,
         LAG(rank) OVER (PARTITION BY asin ORDER BY run_date) AS prev_rank
  FROM ranks WHERE marketplace='com' AND category='electronics')
SELECT asin, title, prev_rank, rank, rank - prev_rank AS delta
FROM last_two
WHERE prev_rank IS NOT NULL AND rank - prev_rank >= 10
ORDER BY delta DESC;

Running it every day

Two options, both free:

Apify Scheduler (zero infrastructure). On the actor page click Schedule actor, pick a cron (e.g. daily 09:00), save your input. Then from any machine run the script above with client.actor(...).last_run().get() to pull the latest completed dataset. No local cron, no server.
Local cron / Windows Task Scheduler. Call python track_rank.py daily. Each run also triggers a fresh scrape, so this is enough on its own.

Cost

$1 per 1,000 products returned. Tracking the top 100 of one chart daily for a month is 3,000 products = $3. Watching five country stores for the same category is still only $15/month.

Skipped items (via minRating, minReviews, or dedupe) are not charged.

A few things that bit me while building this

Amazon serves the local language and currency based on cookies, not IP. From a US-based scraper, amazon.de returns prices in dollars by default. You need lc-main=de_DE, i18n-prefs=EUR and Accept-Language: de-DE,de;q=0.9 on every request to get euros and the German review-count label (Sternebewertungen). The scraper does this per-marketplace automatically.
Prices on listing pages are only shown for some categories. Books always show a price. Electronics shows the price for ~40-60% of items, which is why you see -- in the examples above. If you need prices on everything, chain the ASINs into a per-product Amazon scraper after this one — the ASIN is the Amazon-wide product ID.
Review-count parsing is UI-language sensitive. 1,214 ratings on amazon.com is three different words on amazon.de (Sternebewertungen), amazon.fr (évaluations), amazon.it (valutazioni), amazon.co.jp (個の評価). The scraper has a regex union over 15 UI languages; still, a few less-common marketplaces may leave reviewsCount empty — rank, asin, title, url, image and rating are always set.
Movers & Shakers / Most Wished For / Gift Ideas need a residential IP — Amazon serves them empty from datacenter IPs. The scraper currently supports Best Sellers and Hot New Releases, which cover the two charts most people actually track.

Feedback welcome

If you'd like a specific feature (a specific marketplace that's missing, SQLite → Google Sheets sync, a Discord alert webhook, residential-proxy mode for the gift charts), the repo issues are open and I ship fixes within a day.

Code and more examples: github.com/huynhtanan/amazon-bestsellers-tracker. Scraper: apify.com/zet46/amazon-best-sellers-scraper.

Daily price tracking for competitor hotels, with Python and SQLite

huynhtanan — Thu, 15 Oct 2026 14:12:56 +0000

If you run a hotel, a travel site, or just a spreadsheet of competitors you want to keep an eye on, the question that comes up every morning is simple: are my competitors cheaper than me today, and by how much?

Google Hotels is the easiest place to answer it. For every hotel it shows the lowest price from 20-40 booking sites plus the hotel's own website, for the exact dates you pick, in any currency. There is no official API, but you can get the same data with a one-page Python script and a daily schedule.

This post shows the full setup. Code is in github.com/huynhtanan/google-hotels-api (MIT). Disclosure: I built the Apify scraper this uses; it's paid per result, new Apify accounts get free monthly credit that covers a few thousand hotels.

The script: one SQLite table, one function per concern

Give it a list of hotel names (or hotel URLs from Google Hotels) and a check-in date. Each run saves one row per hotel to a local SQLite file and prints how prices moved versus the previous observation.

# track_prices.py — see github.com/huynhtanan/google-hotels-api/blob/main/python/track_prices.py
import os, sqlite3
from datetime import date, timedelta
from pathlib import Path
from apify_client import ApifyClient

HOTELS   = ["Hilton Paris Opera", "Pullman Paris Tour Eiffel", "Le Meurice Paris"]
CHECK_IN = date.today() + timedelta(days=30)
DB       = Path("prices.sqlite3")

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/google-hotels-scraper").call(run_input={
    "queries": HOTELS, "maxHotelsPerQuery": 1,
    "checkIn": CHECK_IN.isoformat(),
    "checkOut": (CHECK_IN + timedelta(days=1)).isoformat(),
    "currency": "EUR",
})
items = list(client.dataset(run.default_dataset_id).iterate_items())

with sqlite3.connect(DB) as con:
    con.execute("""CREATE TABLE IF NOT EXISTS prices (
        run_at TEXT, hotel TEXT, check_in TEXT, nightly REAL,
        PRIMARY KEY (run_at, hotel, check_in))""")
    for h in items:
        con.execute("INSERT OR REPLACE INTO prices VALUES (?,?,?,?)",
                    (str(run.started_at), h["name"], CHECK_IN.isoformat(), h.get("pricePerNight")))

Full version (with the "DOWN 5.4% (was 280.00 on 2026-10-15)" comparison printing) is in the repo.

First run, then the next day

$ python track_prices.py
...Status: SUCCEEDED, Message: Done: 3 hotels from 3 queries

Prices on 2026-10-15 for check-in 2026-11-14 (EUR):

  Hilton Paris Opera                               280.00   (first observation)
  Le Meurice                                      1535.00   (first observation)
  Pullman Paris Tour Eiffel                        320.00   (first observation)

The next time the script runs it compares against the previous row for the same (hotel, check_in) and prints the direction and the diff:

  Hilton Paris Opera                               265.00   DOWN  5.4%  (was 280.00 on 2026-10-15)
  Le Meurice                                      1535.00   flat  0.0%  (was 1535.00 on 2026-10-15)
  Pullman Paris Tour Eiffel                        340.00     UP  6.3%  (was 320.00 on 2026-10-15)

Because the data lives in SQLite, you can plot the whole history or alert yourself with one SQL line:

-- competitors who undercut their own 7-day average by 10% or more
SELECT hotel, nightly, avg7
FROM (
  SELECT hotel, nightly, run_at,
         AVG(nightly) OVER (PARTITION BY hotel, check_in
                            ORDER BY run_at ROWS BETWEEN 7 PRECEDING AND 1 PRECEDING) AS avg7
  FROM prices)
WHERE avg7 IS NOT NULL AND nightly < avg7 * 0.9
ORDER BY run_at DESC;

Running it every day

Two options, both free:

Apify Scheduler (zero infrastructure). On the actor page click Schedule actor, pick a cron (e.g. daily 09:00), save your input (hotel list + dates). Then from any machine run the script above with client.actor(...).last_run().get() to pull the latest completed dataset. No local cron, no server.
Local cron / Windows Task Scheduler. Call python track_prices.py daily. Each run also triggers a fresh scrape, so this is enough on its own.

Cost

The scraper charges $2 per 1,000 hotels. Ten competitors tracked daily is ~300 hotels/month, so about $0.60/month. Turn on includeProviderPrices: true only if you also want the per-site breakdown (Booking.com vs Expedia vs the hotel's website); it doubles the per-hotel cost but lets you catch rate-parity breaks on specific channels.

A couple of things that bit me

pricePerNight is the nightly price including taxes that Google displays. totalPrice is the whole stay including taxes and fees. If you compare across sources, pick one and stick with it.
Dates and currency are not URL query parameters on Google Hotels; they are encoded in the ts protobuf blob. The scraper handles that for you, which is why calling it directly is a lot less work than parsing Google's HTML yourself.
Hotel names are matched by Google's own search, so "Hotel Lutetia Paris" may silently return 0 results if Google's suggest doesn't lock on; pass the hotel's Google Hotels URL (/travel/hotels/entity/<token>) via hotelUrls when you need to be exact.

Feedback welcome

If you'd like a specific feature (price by room type, SQLite -> Google Sheets sync, a Discord alert webhook), the Apify actor repo issues are open and I ship fixes within a day. Code and more examples: github.com/huynhtanan/google-hotels-api.

How to get Google Hotels prices for any dates with Python (and see which booking site is cheapest)

huynhtanan — Thu, 15 Oct 2026 13:04:31 +0000

Google Hotels is one of the best places to compare hotel prices: for every hotel it shows the rate on Booking.com, Expedia, Agoda, Hotels.com, the hotel's own website and a dozen smaller sites, for the exact dates you pick. There is no official API for it, though.

I needed this data for a price-monitoring project, so I built three scrapers for it and published them on Apify. This post shows how to use them from Python. Disclosure: I'm the author of these scrapers, and they are paid per result. New Apify accounts get free monthly credit, which covers a few thousand hotels.

All code is in this repo: github.com/huynhtanan/google-hotels-api

Setup

pip install "apify-client>=3"
export APIFY_TOKEN=...   # free account -> Settings -> API & Integrations

1. Every hotel in a city, for your dates, under a budget

import os
from datetime import date, timedelta
from apify_client import ApifyClient

check_in = date.today() + timedelta(days=30)
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zet46/google-hotels-scraper").call(run_input={
    "queries": ["Lisbon"],
    "checkIn": check_in.isoformat(),
    "checkOut": (check_in + timedelta(days=2)).isoformat(),
    "currency": "EUR",
    "maxHotelsPerQuery": 20,
    "maxPricePerNight": 200,
})
for h in client.dataset(run.default_dataset_id).iterate_items():
    print(h["name"], h["hotelClass"], h["pricePerNightText"], h["totalPrice"], h["rating"], h["reviewsCount"])

Real output (2 nights in November):

Brown's | Avenue Hotel                     5*   €171/night  total   378.16  rating 4.6 (282)
Dos Reis by The Beautique Hotels           4*   €104/night  total   235.54  rating 4.4 (423)
20-2 Lisbon Castle view apartment with Fre       €70/night  total   139.93  rating 5 (16)
Hotel Portugal - Portugal Boutique Hotel   4*   €128/night  total   285.90  rating 4.7 (1259)
Boutique Chiado Apartments & Suites        4*   €110/night  total   230.69  rating 4.6 (427)
Hotel Marquês de Pombal                    4*    €81/night  total   179.37  rating 4.4 (2460)
1908 Lisboa Hotel                          4*   €125/night  total   280.63  rating 4.7 (683)
Lisbon Wine House - Rooms & Suites         3*    €51/night  total   125.07  rating 3.7 (125)

Each hotel also comes with coordinates, check-in/out times, nearby places with travel times, photos, the hotel website, the rating distribution, and review topics: what guests mention, with positive and negative counts. For example, {"topic": "Location", "mentions": 342, "positive": 301, "negative": 16}.

Two details that bit me while building this:

Dates and currency are not URL parameters. Google Hotels encodes the search state in a protobuf blob in the ts query parameter, so ?checkin= is simply ignored. The scraper builds that blob for you.
Prices: pricePerNight is the nightly price including taxes. totalPrice is the whole stay including taxes and fees.

2. Which booking site is cheapest? (rate parity)

Set includeProviderPrices: true and each hotel gets the full list of booking sites, cheapest first, with direct booking links:

Hôtel CHEVALLIER  (20 booking sites, 38% spread)
   Hotels.com                      $64
   Expedia.com                     $66
   Travelocity.com                 $66
   Orbitz.com                      $66
   CheapTickets.com                $66
Hôtel Madame Rêve  (33 booking sites, 45% spread)
   Traveluro                      $536
   trivago DEALS                  $541
   Evendo                         $559
   Super.com                      $577
   Clicktrip.com                  $592
Glint Paris  (16 booking sites, 58% spread)
   Booking.com                     $81

The spreads are bigger than I expected: 38% for a small hotel, 58% for Glint Paris, where Booking.com was cheaper than the hotel's own website. If you work in hotel revenue management, this is a rate parity check. If you build travel apps, it's the "cheapest place to book" feature.

3. The cheapest nights to book a specific hotel

The price calendar scraper checks one hotel for every check-in date in a range:

run = client.actor("zet46/google-hotels-price-calendar").call(run_input={
    "hotels": ["Hilton Paris Opera"], "numberOfDates": 30, "nights": 1, "currency": "USD",
})

Hilton Paris Opera: 5 cheapest nights in the next 30 days
  2026-11-01 (Sun)  $314 on KAYAK.com
  2026-11-08 (Sun)  $314 on KAYAK.com
  2026-11-14 (Sat)  $314 on KAYAK.com
  2026-10-26 (Mon)  $315 on Expedia.com
  2026-11-02 (Mon)  $327 on KAYAK.com
Average: 477.89 | most expensive: 2026-10-24

The cheapest night was 34% below the 30-day average. That's useful for flexible travelers, and for anyone tracking how a competitor prices weekends versus weekdays.

4. Vacation rentals

Google Hotels also lists apartments and villas from Vrbo, Booking.com, Expedia, HomeToGo and others. The rentals scraper adds bedrooms, bathrooms, guests and amenities, plus filters (filtered-out rentals aren't charged):

LOVELY FLAT. GREAT LOCATION, CASTLE VIEWS AND Entire apartment   sleeps 4, 2 bd   $193/night  rating 4.82
Alfama River View | Balcony | Families | Fast Entire apartment   sleeps 4, 2 bd   $123/night  rating 4.78
WHome City View Penthouse Luxurious Living in Entire apartment   sleeps 8, 3 bd   $224/night  rating 4.75
Alecrim 3 Luxury Tailor Made Flat With a View Entire apartment   sleeps 4, 2 bd   $243/night  rating 4.79
2 Bedroom Apartment with Great Transport Link Entire apartment   sleeps 4, 2 bd    $65/night  rating 4

Bonus: give an AI agent live hotel prices

All three scrapers work through Apify's MCP server, so Claude, Cursor or any MCP client can call them:

{"mcpServers": {"apify": {"url": "https://mcp.apify.com?tools=zet46/google-hotels-scraper,zet46/google-hotels-price-calendar"}}}

Then ask "Find 4-star hotels in Lisbon under 150 EUR for 12-14 December and tell me which site is cheapest."

Cost

Hotels: $2 per 1,000.
Booking-site prices: +$2 per 1,000 hotels, only when you turn them on.
Price calendar: $1.50 per 1,000 date prices.

A 30-day calendar for one hotel costs about $0.05.

Code and examples: github.com/huynhtanan/google-hotels-api. Feedback and feature requests are welcome in the comments.

DEV Community: huynhtanan

Add Google Hotels to Claude Desktop as an MCP server (2-minute setup)

1. Get an Apify token

2. Add the MCP server to Claude Desktop

3. Ask Claude a real question

Two more prompts that are useful

Pricing

How it compares

Links

Related tutorials

Track Walmart Rollback deals with Python and SQLite

Setup

1. All Rollback items on one search page, with discount %

2. Daily rollback tracker in SQLite

3. "Deeper than yesterday" alerts

4. Fetch a specific product by URL

Cost

A few things that bit me while building this

Feedback welcome

Related tutorials

Track Amazon Best Sellers in 17 country stores with Python

Setup

1. Today's top sellers in one category

2. Compare one category across many marketplaces

3. Daily rank + price tracking in ~90 lines

Running it every day

Cost

A few things that bit me while building this

Feedback welcome

Related tutorials

Daily price tracking for competitor hotels, with Python and SQLite

The script: one SQLite table, one function per concern

First run, then the next day

Running it every day

Cost

A couple of things that bit me

Feedback welcome

Related tutorials

How to get Google Hotels prices for any dates with Python (and see which booking site is cheapest)

Setup

1. Every hotel in a city, for your dates, under a budget

2. Which booking site is cheapest? (rate parity)

3. The cheapest nights to book a specific hotel

4. Vacation rentals

Bonus: give an AI agent live hotel prices

Cost

Related tutorials