Hotel Rate Parity Checker — OTA Price Comparison
Pricing
$10.00 / 1,000 parity rows
Hotel Rate Parity Checker — OTA Price Comparison
Rate parity check on Google Hotels by name or URL. One row per hotel and stay: every OTA and official site side by side (Booking.com, Expedia, Agoda), nightly rate, free cancellation, link; cheapest source, spread, direct booking rate, undercut by whom and how much. minSpreadPct: violations only.
Pricing
$10.00 / 1,000 parity rows
Rating
0.0
(0)
Developer
Tedj MEABIOU
Maintained by CommunityActor stats
0
Bookmarked
17
Total users
3
Monthly active users
3 hours ago
Last modified
Categories
Features
Share
Hotel rate parity checker built on Google Hotels prices: for each property and stay you name, one row with every booking source Google lists side by side — Booking.com, Expedia, Hotels.com, Agoda, Trip.com, Vio.com, the property's official site — and the parity math already done: the cheapest and dearest source, the spread in percent, the direct rate, and which OTAs undercut it and by how much. It is an OTA price comparison and rate shopping tool for revenue managers, channel managers and owners, priced per row instead of per seat. Put it on a schedule and it becomes rate parity monitoring with a history you own. No API key, no login, no browser: it reads the same public comparison any traveller sees, through Apify's proxies, and returns clean JSON.
You pay only for delivered parity rows. Properties with no rates, names that do not resolve, duplicates, rows a filter removed and status rows cost nothing.
酒店比价、OTA 房价一致性与直订价格:中文调用与语言设置
对同一酒店、入住日期和人数比较 Google Hotels 展示的 OTA 与官网报价。minSpreadPct 只筛选达到差价阈值的结果。
country 是搜索者市场,language 控制可用的名称翻译,currency 控制报价币种。保持市场和币种一致;差价不自动证明违反合同条款。
| 调用需求 | 参数与结果约定 |
|---|---|
| 小规模验证 | 使用下面 JSON;先检查结果和状态,再提高上限 |
| 语言与市场 | 按上面的真实字段选择,不要把中文说明当成自动翻译承诺 |
| 费用控制 | maxTotalChargeUsd 是 Apify 运行选项,不是输入 JSON 字段;按定价页的计费事件设置上限 |
| 数据完整性 | 检查状态行和 SUMMARY;空结果、来源错误与完整数据集是不同情况 |
{"hotels": ["https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE"],"checkIn": "30 days","nights": 1,"currency": "USD","sweepDays": 1,"language": "zh-CN","sessions": 1}
Parité tarifaire / paridad de tarifas / Ratenparität:同条件比较 OTA 与直订报价。
This localized quick start uses the existing input contract. API users should send the JSON as actor input and set maxTotalChargeUsd separately in Apify run options. Source coverage and translation depend on the platform, not the language of this guide.
Hotel rate parity checker for AI agents: which input answers which request?
Use it when the user names one or more hotels and wants every booking site's rate for a stay side by side with the hotel's own rate, the gap, and who undercuts direct: "is anyone undercutting our direct rate for next weekend", "compare OTA rates for the Hyatt in Lisbon", "a parity report for our comp set every morning", "only the breaches over 5 %". Do not use it for a city search or hotels you cannot name (the Google Hotels Prices Scraper searches places), for room-level parity (the same room type on every channel — the parent's offerLevel: "rooms"), for the cheapest date to stay over a window of dates (the Hotel Price Tracker), for reviews, or for more than 6 adults or one room.
| The user asks for | Input |
|---|---|
| Is anyone undercutting hotel X for a stay | {"hotelNames": ["Hyatt Regency Lisbon"], "checkIn": "2026-11-14", "nights": 2} then read undercut_by and undercut_pct |
| Every OTA's rate for hotel X side by side | the same input; the sources array, cheapest first, each with price_nightly, price_total, free_cancellation, url |
| A parity report for our comp set every morning | {"hotels": ["<entity_id>", "<entity_id>"], "checkIn": "30 days", "nights": 1} (entity ids from a first run by name) and an Apify schedule |
| Only stays with at least 5% cheapest-to-dearest spread | add "minSpreadPct": 5; this does not itself prove an OTA undercut of the official site |
| Only where an OTA is under the official site | keep minSpreadPct 0 and filter rows on undercut_by not empty (spread_pct measures cheapest vs dearest source, not direct) |
| The next week of check-in dates per hotel | "sweepDays": 6 (7 stays per hotel, one row each) |
| A family stay, prices in pounds as a UK booker sees them | "adults": 2, "childrenAges": [5, 9], "currency": "GBP", "country": "gb" |
| A spending limit | the Apify run option maxTotalChargeUsd; hotels × (sweepDays + 1) bounds the rows ($0.01 each) |
One parity row per hotel and stay, $0.01, however many sources the row holds (4 to 36, about 18 on average, measured on 174 hotels with the same call). Hotels with no rate, rows under minSpreadPct, names that match nothing, duplicates and status rows are never billed. Measured on 2026-08-30 across 100 independent US hotels over 14 nights: 71 were undercut by at least one OTA on most nights where Google showed a direct rate, 18 by 20 % or more on average, mostly by wholesale resellers (Super.com, Vio.com, Etrip, Traveluro) rather than the major OTAs.
Rows come in two types. parity: hotel_name, entity_id, check_in, check_out, nights, currency, sources (array, cheapest first: source, source_id, official, price_nightly, price_total, free_cancellation, url), n_sources, min_source, min_price, max_source, max_price, spread_pct, median_price, official_source, official_price, official_is_cheapest, undercut_by (OTAs priced under the official site, cheapest first), undercut_pct, fetched_at; stars, rating, reviews are filled for hotels given by name, null for hotels given by URL. When Google lists no official site for the hotel that day, official_source, official_price, official_is_cheapest and undercut_pct are null and undercut_by is empty — and Google does not list it on every run: a null one day and a rate the next is Google's listing changing, not the hotel's rate, so confirm a missing direct rate on a second run before acting on it. status: one per hotel and stay with status ok, filtered, no_rates, not_found, duplicate, unpaid or error, never charged. An empty result is a status row that says why, not a failed run; the run's status message counts the rows and how many undercut the official site.
In other languages: Preisvergleich Hotelpreise, Ratenparität (DE); comparador de precios de hoteles, paridad tarifaria (ES); comparateur de prix d'hôtel, parité tarifaire (FR); comparação de preços de hotéis (PT).
Flag a lower OTA quote without confusing missing evidence with parity
For an OTA quote at least 5% below direct, leave minSpreadPct at zero. That input measures the cheapest-to-dearest source spread, not the discount from the official site.
{"actor": "kestrel/hotel-rate-parity","input": {"hotelNames": ["Hyatt Regency Lisbon"],"checkIn": "2026-12-10","nights": 3,"adults": 2,"currency": "EUR","minSpreadPct": 0,"sweepDays": 0},"callOptions": {"maxTotalChargeUsd": 0.05, "timeout": 180},"waitSecs": 30}
This call-actor envelope requests one hotel/stay: at most one $0.01 parity event plus a free status row. Poll get-actor-run if needed and fetch its default dataset with get-dataset-items. Validate the resolved hotel_name, hotel_url and entity_id; the name guard is a heuristic, not proof of identity. Reuse the verified entity_id in hotels on later runs. A 180 s timeout covers roughly 100 to 150 property-stays at the default speed; a bigger request ends green with the rows that fit (time_hit), never as a timed-out run.
Interpret type: "parity" rows as follows:
| Returned evidence | Interpretation |
|---|---|
official_price is null | Direct comparison is unknown; an empty undercut_by does not mean parity passed. |
Official price exists, undercut_by is nonempty, and undercut_pct >= 5 | At least one returned OTA quote is 5% or more below the lowest returned direct quote. Inspect sources for the source and rate. |
| Official price exists and the condition above is false | No returned quote met that threshold; this is limited to the offers Google exposed for this request. |
Status is no_rates, not_found, filtered, unpaid or error | No comparable delivered parity result; report the reason instead of declaring parity. |
These are per-source minimum quotes for the requested stay/party. The code does not join an identical room, meal plan, cancellation contract, payment timing or tax basis across channels. A source's free_cancellation value is an available indicator, not that full contract. Treat a lower quote as a lead to investigate, not a verified equivalent-rate violation. The Actor sends no notification itself; a downstream integration can act on qualified rows.
Each run uses its own dataset. Save the rows with fetched_at and the request context to build a history; fixed absolute dates compare the same stay, while relative dates compare a moving lead time.
What does the rate parity checker return?
Google Hotels is a metasearch engine: for a property and a stay it shows the rate of every booking site it knows and the property's own site. The parent scraper of this actor returns that comparison as one row per source. This actor collapses it into what a parity check actually needs — one parity row per property and stay:
sources— every source that carried a rate, cheapest first, each with its name, Google'ssource_id, anofficialflag, the nightly rate, the stay total, the free-cancellation flag and the booking link with your dates filled in (official sites: the booking engine URL).free_cancellationistrueorfalsewhere Google states that site's own terms for its lowest rate (about one site in three, measured 2026-11-18) andnullwhere it does not.min_source/min_priceandmax_source/max_price— who is cheapest, who is dearest, andspread_pctbetween them.median_priceshows where the market sits.official_source/official_price— the property's own listing when Google shows one,official_is_cheapest, the list of OTAs inundercut_by, andundercut_pct: how far the cheapest channel beats direct.- Identity and context:
hotel_name,entity_id,hotel_url,check_in,check_out,nights,adults,children,currency,fetched_at; for name lookups alsohotel_id,stars,ratingandreviews.
A status row per property and stay (never charged) says what happened: ok, filtered, no_rates, not_found, duplicate, unpaid or error. A property and stay the run had no time left for gets no row and no charge; SUMMARY.timeout_skipped counts them (see How long does a run take?).
Rate parity monitoring on a schedule
Parity breaks quietly: a wholesaler feeds a bed bank, a bed bank feeds a metasearch, and by Friday an OTA is 8% under your direct rate for the weekend you were sure of. A rate parity checker is only useful if it runs every day, so this actor is built for schedules:
- Relative dates.
"checkIn": "30 days"means "the stay 30 days from whenever this run starts", forever. No stale dates, no edited schedules. - A window per run.
sweepDays: 6checks the same length of stay on seven consecutive check-in dates — one parity row each — so a single scheduled run covers the week that matters for your pickup. - Spread filter.
minSpreadPct: 5delivers only stays whose cheapest-to-dearest spread reaches 5%. A filtered stay is not a verified parity pass; for an official-site undercut threshold, keep this filter at zero and qualify the direct-rate evidence downstream. - History you own. Each run writes dated rows to its own dataset; combine saved datasets externally to build a history. Export to Sheets, BigQuery or a warehouse and the
undercut_pctcolumn over time is your parity violation report — and, read across properties, plain hotel price tracking and hotel price comparison for the set you named.
Pair the run with Apify's webhooks or an n8n, Make or Zapier flow and a breach becomes a Slack message with the property, the OTA, the gap and the booking link — see the integrations section below.
OTA price comparison: the sources Google lists
Whatever Google Hotels shows for that property and market is what you get: Booking.com, Expedia, Hotels.com, Agoda, Trip.com, Priceline, Vio.com, Etrip, Super.com, KAYAK, Kiwi.com, eDreams, Bluepillow, Hostelworld, Vrbo, Holidu and dozens of regional OTAs, plus the official site. Two details matter for a clean OTA rate comparison:
- Sources are keyed by Google's
source_id, not by name. A brand can appear twice for one property — its official listing (official: true) and its marketplace rate — and both are kept as separate entries insources. - Rates are the lowest rate each source offers for your occupancy and dates, in one currency, for one market. Set
countryto the market you sell in, because which sources Google lists differs by market, and compare like with like. Whether the displayed rate includes taxes follows the country of the proxy IP the request leaves from (pre-tax plus mandatory fees from a US IP, all-in from most others), notcountry.
The official site is identified by Google itself, not guessed from the name. When Google lists no official site the direct fields are null and the row still gives you the full OTA price comparison. Google does not list the official site on every run (measured: 8 of 14 nights one day, 14 of 14 the next for the same hotel), so treat a null direct rate as "not shown today" and confirm it on a second run before telling anyone their direct rate is missing.
Hotel price monitoring for your competitive set
A revenue manager's comp set is a list of names, not tokens. hotelNames accepts names — "Hyatt Regency Lisbon", "Brown's Avenue Hotel Lisbon" — and resolves each with one place search. Google answers every search with something, so only the words that say which property you mean count: words that say what kind of lodging it is (hotel, villa, inn, suites, resort, apartments…) and the town Google searched do not. When Google answers with one property, it must carry most of your words, and a city it leaves out of its name does not count against you ("The Plaza New York" finds "The Plaza"); when Google answers with a list (it read the name as a place), a property must carry all of them, and when several do, none is picked. Anything else is a free not_found status row whose error says why. Until 1.4 two shared words of three were enough: the invented "Zorblax Villa Legian" was billed as "Wyanna Villa LEGIAN" and "Hilton Lisbon" as a Curio Collection hotel (runs kaSjvdxOwyJvLnBEh, 8tjQ1RaqlcOSZNI8u). Name lookups also carry stars, rating, reviews and hotel_id from the listing, which URL lookups do not.
Once resolved, reuse the entity_id from the row in hotels: exact, one call per stay, and no search at all. That is the cheapest and most reliable way to run the same comp set every morning, and it is how hotel price monitoring should be wired after the first run.
Input
| Field | Meaning |
|---|---|
hotels | Google Hotels URLs (…/travel/hotels/entity/ChkI…) or bare entity tokens, or a hotel's Google Maps link (one with its place id, …!1s0x…:0x…) or place id (ChIJ…). Exact: one offers call per property and stay, no search, nothing unrelated billed; a hotel given two ways is billed once. |
hotelNames | Property names. One place search each; a property is used only when its name carries your distinctive words (not hotel, villa, inn, suites… nor the town). A name that matches no listed property, or several, is a free not_found row with the reason. |
checkIn | YYYY-MM-DD, or relative for schedules: "30 days", "6 weeks", "+30d", today, tomorrow. Past check-ins are rejected before anything is fetched. |
nights | Length of stay, 1–30. Check-out = check-in + nights. An agent's checkOut date (as google-hotels-prices takes it) sets the stay when nights is left at 1; SUMMARY says so in aliased_fields. |
sweepDays | Also check the same stay starting on each of the next N days (a week of check-in dates = 6). |
adults, childrenAges | Occupancy per room; rates scale with it exactly as on Google. |
currency, language, country | One currency for every price; Google UI language (hl); market (gl) — the booker's country, which decides which booking sites Google lists. |
minSpreadPct | 0 = every priced property. N = only properties whose cheapest-to-dearest spread is at least N%. This is not an official-site undercut filter. Dropped properties are never billed. |
proxyConfiguration | Apify datacenter proxies work; keep the default. |
sessions, perIp | Parallel proxy sessions and requests per second per IP (defaults 4 and 0.5). |
Example: two properties, tonight plus 30 days, one night
{ "hotels": ["https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE", "ChkIg-b2ismUj7M1Gg0vZy8xMWg3MThreGg1EAE"], "checkIn": "30 days", "nights": 1, "adults": 2, "currency": "USD" }
Example: a comp set by name, a week of check-in dates, breaches only
{ "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" }
Example: a family occupancy in the market you sell in
{ "hotels": ["ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE"], "checkIn": "2026-10-16", "nights": 3, "adults": 2, "childrenAges": [5, 9], "currency": "GBP", "country": "gb", "language": "en" }
Output
parity row (the Console's Rate parity and Undercut check views show the same rows as tables; the dataset schema documents every field):
{ "type": "parity", "query": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE", "hotel_name": "Brown's | Avenue Hotel", "entity_id": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE", "hotel_id": null, "hotel_url": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE", "stars": null, "rating": null, "reviews": null,"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" }
status row (never charged):
{ "type": "status", "query": "Brown's Avenue Hotel Lisbon", "hotel_name": "Brown's | Avenue Hotel", "entity_id": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE", "check_in": "2026-09-27", "check_out": "2026-09-29", "status": "ok", "n_sources": 4, "spread_pct": 52.1, "filtered": false, "error": null, "fetched_at": "2026-08-29T06:15:42+00:00" }
A run also writes a SUMMARY record to its key-value store: parity rows delivered, how many undercut their official site, filtered, no rates, not found, duplicates, errors, charged events and HTTP stats, plus time_hit: true and timeout_skipped when the run stopped before its timeout, ignored_fields (input fields this actor does not know, also named at the end of the status message) and aliased_fields (a checkOut read as the stay).
How is the parity math calculated?
Everything is computed from the nightly rate of each source's lowest offer for your occupancy (when a source shows only a stay total, nightly = total ÷ nights). Using the row above:
- Spread: (max − min) ÷ min × 100 = (573.94 − 377.39) ÷ 377.39 × 100 = 52.1%. This is the size of the gap across the whole distribution, official site included, and it is what
minSpreadPctfilters on. - Official is cheapest: the official rate is 488.46 and the cheapest source is 377.39, so false. A tie counts as parity (half a cent tolerance), and an official rate that is the minimum makes
undercut_byempty andundercut_pct0. - Undercut by: every non-official source below 488.46 — here only Vio.com. Cheapest first, so the first name is your worst offender.
- Undercut %: (official − min) ÷ official × 100 = (488.46 − 377.39) ÷ 488.46 × 100 = 22.7%: the discount a guest gets for not booking direct.
- Median: the middle of the four nightly rates, 525.88 — a quick read on whether one outlier or the whole market has moved.
When Google lists no official site, official_price, official_is_cheapest and undercut_pct are null and undercut_by is empty; spread, min, max and median still describe the OTA market.
How much does it cost?
Pay per event: one parity event per delivered parity row, at the price on this page's pricing tab. A comp set of ten properties checked over seven check-in dates is 70 rows; the same run with minSpreadPct set delivers and bills only rows meeting the cheapest-to-dearest spread threshold. That filter does not establish a direct-price undercut or equivalent-room violation. Properties with no rates for the stay, names that do not resolve, a property listed twice, rows removed by the filter, rows the spending limit refused and status rows are all free, and a property and stay is billed once per run. Apify's platform usage for such a run is a fraction of a cent: name lookups take one search each, every property and stay takes one offers call.
Compared with the parent Google Hotels Prices Scraper, which bills one row per source, a parity row is one event for the whole comparison — usually cheaper per property, and already in the shape a rate shopper wants.
Google Hotels prices vs rate shopping tools: how this compares
- Rate shopping tools for hotels — the hotel rate shopper and parity monitor SaaS sold per property per month, the competitor rate shopping and hotel price intelligence suites — shop the same public sources, add dashboards and alerts, and charge a seat or a property licence. This actor gives you the rows and the math for cents, and the dashboard is whatever you already use — a sheet, Metabase, Looker, a Slack channel.
- SERP APIs (SerpApi, DataForSEO, Bright Data) return Google's search page per query; per-source rates are usually a second product, there is no parity math, and you pay per search whether or not it had results.
- Channel managers know your own rates, not the OTAs' displayed prices after wholesaler and bed-bank markups. A channel manager rate check against what a guest actually sees needs a metasearch read, which is what this is.
- Building it yourself: Google Hotels renders prices through internal RPC calls, not HTML, and the payload changes. The point of this actor is that someone keeps that working and reports failures as
statusrows instead of silent zeros.
There is no public Google Hotels API for reading prices; Google's own hotel APIs are feeds for properties that send rates to Google. Reading them back is a scraper, and this one is watched by a daily canary run.
How to use it from Python, JavaScript, curl, n8n, Make or an AI agent
Run it from the Apify Console with the form, or programmatically. Replace <TOKEN> with your Apify API token.
Python — observed direct-price undercuts to stdout, for further comparison of terms:
from apify_client import ApifyClientclient = ApifyClient("<TOKEN>")run = client.actor("kestrel/hotel-rate-parity").call(run_input={"hotelNames": ["Hyatt Regency Lisbon", "Altis Grand Hotel Lisbon"], "checkIn": "30 days", "nights": 2, "sweepDays": 6, "currency": "EUR", "country": "pt"})rows = [r for r in client.dataset(run["defaultDatasetId"]).iterate_items() if r["type"] == "parity"]for r in sorted(rows, key=lambda r: -(r["undercut_pct"] or 0)):if r["undercut_by"]: print(r["hotel_name"], r["check_in"], f'{r["undercut_pct"]}% under direct via {r["undercut_by"][0]} ({r["min_price"]} vs {r["official_price"]} {r["currency"]})')
JavaScript / Node.js — observed direct-price undercuts of at least 5%, with unknown results kept distinct:
import { ApifyClient } from 'apify-client';const client = new ApifyClient({ token: '<TOKEN>' });const run = await client.actor('kestrel/hotel-rate-parity').call({ hotels: ['ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE'], checkIn: '30 days', nights: 1, minSpreadPct: 0 });const { items } = await client.dataset(run.defaultDatasetId).listItems();const comparisons = items.filter(r => r.type === 'parity');const lines = comparisons.filter(r => r.official_price != null && r.undercut_by.length && r.undercut_pct >= 5).map(r => `${r.hotel_name} ${r.check_in}: ${r.min_source} ${r.min_price} vs direct ${r.official_price} (${r.undercut_pct}%) — verify room and rate terms`);const unknown = !comparisons.length || comparisons.some(r => r.official_price == null || !r.sources.some(s => !s.official));if (unknown) lines.push('Some comparisons lack direct/OTA evidence; parity unknown for those results');console.log(lines.join('\n') || 'No observed OTA undercut of at least 5%; equivalent room and rate terms remain unverified');
curl:
curl -X POST "https://api.apify.com/v2/acts/kestrel~hotel-rate-parity/run-sync-get-dataset-items?token=<TOKEN>" \-H "Content-Type: application/json" \-d '{"hotels": ["ChkIg-b2ismUj7M1Gg0vZy8xMWg3MThreGg1EAE"], "checkIn": "30 days", "nights": 1, "currency": "USD"}'
- n8n, Make, Zapier: a Schedule trigger, an HTTP Request (or the Apify node) calling
run-sync-get-dataset-itemswith the input above, a filter onundercut_bynot empty, and a Slack, email or Sheets node — four nodes for a parity alert. - AI agents and MCP: the actor is available through the Apify MCP server and Apify AI; the README, input schema and flat rows are written so an agent can answer "is anyone undercutting our direct rate for next weekend?" from one run.
- Google Sheets, BigQuery, Airtable: export the dataset from the run page or through Apify's integrations;
sourcesis a nested array, so flatten it or keep the summary columns.
Is it legal to check rate parity with scraped prices?
The actor reads publicly displayed prices — the same figures any visitor sees without logging in — and stores no personal data: rows describe properties, booking sources and rates, not people. Comparing public rates across channels is standard practice in the industry (it is what every rate shopping tool does), but terms of service and local law differ; check that your use complies, and use the data for your own analysis rather than republishing it as Google's.
How long does a run take?
Each property and stay is one Google call, paced at perIp requests per second on each of sessions proxy IPs (defaults 0.5 and 4, so about 2 calls a second at most). A name costs one search per run, and a property whose rates name no official site one small lookup per run. Measured on Apify on 2026-11-18 with the defaults:
| request | property-stays | run time |
|---|---|---|
| 2 properties by URL, one stay (the form's example) | 2 | 4 s |
| 3 vacation rentals by URL × 7 check-in dates | 21 | 20 s (48 s before 1.3) |
| 5 hotels by name × 7 check-in dates | 35 | 28 to 38 s |
2 hotels × 30 check-in dates (sweepDays 29) | 60 | 35 to 76 s |
Plan about one second per property and stay; the pace follows the proxy IPs a run draws, so the same input can take twice as long on another run. For long sweeps raise sessions (up to 16) rather than perIp.
The run timeout never loses a run. About 10% before the timeout you set (at least 20 s) no new property and stay starts; in the last ~3% no request is sent, and in the last seconds anything still waiting on Google is dropped. The run ends SUCCEEDED with every row it delivered (and charged), SUMMARY.time_hit: true, SUMMARY.timeout_skipped = the property-stays not checked (never charged, no row), and the status message ends stopped before the run timeout (time_hit): N of M jobs not run. Until 1.3 such a run was stopped by the platform as TIMED-OUT, with no SUMMARY and no status message. Re-run the rest with a longer timeout, fewer stays or more sessions.
Limits and honest notes
- Rates are what Google Hotels displays for the market (
country) and currency you choose. Proxy location can affect tax presentation. Keep the request context consistent and verify each source's taxes and fees before treating a difference as comparable; a shared market and currency do not prove identical rate terms. - Sources per property vary by market and day: 4 to 36, about 18 on average (measured on 174 hotels with the same call). A property with a rate on only one source still gets a row (spread 0); a property with none gets a free
no_ratesstatus. - Official-site detection is Google's. A few properties are listed under a marketplace brand (a property manager, a franchise engine) and carry no official flag; the row then has
official_price: null. Google also drops the official listing on some runs and shows it again the next: confirm a missing direct rate on a second run. - Google's comparison shows each source's lowest offer for the occupancy. Use the parent scraper with
offerLevel: "rooms"to inspect room-level offers, then verify room, cancellation and other rate terms across channels; collecting room offers does not itself prove equivalence. - Name lookups are guarded, not clairvoyant: a name Google lists several matching properties for is refused, but a name Google itself resolves to one property is taken when that property carries most of your distinctive words. Check the
entity_idonce, then switch tohotels. - Google changes its internal formats occasionally; a daily canary run watches for that, the actor is rebuilt within days, and every run reports
statusrows so a failure is visible rather than a silent zero.
FAQ
Does it need a Google Hotels API key or a Google account?
No. There is no public API for reading Google Hotels prices; the actor reads the public results through Apify's proxies. No login, cookies or API key.
What is rate parity, in the terms this actor uses?
Rate parity compares the same room and rate terms across channels, including your own site. This row summarizes displayed source minima: spread_pct is the gap between cheapest and dearest, and undercut_pct is how far the cheapest OTA is below the official quote. Scan undercut_by for candidate gaps to investigate; official_price is the direct quote Google shows. The row does not verify identical room or rate terms, and an absent official quote leaves that comparison unknown.
Can it run a rate parity check for my whole comp set every morning?
Yes: list the properties in hotels (or hotelNames for the first run), add sweepDays for the booking window, and schedule the actor in Apify Console. Save each run's separate dataset externally. Relative checkIn observes a moving lead time; absolute dates retain a fixed stay. minSpreadPct filters the source spread; keep it zero and qualify official_price, undercut_by and undercut_pct downstream for a direct-undercut alert.
Why is the OTA cheaper than my official site?
Usually a wholesale or bed-bank rate resold on a metasearch-facing OTA, a member price shown to everyone by a listing site, or a stale rate on a channel you stopped updating. The sources array names the exact source and gives its booking link, so the trail starts from the row.
Which booking sites are compared?
Every source Google Hotels lists for that property and market — the big OTAs, metasearch resellers and regional sites — plus the official site when Google identifies one. Names and source_ids come straight from Google.
Does the price include taxes and fees?
It is the nightly and total figure Google Hotels shows. Tax presentation can depend on proxy location. Verify source-level taxes, fees and rate terms before a like-for-like conclusion; the Actor compares displayed minima and does not prove those terms match.
How is this different from the Google Hotels Prices Scraper?
Same data, different shape. The parent returns one row per source (and can go to room level); this one returns one row per property and stay with the comparison and the parity math done, filters on spread before billing, and accepts names. Use the parent when you need every source as its own row or room-level offers.
Can a hotel name bill the wrong hotel?
Not since 1.4. Other scrapers, and this one until 1.3.1, match a name on shared words, and the words people type are often generic: on 2026-11-18 version 1.3.1 billed "Wyanna Villa LEGIAN" for the invented "Zorblax Villa Legian" and "Kuta Seaview Beach Resort" for "Kuta Beach Zimzam Resort" (run kaSjvdxOwyJvLnBEh), and Altis Grand Hotel twice when it was given by its Google Hotels URL and by its Google Maps place id (hM4CPiCvWHqa5DeBq). Now lodging words and the town do not count, a name that matches no listed property or several is a free not_found row with the reason, and a hotel is one property however it is given (tests test_a_name_never_bills_a_look_alike_or_a_stranger, test_a_hotel_by_url_and_by_its_google_maps_place_id_is_billed_once). For an exact match every time, pass the hotel's Google Hotels URL, Google Maps link or place id in hotels.
What happens to an input field this actor does not know?
The run never fails on it: it is left out, listed in SUMMARY ignored_fields and named at the end of the status message (; ignored unknown input fields: …). A checkOut date, which google-hotels-prices takes, is read as the stay when nights is left at 1 (test test_an_agents_check_out_sets_the_stay_when_nights_is_left_at_its_default); until 1.4 it was dropped silently and the run priced one night.
Is there a free tier?
Yes: Apify's free plan covers small runs, and a run that delivers no parity rows costs nothing.
Last verified working: 2026-08-29.
Ready-made runs
Each link opens this actor with the input already filled in — press Start and it runs. Every one is capped, so what it bills is on the page before you run it. What each returns is spelled out at mtedj.github.io/kestrel-actors-examples/recipes.html.
- Daily Parity Violation Report for Hotels
- Direct Booking Rate Undercut Check
- Competitor Rate Shopping Without a Seat
- Rate Parity Check for a Single
- Rate Parity Monitoring Across 30 Days
- Rate Parity Checker: Spreads Over 10%
- Rate Audit on the German Market
- Rate Shopping Tool for a Group
- OTA Price Comparison for Weekend Stays
- Price Comparison at Family Occupancy
- Rate Shopper for the UK Market
- Google Hotels Rate Parity by Entity URL
Related scrapers
Rate parity is one question about a property. These answer the others, with the same pay-per-delivered-row billing and the same scheduling story:
- Google Hotels Prices Scraper — need every source as its own row, room-level offers, or a whole city search? That is the parent of this actor.
- Agoda Reviews Scraper — Agoda guest reviews with separate positives and negatives.
- Airbnb Reviews Scraper — every guest review of an Airbnb listing, with translations.
- Airbnb Scraper — Airbnb prices, availability calendars and occupancy.
- Google Flights Scraper — airfare for a route and date, with a cheapest-day sweep.
All of them bill per delivered row, never charge for rows a filter or a spending limit removed, and write an Apify dataset you can export to CSV, Excel or JSON.