# Google Hotels Scraper — Prices, Ratings & Amenities (`genial_candlestand/google-hotels-scraper`) Actor

Get hotel and vacation-rental prices from Google Hotels: nightly price, total with taxes and fees, star class, rating, reviews and amenities for any destination, dates and guests. Optional booking offers, address and phone. No login.

- **URL**: https://apify.com/genial_candlestand/google-hotels-scraper.md
- **Developed by:** [Flowo](https://apify.com/genial_candlestand) (community)
- **Categories:** Travel, Lead generation
- **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 — Prices, Ratings & Amenities

This actor returns hotel and vacation-rental data from Google Hotels for any destination, dates and guests: nightly price, stay total with taxes and fees, star class, guest rating, review count, amenity names, coordinates and website. Optionally it adds the booking-site offers Google features, the address and the phone number. No login is needed, and each property is one flat row.

### What does Google Hotels Scraper do?

Give it destinations ("hotels in Paris"), hotel names ("Ritz Paris") or Google Hotels hotel URLs, plus check-in and check-out dates and guests. It returns one row per property, priced for those dates. Each row has `pricePerNight`, `baseRate`, `taxes`, `fees` and `totalPriceWithTaxes`, plus `rating`, `reviewsCount`, `hotelClass`, `amenities`, `latitude`/`longitude` and `website`.

It is meant for revenue managers watching competitor rates, travel agencies and startups building price comparisons, analysts comparing destinations, and AI agents answering questions such as "what does a 4-star hotel in Lisbon cost on 10–12 December?".

You can filter by hotel class, minimum rating and maximum price, sort in four ways, add children's ages, and switch to vacation rentals.

### How to use

1. Open the actor in Apify Console and click **Try for free**.
2. Add one or more **Destinations or hotel names**, or paste **Hotel URLs**.
3. Set check-in and check-out dates, adults and children's ages, and the currency.
4. Optionally set filters (hotel class, minimum rating, maximum price, sort) and tick **Include booking offers, address and phone**.
5. Click **Start** and download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

AI agents can call the actor through the Apify API or the Apify MCP server with the same JSON input.

### Pricing

Pay per event, no subscription:

| Event | Price | When |
|---|---|---|
| Hotel | $0.0022 | one property row ($2.20 per 1,000 rows) |
| Booking offers and contacts | $0.0015 | extra per hotel when offers are on, and always for Hotel URLs ($1.50 per 1,000 hotels) |
| Actor start | $0.00005 | once per run, per GB of memory |

Rows removed by your price filters, duplicates and failed searches are free. With **Only priced hotels** on, unpriced rows are free too. The offers event is free when Google returns no offers, address or phone.

Example: the default input (2 searches × 50 hotels = 100 rows) costs about $0.22. The same 100 hotels with offers, address and phone cost about $0.37.

### Input

All fields are optional, but you need at least one of `queries` or `startUrls`.

| Field | Meaning |
|---|---|
| `queries` | Destinations or hotel names, one per line |
| `startUrls` | Google Hotels hotel pages (`/travel/hotels/entity/...`) |
| `checkIn`, `checkOut` | `YYYY-MM-DD`; default: 30 days from today, 2 nights; at most 30 nights |
| `adults`, `childrenAges` | 1–10 adults; ages 0–17 for up to 8 children |
| `vacationRentals` | Search apartments and houses instead of hotels |
| `sortBy` | `relevance`, `lowestPrice`, `highestRating`, `mostReviewed` |
| `minRating`, `hotelClass`, `maxPrice`, `minPrice`, `pricedOnly` | Filters |
| `includeOffers` | Booking offers, address, phone, neighborhood per hotel |
| `maxResultsPerQuery` | 1–1000, default 50 |
| `currency`, `language`, `country` | e.g. `EUR`, `de`, `DE` |

Example:

```json
{
  "queries": ["hotels in Paris"],
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-12",
  "adults": 2,
  "hotelClass": ["4", "5"],
  "minRating": "4.5",
  "sortBy": "highestRating",
  "maxResultsPerQuery": 50,
  "currency": "EUR"
}
```

### Output

One flat row per property. Main fields:

| Field | Description |
|---|---|
| `title`, `url`, `id` | Property name, Google Hotels page, entity token |
| `query`, `searchLocation`, `position` | Your search, the place Google resolved it to, rank |
| `hotelClass`, `propertyType` | Stars, property type |
| `rating`, `reviewsCount` | Google guest rating (out of 5) and review count |
| `pricePerNight`, `baseRate`, `taxes`, `fees`, `totalPriceWithTaxes` | Prices in `currency`; text versions such as `totalPriceText` too |
| `checkIn`, `checkOut`, `nights` | Dates Google actually priced |
| `dealText` | Google deal badge, e.g. "21% less than usual" |
| `latitude`, `longitude`, `country`, `website`, `imageUrl` | Location and links |
| `amenities` | Amenity names in English |
| `address`, `phone`, `neighborhood`, `offersCount`, `offers[]` | Only with booking offers on, or for Hotel URLs |

Real example (shortened):

```json
{
  "id": "ChkIjKOI-tugt-DOARoML2cvMXE1Ym5qNnRrEAE",
  "title": "Hotel Saint Paul Rive Gauche",
  "propertyType": "hotel",
  "hotelClass": 4,
  "rating": 4.7,
  "reviewsCount": 475,
  "pricePerNight": 207,
  "baseRate": 414.55,
  "taxes": 37.87,
  "fees": 0,
  "totalPriceWithTaxes": 452.42,
  "currency": "USD",
  "checkIn": "2026-11-23",
  "checkOut": "2026-11-25",
  "nights": 2,
  "dealText": "21% less than usual",
  "latitude": 48.849635,
  "longitude": 2.340254,
  "country": "FR",
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Air conditioning", "Room service"],
  "query": "hotels in Paris",
  "searchLocation": "Paris",
  "position": 1
}
```

### Use cases

- **Destination price scan:** price every hotel in a city for your dates and compare nightly rates.
- **Filtered shortlist:** 4–5 star hotels rated 4.5+, cheapest or best rated first, within a budget.
- **Family vacation rentals:** apartments for a week with children's ages, in your currency.
- **Competitor rate tracking:** schedule runs for named hotels or hotel URLs and compare booking-site offers, address and phone over time.
- **Multi-city comparison:** several destinations in one run, with offers on top.

### Limitations

- Offers are the 2–4 booking-site offers Google features on the hotel card, not the full "all options" list. They may be for a different room than the lead price.
- Prices, ratings and many fields can be empty: a property without a rate for your dates has `pricePerNight: null`. Large groups get fewer priced hotels.
- Google has few or no prices more than about 330 days ahead; stays are limited to 30 nights.
- A bare city name can be resolved by Google to another place. Write "hotels in <city>" and check `searchLocation`; the run warns on mismatches and when Google prices other dates than requested.
- Vacation rentals have no hotel class, no booking offers and usually no amenities.
- `minPrice` is applied by the actor after Google answers; Google only filters the maximum.
- Google lists a few hundred properties per destination; the run stops when it runs out.

### FAQ

**Is it legal to scrape Google Hotels?**
The actor reads publicly visible hotel prices and property data without logging in. It returns business data about properties, not personal data. You are responsible for using the data in line with Google's terms and the laws that apply to you.

**Do I need an account or API key?**
No. There is no login, and Google offers no public hotel-price API.

**Why do the checked dates differ from my input?**
If Google replaces the dates, the rows carry the dates it really priced and the run logs a warning.

**How is this different from other Google Hotels actors?**
It combines destinations, hotel names and hotel URLs in one run, supports children's ages, sorting, class, rating and price filters and vacation rentals, returns amenity names instead of codes, and gives numeric base, tax, fee and total prices. Empty results end as successful runs with a reason, not as failures.

### Other actors

Other public data actors from the same author:

- [Google Trends Scraper](https://apify.com/genial_candlestand/google-trends-scraper) — interest over time, regions and related queries for search terms.
- [Google Trends Trending Now Scraper](https://apify.com/genial_candlestand/google-trending-now-scraper) — trending Google searches by country with volume and growth.
- [Google Play Reviews Scraper](https://apify.com/genial_candlestand/google-play-reviews-scraper) — app reviews with ratings, versions and developer replies.
- [Google Ads Transparency Scraper](https://apify.com/genial_candlestand/google-ads-transparency-scraper) — ads of any domain or advertiser.

# Actor input Schema

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

One per line: a destination ("hotels in Paris", "Zermatt") or a hotel name ("Ritz Paris"). Use "hotels in <city>" for cities. Give this, Hotel URLs, or both.

## `startUrls` (type: `array`):

Google Hotels hotel pages (https://www.google.com/travel/hotels/entity/...) to price directly. One row per URL, always with booking offers, address and phone. Filters and limits do not apply.

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

Arrival date, YYYY-MM-DD, today or later. Empty = 30 days from today. Google has few or no prices more than about 330 days ahead (the run warns).

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

Departure date, YYYY-MM-DD, 1 to 30 nights after check-in. Empty = 2 nights after check-in.

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

Number of adult guests (1–10). Large groups get fewer priced hotels, because many hotels have no room for them.

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

Age of each child at check-in (0–17), up to 8 children, e.g. \[5, 10]. Empty = no children.

## `vacationRentals` (type: `boolean`):

Search apartments and houses (Google's "Vacation rentals" tab) instead of hotels. Rentals have no hotel class and no booking offers: Hotel class and Include booking offers are ignored, and "Most reviewed" sort falls back to Relevance (the run warns).

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

Order of results as Google sorts them. "Most reviewed" works only for hotels (with Vacation rentals it falls back to Relevance).

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

Only properties with at least this Google guest rating (out of 5). Works for hotels and vacation rentals.

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

Only hotels of these star classes, e.g. \["4", "5"]. Empty = all. Hotels only: ignored with Vacation rentals.

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

Only properties up to this nightly price (before taxes), in the Currency field's units, e.g. 150. Applied by Google. Empty = no limit.

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

Drop properties below this nightly price (before taxes), in the Currency field's units. Google has no such filter, so the actor filters rows itself; unpriced properties are dropped too. Must not exceed Maximum price. Dropped rows are free.

## `pricedOnly` (type: `boolean`):

Skip properties Google shows without a price for your dates and guests (sold out or no rate). Skipped rows are free.

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

Adds the booking-site offers Google features, address, phone and neighborhood for each hotel. One extra charged event ($0.0015) per hotel. Hotels only.

## `maxResultsPerQuery` (type: `integer`):

Stop each search after this many unique properties (1–1000, default 50). The run stops earlier if Google lists fewer.

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

Optional cap on all rows of the run (all searches and hotel URLs together). Empty = no cap besides Max hotels per search.

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

ISO 4217 code of the prices, e.g. USD, EUR, GBP, JPY. Unknown codes are an input error (Google would silently switch to another currency).

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

Language of descriptions, price texts and place names, as a language code with optional region, e.g. en-US, en-GB, de, fr, ja. Amenity names are always English.

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

Two-letter country code of the Google market you search from (gl), e.g. US, GB, DE, JP. It sets regional formatting; the destination itself comes from the search text.

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

Apify Proxy settings. The default datacenter proxy works for Google Hotels; switch to residential only if runs start failing.

## Actor input object example

```json
{
  "queries": [
    "hotels in Paris",
    "hotels in Tokyo"
  ],
  "adults": 2,
  "childrenAges": [],
  "vacationRentals": false,
  "sortBy": "relevance",
  "minRating": "any",
  "pricedOnly": false,
  "includeOffers": false,
  "maxResultsPerQuery": 50,
  "currency": "USD",
  "language": "en-US",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one row per hotel (prices, rating, class, amenities, location and optional booking-site offers)

## `overview` (type: `string`):

The main fields of every hotel in a table view

# 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 Paris",
        "hotels in Tokyo"
    ],
    "childrenAges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("genial_candlestand/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 Paris",
        "hotels in Tokyo",
    ],
    "childrenAges": [],
}

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

```

## MCP server setup

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