DEV Community: Tedj MEABIOU

Agoda hotel prices and a per-date price calendar for any city (Python + n8n)

Tedj MEABIOU — Tue, 08 Sep 2026 12:00:03 +0000

Agoda's results page does not arrive priced: it fires a search, then re-polls until each property has a rate — which is why a browser-driven agoda scraper scrolls, waits and still misses the last poll. The same call takes a flag that makes it answer complete. This is how to read agoda prices for a whole destination on exact dates, with a per-date price calendar for the properties you follow.

1. One request, one row per property

The Agoda Prices Scraper on Apify takes destinations, property URLs, ids or names, plus a stay (checkIn, nights, adults, children, childAges, rooms, currency), and returns one hotel row per property.

curl -X POST "https://api.apify.com/v2/acts/kestrel~agoda-prices-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN&timeout=300" \
  -H "Content-Type: application/json" \
  -d '{"locationQueries": ["Lisbon"], "checkIn": "30 days", "nights": 2, "adults": 2, "currency": "EUR", "sortBy": "price_low", "maxHotelsPerQuery": 100}'

A hotel row:

{ "type": "hotel", "mode": "destination", "hotel_id": "13505436", "hotel_name": "Help Yourself Hostels - Restelo",
  "url": "https://www.agoda.com/help-yourself-hostels-restelo/hotel/all/lisbon-pt.html", "property_type": "Hotel",
  "stars": 2.0, "review_score": 6.8, "review_count": 120, "agoda_score": 6.5,
  "city": "Lisbon", "area": "Belem", "country_code": "PT",
  "check_in": "2026-09-28", "check_out": "2026-09-29", "nights": 1, "adults": 2, "rooms": 1, "currency": "USD",
  "price_nightly": 44.71, "price_nightly_with_taxes": 60.67, "price_total": 44.71, "price_total_with_taxes": 60.67,
  "crossed_out_price": null, "available_rooms": 1, "cancellation": "FreeCancellation", "free_cancellation": true,
  "breakfast_included": false, "sold_out": false, "rank": 46, "sort": "price_low" }

price_nightly is the cheapest rate per room per night before taxes — Agoda's display price — and price_total_with_taxes is what the booking would cost: the pair a hotel price comparison needs. crossed_out_price is the struck-through rate when a discount is shown, cancellation and breakfast_included say whether two rates are comparable at all, and available_rooms is what is left.

2. Why one call is enough

The results page calls a citySearch operation on Agoda's /graphql/search. The actor sends the same request with synchronous: true — the flag the site's own client sets once it stops polling — so one answer carries 45 priced properties, already structured, and paging is the next 45. Named properties use Agoda's "extra property" slot: a small answer each, no page read. Destinations, URLs and names resolve through Agoda's autocomplete; a property reached twice is delivered once.

Two behaviours matter. A property Agoda lists but cannot price for your stay is not a zero: it arrives with sold_out: true and empty prices — free, and only if you ask with includeSoldOut. And a throttled session is never an empty destination — the proxy session rotates and retries, and only if every attempt is refused does the input become an error.

3. Filters that run before billing

maxPrice, minStars, minReviewScore and freeCancellationOnly run on the actor before the charge call, so a property a filter removes is never billed.

{ "locationQueries": ["Lisbon", "Porto"], "checkIn": "6 weeks", "nights": 3, "adults": 2, "children": 1, "childAges": ["7"],
  "rooms": 1, "currency": "EUR", "sortBy": "price_low", "maxHotelsPerQuery": 300, "maxPrice": 90,
  "minReviewScore": 8, "freeCancellationOnly": true, "includeSoldOut": true }

That is a standing sweep for well-reviewed, free-cancellation stays under €90 in two cities. It reads the pages either way but bills only what it hands you, so a weekend when nothing qualifies costs nothing — the free status row still reports hotels, filtered, sold_out_hotels and pages.

4. Python: a city's ladder, then the price calendar

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(inp, kind="hotel"): return [r for r in client.dataset(client.actor("kestrel/agoda-prices-scraper").call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == kind]

city = rows({"locationQueries": ["Lisbon"], "checkIn": "6 weeks", "nights": 2, "adults": 2, "currency": "EUR", "sortBy": "price_low", "maxHotelsPerQuery": 200})
for r in city[:10]: print(f'{r["price_nightly"]:7.2f} {r["price_total_with_taxes"]:8.2f}  {r["review_score"]}  {r["hotel_name"]}')

cal = rows({"hotelIds": ["6988894", "63820"], "checkIn": "2026-10-10", "nights": 3, "adults": 2, "currency": "EUR", "calendarDays": 60}, kind="calendar")
for r in sorted(cal, key=lambda r: r["price_nightly"])[:5]: print(r["hotel_name"], r["check_in"], r["price_nightly"], r["trend"], r["cheapest_in_window"])

The first run is a hotel rate scraper reading a destination's price ladder for one stay, cheapest first, taxed total beside display price. The second asks two named properties how the same three-night stay moves by check-in date: one calendar row per date, with Agoda's trend flag (Low, Normal, High), rank_in_window and cheapest_in_window. That calendar is sparse by design — only dates Agoda has a cached price for come back, so a quiet property returns a handful and a busy one most of the window. It answers "when is this cheap", not "is this bookable". For the guest side, the Agoda Reviews Scraper takes the same hotel_id.

5. Hotel price monitoring on a schedule (n8n)

checkIn takes relative dates — "30 days", "6 weeks", "tomorrow" — so a scheduled run prices the same lead time every day and rows line up on hotel_id and check_in. Copy the Google Flights template in the n8n/ folder of kestrel-actors-examples: a 07:00 Schedule trigger, an HTTP Request to the run-sync endpoint with the section 3 body and a 300 s timeout, a Code node holding yesterday's price_nightly per hotel_id, an IF on the drop, Telegram or Slack.

6. Cost and limits

$0.004 per priced hotel row, $0.002 per calendar day. A 100-property city sweep is $0.40; twenty named hotels with a 30-day calendar, of which about 18 dates come back priced, is $0.08 + $0.72 = $0.80 a day. Sold-out properties, status rows, duplicates and anything a filter removed are free.
Prices are for the party and dates you ask for; Agoda's member and app discounts are not in the row.
The row is the cheapest rate on the property card — one room type, one supplier — not the room grid.
The actor reads public, logged-out price listings — the same data Agoda publishes to search engines and metasearch partners — and stores no personal data. Using it for price comparison, market research and revenue management is a normal business use; check Agoda's terms and your local law before republishing prices commercially, keep the pacing sensible, and do not use the data to interfere with Agoda's service.

That is the feed: one synchronous call for a destination's agoda hotel prices, a sparse calendar for the properties you follow. Full reference on the actor page: apify.com/kestrel/agoda-prices-scraper.

Every actor's inputs, output fields, a sample row and its honest limits are documented at mtedj.github.io/kestrel-actors-examples, including a side-by-side comparison of every review scraper — what each source really carries and where its ceiling is.

TripAdvisor hotel reviews in 30 site languages, without a browser (Python)

Tedj MEABIOU — Mon, 07 Sep 2026 12:00:06 +0000

TripAdvisor has no public API for review text and its pages sit behind DataDome, so most tools that read them drive a headless browser. They do not have to: the full record is already in the HTML the server sends, ten reviews to a page, paged by a plain offset. This is how to read TripAdvisor reviews as rows in thirty site languages, with no browser and no key.

1. One request, one row per review

The TripAdvisor Reviews Scraper on Apify is a hotel reviews scraper: give it hotel URLs, TripAdvisor location ids (the d<number> in a URL) or hotel names, get reviews as rows.

curl -X POST "https://api.apify.com/v2/acts/kestrel~tripadvisor-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locationIds": ["4509998"], "maxReviewsPerHotel": 50, "languages": ["en"]}'

A review row:

{ "type": "review", "review_id": "1075128384", "hotel_name": "Memmo Alfama Hotel",
  "language": "en", "original_language": "en", "translated": false, "title": "A Gem in the Heart of Alfama",
  "text": "This place is a gem — a gorgeous haven in the heart of Alfama, just off tram 28.",
  "rating": 5, "sub_ratings": {"value": 4, "rooms": 4, "location": 5, "cleanliness": 5, "service": 5, "sleep_quality": 5},
  "review_date": "2026-08-27", "stay_date": "2026-08-31", "trip_type": "COUPLES", "helpful_votes": 0,
  "reviewer_name": "Frank S", "reviewer_contributions": 391, "reviewer_hometown": "Brooklyn, New York",
  "photos": [], "response": "Dear Frank, thank you so much for your incredible review",
  "url": "https://www.tripadvisor.com/ShowUserReviews-g189158-d4509998-r1075128384-Memmo_Alfama_Hotel-Lisbon.html" }

rating is 1–5 bubbles; sub_ratings carries the six aspects a reviewer can score on their own — value, rooms, location, cleanliness, service, sleep quality — and only the ones they filled in. stay_date is the month of the stay, trip_type one of FAMILY, COUPLES, SOLO, BUSINESS, FRIENDS or null.

2. Why no browser is needed

A review page is /Hotel_Review-g<geo>-d<id>-Reviews-or10-…html: or10 is the review offset and page three or20. It is server-rendered, with the whole record — sub-ratings, reviewer profile, management response — inside its hydration payload, a JSON.parse("…") literal in the bootstrap script.

DataDome reads the TLS handshake, not the traffic pattern: datacenter ranges are refused outright and Chrome-shaped clients challenged, while a residential IP with a Firefox fingerprint is served at a page per second. A refused page is rotated onto a fresh session; a hotel that never comes through is error, never no_reviews.

3. Language is the domain

TripAdvisor is not one site. tripadvisor.com serves English, tripadvisor.de German, tripadvisor.fr French, and each domain carries the reviews written in its own language plus machine translations of the rest. languages is therefore a list of hosts — thirty, from de and ja to en-sg — and one hotel × one language is one job. Each row names the site it was read on (language), what the guest wrote in (original_language) and whether this is a translation (translated); includeTranslated: false keeps each review once, in its author's words.

{ "locationIds": ["4509998", "228423"], "hotelNames": ["The Lumiares Lisbon"], "languages": ["en", "de", "fr"],
  "includeTranslated": false, "maxRating": 3, "requireText": true, "tripTypes": ["business", "solo"],
  "sinceDate": "6 months", "maxReviewsPerHotel": 0 }

maxRating, tripTypes, sinceDate and requireText run before billing, so what they drop is never charged, and sinceDate stops the paging once a whole page predates it. A URL, its id and its name are one hotel, read once.

4. Python: which aspect each hotel loses on

import os, statistics
from collections import Counter, defaultdict
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(inp): return [r for r in client.dataset(client.actor("kestrel/tripadvisor-reviews-scraper").call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == "review"]

comp = rows({"locationIds": ["4509998", "228423", "190364"], "languages": ["en", "de", "fr"],
             "includeTranslated": False, "sinceDate": "12 months", "requireText": True, "maxReviewsPerHotel": 0})
aspects = defaultdict(list)
for r in comp:
    for aspect, bubbles in (r["sub_ratings"] or {}).items(): aspects[(r["hotel_name"], aspect)].append(bubbles)
for (hotel, aspect), v in sorted(aspects.items(), key=lambda kv: statistics.mean(kv[1]))[:10]: print(f"{statistics.mean(v):.2f}  {len(v):4}  {hotel:30} {aspect}")
print(Counter(r["language"] for r in comp), sum(r["response"] is None for r in comp), "of", len(comp), "unanswered")

Three hotels, a year of guest feedback in three languages, and the first ten lines are each property's weakest aspect and how many guests scored it — counted, no text model anywhere. The last line is the reputation one: how many reviews nobody answered. The Booking.com Reviews Scraper is the second corpus beside it: no aspect scores, but it splits what guests liked from what they did not.

5. Review monitoring on a schedule (n8n)

The Agoda template in the n8n/ folder of kestrel-actors-examples is the workflow to copy: an 08:00 Schedule trigger, an HTTP Request to the run-sync endpoint, a Code node dropping ids seen before, an IF, a Sheets append and a Slack message. For a tripadvisor scraper feed, send the section 3 body with sinceDate: "2 days" and dedupe on review_id plus language — a German review read from two sites is one review, twice.

6. Cost and limits

$0.005 per delivered review row; hotel and status rows, filtered reviews, unknown ids and duplicates are free. A hotel's whole English corpus of 1,456 reviews is $7.28; ten hotels at their 500 newest, $25 once — the daily feed after it costs cents a month.
Pages come newest first and there is no rating sort, so maxRating still reads the pages it filters — pair it with sinceDate or a cap.
The free hotel row carries reviews_by_language; review_count is the all-language total; one site lists far fewer.
Hotels only; restaurants and attractions have other page shapes.
The actor reads public review pages that any visitor sees without logging in. Reviews are user-generated content published under a public name or handle: if you build a product on top, you are the data controller for whatever you keep, so retain what you need and respect deletion. Read TripAdvisor's terms before scraping at scale — they restrict automated access, and the responsibility for how the data is used is yours. Do not republish reviews wholesale; do use them to understand what guests say about a property.

That is the feed: the record already in the page, the right IP and TLS to reach it, one domain per language. Full reference on the actor page: apify.com/kestrel/tripadvisor-reviews-scraper.

Amazon product details by ASIN in 20 marketplaces: buybox price, stock, gallery, details table (Python)

Tedj MEABIOU — Sun, 06 Sep 2026 12:00:02 +0000

Turning an ASIN into amazon product data — price, stock, gallery, bullets, details — means reading the product page, since the Product Advertising API needs an approved associate account. This is an amazon asin lookup as one row per product in 20 marketplaces, the buybox rule, and why the currency depends on where the request leaves from.

1. One request, one row per ASIN

The Amazon Product Scraper on Apify is an amazon product scraper that takes ASINs or product URLs and returns one product row each.

curl -X POST "https://api.apify.com/v2/acts/kestrel~amazon-product-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"asins": ["B0CHWRXH8B", "B09B8V1LZ3", "B0BSHF7WHW"], "domain": "com"}'

A product row (gallery shortened):

{ "type": "product", "asin": "B09B8V1LZ3", "domain": "com", "marketplace": "US", "url": "https://www.amazon.com/dp/B09B8V1LZ3?th=1&psc=1",
  "title": "Amazon Echo Dot (newest model), Vibrant sounding Alexa speaker, Great for bedrooms, dining rooms and offices, Charcoal", "brand": "Amazon",
  "price": 54.99, "price_display": "$54.99", "currency": "USD", "list_price": 79.99, "list_price_display": "$79.99",
  "availability": "In Stock", "in_stock": true, "prime": false, "rating": 4.7, "ratings_count": 198808,
  "image": "https://m.media-amazon.com/images/I/61J2sQtBYDL._AC_SL1000_.jpg", "images": ["https://m.media-amazon.com/images/I/61J2sQtBYDL._AC_SL1000_.jpg", "https://m.media-amazon.com/images/I/71xoR4A6q-L._AC_SL1500_.jpg"],
  "features": ["Our most popular smart speaker with a fabric design. It is our most compact smart speaker that fits perfectly into small spaces."],
  "description": null, "breadcrumbs": null, "category": null, "details": null, "bsr": null, "bsr_top": null, "date_first_available": null, "sold_by": null, "variations_count": 3,
  "5_star_pct": 82, "4_star_pct": 11, "3_star_pct": 4, "2_star_pct": 1, "1_star_pct": 2, "fetched_at": "2026-08-29T10:31:04+00:00" }

images is the gallery, highest resolution first; details the Product information, Technical details and Product overview tables merged into one object; breadcrumbs null on most amazon.com pages. bsr is best-effort: Amazon renders Best Sellers Rank for some sessions only, never invented.

2. The buybox price, and only the buybox price

A product page prints many prices: other sellers, bundles, carousels. Take the first one and you are wrong on the pages that matter: an earlier page-wide approach labelled a discontinued iPad at 149 GBP, a carousel neighbour's price on a page with no buying option. This actor reads the buybox block only: price is what Buy now would charge, list_price the struck-through figure when shown, and an unavailable product has a null price with the rest filled in. in_stock comes from the availability wording, then from whether a buybox price exists; otherwise null, and null is not "in stock".

3. Twenty marketplaces, and where the currency comes from

domain sets the marketplace for bare ASINs (com, co.uk, de, co.jp and sixteen more); a URL's marketplace wins. The same ASIN on two marketplaces is two products.

{ "asins": ["B09B8V1LZ3", "https://www.amazon.co.uk/dp/B09B8V1LZ3"], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } }

Amazon localises the buybox to the caller's location, not the marketplace: a co.uk page fetched through a US egress is priced in USD, or shows no offer, so currency is read from the printed price. Datacenter proxies do for amazon.com; with RESIDENTIAL the run routes through the marketplace's own country unless you set one, and the co.uk buybox appears in GBP.

4. Filters before billing, unknown ASINs free

inStockOnly keeps products whose availability line says in stock; maxPrice keeps products at or under a figure in the marketplace's currency. Both run before billing: a verified run over the three ASINs above with inStockOnly: true and maxPrice: 100 delivered one row, the $54.99 speaker, and dropped the $263.86 earbuds and the discontinued laptop with free status rows saying filtered. An unknown ASIN is not_found after one attempt, free; a captcha that survives five IP rotations is blocked, free.

5. Python: from a chart to product rows to reviews

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(actor, inp, kind="product"): return [r for r in client.dataset(client.actor(actor).call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == kind]

chart = rows("kestrel/amazon-best-sellers-scraper", {"categories": ["electronics/headphones"], "chart": "bestsellers", "domain": "com"})
products = rows("kestrel/amazon-product-scraper", {"asins": [r["asin"] for r in chart if r["rank"] <= 20], "domain": "com"})
for r in products:
    cut = round(100 * (1 - r["price"] / r["list_price"])) if r["price"] and r["list_price"] else 0
    print(r["asin"], r["price_display"], f"-{cut}%", r["in_stock"], r["sold_by"], len(r["images"] or []), len(r["features"] or []))
reviews = rows("kestrel/amazon-reviews-scraper", {"asins": [r["asin"] for r in products if len(r["images"] or []) < 5], "domain": "com", "requireText": True}, kind="review")

The ASINs come from the Best Sellers chart; the Amazon Search Scraper's asin column feeds the same input from a keyword. The loop is the amazon price scraper question — which top-20 discounts are cuts against a list price nobody paid — and a content audit; thin listings go to the Amazon Reviews Scraper for the text behind rating, 8–13 public reviews per product.

6. A daily price and stock check (n8n)

Every row is stamped fetched_at, so a scheduled run over a fixed list is a price history by asin, with a changed sold_by showing a lost buybox. In n8n: a Schedule trigger, an HTTP Request to the run-sync endpoint with the section 1 body, a Filter on type = product, a Code node comparing price with yesterday's in static data, an IF, Slack. The Amazon Best Sellers rank tracker in the n8n/ folder of kestrel-actors-examples has that comparison written.

7. Cost and limits

$0.004 per product row: 500 ASINs daily is $2 a day, $1 with inStockOnly on a catalogue where half the listings are dead. status rows, filtered products, duplicates, not_found and blocked are free.
availability and details labels arrive in the marketplace's language.
The actor reads publicly available product pages — the same data a shopper sees without logging in — and stores nothing personal. Price, availability, rating and product descriptions are facts about products, not people. Scraping public data is legal in most jurisdictions for legitimate purposes such as price comparison, market research and catalogue management, but you are responsible for how you use it: respect the site's terms, keep request rates modest (the defaults are), and do not republish copyrighted images or descriptions as your own.

That is the amazon product api most people want: one row per ASIN, the buybox price or null, filters before billing. Full reference on the actor page: apify.com/kestrel/amazon-product-scraper.

Booking.com hotel prices for a whole city and exact dates, without a browser (Python + n8n)

Tedj MEABIOU — Sat, 05 Sep 2026 12:00:03 +0000

Booking.com prices are the reference rate for most hotel inventory, and every Booking page answers a script with an AWS WAF challenge, so a typical booking.com scraper drives a headless browser through the results. The results page loads its list from a search call that needs no browser. This is how to get booking.com prices for a whole destination, on exact dates and for your party, as rows, and how to keep a hotel rate scraper running every morning.

1. One request, one row per property

The Booking.com Scraper on Apify takes destinations as typed into Booking's search box, or property URLs, names and ids, plus a stay (checkIn, nights, adults, childrenAges, rooms, currency), and returns one hotel row per property.

curl -X POST "https://api.apify.com/v2/acts/kestrel~booking-prices-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locationQueries": ["Lisbon"], "maxHotelsPerQuery": 100, "checkIn": "6 weeks", "nights": 2, "adults": 2, "currency": "EUR", "sortBy": "price"}'

A hotel row:

{ "type": "hotel", "hotel_id": "536251", "name": "Memmo Alfama - Design Hotels", "url": "https://www.booking.com/hotel/pt/memmo-alfama.html",
  "property_type": "hotel", "stars": 4, "review_score": 9.3, "review_count": 894, "city": "Lisboa", "country_code": "pt",
  "display_location": "Santa Maria Maior, Lisbon", "distance_from_center": "0.8 km from downtown",
  "check_in": "2026-09-28", "check_out": "2026-09-29", "nights": 1, "adults": 2, "currency": "EUR",
  "price_total": 415.09, "price_nightly": 415.09, "price_display": "€ 415.09", "hotel_currency": "EUR",
  "taxes_included": true, "free_cancellation": true, "breakfast_included": true,
  "room_name": "Superior Double Room with Terrace", "rooms_listed": 3, "sold_out": false, "rank": 1, "query": "Memmo Alfama Lisbon" }

price_total is the lowest total for the stay and party, price_nightly that divided by nights; taxes_included, taxes_fees_excluded and charges_note say what it leaves out. free_cancellation, no_prepayment and breakfast_included say whether two rates are comparable; room_name is the room behind the price; latitude and longitude place it.

2. Why no browser is needed

Every Booking.com page sits behind AWS WAF. The results page, once loaded, calls a GraphQL operation named FullSearch on Booking's /dml/graphql endpoint, 100 properties per page, and that call is served without the WAF token — on residential IPs. A datacenter address gets the same 202 challenge as a page, so the default proxy is Apify's RESIDENTIAL group. The WAF also reads the TLS handshake, so the transport presents Chrome's fingerprint rather than Python's.

Destinations go through Booking's autocomplete, also outside the WAF. hotelNames and startUrls (a URL carries no id) take the same path, hotelIds skips it, and a property seen twice — in two destinations, or as a URL and its id — is billed once.

3. Filters before billing, sold-out rows free

minStars is passed to Booking as its own star filter, so those properties are never fetched. maxPrice drops rows whose nightly rate is above the line before billing. Sold-out properties arrive free with sold_out: true, sold_out_message, alternative_check_in and alternative_check_out; with maxPrice set they are dropped.

{ "locationQueries": ["Algarve"], "maxHotelsPerQuery": 200, "checkIn": "2026-10-10", "nights": 7, "adults": 2, "childrenAges": [5, 9], "rooms": 1, "currency": "GBP", "sortBy": "review_score", "minStars": 4, "maxPrice": 180 }

sortBy decides completeness: price, review_score, stars and distance are deterministic; the default popularity is personalised and reshuffles between pages.

4. Python: a city's price ladder, then a comp set with rooms

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(inp, kind="hotel"): return [r for r in client.dataset(client.actor("kestrel/booking-prices-scraper").call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == kind]

city = rows({"locationQueries": ["Lisbon"], "maxHotelsPerQuery": 100, "checkIn": "6 weeks", "nights": 2, "adults": 2, "currency": "EUR", "sortBy": "price"})
priced = [r for r in city if r["price_total"] is not None]
print(len(priced), "priced,", len(city) - len(priced), "sold out;", sum(r["price_nightly"] <= 120 and r["free_cancellation"] for r in priced), "under 120 EUR with free cancellation")

comp = rows({"hotelIds": ["536251", "2251985", "1471925"], "checkIn": "30 days", "nights": 1, "adults": 2, "currency": "USD", "includeRooms": True}, kind="room")
for r in sorted(comp, key=lambda r: r["price_nightly"]): print(r["hotel_name"], r["room_name"], r["meal_plan"], r["price_nightly"], r["free_cancellation_until"], r["only_x_left"])

The first run is the cheapest 100 places in Lisbon for a weekend and how many sit under a budget with free cancellation; raise maxHotelsPerQuery to the total in the free status row and the ladder is the whole city. The second is a comp set by id with includeRooms: one room row per room and rate, with meal plan and cancellation deadline, so a non-refundable room-only rate is not mistaken for undercutting. For hotel price comparison across sites, the Hotel Rate Parity Checker reads Google's view of the same stay, every booking site side by side.

5. Hotel price monitoring on a schedule (n8n)

checkIn takes relative dates — "30 days", "6 weeks", "tomorrow" — so a scheduled run prices the same lead time every day and rows line up on hotel_id and check_in. There is no hotel template in the n8n/ folder of kestrel-actors-examples yet; copy the Google Flights one: a 07:00 Schedule trigger, an HTTP Request to the run-sync endpoint with the section 1 body, a Code node keeping yesterday's price_nightly per hotel_id in workflow static data, an IF on the drop, Telegram or Slack. Filter type = hotel and sold_out = false first.

6. Cost and limits

$0.004 per priced hotel row, $0.002 per room row. A 100-hotel city sweep is one request and $0.40; a daily comp set of 10 hotels with about 60 room rows is $0.16 a day. Sold-out properties, status rows, duplicates and anything a filter removes are free.
Prices are for the party you ask for; Genius member rates are not visible; the row says whether the total includes taxes.
The actor reads the publicly visible prices and property facts that Booking.com shows every anonymous visitor for the dates and party you specify — no login, no personal data, nothing behind an account. Prices are facts, not copyrighted works. Whether your use complies with Booking's terms and with the laws where you operate is your responsibility; keep the request rate reasonable, do not resell Booking's data as your own, and attribute where you publish comparisons.

That is the feed: one search call outside the WAF, filters before billing, a relative date on a schedule. Full reference on the actor page: apify.com/kestrel/booking-prices-scraper.

HRS hotel reviews: twelve category votes from business travellers, twenty hotels per request

Tedj MEABIOU — Fri, 04 Sep 2026 12:00:05 +0000

HRS is the German corporate-travel booking platform: companies put their hotel programme on it and staff book through it, so an HRS rating is usually a business traveller's. A rating is also more than a score and a paragraph — twelve category votes, the traveller type and age group on the booking — and the ratings endpoint returns a hotel's whole comment list in one answer, twenty hotels per request. This is how to read hrs reviews as rows, why a 100-hotel comp set is five requests, and why the proxy must be residential.

1. One request, one row per commented rating

The HRS Reviews Scraper on Apify takes HRS hotel URLs or the numeric id after /hotel/ and returns hrs hotel reviews as rows, through the JSON endpoint the hotel page's own ratings dialog loads. No login, no browser, no API key.

curl -X POST "https://api.apify.com/v2/acts/kestrel~hrs-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN&timeout=300" \
  -H "Content-Type: application/json" \
  -d '{"hotelIds": ["10520"], "maxReviewsPerHotel": 30, "reviewsSort": "most_recent", "proxyConfiguration": {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}}'

A review row:

{ "type": "review", "review_id": "315653282", "hotel_id": "10520", "hotel_name": "Bilderberg Bellevue Hotel Dresden",
  "rating": 9.36, "rating_5": 4.68,
  "positives": "Tolle Lage direkt an der Elbe und fußnah zu Altstadt", "negatives": null,
  "hotel_reply": "Das klingt nach einer schönen Zeit in Dresden! Wir freuen uns, dass Sie bei der Gelegenheit mit uns als Ihren Gastgeber geplant haben.",
  "traveller_type": "PRIVATE", "age_group": "OVER_59", "language": "deu",
  "arrival_date": "2025-12-08", "departure_date": "2025-12-11", "nights": 3, "review_date": "2025-12-11T14:28:35Z",
  "votes": { "FRIENDLINESS_OF_RECEPTION": 10, "SERVICE_OF_HOTEL_EMPLOYEES": 10, "HOTEL_AMBIANCE": 9, "ROOM_CONFIGURATION": 10, "HOTEL_TIDINESS": 10, "SANITARY_FACILITIES": 8, "ROOM_SIZE": 10, "BREAKFAST_SERVICE": 9, "RESTAURANT_SERVICE": 0, "PRICE_PERFORMANCE_RATIO": 9, "WELLNESS_RANKING": 8, "QUALITY_OF_BEDS": 10 },
  "fetched_at": "2026-08-29T10:20:11+00:00" }

rating is HRS's 0–10 score, rating_5 the same out of five, votes the twelve categories behind it (0 = not rated). positives and negatives are the guest's two boxes, hotel_reply the hotel's answers to each, joined. traveller_type is one of eight HRS booking types (BUSINESS, CONFERENCE, PRIVATE …), age_group UP_TO_59 or OVER_59, and language an ISO 639-2 code.

2. Twenty hotels per request, only the commented ratings

The ratings endpoint has no paging: one answer holds a hotel's whole comment list, and one request takes up to twenty hotel ids. A comp set of 100 hotels is five requests, plus one page per hotel for the name unless includeHotelRow is off. maxReviewsPerHotel is a cost cap applied after reviewsSort, not a saving on requests.

Only ratings with a written comment become rows: rating_count counts every rating HRS has and comment_count the ones with text — a property may show 150 and 85. Both sit on the free hotel row (with avg_by_category and ratings_by_traveller_type) and on the status row as total and comments.

The proxy is not optional: hrs.com and its ratings API answer 403 to datacenter IPs, so the input defaults to Apify's RESIDENTIAL group; traffic is about 100 KB of JSON per hotel plus the page.

3. Business travel hotel reviews, filtered before billing

travellerTypes: ["BUSINESS"] is asked of HRS directly, so nothing else downloads; languages: ["de"] keeps German comments; maxRating: 7 keeps ratings at or below 7 (a middling stay here); requireText guarantees every billed row carries text. Dropped rows count as filtered, never charged.

{ "startUrls": ["https://www.hrs.com/de/hotel/162"], "travellerTypes": ["BUSINESS"], "languages": ["de"], "language": "de", "maxReviewsPerHotel": 0, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } }

4. Python: a comp set ranked on breakfast and beds

import os
from collections import defaultdict
from statistics import fmean
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("kestrel/hrs-reviews-scraper").call(run_input={
    "hotelIds": ["10520", "162", "22991"], "maxReviewsPerHotel": 0,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]}})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

for h in (r for r in rows if r["type"] == "hotel"):
    cat, biz = h["avg_by_category"] or {}, (h["ratings_by_traveller_type"] or {}).get("BUSINESS") or {}
    print(f"{h['hotel_name']:36} {h['rating']}  beds={cat.get('QUALITY_OF_BEDS')} breakfast={cat.get('BREAKFAST_SERVICE')}  business={biz.get('rating')} (n={biz.get('count')})  {h['comment_count']}/{h['rating_count']} commented")

votes = defaultdict(list)
for r in (r for r in rows if r["type"] == "review"): votes[r["traveller_type"]].append(r["votes"]["PRICE_PERFORMANCE_RATIO"])
for kind, vs in votes.items(): print(kind, len(vs), "comments, price-performance", round(fmean([v for v in vs if v] or [0]), 1))

The hotel rows are the benchmark sheet; the review rows say whether business guests vote price-performance lower than private ones. For the other half of the German market, the Kurzurlaub Reviews Scraper reads hotelbewertungen from Kurzurlaub.de, the leisure short-break site: HRS for the weekday guest, Kurzurlaub for the weekend one.

5. Hotel guest feedback on a schedule (n8n)

The review-alert templates in the n8n/ folder of kestrel-actors-examples share one shape: an 08:00 Schedule trigger, an HTTP Request to the run-sync endpoint, a Code node that drops review_ids seen before, an IF, a Google Sheets append and a Slack message per row. For HRS the body is the curl body in section 1 with more hotelIds, maxRating: 7 and includeHotelRow: false; the message carries rating, negatives and traveller_type, and an empty hotel_reply marks the row to route.

6. Cost and limits

$0.003 per delivered review row; hotel rows, status rows, unknown hotels (not_found) and filtered reviews are free. A busy city hotel has 50–150 commented ratings: $0.15–$0.45 in full; 100 hotels at 60 comments is $18; a daily complaints feed over 20 properties is a few cents, plus residential proxy traffic on your Apify plan.
Comments come in the guest's language, mostly German then English, untranslated; language says which.
The scraper reads the same publicly accessible ratings any visitor sees on a hotel page, through the endpoint that page uses, without logging in or bypassing any access control. Reviews contain personal data in the sense of the GDPR — a display name, a stay date, a text — so you need a lawful basis for what you do with them, you should not republish reviewer names, and you should honour deletion requests. Use the data for analysis, not to rebuild HRS's review pages. This is not legal advice; check the rules that apply to you.

That is the feed: five requests for a hundred hotels, twelve votes per row, filters before billing and a schedule. Full reference on the actor page: apify.com/kestrel/hrs-reviews-scraper.

Booking.com reviews without a browser: the review endpoint sits outside the WAF (Python + n8n)

Tedj MEABIOU — Thu, 03 Sep 2026 12:00:02 +0000

Booking.com is the review corpus a hotel reputation feed cannot skip, and every one of its pages refuses a script: a plain HTTP request gets an AWS WAF challenge, which is why most booking.com reviews scrapers run a headless browser. The page itself loads its reviews from a JSON endpoint that answers without the challenge. This is how to read booking.com reviews as rows with no browser, no login and no API key, and what the one real trap looks like.

1. One request, one row per review

The Booking.com Reviews Scraper on Apify is a booking reviews scraper that takes property URLs, hotel names or Booking's numeric ids and returns hotel guest reviews as rows.

curl -X POST "https://api.apify.com/v2/acts/kestrel~booking-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hotelIds": ["536251"], "maxReviewsPerHotel": 25, "languages": ["en"]}'

A review row:

{ "type": "review", "review_id": "c90f61915f999a43", "hotel_id": "536251", "hotel_name": "Memmo Alfama - Design Hotels",
  "rating": 10.0, "rating_5": 5.0, "title": "Best place to stay in Lisbon!",
  "positives": "Great location and amazing terrace.", "negatives": null, "text": "Great location and amazing terrace.",
  "language": "en", "review_date": "2026-08-28", "check_in": "2026-08-24", "check_out": "2026-08-27", "nights": 3,
  "room_type": "Premium Double or Twin Room", "traveler_type": "Couple", "traveler_type_code": "COUPLES",
  "reviewer_name": "Jean", "reviewer_country": "Canada", "response": null, "fetched_at": "2026-08-29T10:12:04+00:00" }

positives and negatives are Booking's two questions kept apart, text the two joined. rating is Booking's 1–10 scale, rating_5 the same out of five. traveler_type_code is Booking's category on the booking (COUPLES, FAMILIES, GROUP_OF_FRIENDS, SOLO_TRAVELLERS, BUSINESS_TRAVELLERS), response the property's reply or null, and check_in, nights and room_type tie the score to a stay.

2. Why no browser is needed

Every Booking.com page sits behind AWS WAF: a script asking for HTML gets a 202 and a JavaScript challenge. Once a hotel page has loaded, though, it calls a GraphQL operation named ReviewList, and that call does not need the WAF token; neither does the autocomplete behind the search box. The actor makes only those two calls, on datacenter proxies.

The trap is that the WAF still reads the TLS handshake. A plain Python HTTP client in a Linux container is challenged on that endpoint too, on every proxy pool; a client that presents Chrome's TLS fingerprint gets JSON. A transport choice, not a login or a cookie. A challenged or empty answer is retried on a fresh IP and, failing that, reported as error, never no_reviews.

3. Filters before billing, hotels by name

languages, travelerType and keyword are applied by Booking's server, so what you skip is never fetched. maxRating keeps only reviews at or below a score and reads the property lowest score first, stopping at the line: 892 reviews with 24 at 6 or below cost one page, not thirty-six. requireText drops score-only reviews, about four in ten on Booking.

{ "startUrls": ["https://www.booking.com/hotel/pt/memmo-alfama.html", "https://www.booking.com/hotel/pt/the-lumiares.en-gb.html"], "maxReviewsPerHotel": 50, "reviewsSort": "most_recent", "maxRating": 6, "requireText": true }

Booking's URLs carry no numeric id, so a URL's slug is resolved through Booking's own autocomplete, held to the country in the URL; hotelNames takes the same path, and the resolved hotel_name comes back on every row. hotelIds skips the lookup; a URL, its name and its id are one property, harvested once.

4. Python: complaints by room type, then Agoda alongside

import os
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(actor, inp): return [r for r in client.dataset(client.actor(actor).call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == "review"]

booking = rows("kestrel/booking-reviews-scraper", {"hotelNames": ["Memmo Alfama Lisbon"], "maxReviewsPerHotel": 0, "maxRating": 6, "requireText": True})
for (room, kind), n in Counter((r["room_type"], r["traveler_type_code"]) for r in booking).most_common(): print(f"{n:3}  {room:40} {kind}")
print(sum(r["response"] is None for r in booking), "of", len(booking), "unanswered")

agoda = rows("kestrel/agoda-reviews-scraper", {"hotelIds": ["63820"], "maxReviewsPerHotel": 0, "maxRating": 6, "requireText": True})
feed = [("booking", r["rating"], r["review_date"], r["negatives"], r["response"] is not None) for r in booking]
feed += [("agoda", r["rating"], r["review_date"][:10], r["negatives"] or r["text"], r["response"] is not None) for r in agoda]

The first loop is the ops question — which room type the complaints cluster in, by guest kind — with no text model; the response count is the reputation one. The Agoda Reviews Scraper also scores 0–10 and splits negatives out, so both sites land in one feed on one scale: a voice of customer table.

5. Review monitoring on a schedule (n8n)

The Agoda template in the n8n/ folder of kestrel-actors-examples is the workflow: an 08:00 Schedule trigger, an HTTP Request to the run-sync endpoint for the 50 most recent reviews at or under 6/10 with text, a Code node that drops review_ids seen before, an IF, a Google Sheets append and a Slack message per review. Pointing it at Booking is the endpoint and the body in section 3; rating, negatives, response and review_id already share names. keyword: "breakfast" narrows the feed before a row exists.

6. Cost and limits

$0.005 per delivered review row; hotel and status rows and anything a filter removes are free. The 892-review property in full: $4.46. Ten properties at 50 most recent, daily: at most $2.50 a day; the complaints version delivers a few rows, a cent or two.
Reviews arrive as written, tagged with language, never translated; the free hotel row lists every language with a count, so read it before choosing languages.
Ids carry no name, and an unknown id looks like an empty property: no_reviews, free.
The actor reads publicly visible guest reviews through the same request Booking's own page makes, with no login and no personal accounts. Whether you may use the data for your purpose depends on your jurisdiction, on Booking.com's terms and on data-protection law (GDPR in the EU treats reviewer names as personal data) — read them and take advice before scraping at scale or republishing. Use the data for analysis and monitoring; do not repost reviews as your own content.

That is the feed: one endpoint outside the WAF, the right TLS stack to reach it, filters before billing and a schedule. Full reference on the actor page: apify.com/kestrel/booking-reviews-scraper.

Estimate Airbnb occupancy rates from the public calendar (an AirDNA-style feed for a few cents)

Tedj MEABIOU — Wed, 02 Sep 2026 12:00:03 +0000

Every short term rental data subscription sells two numbers per listing and month: how full it is and what it charges. Both come from the public availability calendar on the listing page and a priced stay, and both can be read per listing for a fraction of a cent. This is an Airbnb occupancy rate per listing and month as rows you own, with the caveat the vendors keep in a footnote said up front: the calendar cannot tell a booked night from one the host blocked.

1. One row per listing and month

The Airbnb Occupancy Rate Scraper on Apify takes a place, a search URL or listing ids, reads each listing's calendar for the next months months and folds each into one occupancy row — an airbnb calendar scraper with the arithmetic done.

curl -X POST "https://api.apify.com/v2/acts/kestrel~airbnb-occupancy-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locationQueries": ["Lisbon, Portugal"], "maxListingsPerQuery": 50, "months": 3, "currency": "USD"}'

One of at most 150 rows:

{ "type": "occupancy", "id": "17088279", "url": "https://www.airbnb.com/rooms/17088279",
  "name": "Bairro Alto Refuge", "title": "Apartment in Lisbon", "property_type": "Apartment", "room_type": "Entire home/apt",
  "location": "Lisbon", "lat": 38.71209, "lng": -9.14346, "rating": 4.91, "reviews_count": 374,
  "bedrooms": 1, "beds": 1, "bathrooms": 1, "person_capacity": 4, "is_superhost": false, "is_guest_favorite": true, "query": "Lisbon, Portugal",
  "month": "2026-09", "days_in_month": 30, "days_total": 30, "days_available": 12, "days_unavailable": 18, "occupancy_pct": 60.0,
  "checkin_days": 9, "nights_min": 3, "next_available": "2026-09-08", "first_day": "2026-09-01", "last_day": "2026-09-30",
  "currency": "USD", "rate_status": "ok", "rate_check_in": "2026-09-08", "rate_check_out": "2026-09-11", "rate_nights": 3, "rate_total": 791, "rate_nightly": 263.67,
  "fetched_at": "2026-08-29T08:40:12+00:00" }

occupancy_pct is days_unavailable ÷ days_total × 100; days_total counts from today, so the current month is partial. nights_min is the most common minimum stay; checkin_days and next_available show whether the free days are bookable — a listing 40% available in one-night gaps is full for a three-night minimum.

2. What the number is, and is not

A night is unavailable because a guest booked it or because the host blocked it, and the calendar does not say which. occupancy_pct counts both: an occupancy proxy, not a booking ledger, and for one listing whose host blocks whole months it overstates. Across a comp set of forty similar listings the blocked share is small and fairly constant, so the proxy tracks real STR occupancy closely; that is why days_unavailable sits next to the percentage on every row.

The rate is a sample. The calendar shows no prices to a logged-out visitor, so the actor prices a real stay: the first available check-in day of the month, the listing's minimum nights (capped at seven), for adults guests. rate_nightly is that total divided by nights — an ADR proxy sampled at the start of the month, with rate_check_in, rate_check_out and rate_total on the row so the quote can be reproduced. rate_status explains a missing number: no_stay for a full month, unavailable when adults exceeds capacity, skipped when includeRates is off (half the requests).

3. Python: market pace by month, comps by shape

import csv, os
from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("kestrel/airbnb-occupancy-scraper").call(run_input={
    "locationQueries": ["Alfama, Lisbon"], "maxListingsPerQuery": 60, "months": 4, "currency": "EUR"})
rows = [r for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["type"] == "occupancy"]

with open("occupancy_history.csv", "a", newline="") as f:
    csv.writer(f).writerows([r["fetched_at"][:10], r["id"], r["month"], r["room_type"], r["bedrooms"], r["days_available"], r["occupancy_pct"], r["rate_nightly"], r["rate_status"]] for r in rows)

comps = [r for r in rows if r["room_type"] == "Entire home/apt" and r["bedrooms"] == 1]
by_month = defaultdict(list)
for r in comps: by_month[r["month"]].append(r)
for m, rs in sorted(by_month.items()):
    priced = sorted(r["rate_nightly"] for r in rs if r["rate_status"] == "ok")
    print(m, f"{sum(r['occupancy_pct'] for r in rs) / len(rs):.1f}% occupied, {len(rs)} one-bed entire homes, median {priced[len(priced) // 2] if priced else None} EUR")

Run it every Monday and the CSV holds days_available per listing, month and run; nights that went from available to unavailable between runs are the booking pace, which the calendar does tell you. A monthly run over a season is the occupancy history for the market, the part the vendors charge for.

4. A sheet and a threshold (n8n)

A portfolio watch is three nodes: a weekly Schedule trigger, an HTTP Request to the run-sync endpoint with listingIds for your portfolio and its comp set and months: 3, and a Google Sheets append. The templates in the n8n/ folder of kestrel-actors-examples share that shape, minus the dedupe Code node: every row here is new by fetched_at. For an alert, set minOccupancyPct: 80: only months at or above 80% are delivered, the filter runs before billing, and an empty array means nothing that full this week.

For an exact stay's price or a day-by-day calendar, the sibling Airbnb Scraper bills per listing and calendar month; this one is the cheaper shape for occupancy across many listings.

5. Cost and limits

$0.002 per delivered occupancy row, one per listing and month. 100 listings, 6 months: $1.20. Sixty listings, 3 months, weekly: $0.36 a run, about $1.56 a month. listing and status rows, months under minOccupancyPct, unknown places and failed calendars are free.
As an AirDNA alternative it is not a dashboard and has no history you did not run; it is the calendar layer a spreadsheet or model sits on.
A search returns the site's ranking up to about 280 listings; cover a city with neighbourhood queries or a search URL with map bounds. months is capped at twelve.
One rate sample per month, priced for adults guests; weekend premiums and mid-month prices differ.
The rows describe properties, not people. The site's terms discourage automated access; that is a terms question, with the risk on whoever runs it. A compiled database can attract database rights in the EU, so do not resell the raw dataset. Not legal advice.

That is the feed: one call for the rows, a comp filter so the proxy means something, a schedule for the history. Full input/output reference and FAQ on the actor page: apify.com/kestrel/airbnb-occupancy-scraper.

Trip.com (Ctrip) hotel reviews: the guest corpus Western OTAs don't carry (Python + n8n)

Tedj MEABIOU — Tue, 01 Sep 2026 12:13:52 +0000

A reputation feed built from Booking, TripAdvisor and Google is missing a whole guest segment. Chinese-speaking travellers review on Ctrip, and Ctrip's international brand Trip.com serves those reviews alongside its own and the Expedia-group ones it aggregates, so trip.com reviews and Ctrip reviews are the same rows. One Lisbon boutique hotel returned nine languages in a single run, about a quarter Chinese — chinese traveller reviews that exist on no Western OTA. If your guest feedback data stops at English-language sites, this is how to read the rest as rows: a 0–10 score, four sub-scores, the language, the travel type and the hotel's reply.

1. One request, one row per review

The Trip.com Reviews Scraper on Apify is a hotel reviews scraper that takes Trip.com hotel URLs or numeric hotel ids (the number after hotel-detail- in any URL). No login, no API key, no browser: it reads the JSON endpoint Trip.com's own review panel calls.

curl -X POST "https://api.apify.com/v2/acts/kestrel~trip-com-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hotelIds": ["2561632"], "maxReviewsPerHotel": 100, "reviewsSort": "most_recent", "languages": ["Chinese"]}'

A review row:

{ "type": "review", "review_id": "2067108455", "hotel_id": "2561632", "hotel_name": "Hotel Valverde Lisboa - Relais & Chateaux",
  "rating": 9.7, "rating_5": 4.85, "rating_text": "Amazing",
  "rating_location": 10, "rating_facility": 9.5, "rating_service": 10, "rating_room": 9.5,
  "text": "非常精緻的小型酒店，新裝修的設施很新，床品舒適…", "language": "zh", "recommend": true,
  "review_date": "2026-08-17T06:13:30", "check_in": "2026-08-01", "room_type": "Classic Room", "travel_type": "Couple",
  "reviewer_name": "Xiaoyufeifeijiejie", "reviewer_country": "China", "reviewer_country_code": "CN",
  "reviewer_reviews": 10, "reviewer_level": "Review Specialist", "helpful_votes": 0,
  "images": ["https://ak-d.tripcdn.com/images/…_W_1280_853_R5_Q70.jpg"],
  "source": "ctrip", "response": "Dear Guest, Thank you very much for your wonderful review…", "response_date": "2026-08-19",
  "url": "https://www.trip.com/hotels/lisbon-hotel-detail-2561632/valverde-hotel/", "locale": "en-US", "fetched_at": "2026-08-29T04:30:12+00:00" }

rating is Trip.com's 0–10 scale and rating_5 the same score out of five. The four sub-scores — rating_location, rating_facility (amenities), rating_service, rating_room (cleanliness) — come with every review, so "which room type is losing on cleanliness with families" is a group-by on room_type and travel_type, not a text model. source says where the review was written: ctrip, Trip.com, or an Expedia or Hotels.com verified review. language is the text's language code; the actor does not translate.

2. Three filters, all before billing

languages is applied by Trip.com's server, so the reviews you skip are never fetched and never billed. maxRating keeps only reviews at or below a score (Trip.com's own labels put 6 and below at a poor stay), and requireText drops the rare score-only review. A complaints feed:

{ "startUrls": ["https://www.trip.com/hotels/lisbon-hotel-detail-2561632/valverde-hotel/"], "maxReviewsPerHotel": 0, "reviewsSort": "lowest_rated", "maxRating": 6, "requireText": true }

The free hotel row (includeHotelRow, on by default) lists the languages the property's reviews come in with a count for each, plus the property's overall score and the same four sub-scores. Read that row first, then decide which languages are worth paying for.

3. Python: sub-scores by language, then Agoda alongside

import os
from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(actor, inp): return [r for r in client.dataset(client.actor(actor).call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == "review"]

trip = rows("kestrel/trip-com-reviews-scraper", {"hotelIds": ["2561632"], "maxReviewsPerHotel": 0, "reviewsSort": "most_recent"})
subs = ("rating_location", "rating_facility", "rating_service", "rating_room")
by_lang = defaultdict(list)
for r in trip: by_lang[r["language"]].append(r)
for lang, rs in sorted(by_lang.items(), key=lambda kv: -len(kv[1])):
    means = {s: sum(r[s] for r in rs if r[s] is not None) / max(1, sum(r[s] is not None for r in rs)) for s in subs}
    print(f"{lang:3} n={len(rs):4}  " + "  ".join(f"{s[7:]}={m:.1f}" for s, m in means.items()))

agoda = rows("kestrel/agoda-reviews-scraper", {"hotelIds": ["63820"], "maxReviewsPerHotel": 200, "reviewsSort": "most_recent"})
feed = [("tripcom", r["rating"], r["language"], r["review_date"][:10], r["text"]) for r in trip]
feed += [("agoda", r["rating"], r["language"], r["review_date"][:10], r["negatives"] or r["text"]) for r in agoda]

The first loop answers, per language, whether Chinese-speaking guests score service or cleanliness differently from English-speaking ones — a question TripAdvisor cannot answer. The second half is the pairing: the Agoda Reviews Scraper also scores 0–10 and carries language and review_date, so Agoda's Asia-Pacific corpus and Trip.com's Chinese one land in one feed on the same scale. Together they are the voice-of-customer feed for the guests Western OTAs do not hear from.

4. A daily channel without code (n8n)

The Agoda template in the n8n/ folder of kestrel-actors-examples is this workflow with a different URL: an 08:00 Schedule trigger, an HTTP Request to the run-sync endpoint for the 50 most recent reviews per hotel at or under 6/10 with text, a Code node that drops review_ids seen before via workflow static data, an IF, a Google Sheets append, one Slack message per review, and a NoOp. Pointing it at Trip.com is the endpoint and the body (hotelNames to hotelIds); the message fields already share names — rating, text, language, response. Add languages: ["Chinese"] and the channel carries only the reviews an English-reading team would otherwise never see, tagged so a translation step knows what it has.

5. Cost and limits

$0.004 per delivered review row; hotel and status rows and anything languages, maxRating or requireText removes are free. A 95-review property in full: $0.38. Three hotels at 50 most recent, daily: at most $0.60 a day; the complaints version delivers a handful of rows, a cent or two.
Reviews arrive as written; Trip.com's translations are not exposed by the endpoint.
A throttled request looks like a hotel with no reviews. The actor treats that shape as an error and retries on a fresh IP; it never reports it as no_reviews.
Hotel names are not an input: Trip.com has no public autocomplete, and a guessed property would bill for the wrong hotel. Take the id from the URL.
Reviewer names and countries are personal data under GDPR: process them for a stated purpose, keep them no longer than you need, and read Trip.com's terms before scraping at scale. Not legal advice.

That is the feed: one call per hotel, three filters before billing, a schedule for the history, and the Chinese-language corpus in the same table as everything else. Full reference on the actor page: apify.com/kestrel/trip-com-reviews-scraper.

Scrape App Store reviews for every country in one run (the RSS feed is gone)

Tedj MEABIOU — Mon, 31 Aug 2026 12:00:07 +0000

For years the way to get App Store reviews as data was Apple's RSS feed: itunes.apple.com/us/rss/customerreviews/id=310633997/sortBy=mostRecent/json, fifty reviews a page, ten pages, one storefront per URL. In 2026 that feed answers an empty feed for most big apps, and when it does answer it stops at 500. The App Store's own web page never stopped: the reviews panel on apps.apple.com calls a JSON endpoint ten reviews at a time by offset, and it keeps answering deep into an app's history. That is the source to read, and this is how to read it for every storefront at once — Apple app reviews, iOS app reviews, from the US to Japan, as rows with a country column.

1. One run, every storefront

The App Store Reviews Scraper on Apify takes app ids, App Store URLs or plain app names, and a list of two-letter storefront codes. Reviews live per storefront, so a US-only export of a global app misses most of them; here countries is a list and the run reads each app on each one.

curl -X POST "https://api.apify.com/v2/acts/kestrel~app-store-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"appIds": ["310633997"], "countries": ["us", "gb", "de", "fr", "jp", "br", "in"], "sort": "most_recent", "maxReviewsPerApp": 200}'

Seven storefronts, up to 1,400 review rows, seven free app rows and seven free status rows. A review row:

{ "type": "review", "review_id": "13657831289", "app_id": "310633997", "app_name": "WhatsApp Messenger", "country": "us",
  "rating": 5, "title": "WhatsApp not bad",
  "text": "WhatsApp's not bad at all—it's actually great for what it does. End-to-end encryption keeps your actual messages and calls private…",
  "author": "Ed Bradway", "version": null, "is_edited": false,
  "review_date": "2026-01-21T04:48:38Z", "review_day": "2026-01-21",
  "developer_response": null, "developer_response_date": null,
  "url": "https://apps.apple.com/us/app/id310633997?see-all=reviews", "fetched_at": "2026-08-29T06:10:04+00:00" }

rating is an integer 1–5. developer_response is null until the developer answers, which makes it the "unanswered" flag. version is null when Apple's endpoint does not attach one, which it often does not. A review Apple lists on two storefronts is delivered once, by the first storefront to return it.

The free app row is the part the RSS feed never had: per storefront, rating_avg, rating_count, the histogram hist_1 through hist_5, written_reviews, version, price and genre. Seven storefronts in one run is app store ratings by country as a table — WhatsApp's US row carries 18,484,827 ratings, 630,438 of them one star, against 198,881 written reviews.

2. The complaints feed bills only what it keeps

minRating, maxRating, sinceDate and requireText run before billing. A run that reads 300 reviews in most-critical order and keeps 40 pays for 40; the status row's filtered column says how many were dropped for free.

{ "appNames": ["Duolingo"], "countries": ["us", "gb", "de"], "sort": "most_critical", "maxRating": 2, "requireText": true, "maxReviewsPerApp": 300 }

appNames resolves through Apple's own search API on each storefront, so there is no id hunting; when a name is ambiguous, use the id. For app review monitoring on a schedule the pair is sort: "most_recent" and a relative sinceDate — "1 day" on a daily run, "7 days" on a weekly one — never a fixed date that goes stale.

3. Python: reviews and the histogram per storefront

import csv, os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("kestrel/app-store-reviews-scraper").call(run_input={
    "appIds": ["310633997", "570060128"], "countries": ["us", "gb", "de", "jp"],
    "sort": "most_recent", "sinceDate": "7 days", "maxReviewsPerApp": 500})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("app_ratings.csv", "a", newline="") as f:
    w = csv.writer(f)
    for r in rows:
        if r["type"] == "app": w.writerow([r["fetched_at"][:10], r["app_name"], r["country"], r["rating_avg"], r["rating_count"], r["hist_1"], r["hist_5"], r["written_reviews"]])
for r in rows:
    if r["type"] == "review" and r["rating"] <= 2 and r["developer_response"] is None:
        print(r["country"], r["app_name"], r["rating"], r["review_day"], (r["title"] or "")[:60])

Run it daily and app_ratings.csv becomes the rating history per storefront that nobody exports for you: whether a release moved rating_avg in Germany, whether the one-star share in Japan is climbing. The second loop is the reply queue — low stars, nobody answered yet.

4. Slack without code (n8n)

The shape is the one the Airbnb and Agoda review templates use in the n8n/ folder of kestrel-actors-examples: an 08:00 Schedule trigger, one HTTP Request to the run-sync endpoint with the complaints input above plus sinceDate: "1 day", a Code node that drops review_ids seen before via workflow static data, an IF on whether anything is left, a Google Sheets append, and one Slack message per review carrying country, rating, title and text. Porting the Airbnb one is the URL, the body and one field: host_reply becomes developer_response.

5. Cost and limits

$0.004 per delivered review row; app and status rows, filtered reviews, unknown apps and failed storefronts are free. 200 reviews on one storefront: $0.80. The seven-storefront run above, full: $5.60. A daily complaints feed that keeps three reviews: $0.012.
Apple pages ten reviews per request and answers about one request a second per IP; a large run wants several proxy sessions, which the actor manages.
rating_count counts star ratings, most of them with no text. Only written reviews are pageable; written_reviews on the app row is how many the storefront holds.
It reads the App Store only. Google Play is a different store and a different tool.
Reviews are public content Apple shows without an account, read through the same endpoint a browser uses. A nickname plus review text is personal data under GDPR, so keep what you need, and read Apple's terms for the App Store website. Not legal advice.

That is what the RSS feed used to be, and more: one call, every storefront, rows past 500, complaints filtered before billing. Full input/output reference and FAQ on the actor page: apify.com/kestrel/app-store-reviews-scraper.

Automate hotel rate parity checks: which OTAs undercut your direct rate (Python + n8n)

Tedj MEABIOU — Sun, 30 Aug 2026 12:05:30 +0000

Open your property on Google Hotels and you see what a guest comparing channels sees: Booking.com, Expedia, Agoda, Vio.com and your own site, each with a nightly rate. One of them under your direct rate is a hotel rate parity problem found by looking, and looking does not cover a comp set, run at 07:00 or record how long the gap lasted; a rate shopping tool sells that per property per month. The alternative is rows: one per property and stay, every source side by side, the parity math done.

This is how to get that row as JSON with no API key (there is no public Google Hotels API for prices), keep only the breaches, and run rate parity monitoring from Python or n8n.

1. One request, one row per property and stay

The Hotel Rate Parity Checker on Apify takes Google Hotels URLs or property names, a check-in date and a length of stay, reads Google's OTA price comparison for each property and returns one parity row: every source with a rate, cheapest first, and the summary.

curl -X POST "https://api.apify.com/v2/acts/kestrel~hotel-rate-parity/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hotels": ["https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE"], "checkIn": "30 days", "nights": 2, "adults": 2, "currency": "USD", "country": "us"}'

A parity row:

{ "type": "parity", "hotel_name": "Brown's | Avenue Hotel", "entity_id": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
  "check_in": "2026-09-27", "check_out": "2026-09-29", "nights": 2, "adults": 2, "children": 0, "currency": "USD",
  "sources": [
    { "source": "Vio.com", "source_id": 2017, "official": false, "price_nightly": 377.39, "price_total": 754.78, "free_cancellation": null, "url": "https://www.vio.com/…" },
    { "source": "Brown's Avenue", "source_id": 12058, "official": true, "price_nightly": 488.46, "price_total": 976.92, "free_cancellation": null, "url": "https://be.synxis.com/?hotel=…&arrive=2026-09-27&depart=2026-09-29" },
    { "source": "Booking.com", "source_id": 184, "official": false, "price_nightly": 563.3, "price_total": 1126.61, "free_cancellation": null, "url": "https://www.booking.com/hotel/pt/browns-avenue.html?checkin=2026-09-27&checkout=2026-09-29" },
    { "source": "Expedia.com", "source_id": 232, "official": false, "price_nightly": 573.94, "price_total": 1147.88, "free_cancellation": null, "url": "https://www.expedia.com/…" } ],
  "n_sources": 4, "min_source": "Vio.com", "min_price": 377.39, "max_source": "Expedia.com", "max_price": 573.94, "spread_pct": 52.1, "median_price": 525.88,
  "official_source": "Brown's Avenue", "official_price": 488.46, "official_is_cheapest": false, "undercut_by": ["Vio.com"], "undercut_pct": 22.7,
  "fetched_at": "2026-08-29T06:15:42+00:00" }

The official site is the one Google flags; when Google lists none, official_price and undercut_pct are null. hotelNames takes names instead, one place search each, kept only when the listing's name matches most of your words. A free status row per property and stay says ok, filtered, no_rates, not_found or duplicate.

2. The parity math, and a filter that runs before billing

Every figure is each source's lowest nightly rate for your occupancy. From the row above:

Spread: (573.94 − 377.39) ÷ 377.39 × 100 = 52.1%, across every source, official site included.
Undercut: direct is 488.46 and the cheapest 377.39, so official_is_cheapest is false; undercut_by lists every non-official source under 488.46, worst first; undercut_pct = (488.46 − 377.39) ÷ 488.46 × 100 = 22.7%, the discount for not booking direct.
Median 525.88: one outlier, or the whole market moved.

minSpreadPct: 5 delivers only properties whose spread reaches 5%; the rest get a status row with filtered: true and are not billed. The spread includes the official site, so a property undercut by N% always has a spread of at least N%: the filter never hides a breach above your line. It does pass a gap the other way, an OTA above direct, which is why the script below also checks undercut_by.

{ "hotelNames": ["Hyatt Regency Lisbon", "Altis Grand Hotel Lisbon", "Brown's Avenue Hotel Lisbon"], "checkIn": "14 days", "nights": 2, "sweepDays": 6, "minSpreadPct": 5, "currency": "EUR", "country": "pt" }

That is a rate parity checker on a schedule: a relative checkIn stays the same distance ahead, sweepDays: 6 covers a week of check-in dates, and on a day when every property is in parity the run costs nothing.

3. Python: a violations log you own

import csv, os
from apify_client import ApifyClient

COMP_SET = ["Hyatt Regency Lisbon", "Altis Grand Hotel Lisbon", "Brown's Avenue Hotel Lisbon", "Tivoli Avenida Liberdade Lisbon", "Bairro Alto Hotel Lisbon"]
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("kestrel/hotel-rate-parity").call(run_input={
    "hotelNames": COMP_SET, "checkIn": "14 days", "nights": 2, "sweepDays": 6, "minSpreadPct": 3, "currency": "EUR", "country": "pt"})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
breaches = [r for r in rows if r["type"] == "parity" and r["undercut_by"]]

with open("parity_log.csv", "a", newline="") as f:
    w = csv.writer(f)
    for r in breaches: w.writerow([f'{r["hotel_name"]}|{r["check_in"]}', r["fetched_at"][:10], r["currency"], r["official_price"], r["min_source"], r["min_price"], r["undercut_pct"], ";".join(r["undercut_by"]), r["sources"][0]["url"]])
for r in sorted(breaches, key=lambda r: -r["undercut_pct"]): print(r["hotel_name"], r["check_in"], f'{r["undercut_pct"]}% under direct via {r["min_source"]}')
print([(r["query"], r["status"]) for r in rows if r["type"] == "status" and r["status"] != "ok"])

After the first run, copy each row's entity_id into hotels in place of hotelNames: exact, no search, and a generic name can never resolve to a stranger. Daily, the CSV is hotel price monitoring for the comp set: undercut_pct per hotel|check_in key over time is the parity violation report, and the last column is the offending OTA's booking link.

4. Slack alerts without code (n8n)

No template exists for this one yet; wire it in n8n like the review-alert templates in the n8n/ folder of kestrel-actors-examples:

Schedule trigger, 07:00.
HTTP Request: POST the section 2 input to the run-sync-get-dataset-items URL above; each row becomes one item.
IF: {{ $json.type }} is parity and {{ $json.undercut_pct }} ≥ 3.
Slack: hotel_name, check_in, min_source at min_price vs direct official_price, undercut_pct, sources[0].url.

5. Cost and limits

$0.01 per delivered parity row, once per property and stay per run. Five properties, seven check-in dates: at most $0.35 per run, $10.50 for a month of mornings. With minSpreadPct set only breaches are delivered and billed, so a quiet day is $0. Status rows, unresolved names, no-rate properties and duplicates are free.
Each source's rate is its lowest offer for the occupancy, not the same room on every channel. Room-level parity needs the parent Google Hotels Prices Scraper with offerLevel: "rooms", one row per source and room at $0.002.
Set country to the market you sell in: sources, prices and tax display differ by market.
The actor reads publicly displayed prices, the figures any visitor sees without logging in, and stores no personal data. Comparing public rates across channels is standard practice in the industry, but terms of service and local law differ; check that your use complies, and keep the data for your own analysis rather than republishing it as Google's.

That is the pipeline: one call for the comparison, minSpreadPct for the alert, a schedule for the history. Full input/output reference and FAQ on the actor page: apify.com/kestrel/hotel-rate-parity.

Monitor guest reviews across Airbnb and Agoda: a voice-of-customer feed for hotels (Python + n8n)

Tedj MEABIOU — Sat, 29 Aug 2026 15:26:33 +0000

A property with a few hundred hotel reviews across two booking sites gets a handful of bad ones a month. Those need a reply the same day and a line in the ops log; the five-star ones can wait. Turning that into guest feedback data — one feed, both sites, low scores only, with whether anyone answered — is a data job, and the cost question is whether you pay for the 95% of reviews nobody needs to read. Not if the filter runs before billing.

1. Two actors, both filter before billing

The Airbnb Reviews Scraper on Apify takes listing ids, URLs or a place name, and returns airbnb guest reviews as rows: star rating, original text plus Airbnb's translation, language, date, reviewer, stay type and the host's public reply. minRating keeps only reviews at or below that rating, and only those are billed: in a verified run, a listing with 441 reviews returned 4 rows under minRating: 3 — $0.02 instead of $2.20.

The Agoda Reviews Scraper takes hotel names (resolved through Agoda's own search), property URLs or numeric ids. Agoda scores 0–10, so the ceiling is maxRating; requireText drops the score-only reviews that are a large share of Agoda's corpus. A property with 324 visible reviews delivered 8 rows under maxRating: 5 with requireText on.

The Airbnb request:

curl -X POST "https://api.apify.com/v2/acts/kestrel~airbnb-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"listingIds": ["11562247", "45307024"], "maxReviewsPerListing": 0, "reviewsSort": "most_recent", "minRating": 3, "locale": "en"}'

A review row (the docs' five-star example; minRating: 3 returns only 3 and below):

{ "type": "review", "id": "11562247", "url": "https://www.airbnb.com/rooms/11562247", "name": "Charming studio in Baixa",
  "reviews_total": 441, "review_id": "1752111840493470784", "rating": "5",
  "text": "El departamento es muy lindo. Esta todo muy bien ubicado.",
  "text_localized": "The apartment is very nice. Everything is very well located.", "language": "es",
  "created_at": "2026-08-14T10:53:27Z", "reviewer_name": "Luis Armando", "reviewer_location": "Buenos Aires, Argentina",
  "reviewer_is_superhost": false, "host_reply": null, "host_reply_date": null, "stay_type": null }

rating is a string, as Airbnb returns it; host_reply is null when nobody answered — that null is the "unanswered" flag.

2. Agoda: positives and negatives already split

curl -X POST "https://api.apify.com/v2/acts/kestrel~agoda-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"hotelNames": ["Tivoli Avenida Liberdade"], "maxReviewsPerHotel": 0, "reviewsSort": "most_recent", "maxRating": 5, "requireText": true}'

{ "type": "review", "hotel_id": "63820", "hotel_name": "Tivoli Avenida Liberdade", "review_id": "1059514024",
  "rating": 10.0, "rating_5": 5.0, "rating_text": "Exceptional", "title": "Nice Hotel", "text": "Beautiful hotel in the center!",
  "positives": null, "negatives": null, "language": "en", "review_date": "2025-12-15T10:54:00+07:00",
  "check_in": "2025-12-08T00:00:00+07:00", "check_out": "2025-12-14T00:00:00+07:00", "room_type": null,
  "reviewer_name": "VARDAN", "reviewer_country": "Mozambique", "source": "Agoda",
  "responder": "Tivoli Avenida Liberdade", "response": null, "response_date": null }

When the guest filled Agoda's two boxes, positives and negatives arrive as separate fields — the complaint is a column read, not a sentiment model. check_in, check_out and room_type tie a score to a stay and a room. rating_5 is the same score out of five, for lining up with Airbnb.

3. Python: one voice-of-customer table from both

import csv, os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
def rows(actor, inp): return [r for r in client.dataset(client.actor(actor).call(run_input=inp)["defaultDatasetId"]).iterate_items() if r["type"] == "review"]

airbnb = rows("kestrel/airbnb-reviews-scraper", {"listingIds": ["11562247", "45307024"], "maxReviewsPerListing": 50, "reviewsSort": "most_recent", "minRating": 3})
agoda = rows("kestrel/agoda-reviews-scraper", {"hotelIds": ["63820"], "maxReviewsPerHotel": 50, "reviewsSort": "most_recent", "maxRating": 6, "requireText": True})

feed = [("airbnb", r["id"], int(r["rating"]), r["created_at"][:10], r["text_localized"] or r["text"], r["host_reply"] is not None) for r in airbnb]
feed += [("agoda", r["hotel_name"] or r["hotel_id"], r["rating_5"], r["review_date"][:10], r["negatives"] or r["text"], r["response"] is not None) for r in agoda]
with open("voc_feed.csv", "a", newline="") as f: csv.writer(f).writerows(feed)
for src, prop, score, day, text, replied in sorted(feed, key=lambda x: x[3], reverse=True):
    print(f"{day} {src:6} {prop:24} {score}/5 {'replied' if replied else 'UNANSWERED'}  {text[:80]}")

Every row carries fetched_at, so a daily run makes the CSV a time series: complaints per property per week, response rate, which negatives repeat. language lets you route by language before spending model tokens.

4. Slack and a Sheet, no code (n8n)

Two templates in the n8n/ folder of kestrel-actors-examples, one per site, share a shape: an 08:00 Schedule trigger, an HTTP Request to the run-sync endpoint for the 50 most recent reviews per property (3 stars or below on Airbnb, 6/10 or below with text on Agoda), a Code node that drops review_ids seen before via workflow static data, an IF, a Google Sheets append, one Slack message per review, and a NoOp. The Airbnb one flags each message unanswered until host_reply appears. Swap listingIds for locationQueries: ["Lisbon, Portugal"] to watch a whole market.

5. Cost and limits

$0.005 per delivered review row on both actors; listing, hotel and status rows are free, and whatever minRating, maxRating or requireText removes is never billed. Worst case per property per day at 50 most recent: $0.25; the verified template runs delivered 1–3 rows, $0.005–$0.015.
Reviews are personal data — a first name, a location, someone's words. Under GDPR you are a controller once you store them: keep them only as long as needed, do not republish identities. Neither actor exposes email, phone or full names.
reviewer_location on Airbnb is self-declared and often blank; positives, negatives, room_type and stay_length on Agoda are only present when Agoda shows them.
Both sites' terms discourage automated access; that is a terms question, with the risk on whoever runs it.

That is the review monitoring feed: two filtered calls, one normalised table, a schedule. Full references on the actor pages: apify.com/kestrel/airbnb-reviews-scraper and apify.com/kestrel/agoda-reviews-scraper.

Every actor's inputs, output fields, a sample row and its honest limits are documented at mtedj.github.io/kestrel-actors-examples, including a side-by-side comparison of every review scraper.

Scrape the full Amazon Best Sellers Top 100 (a chart page only renders 30 of 50)

Tedj MEABIOU — Sat, 29 Aug 2026 12:00:05 +0000

Amazon Best Sellers is the one ranking on the site that comes from actual sales, and for amazon product research it is the fastest read on a category: what it charges, how crowded the top is, how many ratings a top-10 product carries. Two chart pages are the Top 100, and most scrapers return something that looks like it and is not.

1. Where the missing ranks go

A chart page holds 50 ranks, but the server renders only 30 as HTML; the browser lazy-loads the other 20 as you scroll. Read the page as served and you get ranks 1–30, then 51–80 from page 2. That scraper reports "the Top 100" as 60 rows, and the gaps are silent — nothing in the output says 31–50 are missing.

The page does carry the complete ranked list, though, because its own lazy-loader needs it: every ASIN with its rank, in the served HTML. The Amazon Best Sellers Scraper on Apify reads that list, then makes the same load-more call the browser makes, which returns the remaining 20 entries rendered like the first 30: title, price, rating, rating count, image. If that call is refused, the missing entries are completed from their product pages; if that fails too, the row still arrives with rank, asin and url, and the free status row counts it under partial. pages: 2 is ranks 1–100, contiguous, and the run says how complete it is.

curl -X POST "https://api.apify.com/v2/acts/kestrel~amazon-best-sellers-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories": ["electronics"], "chart": "bestsellers", "pages": 2, "domain": "com"}'

A product row — rank 31, the first lazy-loaded entry:

{ "type": "product", "rank": 31, "asin": "B0CFPJYX7P", "title": "Example Wireless Earbuds, Bluetooth 5.4",
  "chart": "bestsellers", "category": "electronics", "page": 1,
  "price": 24.99, "price_display": "$24.99", "currency": "USD", "rating": 4.5, "ratings_count": 18342,
  "image": "https://m.media-amazon.com/images/I/example.jpg", "url": "https://www.amazon.com/dp/B0CFPJYX7P",
  "domain": "com", "marketplace": "US", "fetched_at": "2026-08-29T06:20:11+00:00" }

fillRanks: false turns the completion off: one request per page, 30 rows, the gaps back. maxResultsPerCategory: 20 caps each category and minRating: 4.5 drops the rest; neither is billed. chart: "new_releases" pulls New Releases with the same slugs.

2. Python: a BSR tracker in a CSV

rank is the product's amazon best sellers rank within that category node; keep the runs and rank history is a group-by. This appends today's chart and prints new top-20 entrants.

import csv, os
from pathlib import Path
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("kestrel/amazon-best-sellers-scraper").call(run_input={
    "categories": ["electronics", "electronics/headphones"], "chart": "bestsellers", "pages": 2, "domain": "com"})
rows = [r for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["type"] == "product"]

path = Path("bsr_history.csv")
seen = {(r[1], r[2]) for r in csv.reader(path.open())} if path.exists() else set()
with path.open("a", newline="") as f:
    w = csv.writer(f)
    for r in rows: w.writerow([r["fetched_at"][:10], r["category"], r["asin"], r["rank"], r["price"], r["rating"], r["ratings_count"], r["title"]])
new = [r for r in rows if r["rank"] <= 20 and (r["category"], r["asin"]) not in seen]
for r in new: print(f"new in top 20: #{r['rank']} {r['category']} {r['asin']} {r['price_display']} {(r['title'] or '')[:60]}")

The change in ratings_count between runs is a better velocity signal than rank alone, and only exists if you keep the runs. Join a chart: "new_releases" run on asin: a product that reaches the Best Sellers top 50 within a month of appearing there is a launch that worked.

3. Rank history in Google Sheets, alerts in Slack (n8n)

The n8n template Amazon Best Sellers rank tracker → Google Sheets (n8n/ folder of kestrel-actors-examples) is seven nodes: a 06:00 Schedule trigger, an HTTP Request to the run-sync endpoint for the Top 50 of one category, a Code node that looks up yesterday's rank per category|chart|asin in workflow static data and adds previous_rank and change (+3, -2, 0, new), a Google Sheets append of all 50 rows, an IF for change = new and rank ≤ 10, Slack, and a NoOp. The first run only seeds the history; pages: 2, maxResultsPerCategory: 100 makes it the Top 100.

4. From rank to reviews

Every row carries asin, which is the input the Amazon Reviews Scraper wants:

asins = [r["asin"] for r in rows if r["rank"] <= 10]
reviews = client.actor("kestrel/amazon-reviews-scraper").call(run_input={"asins": asins, "domain": "com", "minRating": 3, "requireText": True})

That returns the reviews Amazon shows on the public product page — roughly 8–13 per product. The full archive sits behind a login and the actor does not attempt it: enough for "what sells, and what its buyers complain about", not a complete review corpus.

5. Cost and limits

$0.004 per delivered product row; status rows, filtered rows and empty categories are free. Top 100 of one category: $0.40. Ten categories daily: $4 a day. The reviews actor is $0.005 per review row plus $0.003 per product row.
rank is chart position, not units sold; Amazon does not publish sales volume.
Prices are what the page rendered, in the currency it rendered; price is null when the page prints a range.
Movers & Shakers is rendered entirely client-side — the served page carries no entries — so it is not offered.
Slugs differ between marketplaces; on no_results, copy the segment after /gp/bestsellers/ from that marketplace's URL.
Apify Proxy is required; the run rotates IP on a captcha.

That is the whole thing: one run for a complete chart, a schedule for the rank history, one join for the reviews. Full input/output reference and FAQ on the actor page: apify.com/kestrel/amazon-best-sellers-scraper.

Every actor's inputs, output fields, a sample row and its honest limits are documented at mtedj.github.io/kestrel-actors-examples, including a side-by-side comparison of every review scraper.