# Google Hotels Scraper — Prices, Ratings & Booking Sites (`datafabrik/google-hotels-scraper`) Actor

Google Hotels for any city and dates: up to 500 hotels per search with nightly price, stay total with taxes, deals, stars, rating, amenities, location. Optional: every booking site's price and link (Booking.com, Expedia, hotel site). Pay per hotel; failed searches are free.

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

## Pricing

from $1.50 / 1,000 hotels

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 and every booking site

Scrape **Google Hotels** for any city, neighbourhood or landmark and any dates. For each property you get the **nightly price and the stay total with taxes**, Google's **deal label** ("35% less than usual"), **star class**, **guest rating and review breakdown**, **amenities**, **coordinates**, **nearby places** (airport, transit, sights with walking or driving time), photos, check-in/check-out times and the Google Hotels link.

Turn on one option and you also get **every booking site's offer** for each hotel — Booking.com, Expedia, Hotels.com, Agoda, Trip.com, the hotel's own website and dozens more — with the nightly price, the stay total with and without taxes, and the booking link.

- **Not just the first 20.** Google shows 20 properties per page; this Actor reads the following pages and returns up to **500 hotels per search**, without duplicates.
- **Price monitoring built in.** Give several check-in dates and the Actor runs one search per location × date — ideal for tracking prices over weeks or comparing weekends.
- **Filters from Google itself:** sort order, minimum rating, star class, price range, amenities.
- **Fast and light.** Pure HTTP, no browser. A 100-hotel search takes a few seconds.
- **Fair billing.** You pay per hotel with a price. Unpriced hotels, failed or empty searches are **never charged**.

### What can you do with it?

- **Revenue management & rate shopping:** compare your hotel's price with the competition in your area for every night of the season.
- **Rate parity:** check whether Booking.com, Expedia or the hotel's own site is cheapest for the same stay.
- **Travel apps and AI agents:** feed real hotel availability, prices and ratings into your product.
- **Market research:** average price per night by city, star class or date; which amenities 5-star hotels offer; how prices move before a big event.
- **Lead lists for hospitality suppliers:** hotels of a city with their class, rating, website and location.

### Input

| Field | What it does | Default |
|---|---|---|
| `locations` | One search per line, as you would type it in Google Hotels: `Lisbon`, `Shinjuku, Tokyo`, `hotels near the Eiffel Tower`, `boutique hotels in Rome`. A plain place name is searched as "hotels in …". | required |
| `checkIn` | Check-in date, `YYYY-MM-DD`. Empty = a stay 30 days from today (handy for schedules). | today + 30 |
| `checkOut` | Check-out date, `YYYY-MM-DD`. Empty = `checkIn` + `nights`. | — |
| `nights` | Length of stay when there is no check-out date (1–30). Also used with `checkInDates`. | 1 |
| `checkInDates` | More check-in dates for price monitoring; each location × date is one search. | — |
| `adults` | Number of adult guests (1–12). | 2 |
| `maxResultsPerSearch` | How many hotels to return per search (1–500). | 100 |
| `currency` | Currency of every price: `USD`, `EUR`, `GBP`, `JPY`… | USD |
| `sortBy` | `relevance`, `lowest_price`, `highest_rating`, `most_reviewed`. | relevance |
| `minRating` | `any`, `3.5`, `4.0`, `4.5`. | any |
| `hotelClass` | Keep only these star classes, e.g. `["4","5"]`. | all |
| `minPrice` / `maxPrice` | Price per night range, in the chosen currency. | — |
| `amenities` | Required amenities: `free_parking`, `pool`, `indoor_pool`, `fitness_center`, `free_breakfast`, `spa`, `beach_access`, `pet_friendly`. | — |
| `includeOffers` | Also return every booking site's offer for each hotel (opens each hotel's page). | false |
| `maxOfferLookupsPerSearch` | With `includeOffers`, how many hotels per search get booking-site prices (first N). | 20 |
| `language` | Language of names, descriptions and labels (`en`, `fr`, `de`…). | en |
| `country` | Country Google prices for (`us`, `gb`, `fr`…). Sellers and prices can differ by country. | us |
| `maxConcurrency` | Searches running in parallel (1–20). | 5 |
| `maxRetries` | Retries per page, each from a new IP. | 6 |
| `proxy` | Proxy settings. The default Apify Proxy is enough. | Apify Proxy |

#### Example input

```json
{
  "locations": ["Lisbon", "hotels near Sagrada Familia"],
  "checkIn": "2026-11-13",
  "nights": 2,
  "checkInDates": ["2026-11-20", "2026-11-27"],
  "adults": 2,
  "currency": "EUR",
  "minRating": "4.0",
  "hotelClass": ["4", "5"],
  "maxResultsPerSearch": 100,
  "includeOffers": true,
  "maxOfferLookupsPerSearch": 10
}
```

### Output

One row per hotel (view **Hotels**), for example:

```json
{
  "type": "hotel",
  "location": "Lisbon",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "rank": 1,
  "name": "Brown's | Avenue Hotel",
  "hotelClass": 5,
  "hotelClassLabel": "5-star hotel",
  "rating": 4.6,
  "reviewCount": 281,
  "reviewsBreakdown": { "5star": 222, "4star": 30, "3star": 14, "2star": 7, "1star": 8 },
  "pricePerNight": 222.94,
  "pricePerNightWithTaxes": 245.41,
  "totalPrice": 445.88,
  "totalPriceWithTaxes": 490.83,
  "taxesAndFees": 44.95,
  "dealLabel": null,
  "latitude": 38.7220236,
  "longitude": -9.1456424,
  "amenities": ["Breakfast", "Free Wi-Fi", "Parking ($)", "Outdoor pool", "Air conditioning", "Restaurant", "Airport shuttle"],
  "nearbyPlaces": [
    { "name": "Avenida", "kind": "transit", "walk": "5 min" },
    { "name": "Humberto Delgado Airport", "kind": "airport", "drive": "24 min", "transit": "27 min" }
  ],
  "website": "https://www.brownshotelgroup.com/browns-avenue/",
  "countryCode": "PT",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
  "googleMapsUrl": "https://maps.google.com/?cid=4896003618326261334"
}
```

Other fields: `searchedPlace` (the place Google understood — check it for unusual queries), `entityId`, `propertyType` (`hotel` or `vacation rental`), `phone` (on hotel pages), `description`, `checkInTime`, `checkOutTime`, `thumbnail`, `photos`, `priceDates`, `scrapedAt`.

With `includeOffers`, each hotel also has `offersCount`, `cheapestOffer` and `offers` (view **Booking-site prices**):

```json
{
  "provider": "Booking.com",
  "taxesIncluded": true,
  "isOfficialSite": false,
  "pricePerNight": 275.23,
  "pricePerNightWithTaxes": 300.83,
  "totalPrice": 550.46,
  "totalPriceWithTaxes": 601.66,
  "link": "https://www.google.com/travel/lodging/clk?…"
}
```

The hotel's own website comes first (`isOfficialSite: true`), then the other sites from cheapest to most expensive (stay total with taxes). A few sites give Google no price with taxes (`taxesIncluded: false`); they come last and `cheapestOffer` only uses them when nothing else is available.

The key-value store also holds `SEARCHES` — one line per search with the number of hotels, the cheapest and average price per night — and `OUTPUT`, the run summary.

### Pricing

Pay per event — price per 1,000 hotels on the paid plans:

| Event | When | Free plan | Bronze | Silver | Gold+ |
|---|---|---|---|---|---|
| `hotel` | One hotel **with a price** returned | $2.50 | $2.00 | $1.80 | $1.50 |
| `hotel-offers` | One hotel with every booking site's price (only with `includeOffers`) | $4.00 | $3.50 | $3.00 | $2.50 |

- **Hotels without a price** for your dates (sold out, no availability) are returned **for free**.
- Searches that fail or return nothing are **free** and still appear in the dataset with their status, so you always know what happened.
- A search of 100 hotels costs about **$0.20** on the Bronze plan. The Actor stops cleanly when your maximum cost per run is reached.

### Tips

- **Prices are for the whole room** for the number of adults you set, in the currency you choose.
- A property with no price for your dates (sold out) still appears, with empty price fields — and is not charged.
- `country` matters: booking sites and taxes shown by Google depend on it.
- Booking links go through Google's redirect, as on the website; open them soon after the run.

### Is it legal?

The Actor reads public pages of Google Hotels, the way a visitor does, without logging in. It collects hotel information (businesses), not personal data. You are responsible for using the data in line with the laws and terms that apply to you.

### Support

Something missing or not working? Open an issue on the Actor's page — issues are answered quickly.

# Actor input Schema

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

Where to search, one per line, as you would type it in Google Hotels: a city ("Lisbon"), a neighbourhood ("Shinjuku, Tokyo"), a landmark ("hotels near the Eiffel Tower") or a free query ("boutique hotels in Rome"). A plain place name is searched as "hotels in <place>".

## `checkIn` (type: `string`):

Format YYYY-MM-DD. Leave empty to search a stay 30 days from today (handy for saved tasks and schedules).

## `checkOut` (type: `string`):

Format YYYY-MM-DD. Leave empty to use the number of nights below.

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

Length of the stay when no check-out date is given (1–30). Also used with the extra check-in dates below.

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

Optional. More check-in dates (YYYY-MM-DD) to search with the same number of nights, e.g. every Friday of next month. Each location × date is one search.

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

Number of adult guests (1–12). Google prices the room for this many people.

## `maxResultsPerSearch` (type: `integer`):

Google Hotels shows 20 properties per page; the Actor reads the following pages until this number is reached (1–500).

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

Three-letter code for every price in the output: USD, EUR, GBP, JPY, INR…

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

Google's order for the results.

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

Keep only properties rated at least this (Google's 5-point scale).

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

Keep only these star classes, e.g. 4 and 5. Leave empty for all.

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

In the chosen currency. Leave empty for no minimum.

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

In the chosen currency. Leave empty for no maximum.

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

Keep only properties that have all of these amenities.

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

Also open each hotel's Google Hotels page and return all booking offers: provider (Booking.com, Expedia, Agoda, the hotel's own site…), nightly price and stay total with and without taxes, and the booking link. Charged per hotel that has offers.

## `maxOfferLookupsPerSearch` (type: `integer`):

When the option above is on, fetch booking-site prices for the first N hotels of each search (1–500).

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

Language code for names, descriptions and labels, e.g. en, fr, de, es.

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

Two-letter country code Google prices for (point of sale), e.g. us, gb, fr, de. Booking sites and prices can differ by country.

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

How many searches run at the same time (1–20).

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

How many times a page is retried, each time from a new IP, before the search is marked as failed (not charged).

## `proxy` (type: `object`):

The default Apify Proxy (datacenter) is enough for Google Hotels.

## Actor input object example

```json
{
  "locations": [
    "Lisbon"
  ],
  "nights": 1,
  "adults": 2,
  "maxResultsPerSearch": 100,
  "currency": "USD",
  "sortBy": "relevance",
  "minRating": "any",
  "includeOffers": false,
  "maxOfferLookupsPerSearch": 20,
  "language": "en",
  "country": "us",
  "maxConcurrency": 5,
  "maxRetries": 6,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `offers` (type: `string`):

No description

## `searches` (type: `string`):

No description

## `summary` (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 = {
    "locations": [
        "Lisbon"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datafabrik/google-hotels-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 = {
    "locations": ["Lisbon"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datafabrik/google-hotels-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 '{
  "locations": [
    "Lisbon"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call datafabrik/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datafabrik/google-hotels-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/LnRxLfpVnBXxuMDG5/builds/41NzElXCcUJKjNO60/openapi.json