# Google Hotels Prices Scraper | OTA Rates & Rate Parity (`zrk1212/google-hotels-prices-scraper`) Actor

Scrape Google Hotels prices from every seller Google lists (Booking.com, Expedia, Hotels.com, Agoda, the official site and more, typically 15 to 30 per hotel) for your exact dates. City search, hotel lists, date sweeps, rate-parity flags and price-change monitoring.

- **URL**: https://apify.com/zrk1212/google-hotels-prices-scraper.md
- **Developed by:** [zachary klein](https://apify.com/zrk1212) (community)
- **Categories:** Travel, E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 hotel prices

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Hotels Prices Scraper

Every OTA's price for a hotel on your exact dates, from Google Hotels, with rate-parity flags.

Google Hotels lists the price from every seller for a hotel and a stay: Booking.com, Expedia, Hotels.com, Priceline, Agoda, Trip.com, KAYAK, the hotel's own site and more, usually 15 to 30 sellers per hotel. This actor returns all of them as structured data, checks that the prices are really for the dates you asked, and computes the gap between the official site and the cheapest OTA.

### What does it do?

- **All seller prices per hotel and date**: nightly price before and after taxes, stay total, free cancellation and its deadline, a deep link to the seller, and a flag for the official hotel site.
- **Correct dates, guaranteed**: Google silently shows prices for other dates when it cannot price yours (past dates, or dates too far ahead). This actor compares the dates Google priced with the dates you asked for and returns a free error row instead of wrong prices.
- **Rate parity per hotel-date**: official price vs cheapest OTA, the gap in money and percent, which OTAs undercut the hotel, and how many sellers offer free cancellation.
- **City and hotel-list search, date sweeps and monitoring**: search a city, list specific hotels, sweep a month of check-in dates for a price calendar, and use a monitor key so only changed prices are output and charged.
- **Two modes**: `prices` (per-seller prices) and `search` (a cheaper hotel list with lowest price, rating, class, amenities, coordinates).

### Who is it for?

- **Hotel revenue managers** checking rate parity and OTA undercutting: official site vs Booking.com and Expedia.
- **Hotel groups** tracking a competitor set every day (`monitorKey` plus an Apify schedule).
- **Travel deal sites and arbitrage tools** that need the cheapest OTA per hotel.
- **Event and market analysts** who sweep a month of check-in dates to build a price calendar.
- **Travel startups and analysts** who need structured Google Hotels data over an API or MCP.

### What data do you get?

Prices mode, one row per hotel per stay date (`outputFormat: perHotel`):

| Field | Example |
|---|---|
| `id` | `ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB\|2026-12-18\|2026-12-20\|2a\|USD` (stable) |
| `name`, `hotelClass`, `rating`, `reviewCount` | `Hotel Van Zandt`, `4`, `4.5`, `4401` |
| `address`, `website`, `latitude`, `longitude` | `605 Davis St, Austin, TX 78701` |
| `checkIn`, `checkOut`, `nights`, `adults`, `currency` | `2026-12-18`, `2026-12-20`, `2`, `2`, `USD` |
| `lowestPrice`, `lowestPriceWithTaxes` | `178`, `216` (nightly, Google's organic lowest) |
| `sellerCount`, `sellers` | `18`, the list of every seller (see below) |
| `cheapestSeller`, `cheapestPrice` | `KAYAK.com`, `166` |
| `officialSeller`, `officialPrice` | `Hotel Van Zandt`, `314` |
| `parityGap`, `parityGapPct`, `undercutters` | `148`, `47.1`, `["Hotels In America","Super.com"]` |
| `parityPriceBasis` | `withTaxes` (see the FAQ) |
| `freeCancellationSellers` | `8` |
| `googleHotelsUrl` | opens the same hotel and dates on Google Hotels |

Each entry of `sellers`: `seller`, `partnerId`, `isOfficial`, `isSponsored`, `nightlyPrice`, `nightlyPriceWithTaxes`, `totalPrice`, `totalPriceWithTaxes`, `freeCancellation`, `freeCancellationUntil`, `bookingUrl`, `logoUrl`.

With `outputFormat: perSeller` you get one flat row per seller per hotel-date (same prices, better for spreadsheets). Search mode rows contain the hotel fields, `amenities`, `lowestPrice`, `priceInsight` and `position` but no per-seller prices.

### How much does it cost?

You pay per result. Apify also charges a small start fee per run.

| What you get | Price per 1,000 | 100 | 1,000 | 10,000 |
|---|---|---|---|---|
| Hotel-date with all sellers' prices (prices mode) | $4.00 | $0.40 | $4 | $40 |
| Hotel from search results (search mode) | $1.50 | $0.15 | $1.50 | $15 |

A hotel-date is one hotel for one check-in date. 10 hotels over 30 check-in dates is 300 hotel-dates, which is $1.20. The `perHotel` and `perSeller` formats cost the same.

**You are never charged for:** error rows (including blocked pages and unsupported currencies), sold-out or unpriced hotels, dates Google did not accept, skipped vacation rentals or hotels below your minimum star class, duplicates, and unchanged hotels in monitor mode.

The free plan's monthly credit is enough to try about 1,000 hotel-dates.

### How to use it

1. Open the actor and keep the example input, or put your own hotels in **Specific hotels** (Google Hotels URLs, entity ids, or `Hotel name, City`) or your own searches in **Search queries**.
2. Pick your dates: either **Check-in date** and **Check-out date**, or **Days ahead** and **Nights** (always in the future, ideal for scheduled runs).
3. For a price calendar, set **Date sweep** (for example 29 extra dates for 30 check-in dates).
4. Click **Start** and read the **Prices (rate parity)** view in the Output tab.

Example input:

```json
{
  "mode": "prices",
  "queries": ["hotels in Austin"],
  "hotels": ["ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB", "ChYI6YrJipS6urUgGgovbS8wYm1nbnBmEAE"],
  "maxHotels": 3,
  "daysAhead": 30,
  "nights": 2
}
```

Advanced inputs: `currency`, `adults`, `childAges`, `includeSponsored`, `propertyTypes`, `minHotelClass`, `monitorKey`, `maxRunSecs`, `maxConcurrency`, `maxResidentialPages`, `proxyConfiguration`.

### Example output

```json
{
  "id": "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB|2026-12-18|2026-12-20|2a|USD",
  "rowType": "hotelPrices",
  "name": "Hotel Van Zandt",
  "hotelClass": 4,
  "rating": 4.5,
  "checkIn": "2026-12-18",
  "checkOut": "2026-12-20",
  "currency": "USD",
  "lowestPrice": 178,
  "lowestPriceWithTaxes": 216,
  "sellerCount": 18,
  "parityPriceBasis": "withTaxes",
  "cheapestSeller": "KAYAK.com",
  "cheapestPrice": 166,
  "officialSeller": "Hotel Van Zandt",
  "officialPrice": 314,
  "parityGap": 148,
  "parityGapPct": 47.1,
  "undercutters": ["Hotels In America", "Super.com", "Prestigia.com", "KAYAK.com"],
  "freeCancellationSellers": 8,
  "sellers": [
    { "partnerId": 121, "seller": "Hotel Van Zandt", "isOfficial": true, "isSponsored": false, "nightlyPrice": 265, "nightlyPriceWithTaxes": 314, "totalPriceWithTaxes": 628, "freeCancellation": true, "freeCancellationUntil": "2026-12-16" },
    { "partnerId": 1681392501, "seller": "Hotels In America", "isOfficial": false, "isSponsored": false, "nightlyPrice": 178, "nightlyPriceWithTaxes": 216, "totalPriceWithTaxes": 433, "freeCancellation": false, "freeCancellationUntil": null },
    { "partnerId": 311056061, "seller": "Super.com", "isOfficial": false, "isSponsored": false, "nightlyPrice": 185, "nightlyPriceWithTaxes": 224, "totalPriceWithTaxes": 449, "freeCancellation": false, "freeCancellationUntil": null }
  ]
}
```

An error row looks like this and is never charged:

```json
{ "error": true, "errorCode": "DATES_UNAVAILABLE", "errorMessage": "Google did not price 2027-12-20 to 2027-12-22 for this hotel (past dates or too far ahead). Not charged.", "input": "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB", "checkIn": "2027-12-20", "checkOut": "2027-12-22", "scrapedAt": "2026-11-18T20:00:00.000Z" }
```

Error codes: `INVALID_DATES`, `DATES_UNAVAILABLE`, `HOTEL_NOT_FOUND`, `QUERY_NO_RESULTS`, `NO_PRICES`, `BLOCKED`, `CONSENT_WALL`, `CURRENCY_UNSUPPORTED`, `PARSE_FAILED`, `TIME_LIMIT`, `UNKNOWN`.

### Use it via API, MCP, n8n, Make or Zapier

```bash
curl -X POST "https://api.apify.com/v2/acts/Zrk1212~google-hotels-prices-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"prices","hotels":["ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB"],"daysAhead":30,"nights":2,"sweepDays":6}'
```

The actor works with the Apify MCP server (AI agents can call it as a tool), n8n, Make and Zapier through the standard Apify integrations. To track prices every day, create a schedule in Apify and set the same `monitorKey` every time: only new and changed hotel-dates are output and charged.

### FAQ

**Is it legal?** The actor reads public hotel pricing shown to any visitor, with no login. Google's terms restrict automated access, and Google's robots.txt disallows `/travel/search`. Inputs given as Google Hotels entity URLs or entity ids only touch `/travel/hotels/entity/...` pages, which robots.txt does not disallow, so use those if you are compliance-sensitive (do not use **Search queries**). You are responsible for your use. The actor is meant for price research and monitoring and collects no personal data.

**Why does my price differ from what I see in my browser?** Logged-in member rates, your location, how taxes are displayed, and the fact that prices change by the minute. Compare `nightlyPriceWithTaxes`, which is the price with taxes and fees.

**What is `parityPriceBasis`?** All parity fields (`cheapestPrice`, `officialPrice`, `parityGap`, `undercutters`) use one price basis for every seller of a hotel-date: `withTaxes` when the official site shows a with-taxes price, otherwise `base`. The two are never mixed.

**Why did I get DATES_UNAVAILABLE?** The dates are in the past, or too far ahead for hotels to have loaded rates (usually about 11 months). If three later dates in a sweep are refused, the rest of that hotel's sweep is marked without more requests.

**Are vacation rentals included?** Not by default. Set `propertyTypes` to include them.

**Which sellers are covered?** Whatever Google shows, typically 15 to 30: Booking.com, Expedia, Hotels.com, Priceline, Agoda, Trip.com, KAYAK, Tripadvisor, Travelocity, the official site and smaller sites. Sellers that appear only in Google's sponsored "Featured options" are flagged `isSponsored`. Set `includeSponsored` to false to leave them out.

**Are amenities included?** In search mode only (version 1). In prices mode `amenities` is always an empty list.

**Which prices do I get, my country or the US?** Prices are what a visitor from the IP's country sees. By default the actor runs without a proxy from the US, so you get US prices. For UK or EU prices set a residential proxy in that country in `proxyConfiguration` (slower). Other countries are best effort, for example EU consent pages are handled but not guaranteed.

**What happens if Google blocks a request?** The actor never tries to solve a CAPTCHA or block page. Block recovery is automatic and included in the price: it waits once, then retries that single page through a US residential proxy, with a per-run cap (`maxResidentialPages`, default 50) and a data cap tied to the number of results you are charged for. If recovery fails you get a free `BLOCKED` row and the run continues. Set `maxResidentialPages` to 0 to turn the retry off.

**Can I track prices every day?** Yes. Schedule the actor and set a `monitorKey`. Only new hotel-dates and hotel-dates where the lowest price, the cheapest organic seller price or the official price changed are output and charged. Changes in which sellers Google lists, without a price move, are ignored.

**Something broke?** Open an Issue on the actor page. Google can change its pages at any time, and a fix usually follows within 24 hours.

### Related actors

- [Workday Jobs Scraper](https://apify.com/zrk1212/workday-jobs-scraper)
- [ATS Jobs Monitor](https://apify.com/zrk1212/ats-jobs-monitor)
- [PageSpeed Bulk Auditor](https://apify.com/zrk1212/pagespeed-bulk-auditor)
- [UK New Company Leads](https://apify.com/zrk1212/uk-new-company-leads)

# Changelog

This Actor's version history is a separate document: https://apify.com/zrk1212/google-hotels-prices-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Prices: one row per hotel per stay date with the price from every seller (or one row per seller, see Output format). Search: one row per hotel from the Google Hotels results list with the lowest price, rating, class, amenities and coordinates. Search is cheaper and has no per-seller prices.

## `queries` (type: `array`):

Free-text Google Hotels searches, for example hotels in Austin, hotels near Times Square, or Paris 5-star hotels. Each query returns up to Max hotels per query hotels.

## `hotels` (type: `array`):

Google Hotels entity URLs (https://www.google.com/travel/hotels/entity/ChoIn5iv34ia.../prices), raw entity ids (ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB) or hotel names with a city (Hotel Van Zandt, Austin). Entity URLs and ids are the fastest and most reliable input.

## `checkInDate` (type: `string`):

Exact check-in date. If empty, Days ahead is used. Dates in the past or more than 330 days ahead return a free error row.

## `checkOutDate` (type: `string`):

Exact check-out date. If empty, check-in plus Nights is used.

## `daysAhead` (type: `integer`):

Used when Check-in date is empty: check-in is today (UTC) plus this many days. Keeps scheduled runs always in the future.

## `nights` (type: `integer`):

Length of stay when Check-out date is empty.

## `adults` (type: `integer`):

Number of adults.

## `sweepDays` (type: `integer`):

Price calendar: also check this many additional check-in dates after the first one (same number of nights). 0 means a single stay. Example: 29 gives 30 check-in dates.

## `sweepStepDays` (type: `integer`):

Days between swept check-in dates. 7 means the same weekday every week.

## `childAges` (type: `array`):

One entry per child, as the age from 0 to 17, for example 8 and 5.

## `currency` (type: `string`):

Three-letter ISO 4217 currency code, for example USD, EUR or GBP. If Google prices a hotel in a different currency, that hotel-date becomes a free CURRENCY_UNSUPPORTED error row.

## `outputFormat` (type: `string`):

perHotel gives one row per hotel-date with a sellers array. perSeller gives one flat row per seller per hotel-date, which suits spreadsheets. You pay once per hotel-date in both formats.

## `includeSponsored` (type: `boolean`):

Include sellers that appear only in Google sponsored Featured options block. They are flagged isSponsored.

## `maxHotels` (type: `integer`):

Maximum hotels per search query. Results are read 20 properties per page, up to 15 pages. Does not limit the Specific hotels list.

## `propertyTypes` (type: `string`):

Google mixes vacation rentals into city results. Hotels skips them, and skipped properties are never charged.

## `minHotelClass` (type: `integer`):

Skip hotels below this star class. 0 keeps all.

## `monitorKey` (type: `string`):

Price-change monitoring: give any name, for example austin-weekend. The actor remembers the last prices under this name and outputs only hotel-dates (prices mode) or hotels per stay (search mode) that are new or whose prices changed. Unchanged ones are not output and not charged.

## `gl` (type: `string`):

Two-letter Google country code. The prices you see follow the country of the IP address, see the README.

## `hl` (type: `string`):

Interface language. Keep en unless you need localized text fields. Prices are read from numeric fields either way.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep it low to stay polite to Google.

## `maxRunSecs` (type: `integer`):

Stop cleanly with partial results after this many seconds. The example input uses 100 so the daily test stays fast. Set 0 (no limit) for larger runs.

## `maxResidentialPages` (type: `integer`):

If Google shows a block page, the actor never solves it. It waits once, then retries that single page through a US residential proxy, up to this many pages per run. Block recovery is automatic and included in the price. 0 turns the retry off and returns a free BLOCKED row instead.

## `proxyConfiguration` (type: `object`):

No proxy is enough for US prices and is the fastest. Set a proxy only if you need another point of sale (use a residential group with that country), which is slower.

## Actor input object example

```json
{
  "mode": "prices",
  "queries": [
    "hotels in Austin"
  ],
  "hotels": [
    "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB",
    "ChYI6YrJipS6urUgGgovbS8wYm1nbnBmEAE"
  ],
  "daysAhead": 30,
  "nights": 2,
  "adults": 2,
  "sweepDays": 0,
  "sweepStepDays": 1,
  "childAges": [],
  "currency": "USD",
  "outputFormat": "perHotel",
  "includeSponsored": true,
  "maxHotels": 3,
  "propertyTypes": "hotels",
  "minHotelClass": 0,
  "gl": "us",
  "hl": "en",
  "maxConcurrency": 4,
  "maxRunSecs": 100,
  "maxResidentialPages": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `prices` (type: `string`):

No description

## `sellers` (type: `string`):

No description

## `hotels` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `stats` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "prices",
    "queries": [
        "hotels in Austin"
    ],
    "hotels": [
        "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB",
        "ChYI6YrJipS6urUgGgovbS8wYm1nbnBmEAE"
    ],
    "daysAhead": 30,
    "nights": 2,
    "maxHotels": 3,
    "maxRunSecs": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zrk1212/google-hotels-prices-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "prices",
    "queries": ["hotels in Austin"],
    "hotels": [
        "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB",
        "ChYI6YrJipS6urUgGgovbS8wYm1nbnBmEAE",
    ],
    "daysAhead": 30,
    "nights": 2,
    "maxHotels": 3,
    "maxRunSecs": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("zrk1212/google-hotels-prices-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "prices",
  "queries": [
    "hotels in Austin"
  ],
  "hotels": [
    "ChoIn5iv34iajuemARoNL2cvMTFidjFubnp6MxAB",
    "ChYI6YrJipS6urUgGgovbS8wYm1nbnBmEAE"
  ],
  "daysAhead": 30,
  "nights": 2,
  "maxHotels": 3,
  "maxRunSecs": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call zrk1212/google-hotels-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zrk1212/google-hotels-prices-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/sXaVKqELlMIwgs4o3/builds/gOG0nDnGfID0aFANO/openapi.json
