# Google Hotels Scraper – Prices, Ratings & Every Booking Site (`ecclesiasteslabs/google-hotels-scraper`) Actor

Scrape Google Hotels for any city and dates: hundreds of hotels with nightly and total price, star class, rating, reviews, amenities, address, phone, website and photos. Optional: every booking site's price (Booking.com, Expedia, Hotels.com, Agoda, official site) with links. Filters, any currency.

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

## Pricing

from $1.28 / 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 & Every Booking Site

#### What does Google Hotels Scraper do?

Google Hotels compares prices for almost every hotel in the world across Booking.com, Expedia, Hotels.com, Agoda, Trip.com, Priceline, the hotel's own website and dozens of other booking sites. This actor runs a Google Hotels search for any city and dates and gives you **every hotel as one clean row**: name, star class, guest rating, review count, nightly and total price (with and without taxes), amenities, address, phone, website, coordinates and photos. Turn on one switch and you also get **each booking site's price** for every hotel, with free-cancellation info and direct links.

#### Why use it?

- **Hundreds of hotels per city, not 20.** One Google page shows about 20 hotels. The actor automatically runs variations of your search (star classes, amenities, property types, nearby towns) and removes duplicates by Google's hotel id. Tested: Paris 501 hotels, New York 300+, Amsterdam 266, Bruges 179.
- **Every booking site's price (optional).** Usually 5–20 sites per hotel: Booking.com, Expedia, Hotels.com, Agoda, Trip.com, Priceline, Vio, the official hotel site and more. Cheapest first, with taxes, stay totals, free-cancellation deadlines and the booking link.
- **Your dates, guests and currency.** Any check-in/check-out (up to 30 nights), adults and children's ages, and any currency (USD, EUR, GBP, JPY, INR, THB, ILS ...). Prices are exactly what Google shows for that stay.
- **Real filters.** Price range per night, hotel class (2–5 stars), minimum guest rating and 17 amenities (pool, free breakfast, free parking, pet-friendly, spa ...). Google applies them to its search, and the actor double-checks every hotel.
- **Reliable and fast.** No browser, no login, no cookies, automatic retries. In our tests every Google request succeeded. 300 hotels with all booking-site prices take about 2 minutes; 500 hotels without them take about 1 minute.
- **Pay only for hotels you get.** No start fee, no monthly rent.

#### What data do you get?

One row per hotel:

| Field | Example |
|---|---|
| `name` | DoubleTree by Hilton Hotel New York Times Square West |
| `hotelClass` / `hotelClassText` | 4 / 4-star hotel |
| `rating` / `reviewCount` | 3.5 / 6925 |
| `pricePerNight` / `pricePerNightWithTaxes` | 127.67 / 150 |
| `totalPrice` / `totalPriceWithTaxes` | 383.01 / 450 (3 nights) |
| `currency` | USD |
| `dealLabel` | 17% less than usual |
| `checkInDate` / `checkOutDate` / `nights` / `adults` / `children` | 2027-01-15 / 2027-01-18 / 3 / 2 / 0 |
| `address` / `fullAddress` | 350 W 40th St / 350 W 40th St, New York, NY 10018 |
| `latitude` / `longitude` | 40.7566 / -73.9931 |
| `phone` / `website` | (212) 607-8888 / https://www.hilton.com/... |
| `description` | Contemporary, upscale property offering terrace dining & a gym... |
| `checkInTime` / `checkOutTime` | 3:00 PM / 12:00 PM |
| `amenities` | Free Wi-Fi, Parking ($), Fitness center, Bar, Restaurant, Pet-friendly ... |
| `ratingBreakdown` | {"5": 2231, "4": 1794, "3": 1043, "2": 672, "1": 1185} |
| `nearbyPlaces` | Times Square (8 min by public transport), 42 St-Port Authority (5 min walk) ... |
| `photos` / `thumbnail` | up to 10 image URLs |
| `bookingPrices` | \[{"source": "Traveluro", "pricePerNight": 127.67, "pricePerNightWithTaxes": 150, "totalPriceWithTaxes": 450, "freeCancellationUntil": null, "isOfficialSite": false, "url": "https://www.traveluro.com/hotels/..."}, {"source": "Hotels.com", ...}, ...] |
| `lowestPriceSource` | Traveluro |
| `typicalPriceLow` / `typicalPriceHigh` | e.g. $71 / $111 (Google's "usually costs" range, when shown) |
| `hotelId` | Google's unique hotel id: use it to track a hotel over time |
| `googleHotelsUrl` / `googleMapsUrl` / `googleMapsCid` | links and ids to join with Google Maps data |

#### How to use it

1. Enter one or more **destinations** (e.g. `Paris`, `New York, NY`, `Shibuya, Tokyo`, `Times Square`).
2. Pick **check-in and check-out dates**, the number of **adults** (and children's ages if any) and your **currency**.
3. Set the **maximum number of hotels**. Optionally add filters and turn on **Include every booking site's price**.
4. Click Start. Download the results as JSON, CSV or Excel, or get them through the API.

Example input:

```json
{
  "destinations": ["Lisbon", "Porto"],
  "checkIn": "2027-05-14",
  "checkOut": "2027-05-17",
  "adults": 2,
  "currency": "EUR",
  "maxItems": 200,
  "hotelClass": ["4", "5"],
  "amenities": ["pool"],
  "includeBookingPrices": true
}
```

#### How much does it cost?

**$1.50 per 1,000 hotels** ($0.0015 per hotel). With **every booking site's price** turned on, add **$1.00 per 1,000 hotels** ($0.001 per hotel that has prices), so **$2.50 per 1,000** in total. No start fee, no monthly rent. 100 hotels with all booking-site prices cost $0.25. Apify's free plan ($5/month credit) covers about 2,000 hotels a month with booking-site prices, or 3,300 without. You can set a maximum cost per run, and the actor stops cleanly when it's reached.

#### Run it from your code

Get your API token in Apify Console → Settings → API & Integrations.

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("ecclesiasteslabs/google-hotels-scraper").call(run_input={
    "destinations": ["Barcelona"], "checkIn": "2027-06-10", "checkOut": "2027-06-13",
    "currency": "EUR", "maxItems": 100, "includeBookingPrices": True,
})
for hotel in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(hotel["name"], hotel["pricePerNight"], hotel["lowestPriceSource"])
```

**JavaScript / Node.js** (`npm install apify-client`)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('ecclesiasteslabs/google-hotels-scraper').call({
    destinations: ['Barcelona'], checkIn: '2027-06-10', checkOut: '2027-06-13',
    currency: 'EUR', maxItems: 100, includeBookingPrices: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**HTTP (one call, returns the results)**

```bash
curl -X POST "https://api.apify.com/v2/acts/ecclesiasteslabs~google-hotels-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"destinations": ["Barcelona"], "checkIn": "2027-06-10", "checkOut": "2027-06-13", "currency": "EUR", "maxItems": 100}'
```

#### Integrations

- **AI agents (MCP):** connect Claude, ChatGPT, Cursor or any MCP client to [Apify's MCP server](https://mcp.apify.com) and the agent can search hotels with this actor directly.
- **No-code:** use the Apify modules in **Make**, **Zapier** or **n8n** to send results to Google Sheets, Airtable, Slack or a database.
- **Schedules:** run it daily in Apify Console → Schedules to track prices over time. Join days by `hotelId`.

#### Use cases

- **Hotel revenue managers:** track competitors' prices and rate parity across booking sites for your dates.
- **Travel startups and agencies:** fill your search or trip planner with live hotel prices and booking links.
- **Price monitoring and analytics:** build price indexes by city, season, star class or event dates.
- **Lead generation:** hotel names, phones, websites and addresses for any city, filtered by class and rating.
- **AI travel agents:** give your agent real prices for real dates.

#### Tips

- City names give the most hotels. Landmarks and neighbourhoods work too (`near Eiffel Tower`, `Shibuya, Tokyo`). If Google doesn't recognize a destination, the run says so and skips it, so you aren't charged for unrelated hotels.
- Each run uses one set of dates. To compare dates, run once per date range (or schedule daily runs).
- `country` is where the traveler searches **from** (default `us`), not where the hotel is. It can change which booking sites appear.
- Big cities give 250–500 hotels. Turn off **Include nearby towns** to stay strictly inside the main destination's results.
- Some hotels have no price for your dates (sold out or not bookable online). They still appear, with empty price fields, unless you set a price filter.
- Prices before taxes are what Google shows first in the US; `...WithTaxes` fields include taxes and fees.

#### FAQ

**Is it legal?** The actor reads publicly available hotel listings and prices from Google Hotels. It doesn't log in or collect personal data. Check the rules that apply to your use case and jurisdiction.

**Is this an official Google API?** No. It's an independent tool that reads the public Google Hotels pages.

**Why do I get fewer hotels than I asked for?** Google only has so many hotels for some destinations and filters. Try a bigger area, loosen the filters, or turn on nearby towns.

**Something broke?** Open an issue on the Issues tab. We usually fix layout changes within 24 hours.

# Changelog

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

# Actor input Schema

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

Cities, areas or landmarks to search, e.g. "Paris", "New York, NY", "Shibuya, Tokyo", "near Eiffel Tower". One search is run per destination. City names work best.

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

Arrival date (YYYY-MM-DD). Leave empty for 14 days from today. Google shows prices up to about 11 months ahead.

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

Departure date (YYYY-MM-DD). Leave empty for a 1-night stay. Maximum 30 nights.

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

Number of adult guests. Prices and availability depend on it.

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

One entry per child with their age (0-17), e.g. \["8", "5"]. Leave empty for no children.

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

3-letter currency code for all prices, e.g. USD, EUR, GBP, JPY, INR, AUD, CAD.

## `maxItems` (type: `integer`):

Stop after this many unique hotels in total (across all destinations). You pay per hotel saved. One Google page shows about 20 hotels, so the scraper runs variations of your search (star classes, amenities, nearby towns) and removes duplicates. Big cities give 300-600 hotels; small towns fewer.

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

Also get each hotel's prices on every booking site Google compares (Booking.com, Expedia, Hotels.com, Agoda, Trip.com, the hotel's official site and more, usually 5-20 sites), with free-cancellation info and direct links, plus the full street address. Takes one extra page per hotel, so runs are slower and a small extra charge applies per hotel.

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

Only hotels whose lowest nightly price (before taxes, in your currency) is at least this much. Hotels without a price for your dates are skipped when a price filter is set.

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

Only hotels whose lowest nightly price (before taxes, in your currency) is at most this much.

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

Only hotels with these official star ratings. Leave empty for all, including unrated properties.

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

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

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

Only hotels that have all of these amenities.

## `searchNearbyTowns` (type: `boolean`):

To find more hotels, also search towns and suburbs next to the destination that Google itself shows in the results (e.g. Boulogne-Billancourt for Paris). Turn off to stay strictly inside the main destination's results.

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

Google interface language (hl), e.g. en, de, fr, es, ja. Affects hotel descriptions and labels. Amenity names in the output stay in English.

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

Google country (gl) for the search, e.g. us, gb, de, in. This is where the traveler searches FROM, not where the hotel is. It can change which booking sites appear.

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

Not needed: the scraper works without a proxy. Use only if your runs report blocked requests.

## Actor input object example

```json
{
  "destinations": [
    "Paris"
  ],
  "adults": 2,
  "currency": "USD",
  "maxItems": 50,
  "includeBookingPrices": false,
  "minRating": "any",
  "searchNearbyTowns": true,
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "destinations": [
        "Paris"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecclesiasteslabs/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 = {
    "destinations": ["Paris"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("ecclesiasteslabs/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 '{
  "destinations": [
    "Paris"
  ],
  "maxItems": 50
}' |
apify call ecclesiasteslabs/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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