# Google Hotels Scraper: Prices, Ratings, Booking Offers (`arcadium/google-hotels`) Actor

Google Hotels results for a city or hotel and your dates: price, total, taxes, rating, reviews, class, amenities, coordinates; $4.49 per 1,000 hotels. Each booking site price with free-cancellation deadline $0.90 per 1,000 offers. Many dates per run, free error rows.

- **URL**: https://apify.com/arcadium/google-hotels.md
- **Developed by:** [Arcadium Data](https://apify.com/arcadium) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.69 / 1,000 hotel rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper: Prices, Ratings, Booking Offers

Give it a city or a list of hotels plus dates and guests, and it returns Google Hotels data as JSON: one row per hotel and stay with the lowest price, total, taxes, deal note, rating, review count, star class, amenities and coordinates, and, for hotels you name, one row per booking site with its price and free-cancellation deadline. $4.49 per 1,000 hotels and $0.90 per 1,000 offers on the free plan; you pay only for rows you get.

**Why this actor**

- **Many dates and stay lengths per run**, about 20 hotels per request from Google's own data endpoint, no browser.
- **Per-site offers** (Booking.com, Expedia, the official site and others) with free-cancellation deadlines and a tax flag.
- **Real data or a clear error.** A free `error` row with a `code` per failed input or date; the two most used Google Hotels actors failed 23.9% and 6.2% of their runs over 30 days (Apify Store, 2026-10-28).
- **Easy switch.** Input names of the most used Google Hotels actors are accepted as they are.

Built by Arcadium Data: public data, dated and agent-ready, never personal data.

### Use with AI agents

Returns Google Hotels prices for a place or for named hotels: hotel rows (price per night, total, rating, reviews, class, amenities, coordinates) and booking-site offer rows (Booking.com, Expedia, official site: price, free cancellation). Agents can call it through the Apify MCP server (`https://mcp.apify.com`, open source as `apify/actors-mcp-server`) as `arcadium/google-hotels`: the input schema is read from the actor, the result is a dataset of JSON rows.

Input example for "hotels in Paris next month":

```json
{
  "locations": ["Paris"],
  "checkInDates": ["+30d"],
  "nights": [2],
  "maxHotels": 20
}
```

And for "what does each booking site charge for this hotel":

```json
{
  "hotels": ["Ritz Paris"],
  "checkInDates": ["2026-12-10"],
  "nights": [3],
  "currency": "EUR"
}
```

What comes back: `hotel` rows (charged), `offer` rows (charged) and a free `error` row for an input or date that could not be read. Filter on the `rowType` field. An error row carries `rowType: "error"`, a `code` (`invalid_input`, `not_found`, `no_match`, `blocked` or `unavailable`), a `message` and the `input` it is about. Retry on `blocked` and `unavailable` later; do not retry the other codes with the same input.

Cost of the calls above: 20 hotels at $4.49 per 1,000 is about $0.09; one hotel lookup with its usual 10 to 30 booking-site offers is about $0.01 to $0.03. Each run adds a $0.0005 start fee (512 MB). Paid Apify plans pay less per hotel row.

### What you get

**Hotel row** (`rowType: "hotel"`): one hotel for one stay.

| Field | What it holds |
| --- | --- |
| `entityId`, `name`, `googleUrl` | Google's id for the property (reuse it in `hotels`), its name and Google Hotels link. |
| `propertyType` | `hotel` or `vacation_rental`. |
| `hotelClass`, `hotelClassLabel` | Star class (1-5) and Google's wording, e.g. "4-star tourist hotel". |
| `rating`, `reviewCount` | Google guest rating out of 5 and the number of reviews behind it. |
| `latitude`, `longitude`, `countryCode`, `address` | Where it is. `address` comes with hotel lookups and `includeOffers` (never for vacation rentals). |
| `description`, `thumbnailUrl`, `website`, `checkInTime`, `checkOutTime` | Google's summary line, a photo, the hotel's own site, check-in and check-out times. |
| `amenities`, `amenityCodes` | Amenities from the result card ("Free Wi-Fi", "Pool", "Spa", ...) and Google's codes behind them. |
| `checkIn`, `checkOut`, `nights`, `adults`, `children`, `childrenAges`, `currency` | The stay this row is about. |
| `available` | `false` when Google shows no price for these dates and guests. |
| `pricePerNight`, `pricePerNightText`, `totalPrice` | Lowest price per night (as a number and as displayed) and for the whole stay. |
| `pricesIncludeTaxes`, `totalPriceWithTaxes`, `priceBeforeTaxes`, `taxesAndFees` | Whether the shown prices include taxes (Google decides per market and currency), plus Google's own split. |
| `deal`, `dealPercent` | Google's deal note, e.g. "30% less than usual" or "GREAT PRICE for a 4-star hotel". |
| `offerCount`, `lowestOfferProvider` | Booking sites with a price, and the cheapest one (when offers were read). |
| `searchLocation`, `searchRank`, `totalResults` | Location searches: what you typed, the position in Google's list and Google's total. |
| `input` | Hotel lookups: the link, token or name you gave. |

Output example:

```json
{
  "rowType": "hotel",
  "platform": "google-hotels",
  "entityId": "ChoI_uTZsvz1i6-bARoNL2cvMTFmZHB6eDEwMxAB",
  "name": "The Originals Boutique, Hôtel Maison Montmartre, Paris",
  "googleUrl": "https://www.google.com/travel/hotels/entity/ChoI_uTZsvz1i6-bARoNL2cvMTFmZHB6eDEwMxAB",
  "propertyType": "hotel",
  "hotelClass": 4,
  "rating": 4,
  "reviewCount": 2133,
  "latitude": 48.900537,
  "longitude": 2.336269,
  "amenities": ["Free Wi-Fi", "Air conditioning", "Pet-friendly", "Bar", "Restaurant"],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "available": true,
  "pricePerNight": 81.75,
  "totalPrice": 163.5,
  "pricesIncludeTaxes": true,
  "priceBeforeTaxes": 136.25,
  "taxesAndFees": 27.25,
  "deal": "30% less than usual",
  "dealPercent": 30,
  "searchLocation": "Paris",
  "searchRank": 1,
  "totalResults": 15000
}
```

**Offer row** (`rowType: "offer"`): one booking site's price for one hotel and stay, cheapest first.

| Field | What it holds |
| --- | --- |
| `entityId`, `hotelName`, `googleUrl` | The hotel the offer belongs to. |
| `offerRank`, `provider`, `providerId` | 1 = cheapest; the booking site and Google's id for it (stable across hotels). |
| `isOfficialSite`, `featured` | The hotel's own website; shown in Google's highlighted block. |
| `pricePerNight`, `pricePerNightText`, `totalPrice`, `pricesIncludeTaxes` | The site's price per night and for the stay. |
| `freeCancellation`, `freeCancellationUntil`, `freeCancellationUntilTime` | Whether the site's lowest rate can be cancelled for free, and until when. `null` when Google does not say. |
| `roomName`, `rateCount`, `cheapestFreeCancellationPrice` | For sites where Google lists rooms: the cheapest room, how many rates, the cheapest refundable one. |

```json
{
  "rowType": "offer",
  "hotelName": "Ritz Paris",
  "checkIn": "2026-11-10",
  "nights": 2,
  "currency": "USD",
  "offerRank": 2,
  "provider": "Ritz Paris",
  "isOfficialSite": true,
  "pricePerNight": 2835,
  "totalPrice": 5670,
  "freeCancellation": true,
  "freeCancellationUntil": "2026-11-07",
  "freeCancellationUntilTime": "3:00 PM"
}
```

### Input

```json
{
  "locations": ["Paris", "Lisbon"],
  "hotels": ["https://www.google.com/travel/hotels/entity/ChcIzp-H4rLs0eRnGgsvZy8xdGYxbjN6OBAB", "Ritz Paris"],
  "checkInDates": ["+30d", "+60d"],
  "nights": [2],
  "adults": 2,
  "currency": "USD",
  "maxHotels": 50
}
```

| Field | What it does |
| --- | --- |
| `locations` | Places to search, e.g. `Paris`, `Times Square New York`, `resorts in Cancun`. A plain place is searched as "hotels in ...". |
| `hotels` | Specific hotels: a Google Hotels link, the entity token, or a name with the city. Each returns its hotel row plus every booking-site offer. |
| `maxHotels` | Hotels per location and date, up to 500 (Google lists ~20 per page). |
| `includeOffers` | Also read every booking site's price for each hotel a location search finds (one extra request per hotel). |
| `maxOffersPerHotel` | Keep only the N cheapest offers per hotel and stay; a cost cap. |
| `checkInDates` | Dates as `YYYY-MM-DD` or relative (`+30d`, `6 weeks`, `tomorrow`). Up to a year ahead. |
| `checkInFrom`, `checkInTo`, `checkInStepDays` | A range of check-in dates, one every N days (up to 120 dates). |
| `nights` | One or more stay lengths, 1 to 30. Every date is combined with every value. |
| `adults`, `childrenAges` | The party in one room. Google prices one room. |
| `currency`, `language`, `country` | Currency of all prices; Google interface language; market (country of the searcher). |
| `sortBy`, `hotelClass`, `minRating`, `freeCancellation`, `minPrice`, `maxPrice`, `amenities` | Google Hotels' own sort and filters for location searches. Prices are per night in the run currency. |
| `includeErrorRows` | Add a free row for every location, hotel or date that could not be read. On by default. |

Input names of the most used Google Hotels actors are accepted as they are (`checkInDate`, `checkOutDate`, `maxResults`, `languageCode`, `countryCode`, `includeBookingSources`, `entity`, `days`, `queries`, `hotelNames`, `checkIn`, `checkOut`, `sweepDays`, `q`, `property_token`, `hl`, `gl`, `children`, `children_ages`), so an existing input can be pasted in.

### Use from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("arcadium/google-hotels").call(run_input={
    "locations": ["Lisbon"],
    "checkInFrom": "+30d",
    "checkInTo": "+58d",
    "checkInStepDays": 7,
    "nights": [2],
    "maxHotels": 40,
    "sortBy": "lowest_price",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("rowType") == "hotel" and row["available"]:
        print(row["checkIn"], row["name"], row["pricePerNight"], row["currency"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('arcadium/google-hotels').call({
  hotels: ['Ritz Paris', 'Le Meurice Paris'],
  checkInDates: ['+30d', '+31d', '+32d'],
  nights: [1],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.rowType === 'offer').map((r) => [r.hotelName, r.checkIn, r.provider, r.totalPrice]));
```

### Pricing

You pay per row delivered, at the price of your Apify plan. Error rows and repeats are free.

| Apify plan | Per 1,000 hotel rows | Per 1,000 offer rows |
| --- | --- | --- |
| Free | $4.49 | $0.90 |
| Starter (Bronze) | $3.89 | $0.90 |
| Scale (Silver) | $3.29 | $0.90 |
| Business (Gold) | $2.69 | $0.90 |
| Platinum | $2.69 | $0.90 |
| Diamond | $2.69 | $0.90 |

Plus a one-off $0.001 per GB of memory when a run starts.

Set a maximum cost per run in the Apify run options and the actor stops before it goes over. `maxOffersPerHotel` caps the offer rows per hotel.

### Related actors and data

- [Booking.com Prices Scraper: Rates, Availability, Monitor](https://apify.com/arcadium/booking-prices)
- [Google Hotel Reviews Scraper: Topics, Replies, Partner Sites](https://apify.com/arcadium/google-hotel-reviews)
- [Airbnb Listings Scraper: Prices, Calendar, Amenities](https://apify.com/arcadium/airbnb-listings)
- [Hotel Reviews Scraper: Tripadvisor, Booking.com, Google](https://apify.com/arcadium/hotel-reputation)
- [Hotel demand peaks report](https://arcadiumdata.io/reports/hotel-demand-peaks/): the next 90 nights of hotel rates by city, with spike nights flagged.
- [Arcadium Data MCP Server](https://apify.com/arcadium/arcadium-mcp): AI agents can ask the same questions as tools (`hotel_prices`, `city_rate_curve`).

### Use cases

- Rate shopping: the lowest Google price of your hotel and its competitive set for the next 60 nights, every morning.
- Rate parity: compare the official site with Booking.com, Expedia and the rest for the same stay (`isOfficialSite`, `offerRank`).
- Destination research: what a city costs on a given weekend, by stars, rating and amenities, with Google's deal notes.
- Travel and comparison sites: fill price calendars and hotel lists with coordinates and ratings.

### Limitations

- Public prices as an anonymous visitor sees them from the US market by default (`country`). No login, no member or app-only rates.
- Google prices one room for the whole party; there is no rooms input.
- Whether the shown prices include taxes depends on Google's market and currency; read `pricesIncludeTaxes` and `totalPriceWithTaxes` instead of assuming.
- Relevance order changes a little between requests; use `sortBy` when you need stable ranks.
- `amenities` come from the search result card; hotel lookups leave them empty. A few amenity codes have no label yet and appear only in `amenityCodes`.
- Booking links are Google ad-click links that expire within minutes, so they are not included; use `googleUrl`.
- The actor reads Google over Apify's shared datacenter proxy. When Google rate-limits that pool, the run retries with short pauses and, if the limit persists, stops and reports the remaining inputs as free `blocked` error rows instead of burning time. Run again later.

### Privacy

Only hotel and price data is collected. No guest reviews, reviewer names, phone numbers or accounts.

### FAQ

**How do I find a hotel's entity token?**
It is the `entityId` of any row, and it is the `Ch...` part of a Google Hotels link (`/travel/hotels/entity/<token>`). A hotel name with the city works too.

**Why is `available` false for a hotel?**
Google showed no price for those dates and guests (sold out, closed, or the party is too large for one room). The row is delivered because the availability is the information.

**Why do the offer prices differ from the hotel row price?**
The hotel row has Google's headline price; offers are each site's own price for the same stay. They usually match the cheapest offer, but Google may highlight a different rate.

**Something looks wrong in the output. Who do I tell?**
Open an issue on the actor page with the run link. We read them all.

# Actor input Schema

## `locations` (type: `array`):

Places to search, for example "Paris", "Times Square New York" or "resorts in Cancun". A plain place name is searched as "hotels in <place>". Each location returns up to 'Max hotels' hotels per check-in date, with Google's lowest price, rating, class, amenities and coordinates.

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

Specific hotels: a Google Hotels link such as https://www.google.com/travel/hotels/entity/ChcIzp-H4rLs0eRnGgsvZy8xdGYxbjN6OBAB, the entity token alone (the Ch... part, also in the entityId field of any row), or a name with the city such as "Ritz Paris". Each hotel returns its row plus one offer row per booking site (Booking.com, Expedia, the official site, ...) for every date.

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

Hotels to return for each location and check-in date, 1 to 500, for example 50. Google lists about 20 per page; sort and filters are applied by Google before this cap.

## `includeOffers` (type: `boolean`):

Also read every booking site's price for each hotel found by a location search: one extra request per hotel, and one offer row per site (about 10-30 per hotel). Off by default; hotel lookups always include offers.

## `maxOffersPerHotel` (type: `integer`):

Keep only the N cheapest booking-site offers per hotel and stay, for example 5. 0 = all offers. A cost cap for offer rows.

## `checkInDates` (type: `array`):

Check-in dates as YYYY-MM-DD, or relative to today such as "+30d", "6 weeks" or "tomorrow". Example: \["2026-12-10", "+45d"]. Up to a year ahead. If this and the range below are empty, one stay 30 days from now is used.

## `nights` (type: `array`):

Lengths of stay in nights, for example \[1, 3, 7]. Each value gives its own row per hotel and check-in date. 1 to 30 nights; default \[1].

## `checkInFrom` (type: `string`):

Start of a range of check-in dates (YYYY-MM-DD or +Nd), for example "2026-12-01". With 'to' and 'step' it adds one check-in date every N days, on top of the dates above.

## `checkInTo` (type: `string`):

Last check-in date of the range (YYYY-MM-DD or +Nd), for example "2026-12-31". Up to 120 dates in total.

## `checkInStepDays` (type: `integer`):

Days between check-in dates inside the range, for example 7 for weekly. 1 = every day.

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

Adult guests in one room, 1 to 10, for example 2. Google prices one room for the whole party.

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

Age (0-17) of each child in the room, for example \[5, 9]. Leave empty for none.

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

Three-letter ISO code for every price in the run, for example USD, EUR, GBP or JPY. Google converts the prices.

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

Order of location results: relevance (Google's default), lowest_price, highest_rating or most_reviewed.

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

Star classes to keep, for example \["4", "5"]. Empty = any class.

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

Lowest Google guest rating (out of 5): 3.5, 4.0 or 4.5. Google offers only these steps.

## `freeCancellation` (type: `boolean`):

Only hotels with a free-cancellation rate for the dates; Google then shows that refundable rate as the price.

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

Lowest nightly price in the run currency, for example 80. Empty = no minimum.

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

Highest nightly price in the run currency, for example 250. Empty = no maximum.

## `amenities` (type: `array`):

Only hotels that have all of these, for example \["pool", "free_breakfast"].

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

Google interface language (hl), for example en, de, fr or pt-BR. Sets the language of descriptions and deal labels.

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

Country of the searcher (gl), two letters, for example us, gb or de. Not the destination: it can change which booking sites appear and whether prices include taxes.

## `includeErrorRows` (type: `boolean`):

Add a free row with rowType "error" for every location, hotel or date that could not be read, so you can tell "not found" from "blocked".

## `maxRetries` (type: `integer`):

Advanced. Retries for a failed or rate-limited request, 0 to 10, for example 4. Each retry waits 1 to 6 seconds.

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

Advanced. The actor uses Apify's datacenter proxy by default. Your own proxy URLs are honoured; Apify proxy groups are ignored to keep the price low.

## Actor input object example

```json
{
  "locations": [
    "Paris"
  ],
  "maxHotels": 20,
  "maxOffersPerHotel": 0,
  "checkInDates": [
    "+30d"
  ],
  "nights": [
    2
  ],
  "checkInStepDays": 1,
  "adults": 2,
  "currency": "USD",
  "sortBy": "relevance",
  "minRating": "any",
  "freeCancellation": false,
  "language": "en",
  "country": "us",
  "includeErrorRows": true,
  "maxRetries": 4
}
```

# Actor output Schema

## `results` (type: `string`):

All rows of this run in the default dataset.

## `view_overview` (type: `string`):

No description

## `view_offers` (type: `string`):

No description

## `view_errors` (type: `string`):

No description

## `record_stats` (type: `string`):

Requests, data volume, retries, coverage and cost per result for this run.

# 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 = {
    "locations": [
        "Paris"
    ],
    "maxHotels": 20,
    "checkInDates": [
        "+30d"
    ],
    "nights": [
        2
    ],
    "language": "en",
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("arcadium/google-hotels").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 = {
    "locations": ["Paris"],
    "maxHotels": 20,
    "checkInDates": ["+30d"],
    "nights": [2],
    "language": "en",
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("arcadium/google-hotels").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 '{
  "locations": [
    "Paris"
  ],
  "maxHotels": 20,
  "checkInDates": [
    "+30d"
  ],
  "nights": [
    2
  ],
  "language": "en",
  "country": "us"
}' |
apify call arcadium/google-hotels --silent --output-dataset

```

## MCP server setup

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

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/HGUvnd4FVUCnXOG9A/builds/sg5jZdETFcz9GALY7/openapi.json