# Google Hotels Scraper & API - Hotel Prices (`acebuilds/google-hotels-scraper`) Actor

Google Hotels scraper and API: hotel prices for any city, hotel name or link and your dates. Nightly rate, total with taxes, stars, rating, reviews, photos and GPS, plus every booking site's price (Booking.com, Expedia, Agoda, official site). Hotel price tracking & rate parity.

- **URL**: https://apify.com/acebuilds/google-hotels-scraper.md
- **Developed by:** [Ace](https://apify.com/acebuilds) (community)
- **Categories:** Travel, Automation, Developer tools
- **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 scrapeds

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

### What does Google Hotels Scraper do?

**Google Hotels Scraper** extracts hotel prices from [Google Hotels](https://www.google.com/travel/hotels) for any destination and dates. For every hotel you get the **nightly price**, **price including taxes and fees**, **total stay price**, star class, guest rating, review count, photos, coordinates and Google IDs — and, as an add-on, **every booking site's price** (Booking.com, Expedia, Hotels.com, Agoda, Priceline, the hotel's official site and more), cheapest first.

Search by destination (`hotels in Lisbon`), by hotel name (`Hyatt Regency Lisbon`) or by Google Hotels link. Use it as a **Google Hotels API**: run it on a schedule as a **hotel price tracker**, for rate-parity checks and **hotel price comparison** across OTAs. No browser, no Google account, no API key.

### Why scrape Google Hotels?

Google Hotels aggregates rates from dozens of online travel agencies (OTAs) for almost every property in the world. Use the data to:

- 📈 **Track hotel prices** for a set of hotels or a whole city — schedule a daily run with relative dates (`"30 days"` from today)
- ⚖️ **Check rate parity**: compare the official-site rate against Booking.com, Expedia and Agoda for the same night
- 🏨 **Revenue management & competitor rates**: see what every competitor in your area charges for your dates
- ✈️ **Build travel apps & price comparison tools** with a clean JSON/CSV feed
- 📊 **Market research**: price distribution by star class, rating and neighbourhood

### How much does it cost to scrape Google Hotels?

You pay **per hotel delivered** — never for failed requests, blocked pages or hotels removed by your filters.

| Event | Price (free plan → Gold plan) |
|---|---|
| Hotel row (price, class, rating, photos, location, IDs) | **$3.00 → $2.00 per 1,000 hotels** |
| Booking-site prices add-on (all OTA rates for that hotel) | **$3.00 → $2.00 per 1,000 hotels**, charged once per hotel, **only if at least one price is found** |

So 1,000 hotels with every booking site's price cost at most $6 — no per-offer charges, however many booking sites quote a hotel.

Address & phone, filters and run summaries are free. Your *maximum cost per run* setting is respected exactly: the run stops before it would go over.

### How to scrape Google Hotels

1. Click **Try for free**.
2. Enter one or more **Destinations**, e.g. `hotels in Lisbon`, `resorts in Bali`.
3. Set **Check-in** and **Check-out** — a date like `2026-12-18`, or days from today like `30`.
4. Optionally turn on **Every booking site's price**.
5. Click **Start** and download your data as JSON, CSV, Excel or HTML.

#### Input example

```json
{
    "queries": ["hotels in Lisbon"],
    "checkIn": "30 days",
    "checkOut": "33 days",
    "adults": 2,
    "currency": "EUR",
    "maxHotels": 50,
    "includeOffers": true,
    "minRating": "4"
}
```

Track specific hotels instead:

```json
{
    "hotelNames": ["Hyatt Regency Lisbon"],
    "hotelUrls": ["https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE"],
    "checkIn": "2026-12-18",
    "checkOut": "2026-12-20"
}
```

### What data can you extract from Google Hotels?

| Field | Example |
|---|---|
| `name` | Brown's | Avenue Hotel |
| `hotelClass`, `propertyType` | 5, hotel |
| `rating`, `reviewsCount`, `ratingHistogram` | 4.6, 283, {"5": 224, "4": 30, …} |
| `pricePerNight` | 293.58 (before taxes) |
| `pricePerNightWithTaxes`, `totalPriceWithTaxes` | 319.2, 957.59 |
| `currency`, `checkIn`, `checkOut`, `nights` | EUR, 2026-11-10, 2026-11-13, 3 |
| `offers` (add-on) | \[{"source": "Booking.com", "pricePerNight": 362, "totalPriceWithTaxes": 1177, "link": "…"}, …] |
| `cheapestSource`, `cheapestPricePerNight` (add-on) | Brown's Avenue, 293.58 |
| `address`, `phone`, `website` | R. Rodrigues Sampaio 48, Lisboa · +351 21 098 8970 |
| `latitude`, `longitude`, `countryCode` | 38.722, -9.1456, PT |
| `photos`, `thumbnail`, `description` | up to 10 photo URLs |
| `entityToken`, `googleHotelsUrl`, `googleMapsUrl`, `cid`, `fid` | Google IDs and links |

#### Output example (abridged)

```json
{
    "name": "Brown's | Avenue Hotel",
    "hotelClass": 5,
    "rating": 4.6,
    "reviewsCount": 283,
    "currency": "EUR",
    "checkIn": "2026-11-10",
    "checkOut": "2026-11-13",
    "pricePerNight": 293.58,
    "pricePerNightWithTaxes": 319.2,
    "totalPriceWithTaxes": 957.59,
    "offersCount": 24,
    "cheapestSource": "Brown's Avenue",
    "offers": [
        { "source": "Brown's Avenue", "isOfficialSite": true, "pricePerNight": 293.58, "totalPriceWithTaxes": 957.59 },
        { "source": "Super.com", "isOfficialSite": false, "pricePerNight": 305, "totalPriceWithTaxes": 962 },
        { "source": "Booking.com", "isOfficialSite": false, "pricePerNight": 362, "totalPriceWithTaxes": 1177 }
    ],
    "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE"
}
```

### Features

- **Any currency** Google supports (USD, EUR, GBP, JPY, AUD, INR…) and any Google market and language
- **Children** by age — adults-only hotels correctly show as unavailable for families
- **Relative dates** for scheduled price tracking (`"30 days"` = 30 days after each run starts)
- **Free filters**: min/max nightly price, minimum rating, star class
- **Deduplicated** across destinations, links and names — a hotel is billed once per run
- **Reliable**: blocked requests are retried on fresh proxy sessions and fall back to residential proxies automatically; a run that comes up short says why (blocked vs. no results) in the log and the `OUTPUT` record

### FAQ

#### Is it legal to scrape Google Hotels?

This actor collects publicly visible prices and hotel information, with no login. It returns business data about hotels, not personal data or review text. Always check the laws in your jurisdiction and Google's terms for your use case.

#### Why do some hotels have no price?

Google shows no rate for those dates and guests — sold out, minimum-stay rules, or adults-only hotels when you add children. These rows have `available: false`.

#### Why is my per-night price different from what I see in my browser?

Google prices depend on the **market** (`country`), currency, dates and party size. Match those inputs to your browser settings.

#### Can I use it via API or integrate it?

Yes — run it via the [Apify API](https://docs.apify.com/api/v2), schedule it, or connect it to Make, Zapier, Google Sheets, Slack and others through Apify integrations.

#### Need a field that's missing?

Open an issue on the **Issues** tab — feature requests are answered quickly.

# Actor input Schema

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

What to search on Google Hotels, one per line, as you would type it — e.g. "hotels in Lisbon", "resorts in Bali", "hotels in Shinjuku Tokyo". Each line runs as its own search.

## `hotelUrls` (type: `array`):

Specific hotels by Google Hotels link (https://www.google.com/travel/hotels/entity/…) or by the entity token from a previous run's `entityToken`. One row each, with address, phone and every booking site's price.

## `hotelNames` (type: `array`):

Specific hotels by name — add the city for an exact match, e.g. "Hyatt Regency Lisbon". One row each, like hotel links.

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

Date as YYYY-MM-DD (e.g. 2026-12-18), or days from the day the run starts (e.g. "30" or "30 days") — handy for scheduled price tracking. Empty = 14 days from today.

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

Date as YYYY-MM-DD, or days from today like check-in. Must be after check-in, at most 30 nights. Empty = 2 nights after check-in.

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

Adults in the room (1–6). Google prices one room for the whole party.

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

Ages (0–17) of children in the room, e.g. \[5, 9]. Adults-only hotels show as unavailable, and fewer booking sites quote family rooms.

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

3-letter currency code for every price, e.g. USD, EUR, GBP, JPY, AUD, INR.

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

Stop each destination after this many hotels (1–300). Google usually lists 100–150 per destination.

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

Add an `offers` list to each hotel: the nightly and total price at each booking site (Booking.com, Expedia, Agoda, Hotels.com, the hotel's official site…), cheapest first, with booking links. One add-on charge per hotel — only when at least one price is found.

## `includeDetails` (type: `boolean`):

Open each hotel's page to add its street address and phone number. Free, but slower. Always on for hotel links and names.

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

Only keep hotels whose nightly price (before taxes, in your currency) is at least this. 0 = no minimum.

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

Only keep hotels whose nightly price (before taxes) is at most this. Unpriced (sold-out) hotels are dropped. 0 = no maximum.

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

Only keep hotels with at least this Google guest rating (out of 5).

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

Only keep these star classes, e.g. \[4, 5]. Vacation rentals have no star class and are dropped when this is set. Empty = all.

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

Google interface language (hl), e.g. en, de, fr, es, ja.

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

Google country (gl), e.g. us, gb, de. Changes which booking sites appear.

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

How many hotels' prices are fetched at once (1–10).

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

Apify datacenter proxy by default; the run switches to residential automatically if Google blocks it.

## Actor input object example

```json
{
  "queries": [
    "hotels in Lisbon"
  ],
  "checkIn": "30 days",
  "checkOut": "32 days",
  "adults": 2,
  "childrenAges": [],
  "currency": "USD",
  "maxHotels": 20,
  "includeOffers": false,
  "includeDetails": false,
  "minPrice": 0,
  "maxPrice": 0,
  "minRating": "0",
  "hotelClass": [],
  "language": "en",
  "country": "us",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per hotel: prices, taxes, star class, rating, reviews, photos, location and Google IDs (plus booking-site offers when the add-on is on).

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

Hotels delivered per query, hotels removed by filters, and blocked or failed requests.

# 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 = {
    "queries": [
        "hotels in Lisbon"
    ],
    "checkIn": "30 days",
    "checkOut": "32 days",
    "maxHotels": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("acebuilds/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 = {
    "queries": ["hotels in Lisbon"],
    "checkIn": "30 days",
    "checkOut": "32 days",
    "maxHotels": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("acebuilds/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 '{
  "queries": [
    "hotels in Lisbon"
  ],
  "checkIn": "30 days",
  "checkOut": "32 days",
  "maxHotels": 20
}' |
apify call acebuilds/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acebuilds/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/BtldjnbibV59k61Mn/builds/eAnpHyVsmHZX6jhpl/openapi.json