# Google Hotels Scraper (`tidyharvest/google-hotels-scraper`) Actor

Google Hotels for any city and dates, plus every booking site's rate per hotel (Booking.com, Expedia, Agoda, the hotel's own site). Built to beat Kestrel and Factden: $0.0034 per hotel with all rates vs $0.040 and $0.009. Children, filters, price calendar, hotels by name.

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

## Pricing

Pay per event

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

Search **Google Hotels** for any city, neighborhood, landmark or named hotel and get every property Google lists with the price for your dates, and, if you want it, **every booking site's rate for each hotel** (Booking.com, Expedia, Agoda, Hotels.com, the hotel's own site and more). Rows come back clean for a spreadsheet, a rate tracker, a rate-parity check or a travel app.

### What you can do with it

- **Compare booking sites:** turn on *Booking-site rates* and each hotel carries one rate per site, cheapest first: nightly and whole-stay price with and without taxes, free-cancellation deadline and a booking link. The hotel's own site is flagged `official: true`, so a parity check is one comparison.
- **Track hotel prices on a schedule:** dates can be written `+30` (30 days from today), so a saved run never goes stale. *Price calendar* prices the same stay for the next N check-in days in one run.
- **Price an exact set of hotels:** one per line, by name (`Hyatt Regency Lisbon`), Google Hotels link, or the token from an earlier run. A name that matches nothing costs nothing.
- **Filter before you pay:** sort by price, rating or reviews; amenities, hotel class, kind of hotel, guest rating, price range, free cancellation, special offers. Google applies these before the result cap, so *30 cheapest 4-5 star hotels with a pool under $250* returns 30 (or all that exist).
- **Real parties:** adults 1-12 and children's ages, any currency and language, and the market (country) the prices are shown for.

### Input

| Field | What it does |
|---|---|
| `queries` | Places to search: `San Francisco`, `Waikiki`, `near Eiffel Tower`. |
| `hotelNames` | Exact hotels: name + city, a Google Hotels link, or a token. |
| `checkIn`, `checkOut` | `YYYY-MM-DD`, or `+N` days from today. Default stay: two nights (1 to 30). |
| `sweepDays` | Also price the same stay starting on each of the next N days (price calendar). |
| `adults`, `childrenAges` | Party in one room: 1-12 adults (big parties only see properties that can host them), children aged 0-17. |
| `currency`, `language`, `country` | Price currency, labels, and the market the prices are shown for. |
| `maxResults` | Cap per search (and per check-in day), 20 properties a page. |
| `includeOffers`, `offerLevel`, `maxOffersPerHotel` | Every booking site's rate per hotel; `rooms` adds each room type and rate; cap the sites per hotel. |
| `includeDetails` | Address, phone, place ID, full description, review topics, a few recent reviews. |
| `sortBy`, `minPricePerNight`, `maxPricePerNight`, `minRating`, `minStars`, `hotelClass`, `amenities`, `hotelTypes`, `freeCancellation`, `specialOffers` | Applied by Google before the cap. |
| `propertyTypes`, `nameContains`, `onlyPriced` | Applied while reading: hotels vs vacation rentals, name words, skip sold-out properties. |

Example:

```json
{ "queries": ["Lisbon"], "checkIn": "+30", "checkOut": "+32", "adults": 2, "childrenAges": ["6"],
  "hotelClass": ["4", "5"], "amenities": ["pool"], "sortBy": "price", "maxResults": 30, "includeOffers": true }
```

### Output

One item per property (shortened example):

```json
{
  "name": "Hilton San Francisco Union Square", "propertyType": "4-star hotel", "stars": 4,
  "rating": 4.2, "reviewCount": 11795,
  "pricePerNight": 129.39, "pricePerNightWithTaxes": 152.29, "priceTotal": 258.78, "priceTotalWithTaxes": 304.58,
  "currency": "USD", "nights": 2, "deal": "26% less than usual",
  "checkIn": "2026-12-12", "checkOut": "2026-12-14", "adults": 2,
  "latitude": 37.7857, "longitude": -122.4101, "checkInTime": "3:00 PM", "checkOutTime": "11:00 AM",
  "website": "https://www.hilton.com/...", "googleUrl": "https://www.google.com/travel/hotels/entity/...",
  "offerCount": 32, "cheapestSource": "Super.com", "officialSitePrice": 220,
  "offers": [
    { "source": "Super.com", "official": false, "pricePerNight": 129.39, "pricePerNightWithTaxes": 152.1,
      "priceTotal": 258.78, "priceTotalWithTaxes": 304.2, "freeCancellation": true,
      "freeCancellationUntil": "Dec 10 11:59 PM", "bookingLink": "https://www.google.com/travel/lodging/clk?...",
      "siteLink": "https://www.super.com/..." }
  ],
  "nearby": [{ "category": "airport", "name": "San Francisco International Airport", "travel": [{ "mode": "drive", "time": "23 min" }] }],
  "images": ["https://..."], "search": "San Francisco", "position": 1
}
```

With *Property details* each row also has `address`, `phone`, `placeId`, `descriptionFull`, `reviewTopics` (what guests mention most, with mention counts and sentiment) and `sampleReviews`. With `offerLevel: "rooms"` each offer lists its room types and rates (`rooms`). `pricePerNight` is the base nightly rate; the `WithTaxes` fields add taxes and fees. Vacation rentals come back with `propertyType: "vacation rental"` and no stars. Booking links are Google's own links and expire; use `siteLink` where present, or re-run.

### Pricing

Pay per result, no start fee:

- **Hotel** (`hotel-scraped`): $0.90 per 1,000 properties on the free plan, $0.70 on the Gold plan and above.
- **Booking-site rates** (`hotel-prices-scraped`, only with the option on, only for hotels that have rates): $2.50 per 1,000 hotels free plan, $1.80 Gold. A hotel with every booking site's rate costs **$3.40 per 1,000 hotels** on the free plan, $2.50 on Gold.
- **Property details** (`hotel-details-scraped`, option on): $0.80 per 1,000 free plan, $0.60 Gold.

A run that finds nothing fails instead of silently returning an empty dataset. `onlyPriced` skips sold-out properties so you are not charged for them.

### Compared with the other Google Hotels scrapers

Measured 2026-10-28 on the same two hotels and dates (Hilton San Francisco Union Square, Hyatt Regency Lisbon), two adults, USD:

| | This actor | Kestrel (Google Hotels Prices) | Factden (Google Hotels Scraper) |
|---|---|---|---|
| Booking sites found, Hilton / Hyatt | 32 / 6 | 32 / 5 | 32 / 5 |
| Prices | match Kestrel to the cent on every shared site | reference | lead price equals our price with taxes |
| One hotel with every booking site's rate | **$0.0034** (free plan), $0.0025 Gold | about $0.040 | $0.009 |
| Rate rows | nested in one row per hotel | one extra row per site | nested in one row |
| Children, price calendar, hotels by name or link | yes | yes | yes |
| Filters and sort Google applies before the cap | yes | yes | partly |
| Party | adults + children's ages | adults + children's ages | adults, children, rooms counts |
| Market (country) | yes | yes | yes |

Against Zerobreak (Google Hotels Scraper, $4.99 per 1,000 on the free plan) and Vittuhy (Google Travel Hotel Prices, $1.05 per 1,000): our hotel rows are cheaper ($0.90 / $0.70) and carry the real whole-stay totals with and without taxes. Zerobreak's `compareRate` was 300 on every row we checked.

**Where they still win:** Factden pulls full guest reviews as a separate dataset (we return review topics and a few recent reviews); Kestrel lists about 120 amenities by name per hotel (we return the amenity filters above, applied by Google, and the hotel description). Google Hotels prices one room per search, so there is no rooms input here.

### Limits and notes

- Prices and availability change by the minute; check the rate with the hotel or a booking site before you book.
- One room per search: Google Hotels prices a single room for the whole party, so large parties only see the properties that can host them.
- Public data only. Not affiliated with Google.

### Feedback and requests

Missing a field or an option? Open an issue in the Issues tab and tell us what you need.

# Actor input Schema

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

One place per line: a city, a neighborhood, or a landmark (San Francisco, Paris, Waikiki, near Eiffel Tower). Each is searched separately. Leave empty if you only want the hotels named below.

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

Exact hotels, one per line: a name with its city (Hyatt Regency Lisbon), a Google Hotels link, or the token from a googleUrl of an earlier run. You get one row per hotel with its price and, with the options below, every booking site's rate. A name that matches no hotel costs nothing.

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

YYYY-MM-DD, or +N for N days from today (+30 = a month out; keeps scheduled runs current).

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

YYYY-MM-DD or +N. Defaults to two nights after check-in; up to 30 nights.

## `sweepDays` (type: `integer`):

0 = only the stay above. N = also price the same length of stay starting on each of the next N days (a price calendar; 13 = two weeks of check-ins). Every day is a separate search, so results and charges multiply.

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

Prices are for one room holding this many adults (1 to 12). Large parties only see the properties that can host them.

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

Ages of the children in the same room, 0 to 17 (0 and 1 count as one age band on Google), for example 5 and 9. Prices change with children, and some hotels drop out.

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

Three-letter code, e.g. USD, EUR, GBP.

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

Locale for names and labels, e.g. en, de, fr.

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

Two-letter country of the person searching (us, gb, jp). It changes which booking sites and prices Google shows, not where the hotels are. Empty = Google's default.

## `maxResults` (type: `integer`):

Hard cap on properties returned (and charged) for each place. 20 per page of results.

## `maxTotalResults` (type: `integer`):

Optional cap across all searches.

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

Add every booking site's price for the stay (Booking.com, Expedia, Agoda, Hotels.com, the hotel's own site and about 15 more): nightly and whole-stay price with and without taxes, free-cancellation deadline and a link. Billed once per hotel that has rates (add-on, see Pricing).

## `offerLevel` (type: `string`):

'sources' = one rate per booking site (its lowest). 'rooms' = also every room type and rate the sites share with Google, with room names and cancellation deadlines.

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

0 = all of them. N = only the N cheapest booking sites per hotel (rows stay smaller).

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

Add address, phone, Google place ID, the full hotel description, what guests mention most (review topics with sentiment) and a few recent guest reviews. Billed once per hotel that has details (add-on, see Pricing).

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

Applied by Google before the result cap, so 30 with 'price' is the 30 cheapest properties that have a price for your dates.

## `maxPricePerNight` (type: `number`):

In the chosen currency, as Google shows it (before taxes for most countries). Applied by Google before the result cap.

## `minPricePerNight` (type: `number`):

Same basis as the maximum.

## `minRating` (type: `number`):

0-5, e.g. 4.2. Google pre-filters at 3.5, 4.0 or 4.5; the exact value is applied on top.

## `minStars` (type: `integer`):

1-5 stars. Vacation rentals have no class and are left out when this is set.

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

Only these star classes, for example 4 and 5. Applied by Google before the result cap. Leave empty for any.

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

Only properties that have all the amenities picked. Applied by Google before the result cap.

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

Only properties with a free-cancellation rate for your dates (Google then quotes that rate).

## `specialOffers` (type: `boolean`):

Only properties Google marks as a deal for your dates.

## `hotelTypes` (type: `array`):

Only these kinds (Google's own property-type filter). Leave empty for all.

## `propertyTypes` (type: `array`):

Hotels or vacation rentals. Leave empty for both.

## `nameContains` (type: `array`):

Keep only properties whose name contains one of these words (Hilton, Marriott, hostel).

## `onlyPriced` (type: `boolean`):

Skip properties Google has no price for on your dates (sold out), so you are not charged for them.

## `maxPages` (type: `integer`):

Safety limit on pages read per place (20 properties a page). Defaults to enough for your result cap, or more when filters or sorting need it.

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

Optional. Use if Google refuses direct requests.

## Actor input object example

```json
{
  "queries": [
    "San Francisco"
  ],
  "checkIn": "+30",
  "checkOut": "+32",
  "sweepDays": 0,
  "adults": 2,
  "currency": "USD",
  "language": "en",
  "maxResults": 20,
  "includeOffers": false,
  "offerLevel": "sources",
  "maxOffersPerHotel": 0,
  "includeDetails": false,
  "sortBy": "relevance",
  "freeCancellation": false,
  "specialOffers": false,
  "onlyPriced": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `hotels` (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 = {
    "queries": [
        "San Francisco"
    ],
    "checkIn": "+30",
    "checkOut": "+32"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tidyharvest/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": ["San Francisco"],
    "checkIn": "+30",
    "checkOut": "+32",
}

# Run the Actor and wait for it to finish
run = client.actor("tidyharvest/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": [
    "San Francisco"
  ],
  "checkIn": "+30",
  "checkOut": "+32"
}' |
apify call tidyharvest/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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