# Google Hotels Scraper — Cheap Hotels & Hotel Price API (`prestilink/google-hotels-scraper`) Actor

Google Hotels API for cheap hotels and hotel prices in any city and dates: nightly and total prices, deals, ratings, reviews, stars, location, photos. Optional: Booking.com, Expedia, Hotels.com and official-site prices, room rates, free cancellation, amenities, address, phone. No browser.

- **URL**: https://apify.com/prestilink/google-hotels-scraper.md
- **Developed by:** [Prestilink](https://apify.com/prestilink) (community)
- **Categories:** Travel, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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 — Cheap Hotels & Hotel Price API

Get **cheap hotels and hotel prices from Google Hotels for any city and any dates**: price per night, total stay price, deals, guest rating, reviews, star class, location, photos and nearby places. Turn on one option to also get **prices from every booking site** (Booking.com, Expedia, Hotels.com, the hotel's own website...), room-by-room rates, free cancellation, the full amenities list, address and phone.

No browser and no page loads: the Actor reads Google Hotels data directly, so a search of 100 hotels takes seconds, not minutes. **You only pay for hotels you get.** Searches that fail are never charged.

**A pay-as-you-go alternative to SerpApi's Google Hotels API**: no monthly plan, you only pay for the hotels you get.

### Who uses it

- **Hotels and revenue managers**: track competitor rates for your dates, every day.
- **Travel agencies and OTAs**: compare Booking.com vs Expedia vs direct prices.
- **Travel apps and AI agents**: live hotel prices through a simple API.
- **Analysts and investors**: price levels, ratings and supply by city or neighborhood.
- **Lead generation**: hotel names, websites, phone numbers and locations.

### What you get

| Data | Field |
|---|---|
| Hotel name, type, star class | `name`, `type`, `hotelClass`, `hotelClassText` |
| Price per night and total for your stay | `pricePerNight`, `totalPrice`, `currency` (plus `...Text` as shown on Google) |
| Deal badge | `deal`, for example "29% less than usual" |
| Guest rating, reviews, rating breakdown | `rating`, `reviewsCount`, `ratingBreakdown` |
| What guests mention most | `reviewTopics` (service, cleanliness, location... with positive and negative counts) |
| Location | `latitude`, `longitude`, `countryCode`, `nearbyPlaces` (attractions, transit, airports with travel times) |
| Check-in and check-out times | `checkInTime`, `checkOutTime` |
| Description, website, photos | `description`, `website`, `images`, `thumbnail` |
| Links and IDs | `googleHotelsUrl`, `googleMapsUrl`, `propertyToken`, `position` in the results |

With **Include booking offers and amenities**:

| Data | Field |
|---|---|
| Price from each booking site, cheapest first | `offers[].provider`, `offers[].pricePerNight`, `offers[].totalPrice`, `offers[].isOfficialSite` |
| Room types and rates, free cancellation deadline | `offers[].rooms[].rates[]` |
| Full amenities list | `amenities[]` with `available` and notes like "free" or "extra charge" |
| Address and phone | `address`, `phone` |

### How to use

1. Add one or more **search queries**: a city (`Paris`), a neighborhood (`Shibuya`), a landmark (`Times Square`) or a full search (`beach resorts in Bali`).
2. Set **check-in date** and **check-out date** (or **nights**), **adults** and **children ages**.
3. Choose **currency**, **max hotels per query** and, if you want booking-site prices, turn on **Include booking offers and amenities**.
4. Run, then download the results as JSON, CSV or Excel, or get them through the API.

Optional filters: minimum guest rating, star class, and min or max price per night.

You can also paste **Google Hotels URLs**: a search URL keeps its dates and guests, and a hotel page URL returns that hotel with all its offers.

### Input example

```json
{
  "queries": ["Paris", "Barcelona"],
  "checkInDate": "2026-12-18",
  "checkOutDate": "2026-12-21",
  "adults": 2,
  "childrenAges": ["8"],
  "currency": "EUR",
  "maxResultsPerQuery": 100,
  "includeDetails": true,
  "minRating": "4"
}
```

### Output example

```json
{
  "query": "Paris",
  "position": 1,
  "name": "Hôtel Example Paris",
  "type": "hotel",
  "hotelClass": 4,
  "rating": 4.3,
  "reviewsCount": 1823,
  "pricePerNight": 142.87,
  "pricePerNightText": "€143",
  "totalPrice": 429,
  "currency": "EUR",
  "deal": "22% less than usual",
  "checkInDate": "2026-12-18",
  "checkOutDate": "2026-12-21",
  "nights": 3,
  "latitude": 48.8566,
  "longitude": 2.3522,
  "offers": [
    { "provider": "Booking.com", "pricePerNight": 142.87, "totalPrice": 428.61, "freeCancellation": true, "isOfficialSite": false },
    { "provider": "Hôtel Example Paris", "pricePerNight": 149.0, "totalPrice": 447.0, "freeCancellation": true, "isOfficialSite": true }
  ],
  "amenities": [{ "name": "Wi-Fi", "available": true, "note": "free" }, { "name": "Pool", "available": false }],
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/...",
  "status": "ok"
}
```

Values in this example are illustrative.

### Pricing

Pay per event: a small fee per run, a fee per hotel, and an extra fee per hotel only when booking offers and amenities are included. Bigger Apify plans pay less per hotel. See the **Pricing** tab for exact prices on your plan.

Set a maximum cost per run in the run options and the Actor stops before going over it.

### Good to know

- Prices are what Google Hotels shows for your dates, guests, currency and searcher country, at the time of the run. Taxes and fees follow Google's display for that country.
- Google shows about 20 hotels per page. The Actor follows the pages until it reaches your maximum or the end of the results.
- Some small properties have no price for your dates. They are still returned, with an empty price.
- With filters, the Actor keeps reading pages until it has your maximum of matching hotels or reaches the end of Google's results. You are only charged for hotels that match.

### Use it with

- **AI agents and MCP**: add this Actor as a tool through the Apify MCP server (Claude, Cursor, ChatGPT and other MCP clients), LangChain, LlamaIndex or CrewAI.
- **No-code automation**: n8n, Make and Zapier, for example a daily competitor hotel price report to Google Sheets or Slack.
- **Spreadsheets and dashboards**: Google Sheets, Excel, Looker Studio.
- **Developers**: the Apify API, Python and JavaScript clients, webhooks and scheduled runs.

***

This Actor is not affiliated with, endorsed by, or sponsored by Google. Google Hotels is a trademark of Google LLC.

# Actor input Schema

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

Cities, neighborhoods, landmarks or full searches, one per line. Examples: `Paris`, `Times Square`, `beach resorts in Bali`. A plain place name is searched as "hotels in ...".

## `checkInDate` (type: `string`):

First night of the stay, YYYY-MM-DD. Leave empty for 7 days from today. Relative values like `+30` (30 days from today) also work.

## `checkOutDate` (type: `string`):

Departure day, YYYY-MM-DD. Leave empty to use Nights.

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

Length of stay when Check-out date is empty.

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

Number of adult guests.

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

One age per child (0-17), for example `7` and `12`. Leave empty for no children.

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

Stop each search after this many hotels. Google Hotels shows about 20 per page; the Actor follows the pages for you.

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

Also open each hotel page to get prices from every booking site (Booking.com, Expedia, Hotels.com, the hotel's own site...), room rates, free cancellation, the full amenities list, address and phone. Charged as an extra event per hotel.

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

Currency for all prices.

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

Language of hotel descriptions and labels.

## `countryCode` (type: `string`):

Two-letter country code of the traveler, for example `us`, `gb`, `de`. Some prices and offers depend on it.

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

Keep only hotels rated at least this much.

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

Keep only these star ratings, for example `4` and `5`. Leave empty for all.

## `minPricePerNight` (type: `integer`):

In the selected currency.

## `maxPricePerNight` (type: `integer`):

In the selected currency.

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

Optional. Paste Google Hotels search URLs (google.com/travel/search?...) to reuse their dates and guests, or hotel page URLs (google.com/travel/hotels/entity/...) to get one hotel with all offers.

## Actor input object example

```json
{
  "queries": [
    "Paris"
  ],
  "nights": 1,
  "adults": 2,
  "maxResultsPerQuery": 20,
  "includeDetails": false,
  "currency": "USD",
  "language": "en",
  "countryCode": "us",
  "minRating": ""
}
```

# Actor output Schema

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

One item per hotel: prices for the requested dates, rating, reviews, class, location, photos, and optionally booking-site offers and amenities.

# 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": [
        "Paris"
    ],
    "maxResultsPerQuery": 20
};

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

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

```

## MCP server setup

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