# Google Hotels Price Scraper (`symphonic_mullite/google-hotels-prices`) Actor

Reliable Google Hotels price scraper for price monitoring. Get nightly and total prices, booking-site prices (Booking.com, Expedia, official site...), ratings, reviews, hotel class, amenities and location for any city and dates.

- **URL**: https://apify.com/symphonic\_mullite/google-hotels-prices.md
- **Developed by:** [Damian Boni](https://apify.com/symphonic_mullite) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 hotel results

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 Price Scraper

Reliable **Google Hotels price scraper** for hotel price monitoring. Enter a city (or paste a Google Hotels URL), pick your dates and guests, and get every hotel's **nightly price, total stay price, taxes, deal label, rating, reviews, star class, amenities, photos and coordinates**, straight from [Google Hotels](https://www.google.com/travel/hotels). Turn on **booking-site prices** to compare Booking.com, Expedia, Hotels.com, Agoda, Trip.com, the hotel's official site and more, with direct booking links and free-cancellation flags.

Built for recurring runs: relative dates ("14 days from today"), stable hotel IDs for joining runs, fast plain-HTTP requests (no browser), automatic retries with fresh residential IPs, and clear errors instead of silent empty datasets.

### What you can do with it

- **Hotel price monitoring**: schedule a daily run and track how prices move for the same dates, hotels and cities.
- **Revenue management and rate shopping**: see your hotel's price next to competitors and every OTA, per night and per stay.
- **Travel apps and dashboards**: feed live hotel prices, ratings and photos into your product or spreadsheet.
- **Market research**: compare price levels across cities, dates, star classes and neighbourhoods.
- **Deal alerts**: filter by "lowest price" or Google's "X% less than usual" deal labels.

### What data you get

For every hotel on Google Hotels for your destination and stay:

| Field | Example |
| --- | --- |
| Hotel name, position in Google's list | Pullman Paris Tour Eiffel, #1 |
| Price per night and total stay price (taxes and fees included) | $502.09 / $1,004.18 |
| Price before taxes, taxes and fees, currency | $877.01, $127.17, USD |
| Google deal label | "18% less than usual" |
| Rating, review count, rating histogram | 4.6, 17,213 reviews |
| Hotel class | 4 ("4-star tourist hotel") |
| Amenities | Free Wi-Fi, Air conditioning, Restaurant, ... |
| Latitude, longitude, country, website, check-in/out times | 48.8556, 2.2929, FR |
| Photos (thumbnail + up to 10 images) | googleusercontent.com URLs |
| IDs: Google hotel ID, entity ID, Knowledge Graph ID, Maps CID | stable keys for monitoring |
| Google Hotels URL (same dates) and Google Maps URL | |
| **Booking-site prices** (optional): site, nightly and total price, official-site flag, free cancellation (and until when), direct booking link | Booking.com $682/night |
| Address, neighbourhood, phone (with booking-site prices on) | 18 Avenue De Suffren, 75015 Paris |

### How to use it

1. Add one or more **destinations**: a city, area or landmark ("Paris", "Shibuya, Tokyo", "hotels near Times Square"), or paste a Google Hotels URL (search page, `google.com/travel/hotels/<city>` or a single hotel `google.com/travel/hotels/entity/...`).
2. Set the **check-in date** (a date or a relative value like `14 days`) and **nights** (or a check-out date).
3. Choose **adults, children, currency, language and country**.
4. Optionally add **filters**: sort order, minimum rating, hotel class, price range, free cancellation.
5. Optionally switch on **Include booking-site prices**.
6. Run it, then download the dataset as JSON, CSV, Excel or via API, or connect it to Google Sheets, Make, Zapier or a webhook.

#### Price monitoring tips

- Use a **relative check-in date** (`7 days`, `2 weeks`, `1 month`) in a [schedule](https://docs.apify.com/platform/schedules) so every run looks at future dates.
- Join runs on **`entityId`** (or `hotelId`) plus `checkInDate`/`checkOutDate` to build a price history.
- Paste **single-hotel URLs** to track specific properties (with all booking-site prices).
- Keep the same `currency` and `country` between runs: Google can show different prices to visitors from different countries.

### Input example

```json
{
  "destinations": ["Paris", "London", "https://www.google.com/travel/hotels/entity/ChgIxfW9593Qkbu3ARoLL2cvMXRnczA3ZHQQAQ"],
  "checkInDate": "14 days",
  "nights": 2,
  "adults": 2,
  "children": 1,
  "childrenAges": [7],
  "currency": "EUR",
  "language": "en",
  "country": "gb",
  "maxHotelsPerDestination": 100,
  "sortBy": "lowest_price",
  "minRating": "4.0",
  "hotelClass": ["4", "5"],
  "maxPrice": 300,
  "freeCancellationOnly": true,
  "includeBookingPrices": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

| Input | Description | Default |
| --- | --- | --- |
| `destinations` | Cities/areas/landmarks or Google Hotels URLs. Dates, guests, currency and filters inside a pasted URL are used for that URL. | required |
| `checkInDate` | `YYYY-MM-DD` or relative (`14 days`, `2 weeks`, `1 month`) | `14 days` |
| `nights` / `checkOutDate` | Length of stay, or an explicit check-out date (overrides nights) | 1 night |
| `adults`, `children`, `childrenAges` | Guests. Google Hotels prices the whole party; it has no separate room count. | 2 adults |
| `currency` | Any currency Google Hotels offers (72) | `USD` |
| `language`, `country` | Google `hl` and `gl` values | `en`, `us` |
| `maxHotelsPerDestination` | Hotels to save per destination (Google pages 20 at a time) | 20 |
| `sortBy` | `relevance`, `lowest_price`, `highest_rating`, `most_reviewed` | `relevance` |
| `minRating` | `any`, `3.5`, `4.0`, `4.5` | `any` |
| `hotelClass` | Any of `2`, `3`, `4`, `5` | any |
| `minPrice`, `maxPrice` | Nightly price range in your currency | none |
| `freeCancellationOnly` | Only hotels with a free-cancellation rate | `false` |
| `includeBookingPrices` | Per-booking-site prices, links, address and phone (one extra request per hotel) | `false` |
| `proxyConfiguration` | Apify Proxy settings. Residential is recommended; the proxy country follows `country` unless you set one. | Residential |

### Output example

One dataset item per hotel (shortened):

```json
{
  "destination": "Paris",
  "destinationResolved": "Paris",
  "position": 2,
  "name": "Pullman Paris Tour Eiffel",
  "propertyType": "hotel",
  "hotelId": "5592324419017481846",
  "entityId": "ChgIxfW9593Qkbu3ARoLL2cvMXRnczA3ZHQQAQ",
  "knowledgeGraphId": "/g/1tgs07dt",
  "googleMapsCid": "13219831296943946437",
  "url": "https://www.google.com/travel/hotels/entity/ChgIxfW9593Qkbu3ARoLL2cvMXRnczA3ZHQQAQ?ts=...&hl=en&gl=us",
  "googleMapsUrl": "https://www.google.com/maps?cid=13219831296943946437",
  "hotelClass": 4,
  "hotelClassText": "4-star tourist hotel",
  "rating": 4.6,
  "reviewCount": 17213,
  "ratingHistogram": { "1": 625, "2": 301, "3": 613, "4": 1926, "5": 13748 },
  "pricePerNight": 561.81,
  "totalPrice": 1123.63,
  "priceBeforeTaxes": 990.38,
  "taxesAndFees": 133.25,
  "priceText": "$562",
  "currency": "USD",
  "priceAvailable": true,
  "dealLabel": null,
  "bookingPrices": [
    {
      "source": "Pilot",
      "isOfficialSite": false,
      "pricePerNight": 581,
      "totalPrice": 1162,
      "priceText": "581 US$",
      "totalPriceText": "1.162 US$",
      "freeCancellation": false,
      "freeCancellationUntil": null,
      "link": "https://pilotplans.com/stays/pullman-paris-tour-lp27e2f?checkInDate=2026-10-16&checkOutDate=202...",
      "googleRedirectUrl": "https://www.google.com/travel/lodging/clk?pc=...",
      "logo": "https://www.gstatic.com/travel-hotels/branding/1471863362130829129.png"
    }
  ],
  "cheapestBookingTotalPrice": 1124,
  "cheapestBookingSite": "goseek.com",
  "description": "Polished quarters in a sleek hotel offering Eiffel Tower views, chic dining & 23 meeting rooms.",
  "address": "18 Avenue De Suffren, 22 Rue Jean Rey Entrée Au, 75015 Paris, France",
  "area": "Beaugrenelle",
  "phone": "+33 1 44 38 56 00",
  "website": "https://all.accor.com/...",
  "countryCode": "FR",
  "latitude": 48.8556488,
  "longitude": 2.2928584,
  "checkInTime": "4:00 PM",
  "checkOutTime": "11:00 AM",
  "amenities": ["Paid breakfast", "Free Wi-Fi", "Paid parking", "Air conditioning", "Pet-friendly", "Fitness center", "Bar", "Restaurant"],
  "thumbnail": "https://lh3.googleusercontent.com/...",
  "images": ["https://lh3.googleusercontent.com/..."],
  "checkInDate": "2026-10-16",
  "checkOutDate": "2026-10-18",
  "nights": 2,
  "adults": 2,
  "children": 0,
  "scrapedAt": "2026-09-25T20:03:49.387Z"
}
```

The Output tab has three views: **Hotels and prices**, **Booking-site prices** (one row per hotel and site) and **Hotel details**. A run summary (hotels per destination, errors, requests, traffic) is saved to the key-value store as `SUMMARY`.

### Pricing

This Actor uses **pay-per-event** pricing. You pay only for hotels saved to your dataset; Apify platform usage and proxy traffic are included.

| Event | Price | When it is charged |
| --- | --- | --- |
| `hotel-result` | **$0.0035 per hotel** ($3.50 per 1,000 hotels) | Once for each hotel saved to the dataset, with or without booking-site prices. Lower prices may apply on higher Apify plans (tiered discounts). |
| `apify-actor-start` | $0.00005 per run (Apify's standard start event, per GB of memory) | Once when a run starts. |

Nothing is charged for retries, blocked requests, destinations with no results or booking-site lookups. Examples: 20 hotels ≈ $0.07; monitoring 100 hotels every day for 30 days (3,000 results) ≈ $10.50.

Set **Max total charge** on a run to cap spending: the Actor stops as soon as the next hotel would exceed it and never saves hotels it has not charged for.

### FAQ

**Is it legal to scrape Google Hotels?**
The Actor collects publicly available business information (hotel names, public prices, ratings, business addresses and phone numbers) that anyone can see without logging in. It does not collect personal data about individuals and does not log in to any account. You are responsible for how you use the data; check the terms that apply to your use case and jurisdiction, and consult a lawyer if unsure.

**Why are the prices different from what I see in my browser?**
Google personalises hotel prices by the visitor's country, currency, dates, guest count and sometimes membership or sign-in status. Match `currency`, `country` (and the proxy country) to your browser, and remember prices change during the day.

**Is the price per night or for the whole stay?**
Both: `pricePerNight` and `totalPrice` include taxes and fees; `priceBeforeTaxes` and `taxesAndFees` split the total.

**How many hotels can I get per destination?**
Google returns 20 hotels per page and the Actor pages through them up to `maxHotelsPerDestination` (max 2,000). Very large cities have thousands of properties; small towns may have only a few dozen.

**What if Google blocks a request?**
The Actor detects rate limits, "unusual traffic" and consent pages, switches to a new residential IP and retries with exponential backoff. If Google changes its data format so that no hotels can be read, the run fails with a clear message instead of finishing with an empty dataset.

**Can I track one specific hotel?**
Yes. Paste its Google Hotels URL (`https://www.google.com/travel/hotels/entity/...`) as a destination; you get its price and all booking-site prices for your dates.

**Can I use it through the API, Python, JavaScript, Make or Zapier?**
Yes. Like every Apify Actor it can be started via the Apify API and clients, scheduled, and connected to integrations and webhooks. The dataset schema describes every field for AI agents and MCP clients.

### Limitations

- Prices are what Google shows to an anonymous visitor from the proxy's country; member and signed-in prices are not included.
- Booking-site prices need one extra request per hotel, so those runs take longer.
- Amenities are returned as English names for the most common amenities. For single-hotel URLs amenities may be empty.
- Google Hotels has no room-count selector; prices are for the whole party in the cheapest option Google shows.
- Stays can be up to 30 nights and up to about 500 days ahead.
- Vacation rentals appear when Google mixes them into hotel results (`propertyType: "vacation_rental"`).

### Changelog

See [CHANGELOG.md](./CHANGELOG.md).

- **1.0 (2026-09-25)**: first release: hotel prices with pagination, filters, booking-site prices, hotel URLs, relative dates, pay-per-event budget handling.

# Changelog

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

# Actor input Schema

## `destinations` (type: `array`):

Cities, areas or landmarks (for example "Paris", "Shibuya, Tokyo", "hotels near Times Square"), or Google Hotels URLs: a search URL (google.com/travel/search?...), a city page (google.com/travel/hotels/Paris) or a single hotel (google.com/travel/hotels/entity/...). Dates, guests, currency and filters inside a pasted URL are used for that URL.

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

A date (YYYY-MM-DD) or a relative value counted from the run day, such as "14 days", "2 weeks" or "1 month". Relative values keep scheduled price-monitoring runs pointing at future dates. Default: 14 days from today.

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

Length of stay in nights. Ignored when a check-out date is set.

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

Optional. A date (YYYY-MM-DD) or relative value ("16 days"). When set, it overrides Nights.

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

Number of adult guests.

## `children` (type: `integer`):

Number of children. Google Hotels prices the stay for adults and children together; it has no separate room count.

## `childrenAges` (type: `array`):

Optional ages (0-17), one per child, e.g. \[5, 9]. Missing ages default to 8.

## `maxHotelsPerDestination` (type: `integer`):

How many hotels to save for each destination. Google returns 20 per page; the Actor pages through results until this number is reached or Google has no more.

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

Currency for all prices.

## `language` (type: `string`):

Google interface language code, e.g. "en", "en-GB", "de", "fr", "ja". Affects hotel descriptions and labels.

## `country` (type: `string`):

2-letter country code of the visitor Google should assume, e.g. "us", "gb", "de". Prices can differ by country. With Apify residential proxy, the proxy country follows this value unless you set one.

## `sortBy` (type: `string`):

Order of results, as on Google Hotels.

## `minRating` (type: `string`):

Only hotels with at least this Google guest rating.

## `hotelClass` (type: `array`):

Only hotels of these star classes. Leave empty for any.

## `minPrice` (type: `integer`):

In the selected currency. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

In the selected currency. Leave empty for no maximum.

## `freeCancellationOnly` (type: `boolean`):

Only hotels that offer a free-cancellation rate.

## `includeBookingPrices` (type: `boolean`):

Also fetch each hotel's prices from every booking site Google lists (Booking.com, Expedia, Hotels.com, Agoda, the official site and more) with direct links and free-cancellation flags, plus the full address and phone number. Makes one extra request per hotel, so runs take longer. Same price per hotel.

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

Google blocks datacenter IPs quickly, so Apify residential proxies are the default and recommended.

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

Maximum parallel requests. Pages of one destination are fetched in order; parallelism comes from several destinations and booking-site lookups.

## Actor input object example

```json
{
  "destinations": [
    "Paris"
  ],
  "checkInDate": "14 days",
  "nights": 1,
  "adults": 2,
  "children": 0,
  "maxHotelsPerDestination": 20,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "sortBy": "relevance",
  "minRating": "any",
  "freeCancellationOnly": false,
  "includeBookingPrices": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 10
}
```

# Actor output Schema

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

One item per hotel: prices, rating, class, amenities, location and (optionally) booking-site prices.

## `bookingPrices` (type: `string`):

One row per hotel and booking site (only when 'Include booking-site prices' is on).

## `summary` (type: `string`):

Per-destination counts, errors, requests and approximate traffic.

# 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 = {
    "destinations": [
        "Paris"
    ],
    "checkInDate": "14 days",
    "nights": 1,
    "adults": 2,
    "maxHotelsPerDestination": 20,
    "currency": "USD",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("symphonic_mullite/google-hotels-prices").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 = {
    "destinations": ["Paris"],
    "checkInDate": "14 days",
    "nights": 1,
    "adults": 2,
    "maxHotelsPerDestination": 20,
    "currency": "USD",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("symphonic_mullite/google-hotels-prices").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 '{
  "destinations": [
    "Paris"
  ],
  "checkInDate": "14 days",
  "nights": 1,
  "adults": 2,
  "maxHotelsPerDestination": 20,
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call symphonic_mullite/google-hotels-prices --silent --output-dataset

```

## MCP server setup

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

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/zSYF6hunsiiGpiFqh/builds/D36DbheSuDNT79OaS/openapi.json