Hotel Prices from Google Hotels: Vendor Rates, History

Get Google Hotels prices for a destination (a city, area or landmark) and dates as structured data: one row per hotel with the nightly price, stay total and, where Google shows them, rating, star class (hotels only) and coordinates.

An example row from a search for Lisbon, captured on 9 Oct 2026 (image link and URL shortened):

{
  "hotelId": "ChkI7drbt9vwh-JTGg0vZy8xMWI2cGMwcjE4EAE",
  "name": "InterContinental Lisbon",
  "propertyType": "hotel",
  "hotelClass": 5,
  "rating": 4.6,
  "reviewCount": 2998,
  "address": null,
  "latitude": 38.726817,
  "longitude": -9.1552236,
  "checkIn": "2026-10-23",
  "checkOut": "2026-10-25",
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "leadPrice": {"perNight": 204.06, "total": 408, "currency": "USD", "vendor": null, "isSponsored": null},
  "vendorRates": null,
  "amenities": [],
  "amenityCodes": [165, 29, 15, 2, 18, 8, 4, 23, 24, 1, 31, 27, 7, 11, 25],
  "url": "https://…",
  "filtersApplied": {"google": [], "actor": []},
  "history": [],
  "scrapedAt": "2026-10-09T06:30:32.350585+00:00"
}

A default run (the prefilled input: Lisbon, 2 adults, a two-night stay, 5 hotels) costs up to about $0.02 on the free tier: 5 hotel rows at $0.003 each, plus the $0.005 Actor start fee. It costs less if fewer hotels come back, and a run that returns no rows (blocked, or nothing matched) fails visibly and costs only the start fee. Hotel rows cost less on higher Apify plans; the start fee is flat.

Run it with the default input. Press Start with the prefilled input to get rows like the one above.

At a glance

• You pay only for what you ask for. Each hotel row you receive is one hotel event. Vendor rates are off unless you switch them on, and are charged only for hotels that come back with rates. A history row is charged only when it holds two or more snapshots, and a one-snapshot row is free. A run that returns no rows is charged the start fee only. tracked mode makes no request to Google and is also the start fee only.
• Vendor rates. With includeVendorRates on, each hotel carries one entry per booking vendor Google lists, with that vendor's cheapest price for the stay before taxes (perNight, total) and, as Google shows them, with taxes and fees (perNightWithTaxes, totalWithTaxes), plus vendorDomain and how many offers were collapsed into the entry. In hotel mode the entry comes from Google's hotel page instead: total is null there (Google shows no pre-tax stay total, and the Actor never works one out), and so are guests and vendorDomain.
• Stored price history. The Actor stores lead-price snapshots for the hotels it tracks. history mode returns those stored snapshots, oldest first, with the change in nightly price between one snapshot and the next, and makes no request to Google.
• What it leaves out. No booking links, no reviewer names and no review text. Prices are the figures Google shows, never converted or adjusted.

First run. Press Start with this input (it is the prefilled example, except that it asks for euros):

{"mode": "search", "searches": [{"destination": "Lisbon", "adults": 2, "rooms": 1}], "currency": "EUR", "country": "pt", "maxItems": 5}

It returns up to 5 Lisbon hotels for a two-night stay starting 14 days after the run, and costs up to about $0.02: 5 hotel rows at $0.003 and the $0.005 start fee. Add "includeVendorRates": true to see each vendor's price for each hotel that has them.

What it does

This Actor is not affiliated with, endorsed by or sponsored by Google.

Get hotel prices from Google Hotels as structured data. Search a destination and a pair of dates and get one row per hotel: the lead nightly price Google shows, the total for the stay and, where Google gives them, star class (hotels only), guest rating, review count and coordinates, plus amenity labels (mainly vacation rentals). In search mode and hotel mode you can add the per-vendor rates (the rate each booking vendor and OTA shows, such as Booking, Expedia and other booking vendors) to each row, for rate comparison and price comparison; in hotel mode they carry no pre-tax stay total. You can also look up specific hotels by Google hotel id or Google Travel URL for one pair of dates, and read lead-price history (intended weekly, normally on a Sunday) for the hotels in the cities the Actor tracks, for price tracking over time. It needs no browser and returns no reviewer fields, and AI agents can find it through Apify's MCP server.

It is for travel-analytics and rate-intelligence teams, metasearch builders, researchers pricing destinations, and anyone who needs Google's hotel prices as structured data on a stable schema.

When to use it, and when not to

Use it when you want:

• the lead nightly price and the stay total Google shows for a destination and dates, as one row per hotel;
• the rate each booking vendor lists for those hotels (search or hotel mode with includeVendorRates on);
• the same hotels' prices again on later days, to compare them;
• stored lead-price history for the hotels the Actor tracks (history mode).

Do not use it to book or reserve a room: it returns no booking links and makes no reservations. For a hotel you want to book, use the vendor's name (or vendorDomain, where it is filled; it is always null in hotel mode) together with the row's url. Rates are the lead prices Google returns for the dates you asked, not a quote: check the vendor's final price, including taxes and fees, at booking: the with-tax figures in vendorRates are also only what Google displays. It does not return cancellation terms or reviewer text.

Prices come back in US dollars unless you ask otherwise. To get pounds, set currency to GBP (and language to en-GB, country to uk, if you also want Google's UK results); other ISO 4217 codes are accepted in the same field, and each row's currency is the code Google returned.

If a batch run returns no rows (Google blocks it, or nothing matches), the run fails visibly and no hotel, vendor-rates or history event is charged; only the $0.005 start fee applies. A run blocked part-way keeps, and charges for, the rows it already returned. On Standby a request that finds nothing, or is blocked, gets 200 with empty items and blocked set, and no row event is charged (the start fee is charged once per Standby run).

Every price belongs to the searched dates, and every row carries those dates.

Modes

Mode	Status	What it does	Example question
search	Available	Hotels for each destination and dates in searches.	What do hotels in Lisbon cost for 10 to 12 March?
hotel	Available	The hotels in hotels, for the one pair of dates in dates. With includeVendorRates on, adds per-vendor rates from Google's hotel page (no pre-tax total).	What does this hotel cost for these dates, and what does each booking site charge?
history	Available	Lead-price snapshots, intended weekly (normally on a Sunday), for hotels the Actor tracks, for the dates they are tracked on. See History mode.	How did the lead price for these tracked hotels change between snapshots?
tracked	Available; no event of its own, only the start fee applies	Lists the tracked hotel ids with their dates. See Tracked mode.	Which hotels and dates does history cover?

Vendor rates come with includeVendorRates on: in search mode for each hotel found in a destination, in hotel mode for the hotels you name. A question such as "What do the booking sites Google lists charge for each hotel in Lisbon?" is a search run; the same question for hotels you already know is a hotel run. Three questions to start with: "What do hotels in Lisbon cost for 10 to 12 March?", "What do the booking sites charge for each hotel in Lisbon?" (search with vendor rates on), and "How did the lead price for these tracked hotels change between snapshots?" (history).

Input

The default input (one search for Lisbon, two adults, a two-night stay starting 14 days after the run, 5 hotels in the prefilled input and 20 if maxItems is left out, no vendor rates) runs without changes.

Field	Type	Default	Limits
mode	search, hotel, history, tracked	search	One mode per run. tracked takes no other input and has no event of its own (only the start fee applies).
searches	array of objects	one item: Lisbon, 2 adults, 1 room	search mode. Up to 20 items; at least 1 in search mode.
searches[].destination	string	required	1 to 200 characters; a city, area or landmark. No control characters.
searches[].checkIn, searches[].checkOut	YYYY-MM-DD	see below	checkOut must be after checkIn. If left out, the stay is two nights starting 14 days after the run.
searches[].sweepDays	integer	none	1 to 14. That many consecutive check-in dates, starting at checkIn (or the default start), each for the same number of nights; each date is its own search. A run plans at most 30 stays across all its searches. Hotel rows of every date are charged as hotel events, and maxItems counts them all together, so raise maxItems for a sweep: with the default 20, the first date can use all of it. With includeVendorRates on, every row adds a request, and a run ends early once its per-run request budget is used. search mode only.
searches[].adults	integer	2	1 to 12.
searches[].rooms	integer	1	Must be 1. Google ignores the rooms field, so other values are rejected rather than charged for a setting that changes nothing.
hotels	array of strings	[]	hotel and history modes: Google hotel ids or the hotel's Google Travel page URL. Up to 1,000 entries in hotel mode (the maxItems cap) and 100 in history mode, each up to 500 characters. Required in both modes. A history run stops after 20 untracked hotels in a row; run tracked first to see what's covered.
dates	object { "checkIn", "checkOut" }	none	hotel and history modes: required, YYYY-MM-DD, checkOut after checkIn. Both modes use 2 adults and 1 room; there is no adults input for them.
includeVendorRates	boolean	false	Adds the per-vendor rates to each row, in search and hotel modes; in history and tracked modes it is rejected with an input error. In search mode it makes one extra request per hotel. In hotel mode it makes none (the rates come from the hotel page the Actor already reads), and total, guests and vendorDomain are null there. Charged as its own event (see Pricing).
filters	object	{}	See Filters.
sortBy	relevance, price, rating, reviews	relevance	Order of results as Google sorts them.
currency	string	USD	ISO 4217 code, three capital letters. Each row's currency field is the code Google returned, normally this one.
language	string	en	Google's hl, e.g. en or en-GB.
country	string	us	Two lowercase letters; Google's gl.
maxItems	integer	20	1 to 1,000. Hotels returned per run, across all searches.

One search returns at most about 540 hotels (30 pages), whatever maxItems is.

There is no proxy input. The Actor manages its own network egress.

Example input

A search run for two destinations with fixed dates, vendor rates on and a rating filter (illustrative values; use your own future dates):

{
  "mode": "search",
  "searches": [
    { "destination": "Lisbon", "checkIn": "2026-11-06", "checkOut": "2026-11-08", "adults": 2 },
    { "destination": "Porto", "checkIn": "2026-11-06", "checkOut": "2026-11-08", "adults": 2 }
  ],
  "includeVendorRates": true,
  "filters": { "minRating": 4.0 },
  "sortBy": "price",
  "currency": "GBP",
  "maxItems": 40
}

A hotel run for specific hotels and one pair of dates (illustrative: the hotel id and dates are examples, so use your own future dates; a past date fails the run, which still pays the start fee):

{
  "mode": "hotel",
  "hotels": ["ChkI7drbt9vwh-JTGg0vZy8xMWI2cGMwcjE4EAE"],
  "dates": { "checkIn": "2026-11-06", "checkOut": "2026-11-08" }
}

Filters

minPrice, maxPrice, minRating and hotelClass are applied by the Actor after the results are fetched, and each row's filtersApplied.actor lists the ones applied.

Filter	Meaning	Notes
minPrice	Minimum lead price per night, 0 or more	Hotels with no lead price are excluded when a price filter is set.
maxPrice	Maximum lead price per night, 0 or more	As above.
minRating	Minimum guest rating, 0 to 5	Hotels with no rating are excluded.
hotelClass	Array of star classes, each 1 to 5	Hotels with no star class are excluded.
freeCancellation	Rejected for now	Vendor entries now show Google's free-cancellation text where the vendor-rates lookup carries it (see vendorRates.freeCancellation), but filtering by it is not built: the input is still rejected.
amenities	Rejected for now	Most hotels carry Google's amenity codes without labels (see amenityCodes), so there is nothing reliable to match against.

Because filters are applied after fetch, a run with a narrow filter can fetch many hotels to return few. If every hotel is filtered out, the run ends as blocked with the reason "no hotel matched the filters" and charges no hotel/vendor-rates/history event (only the platform's own start fee applies).

Very narrow filters can stop a search early (after 6 pages with no match, or once far more hotels were checked than returned); sorting by price or rating pages toward matches faster. The run summary's stoppedEarly says when this happened.

Output

One row per hotel per search (search), per looked-up hotel (hotel), or per tracked hotel (history).

Prices (leadPrice and vendorRates) are the figures Google shows for the searched dates, nightly and for the whole stay, rounded half-up to the currency's minor unit (2 decimals for USD, 0 for JPY). For US searches, vendor-offer prices are before taxes and fees as Google splits them, and the lead price appears to be on the same basis (not separately verified). For US searches Google also lists a with-tax figure for vendor offers, which the Actor does not return. Some mandatory fees (for example resort fees) may or may not be included. In other countries prices may be tax-inclusive; we have not verified this. The Actor reports what Google shows and never adds or removes taxes or fees. total is the stay total at that price, not a booking total, so check the vendor's final price at booking.

Field	Type	Notes
hotelId	string	Google's property id, stable across searches.
name	string
propertyType	string or null	hotel when Google shows a star class; the vacation-rental label Google shows when present; otherwise null.
hotelClass	integer or null	Star class, 1 to 5.
rating	number or null	Google's aggregate guest rating, rounded to one decimal (half-up).
reviewCount	integer or null	Number of reviews behind the rating.
address	string or null	Filled in hotel mode. Null in search mode (a search result does not carry it), and normally null in history mode (stored rows come from search results).
latitude, longitude	number, each nullable
checkIn, checkOut	date	The searched itinerary, on every row.
nights, adults, rooms	integer	The searched itinerary.
leadPrice	object or null	The price Google shows first: perNight, total, currency, vendor, isSponsored. A hotel with no lead price is not returned, so rows always carry it. Search results do not attribute the lead price to a vendor, so vendor and isSponsored are filled only when includeVendorRates is on and a vendor's offer matches the lead price; otherwise null. In hotel mode they stay null, because the match is on total, which is null there.
vendorRates	array or null	Null unless includeVendorRates is on. One entry per vendor: in search mode that vendor's cheapest total across Google's room groups; in hotel mode the figures Google's hotel page shows for the vendor, with total, guests and vendorDomain null and offerCount the number of different offers seen. Fields: vendor, perNight, total, perNightWithTaxes, totalWithTaxes, currency, guests, isSponsored, bookingUrl, bookingUrlType, vendorDomain, offerCount, freeCancellation.
amenities	array of strings	Google's own labels, only where Google serves them (vacation rentals carry inline labels). Empty otherwise.
amenityCodes	array of integers	Google's numeric amenity codes as served, for hotel-type records whose labels are not in the response. Empty otherwise. No labels are guessed.
imageUrl	string or null	A thumbnail link as served by Google. The image is not ours and is not copied or served by this Actor; only the link is returned.
url	string	The hotel's Google Travel page.
filtersApplied	object	google and actor: which filters each side applied. Today every filter is applied by the Actor.
history	array	Empty in search and hotel modes. In history mode: { readAt, leadPrice, deltaPerNight } per snapshot, oldest first. deltaPerNight is that snapshot's leadPrice.perNight minus the previous one's, null for the first snapshot or when either price is missing.
scrapedAt	ISO 8601 date-time

Within vendorRates:

• offerCount is how many of Google's room-group offers were collapsed into that vendor's cheapest entry. In hotel mode it is the number of different offers Google's hotel page shows for the vendor.
• perNight and total are the prices Google shows before taxes and fees. perNightWithTaxes and totalWithTaxes are Google's own figures for the same offer with taxes and fees included. Google gives only the combined figure, so there are no separate tax or fee fields, and the Actor never works one out by subtraction.
• bookingUrl and bookingUrlType are always null. Google's click links carry session identifiers, which the Actor never passes on.
• vendorDomain is the vendor site's registrable domain only (for example booking.com, not www.booking.com or secure.booking.com), or null when Google's link does not carry one; always null in hotel mode, where Google's hotel page carries no landing link. To book, use the vendor's name or vendorDomain together with the row's url (Google's hotel page).
• freeCancellation is Google's own free-cancellation text for some room offer of this vendor, for example "Free cancellation until Oct 9", or "Free cancellation until 9 Oct" in British English (the date has no year, as Google shows it; both date orders are matched). It is not the offer behind total, not a cancellation guarantee and not the vendor's terms: check the vendor's terms before booking. Null when the Actor did not find Google's text in one of these two exact forms.

Example search row without vendor rates (values illustrative):

{
  "hotelId": "ChIJ…",
  "name": "Hotel Example Lisboa",
  "propertyType": "hotel",
  "hotelClass": 4,
  "rating": 4.6,
  "reviewCount": 2310,
  "address": "Rua Exemplo 1, Lisbon",
  "latitude": 38.71,
  "longitude": -9.14,
  "checkIn": "2026-11-06",
  "checkOut": "2026-11-08",
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "leadPrice": { "perNight": 142, "total": 284, "currency": "EUR", "vendor": null, "isSponsored": null },
  "vendorRates": null,
  "amenities": [],
  "amenityCodes": [6, 29, 2, 4, 23, 1, 11],
  "imageUrl": "https://…",
  "url": "https://…",
  "filtersApplied": { "google": [], "actor": ["minRating"] },
  "history": [],
  "scrapedAt": "2026-09-28T10:00:00Z"
}

With includeVendorRates on, leadPrice.vendor and leadPrice.isSponsored are filled when a vendor's offer matches the lead price, and vendorRates holds entries like this one (illustrative):

{
  "vendor": "Booking.com",
  "perNight": 142,
  "total": 284,
  "perNightWithTaxes": 160,
  "totalWithTaxes": 320,
  "currency": "EUR",
  "guests": 2,
  "isSponsored": false,
  "bookingUrl": null,
  "bookingUrlType": null,
  "vendorDomain": "booking.com",
  "offerCount": 3,
  "freeCancellation": "Free cancellation until Oct 9"
}

History mode

history mode returns lead-price snapshots (intended weekly, normally on a Sunday) for hotels the Actor tracks, for the dates they are tracked on. It makes no Google request: it reads stored snapshots.

• Input: mode: "history", hotels (ids or Google Travel URLs) and dates. Adults are fixed at 2.
• Tracked hotels come from a seed set of 50 cities (20 in the US, 10 in the UK and 20 elsewhere in Europe): the top 20 hotels Google ranks in each when first read (a hotel that later drops out of the top 20 stays tracked until its stay date). Stays are two nights, 2 adults, starting 2 and 6 weeks out, and are re-read on an intended weekly cadence (normally on a Sunday). Run tracked (no event of its own; only the start fee applies) for the exact list.
• Rows are returned as tracked: one fixed series (USD, US locale). The currency, language and country inputs do not change them.
• includeVendorRates is rejected in this mode, and history rows carry no vendor rates.
• One row per tracked hotel, with history listing its snapshots oldest first.
• A hotel and dates that are not tracked return no row and are not charged. If none of the requested hotels is tracked, the run fails with "none of the requested hotels are tracked for these dates".
• A row with two or more snapshots is charged the history event; a row with one snapshot is free.

No coverage beyond the seed set is promised. Run tracked first to see which hotels and dates history covers.

Tracked mode

tracked mode has no event of its own (only the start fee applies) and makes no Google request. It lists the hotels currently tracked, and it writes the list to the run's key-value store record TRACKED_HOTELS, not to the dataset.

• Input: mode: "tracked". Nothing else is needed; includeVendorRates is rejected.
• The record holds generatedAt, count and items. Each item has hotelId, checkIn, checkOut, adults and destination (the seed city), sorted by destination, then check-in, then hotel id.
• Use an item's hotelId as hotels and its checkIn / checkOut as dates in a history run. history uses 2 adults.
• This code charges no hotel/vendor-rates/history event for a tracked run - only the platform's own apify-actor-start launch fee applies, the same as any run.

Standby

On Apify Standby this Actor also answers two HTTP endpoints directly, instead of running as a single batch job:

• GET /search?destination=&checkIn=&checkOut=&max= - the same validation as search mode's input (destination up to 200 characters, rooms must be 1 if given at all). Optional: adults, sortBy, currency, language, country, includeVendorRates, and the filters as query parameters (minPrice, maxPrice, minRating, hotelClass, repeated or comma-separated). max is 1 to 100 (narrower than batch's maxItems, since one call answers in a single response) and defaults to 20; capped at 20 when includeVendorRates is on (each vendor-rates lookup takes a few seconds and all of them must finish inside the request timeout).
• GET /hotel?id=&checkIn=&checkOut= - the same validation as hotel mode's input. Optional: currency, language, country. includeVendorRates=true is rejected here; vendor rates for one hotel come from a batch run in hotel mode.

Both use the same validation, normaliser, dedupe and filters as a batch run of this Actor, and return { "items": [...], "count", "blocked": null | "<reason>", "vendorRatesCharged": n, "chargeLimitReached": true | false } - items is exactly the Output row schema above; vendorRatesCharged is how many of the returned rows actually got the extra vendor-rates charge (normally equal to how many carry vendorRates, but can be lower if that one extra charge failed after the hotel charge already succeeded - the rows are still returned either way); chargeLimitReached is true when the run's own charge limit either trimmed max before fetching anything or was actually hit while charging, false otherwise. Nothing is pushed to this Actor's dataset from Standby; the response is the only place the rows go.

Only the parameters listed above are accepted per endpoint: an unknown query parameter, a single-value parameter repeated, or a value that does not parse in its documented format (a plain base-10 integer, a plain decimal, or true/false/1/0 for a boolean) is always rejected with 400, naming the parameter - never silently dropped or defaulted.

Each row returned is charged the hotel event (and vendor-rates too, for a row that ends up carrying vendor rates when includeVendorRates is on) before it is returned, so you are only ever billed for rows you actually got back. A request is charged before its response is written, so a dropped connection after that point is still charged. The platform's own apify-actor-start fee applies once per Standby run (the long-lived server process), not per request. In Standby mode you also pay the Apify platform usage of the run that serves your request - its compute units and proxy traffic - on top of these per-row events; a batch run instead absorbs that platform usage into the row price, as the Pricing section below describes. The platform sets each Standby run's own charge limit, and it can vary by caller - you cannot set or raise it yourself. This Actor reads the limit's remaining headroom from the run itself before fetching anything and never assumes a figure: a request can be capped below max, or refused outright, by that headroom, and chargeLimitReached says when it was. A request that found candidate rows but whose charge covered none of them gets 402 ("the run's charge limit allows no further rows"); a request that found nothing at all (or was blocked) gets 200 with items: [] and a blocked reason, and charges no hotel/vendor-rates event either way.

history and tracked mode are not available on Standby.

This server handles one request at a time: a second request made while one is already in progress gets 503 immediately (not queued), so you should not send concurrent requests to your own running instance. After a request ends because Google refused it, the instance answers every request with 503 and the code blocked-cooldown for about ten minutes without contacting Google, nothing is charged, and Retry-After says how long is left (the timer is kept in memory, so a restarted instance starts without it). That run (including its platform usage above) stops after 60 idle seconds, so an idle endpoint costs you little. The first response from a run must arrive within 5 minutes including cold start (an Apify platform limit); this Actor's own request timeout shrinks accordingly for a run's very first request only, so that limit is always met.

See .actor/web_server_schema.json for the full OpenAPI description, including every parameter and error code.

Pricing

What you pay for, and what you get. Billing is per hotel row. In search and hotel modes, and on the Standby endpoints, each hotel row you receive is one hotel event, and rows you don't receive are not charged (on Standby a request is charged before its response is written, so a dropped connection is still charged). history mode charges no hotel event. Two add-ons are priced separately and charged only when used: vendor-rates, for each hotel row that comes back with its per-vendor rates when includeVendorRates is on (search mode, one extra request per hotel; hotel mode, no extra request), and history, for each history row with two or more snapshots. Apify's own start fee applies once per run. A hotel row carries the hotel's Google id and page, its name, the lead nightly price and the stay total in your currency (history rows are always USD; a hotel with no lead price is not returned), and, where Google shows them, property type, star class, guest rating, review count and coordinates. Amenities are Google's labels for vacation rentals; most hotels carry Google's numeric amenityCodes instead. With vendor rates on, a row adds each vendor's cheapest price: in search mode its total before and with taxes and, where available, the vendor's domain; in hotel mode its per-night prices and total with taxes, with no pre-tax total and no domain. History covers only the hotels the Actor tracks itself, the top 20 when first read in each of 50 cities for 2-adult, 2-night stays starting 2 and 6 weeks out; run tracked (no event of its own; only the start fee applies) for the exact list. bookingUrl is always null by design: Google's click-through links carry session identifiers, which the Actor never passes on.

Pay per event. Prices below are the free-tier prices; paid Apify tiers are discounted on the events below (not the start fee): Bronze, Silver and Gold at 10%, 20% and 30% off the free-tier price; Platinum and Diamond at the Gold price.

Standby pays platform usage too. In Standby mode (see above) you also pay the Apify platform usage of the run that serves your request - its compute units and proxy traffic - on top of the events below. A batch run instead absorbs that platform usage into the row price; there is nothing extra to pay beyond the table below for a batch run.

Event	Charged when	Price
Actor start (apify-actor-start)	Charged by Apify itself, at launch - not by this Actor's own code.	$0.005 per GB of memory (1,024 MB default = one event)
hotel	Each hotel row pushed to the dataset.	$0.003 ($3.00 per 1,000)
vendor-rates	Each hotel row that carries vendor rates, in search or hotel mode, and only when includeVendorRates is on. Charged on top of hotel, not instead of it. Never charged otherwise.	$0.0025 ($2.50 per 1,000)
history	Each history row with two or more snapshots. A one-snapshot row is free.	$0.01

Worked example (free-tier prices, batch run, at the default 1,024 MB memory). A search that returns 20 hotels with vendor rates on costs 20 x ($0.003 + $0.0025) + $0.005 start = $0.115: each row is charged hotel and, because it carries vendor rates, vendor-rates as well. The same search without vendor rates costs 20 x $0.003 + $0.005 = $0.065. A run that returns nothing costs only the $0.005 start fee.

What $5 of Apify credit buys (free-tier prices, batch runs, at the default 1,024 MB memory).

Run	Cost per run	Whole runs per $5
Default input (5 hotels, no vendor rates)	$0.02	about 250
20 hotels, no vendor rates	$0.065	about 76
20 hotels, vendor rates on	$0.115	about 43
100 hotels, no vendor rates	$0.305	about 16

Paid Apify tiers discount the hotel and vendor-rates events (not the start fee), so the same credit buys somewhat more.

tracked mode charges no event of this Actor's own. history mode does not charge hotel. Blocked or empty runs charge no hotel/vendor-rates/history event: no row stored means no row charge - only the platform's own start fee applies, the same as any run. A run blocked after some rows were stored charges those rows. Filtered-out hotels are not pushed and not charged.

What to expect

• A run that gets no rows fails visibly. If Google refuses the requests or the responses no longer match the expected layout and no row was returned, the run ends with an error status ("Blocked:
• Currency is what Google returns. In search and hotel modes each row's currency is the code Google returned with the price, normally the one you set in currency. The Actor never converts. History rows are requested in USD.
• No booking links. bookingUrl is always null because Google's click links carry session identifiers, which the Actor never passes on and never follows. Use the vendor's name (and vendorDomain where it is filled) with the row's url.
• Network egress is managed by the Actor. There is no proxy setting to configure.

Recipes

Run it on a schedule. Save your input as a saved task in the Apify Console, then add the task to a schedule (for example daily at 06:00). A new schedule starts disabled, so enable it. Each run writes its own dataset, and you pay for each run as usual.

Run daily and compare. Use the same destination with fixed checkIn and checkOut dates; if you leave the dates out, the stay moves forward with each run and the days are not comparable. Each day, export the dataset and match rows by hotelId: the change in leadPrice.perNight between two days is that hotel's price move for those dates. For the hotels the Actor already tracks, history mode returns these weekly changes for tracked hotels on their tracked dates (run tracked first to see the list; deltaPerNight).

Compare vendors. Run search with includeVendorRates on and read each row's vendorRates: one entry per vendor with its cheapest total for the stay. For hotels you already know, run hotel with includeVendorRates on (no pre-tax total there).

FAQ

How do I get prices in another currency, language or country? Set currency (e.g. GBP), language (e.g. en-GB) and country (uk for the United Kingdom: it returned a normal Google results page when tested; gb has not been tested). They map to Google's curr, hl and gl, sent unchanged. Currency is as Google returns it; nothing is converted.

Why does a price differ from what I see on Google? Every price is specific to the itinerary searched (dates, adults) and to the request being made without a signed-in Google account. Prices you see in your own browser can differ if you are logged in, have a personalised profile or different location, or searched a different number of guests. Google also changes prices frequently, and rooms is not honoured by Google, so it does not affect results.

What are the limits? Up to 20 searches per run, up to 1,000 hotels per run (maxItems), and about 540 hotels per search. Requests are paced at one per two seconds, so large runs take time. As a guide, the default input (5 hotels, no vendor rates) ran in 6 seconds on 12 Oct 2026; larger searches and vendor rates take longer.

Can I filter by free cancellation or amenities? Not yet; see Filters. Vendor entries now show Google's free-cancellation text where the vendor-rates lookup carries it (vendorRates.freeCancellation), but filtering by it is not built: filters.freeCancellation stays rejected.

Does it return cancellation terms? With includeVendorRates on, vendor entries now show Google's own free-cancellation text where the vendor-rates lookup carries it (vendorRates.freeCancellation), but filtering by it is not built: filters.freeCancellation stays rejected. Check the vendor's terms at booking.

Why did my search return fewer rows than maxItems? Very narrow filters can stop a search early (after 6 pages with no match, or once far more hotels were checked than returned); sorting by price or rating pages toward matches faster. The run summary's stoppedEarly says when this happened.

Can I read rate history? Yes, for tracked hotels only; see History mode.

Are prices before or after tax? For US searches, vendor-offer prices are before taxes and fees as Google splits them, and the lead price appears to be on the same basis (not separately verified). Some mandatory fees (for example resort fees) may or may not be included. For other countries we have not verified the basis: the figure is whatever Google shows for that market, and the Actor never adjusts it. Check the vendor's final price at booking.

Legal

This Actor is not affiliated with, endorsed by or sponsored by Google. Google and Google Hotels are trademarks of Google LLC and are named here only to say where the data comes from. You are responsible for how you use the data and for complying with applicable law and terms. This is not legal advice.

The Actor has no reviewer or user fields: it returns no reviewer names and no review text. It returns the listing details Google returns for the search: names, addresses (hotel mode only), coordinates, prices, amenities and vendor names. Vacation-rental rows can be a person's home: a rental's name is free text set by its owner and can contain a host's name, and its coordinates and thumbnail can also point to a home. For history mode it keeps a list of tracked hotel ids and stay dates, and price snapshots for them (intended weekly, normally on a Sunday).

Ratings and reviews

Ratings and reviews on the Store page help other buyers judge whether this Actor fits their use, whatever your experience.

Other Actors from the same publisher

Search the Apify Store for these titles: UK Grocery Prices: Tesco, Sainsbury's, Asda, Aldi; Aldi Australia Price Scraper: Shelf Prices & Special Buys; Rightmove & OnTheMarket UK Property Listings + Sold Prices; UK Contracts Finder and Find a Tender Scraper: Gov Contracts; LEI Lookup: Legal Entity Identifier Search by Name or Status; UK Importers and Exporters: HMRC Trade Data.

About

From Yappman Data, a trading name of Abley-Yapp Consulting Limited. Contact: info@yappman.com.