# Google Travel Dated Hotel Prices (`automation-lab/google-travel-hotel-date-prices`) Actor

Export Google Travel hotel names, displayed USD nightly prices, ratings, optional booking providers, and dated source links for US destinations and selected stays.

- **URL**: https://apify.com/automation-lab/google-travel-hotel-date-prices.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.37 / 1,000 item processeds

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 Travel Dated Hotel Prices

Export displayed **Google hotels** nightly rates for selected stay dates and US destinations. Each result contains a hotel name, displayed starting nightly price, USD currency, optional rating and provider, and a dated Google Travel link. Schedule the same input to collect comparable snapshots over time; the Actor does not store historical comparisons or send alerts.

### Who is it for?

- Revenue analysts compare publicly displayed rates for a particular stay across destination hotels.
- Travel planners export a shortlist of dated hotel prices to a spreadsheet.
- Data teams schedule repeat searches and join snapshots in their own warehouse by hotel and stay dates.

### Why use dated hotel results?

An undated search price is not a quote for your trip. This Actor selects check-in and check-out in Google Travel, waits until the visible hotel cards reflect that stay length, and exports the live displayed starting rates. The source hotel link retains Google's date and hotel selection. It does not claim to capture every bookable room or the final checkout price.

### Get started

1. Enter one or more US destinations, for example `New York`.
2. Enter future `checkInDate` and `checkOutDate` in `YYYY-MM-DD` format; the stay must be 1–30 nights.
3. Set `maxItems` (1–200 across all destinations) and run the Actor.
4. Open the **Hotel rates** dataset view or download its JSON/CSV. Check the run log if a destination fails to produce confirmed dated cards.

Google Travel availability and hotel prices vary by date and location. Try a small run before scheduling a large list.

### Inputs

| Field | Required | Meaning |
| --- | --- | --- |
| `destinations` | Yes | 1–20 destination names, each at most 150 characters; processed in the order entered. |
| `checkInDate` | Yes | Future arrival date in `YYYY-MM-DD`. |
| `checkOutDate` | Yes | Departure date, 1–30 nights after arrival. |
| `maxItems` | No | Maximum total priced hotels across destinations; default 10. |
| `country` | No | `US` only. A country-matched Apify proxy is required. |
| `currency` | No | `USD` only; the output reflects Google's displayed currency. |

The Actor rejects unsupported country/currency combinations before opening the browser. There is no direct hotel URL input; destinations are searched on Google Travel.

#### Single-destination input

```json
{"destinations":["New York"],"checkInDate":"2026-10-21","checkOutDate":"2026-10-23","maxItems":3}
```

These example dates are for demonstration; choose future dates when running after October 2026.

#### Multi-destination monitoring input

```json
{"destinations":["New York","Boston"],"checkInDate":"2026-10-21","checkOutDate":"2026-10-23","maxItems":24}
```

Schedule repeat runs with the same stay dates to compare snapshots outside the Actor. A schedule does not automatically diff results or notify you.

### Dataset fields

| Field | Description |
| --- | --- |
| `destination` | Destination searched. |
| `hotelName` | Name on the Google Travel search card. |
| `checkInDate`, `checkOutDate` | Requested stay dates confirmed on the visible result cards. |
| `nightlyPrice`, `priceText`, `currency` | Displayed starting nightly amount, raw price label, and displayed currency. |
| `provider` | Named offer provider on the search card, or `null` if none is displayed. A generic **View prices** button is not provider attribution. |
| `rating` | Displayed rating out of five, or `null` when unavailable. |
| `hotelUrl` | Google Travel hotel-selection link with stay context; may be `null` if unavailable. |
| `sourceUrl` | Date-selected Google Travel search-results URL. |
| `scrapedAt` | Extraction timestamp in UTC. |

A representative local New York row returned `The One Boutique Hotel`, `$132` (`132`, `USD`), rating `3.3`, `provider: null` for October 21–23, 2026. Prices are live and may have changed by the time you run it. The complete hotel and search URLs are in the dataset, not abbreviated in this example.

### How much does it cost to export dated hotel prices?

The Actor charges $0.005 once per run (`start`) and one `item` event per emitted hotel. At the FREE spend tier, an item costs $0.002622; BRONZE $0.00228, SILVER $0.0017784, and GOLD/PLATINUM/DIAMOND $0.001368. For example, three hotels cost an estimated $0.012866 at FREE ($0.005 + 3 × $0.002622); ten cost $0.03122; 25 cost $0.07055. These are Store-event estimates, not guaranteed invoices: applicable Apify plan charges for compute and US proxy transfer can also apply, and refunds, disputes, taxes or billing corrections may affect final charges. The tier depends on qualifying monthly Store spend, **not** the number of hotels in one run; consult the live **Pricing** tab for your applicable tier. A failed run can still incur a start event; the Actor charges an item only after writing its dataset row. Provider and rating fields have no separate charge event.

### Integrations and recurring rate snapshots

Use Apify Schedules to run the same dated query at regular intervals. Export each run's dataset to Google Sheets through an integration, download CSV, or fetch JSON into your own pipeline. Compare hotel identity, destination, selected stay dates, `nightlyPrice`, and `scrapedAt`; do not interpret a missing hotel as a zero price. Dates must be moved forward for future stays as time passes. No built-in price alerts, historical storage, or provider-specific booking API are included.

### API usage

Replace `APIFY_TOKEN` with your own token and use future dates:

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~google-travel-hotel-date-prices/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"destinations":["New York"],"checkInDate":"2026-10-21","checkOutDate":"2026-10-23","maxItems":3}'
```

JavaScript with `apify-client`:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-travel-hotel-date-prices').call({
    destinations: ['New York'], checkInDate: '2026-10-21', checkOutDate: '2026-10-23', maxItems: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-travel-hotel-date-prices').call(run_input={
    'destinations': ['New York'], 'checkInDate': '2026-10-21',
    'checkOutDate': '2026-10-23', 'maxItems': 3,
})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP setup

To use this Actor from Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/google-travel-hotel-date-prices"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, configure an HTTP MCP server (and authenticate with Apify as required by your client):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/google-travel-hotel-date-prices"}}}
```

Example prompt: “Run automation-lab/google-travel-hotel-date-prices for New York, check in 2026-10-21 and check out 2026-10-23, at most three hotels; summarize displayed nightly prices and missing providers.” Use future dates when necessary. Another prompt: “Export dated rates for New York and Boston to compare two destination shortlists.” MCP clients invoke the Actor; they do not add an internal price-history feature.

### Limitations

- Only US/USD requests are supported and a US Apify datacenter proxy is required. Other currencies and geographies are intentionally rejected.
- Google may vary or remove card fields, block traffic, or display no date-confirmed priced cards. The run then fails rather than mislabeling an undated rate.
- The dataset is a bounded sample of visible cards, not exhaustive inventory; taxes, fees, room types, availability, and final checkout amounts may differ.
- Most Google Travel search cards do not identify a booking provider. `provider` is usually `null`, not an inferred booking company.
- Visible ratings can be absent. Source links and prices may expire or change.

### Troubleshooting

**Why is my run failing on dates?** Ensure check-in is not in the past, check-out follows check-in, and the stay is no more than 30 nights. If Google does not render confirmed date-selected cards, retry later with a smaller destination set; do not interpret an empty or failed run as zero-priced hotels.

**Why is the provider missing?** Google's result card can show only a starting price or a generic **View prices** button. The Actor does not invent an offer provider. Open the hotel URL to check available offers yourself.

**Why do results differ between runs?** Rates, availability, geographic presentation, and Google's cards can change. Match both dates and `scrapedAt` when comparing runs.

### Legality and responsible use

Collect public, non-sensitive hotel search information only; comply with Google's applicable terms and local law. Do not use the output as a guaranteed booking offer. Inputs and result datasets are stored under your Apify account's retention settings; this Actor does not create an external history database. Google receives the destination query through an Apify US proxy. No generative AI provider is used, and the Actor does not ask for hotel accounts or personal credentials. Remove datasets when no longer needed according to your account policy.

### Data handling

The browser processes only the destination and selected dates. The Actor writes hotel fields to the run's default dataset and does not write session cookies, secrets, or a separate historical cache. The Apify account owner controls run/dataset retention and deletion; do not put personal data in destination names.

### Related automation-lab Actors

[Google Flights Scraper](https://apify.com/automation-lab/google-flights-scraper) covers flight itineraries rather than hotel rooms. [Google Search Results Scraper](https://apify.com/automation-lab/google-search-scraper) exports general search results rather than dated accommodation rates.

### FAQ

**Does it book rooms?** No; it exports public search-card prices and dated links.

**Can I specify a hotel URL or get every provider's price?** No. Search is destination-based; the provider field reflects only an explicitly named provider visible on the card, if any.

**Can I export 200 hotels from one city?** The limit is a cap, not a guarantee. Google may display fewer priced results and this Actor does not promise full pagination coverage.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/google-travel-hotel-date-prices/changelog.md

# Actor input Schema

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

Cities or regions to search on Google Travel.

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

Future arrival date in YYYY-MM-DD format.

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

Departure date after check-in, maximum 30 nights.

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

Maximum priced hotel results across all destinations.

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

Only US results have been verified; a US proxy is required.

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

Only USD has been verified; the actual displayed currency is preserved.

## Actor input object example

```json
{
  "destinations": [
    "New York"
  ],
  "checkInDate": "2026-10-21",
  "checkOutDate": "2026-10-23",
  "maxItems": 10,
  "country": "US",
  "currency": "USD"
}
```

# Actor output Schema

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

Default dataset of dated Google Travel hotel search results, including displayed prices and source URLs.

# 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": [
        "New York"
    ],
    "checkInDate": "2026-10-21",
    "checkOutDate": "2026-10-23"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-travel-hotel-date-prices").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": ["New York"],
    "checkInDate": "2026-10-21",
    "checkOutDate": "2026-10-23",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-travel-hotel-date-prices").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": [
    "New York"
  ],
  "checkInDate": "2026-10-21",
  "checkOutDate": "2026-10-23"
}' |
apify call automation-lab/google-travel-hotel-date-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/google-travel-hotel-date-prices"
        }
    }
}
```

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/X4b1wbMJPFqQ5Pdnn/builds/4o4mz0dIsEl2d10ef/openapi.json