# Google Hotels Price Calendar - Hotel Prices for Every Date (`zet46/google-hotels-price-calendar`) Actor

Track any hotel's price history across dates with OTA rates (Booking.com, Agoda, Expedia, official site). Find cheapest dates, monitor rate parity, build price alerts. Any currency. $1.50 per 1,000 date prices.

- **URL**: https://apify.com/zet46/google-hotels-price-calendar.md
- **Developed by:** [An Tan Huynh](https://apify.com/zet46) (community)
- **Categories:** Travel, AI, MCP servers
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 hotel price for one dates

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Price Calendar: Hotel Prices for Every Date

Check what a hotel costs on **every check-in date in a range**, using Google Hotels. For each date you get the lowest price and **the price on every booking site**: Booking.com, Agoda, Expedia, Hotels.com, Trip.com, the hotel's own website and more. Prices come per night and for the whole stay, in any currency.

Give it a hotel name or a Google Hotels link, pick a start date and how many dates to check. You get one row per date, plus a summary with the **cheapest and most expensive dates**.

### Use cases

- **Find the cheapest dates** to stay at a specific hotel.
- **Revenue management and rate shopping**: follow competitors' rates for the next 30, 90 or 365 days.
- **Rate parity monitoring**: see whether the hotel's own website or an OTA is cheaper, date by date.
- **Price alerts and travel apps**: schedule daily runs and send the data to Google Sheets, Slack, a webhook or your database.
- **AI agents**: give an assistant real hotel availability and prices for flexible dates.

### Input

```json
{
  "hotels": ["Hilton Paris Opera", "Pullman Danang Beach Resort"],
  "startDate": "2026-12-01",
  "numberOfDates": 30,
  "nights": 1,
  "adults": 2,
  "rooms": 1,
  "currency": "USD",
  "includeProviderPrices": true
}
```

| Field | Notes |
|---|---|
| `hotels` | Hotel name, ideally with the city, or a Google Hotels URL (`.../travel/hotels/entity/...`) |
| `startDate` | First check-in date. Default: tomorrow |
| `numberOfDates` / `endDate` | How many consecutive check-in dates to check (max 365) |
| `nights` | Length of each stay |
| `adults`, `children`, `rooms` | Party size. Affects which room types and prices Google returns per date |
| `childrenAges` | Optional ages (e.g. `[5, 10]`) for per-age pricing; its length overrides `children` |
| `currency` | USD, EUR, GBP, JPY... |
| `includeProviderPrices` | Include the full list of booking sites for each date. On by default, same price either way |

### Output

One row per hotel per check-in date. A real row from our test run:

```json
{
  "hotel": "Generator Paris",
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-21",
  "dayOfWeek": "Friday",
  "nights": 1,
  "currency": "USD",
  "available": true,
  "lowestPricePerNight": 60.57,
  "lowestTotalPrice": 60.57,
  "cheapestProvider": "Booking.com",
  "providersCount": 15,
  "providers": [
    {
      "provider": "Booking.com",
      "pricePerNight": 60.57,
      "pricePerNightText": "$61",
      "totalPrice": 60.57,
      "sponsored": false,
      "bookingUrl": "https://..."
    },
    {
      "provider": "Hostelworld",
      "pricePerNight": 66.46,
      "pricePerNightText": "$66",
      "totalPrice": 66.46,
      "sponsored": false,
      "bookingUrl": "https://..."
    },
    {
      "provider": "Vio.com",
      "pricePerNight": 66.46,
      "pricePerNightText": "$66",
      "totalPrice": 66.46,
      "sponsored": false,
      "bookingUrl": "https://..."
    }
  ],
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/..."
}
```

A **summary** per hotel is saved in the key-value store as `SUMMARY` and linked from the run's Output tab:

```json
[{"hotel": "Generator Paris", "currency": "USD", "datesChecked": 7, "datesAvailable": 7,
  "cheapestDate": "2026-11-22", "cheapestPricePerNight": 48.54,
  "mostExpensiveDate": "2026-11-21", "mostExpensivePricePerNight": 74.44, "averagePricePerNight": 60.49}]
```

### Pricing

**$1.50 per 1,000 date prices** ($0.0015 per hotel per date), with no monthly fee. A 30-day calendar for one hotel costs about **$0.045**. Dates with no availability are still returned so the calendar has no gaps, and they are charged the same.

Need prices for every hotel in a city instead of a few specific hotels? Use [Google Hotels Scraper](https://apify.com/zet46/google-hotels-scraper).

**Room rates:** for booking sites that list them (usually the hotel's own website and Booking.com), each provider also has a `rooms` list: room name, price per night and total. Use it to compare the same room type across sites.

### Use it from Python, JavaScript or any HTTP client

```python
from apify_client import ApifyClient  # pip install "apify-client>=3"

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zet46/google-hotels-price-calendar").call(run_input={"hotels": ["Hilton Paris Opera"], "numberOfDates": 60, "currency": "USD"})
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["checkIn"], item["lowestPricePerNight"], item["cheapestProvider"])
```

The same works with the JavaScript client (`apify-client` on npm) or a single HTTP call to `https://api.apify.com/v2/acts/zet46~google-hotels-price-calendar/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>` with the input as the JSON body. You can also schedule runs and send results to Google Sheets, Slack, Zapier, Make or n8n.

More ready-to-run examples (Python and Node.js): [github.com/huynhtanan/google-hotels-api](https://github.com/huynhtanan/google-hotels-api). Step-by-step tutorial: [Google Hotels prices with Python on dev.to](https://dev.to/huynhtanan/how-to-get-google-hotels-prices-for-any-dates-with-python-and-see-which-booking-site-is-cheapest-1aod).

### Use it from AI agents (MCP)

Add this to Claude Desktop, Cursor or any MCP client:

```json
{"mcpServers": {"apify": {"url": "https://mcp.apify.com?tools=zet46/google-hotels-price-calendar"}}}
```

Then just ask, for example: *"When is the Hilton Paris Opera cheapest in the next two months, and on which site?"*

### FAQ

**How fast is it?** In our test, 2 hotels x 7 dates (14 prices, 13 to 27 booking sites each) finished in about 10 seconds, startup included.

**Which hotel is used when I type a name?** The first Google Hotels match for that text. Add the city to be safe, or paste the Google Hotels link.

**Do I need proxies?** No setup needed. The actor uses Apify Proxy (datacenter) by default, which gives more complete results than direct requests, and the cost is included in the price.

**Is it legal?** The actor reads publicly visible hotel prices only, with no personal data. You are responsible for using the data in line with the laws and terms that apply to you.

**Found a problem?** Open an issue on the Issues tab. Fixes usually ship within a day.

# Actor input Schema

## `hotels` (type: `array`):

Hotel name with city (e.g. 'Pullman Danang Beach Resort') or a Google Hotels URL. The first Google Hotels match is used.

## `startDate` (type: `string`):

YYYY-MM-DD. Default: tomorrow.

## `numberOfDates` (type: `integer`):

How many consecutive check-in dates to check, starting at the first check-in date.

## `endDate` (type: `string`):

YYYY-MM-DD. If set, overrides 'Number of dates'.

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

Length of each stay. Prices are returned per night and for the whole stay.

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

Number of adult guests. Changes which room types and prices Google shows for each date.

## `children` (type: `integer`):

Number of children. For per-age pricing use childrenAges instead.

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

List of child ages (0 to 17). Overrides 'children' with its length.

## `rooms` (type: `integer`):

Number of rooms needed.

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

ISO currency code, e.g. USD, EUR, GBP, JPY.

## `includeProviderPrices` (type: `boolean`):

Return every provider (Booking.com, Agoda, Expedia, Trip.com, official site...) for each date. Same price either way.

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

Google interface language (hl).

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

Google country (gl). Affects which booking partners Google shows.

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

Apify Proxy (datacenter) is used by default: it returns more complete data than direct requests. You normally don't need to change this.

## Actor input object example

```json
{
  "hotels": [
    "Hilton Paris Opera",
    "Pullman Danang Beach Resort"
  ],
  "numberOfDates": 30,
  "nights": 1,
  "adults": 2,
  "children": 0,
  "rooms": 1,
  "currency": "USD",
  "includeProviderPrices": true,
  "language": "en",
  "country": "us",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `prices` (type: `string`):

One item per hotel and check-in date.

## `pricesCsv` (type: `string`):

No description

## `summary` (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 = {
    "hotels": [
        "Hilton Paris Opera",
        "Pullman Danang Beach Resort"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zet46/google-hotels-price-calendar").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 = {
    "hotels": [
        "Hilton Paris Opera",
        "Pullman Danang Beach Resort",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zet46/google-hotels-price-calendar").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 '{
  "hotels": [
    "Hilton Paris Opera",
    "Pullman Danang Beach Resort"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zet46/google-hotels-price-calendar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zet46/google-hotels-price-calendar"
        }
    }
}
```

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/p9GJl8rtzQiW0LQyQ/builds/gfB6uBQ86Tfqh9G1P/openapi.json