# Google Hotels Prices: Nightly and Total Stay Rates (`quilldata/google-hotels`) Actor

Hotel names, nightly and total stay prices, star class, rating and review count from public Google Hotels search results, by city and dates.

- **URL**: https://apify.com/quilldata/google-hotels.md
- **Developed by:** [Quill Data](https://apify.com/quilldata) (community)
- **Categories:** Travel
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 hotel results

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 Prices – nightly & total stay price

Get the hotel list and prices that Google Hotels shows for a destination and your travel dates — as clean JSON/CSV/Excel rows.

Each row tells you **both** the nightly price and the **total price for the whole stay (taxes and fees included)**, plus star class, guest rating, review count and a link to the hotel on Google.

### What you can use it for

- Track hotel prices for a city over time (run it daily on a schedule).
- Compare destinations or travel dates before booking.
- Feed hotel price data into a spreadsheet, BI dashboard or your own app.
- Check which hotels Google ranks first for a search.

### How to use

1. Enter one or more searches, e.g. `hotels in Lisbon` or `hotels near Shibuya Station`.
2. Set check-in and check-out dates. When no dates are given, the actor searches a default 1-night stay 14 days ahead so the requested currency is applied; prices are for that stay and rows have dates_auto_filled=true.
3. Choose a currency (USD, EUR, GBP, JPY, …).
4. Click **Start** and download the results.

#### Input example

```json
{
  "queries": ["hotels in Lisbon", "hotels in Porto"],
  "checkIn": "2026-12-11",
  "checkOut": "2026-12-14",
  "adults": 2,
  "currency": "EUR"
}
```

#### Output example (one row)

```json
{
  "query": "hotels in Tokyo",
  "position": 1,
  "name": "Mitsui Garden Hotel Gotanda",
  "price_nightly": 112,
  "price_total": 369,
  "nights": 3,
  "total_includes_taxes_fees": true,
  "currency": "EUR",
  "price_basis": "nightly",
  "google_dates_text": "Dec 11 – 14",
  "dates_applied": true,
  "hotel_class": "4-star",
  "star_rating": 4,
  "rating": 4.3,
  "reviews_count": 1847,
  "amenities": ["Free Wi-Fi", "Parking", "Spa", "Restaurant"],
  "google_url": "https://www.google.com/travel/hotels/entity/…",
  "scraped_at": "2026-10-22T13:43:30Z"
}
```

*(Real row from a local test run on 2026-10-22; prices change constantly.)*

### Fields explained

| Field | Meaning |
| --- | --- |
| `price_nightly` | The per-night price shown on the card |
| `price_total` | The price for the whole stay, taxes and fees included |
| `nights` | Number of nights in your stay |
| `currency` | The currency Google actually displayed |
| `dates_applied` | `true` when the dates Google priced match the dates you asked for |
| `price_basis` | `nightly`, `nightly_auto_dates` when dates were filled in for you, or `total` |
| `hotel_class` | Official star class as text, e.g. `4-star`, when Google shows one (many apartments and hostels have none) |
| `star_rating` | The same star class as a number (1–5), or empty |

### Pricing

You pay per hotel row returned (pay-per-event, event `hotel-result` at **$0.002**), plus a tiny Actor start fee ($0.00005 per GB of memory, minimum one event).
**Only rows that show a price are charged.** Hotels without a displayed price (e.g. sold out) are still included in the output for free.
If Google shows a block or consent page, or no hotels are found, **nothing is pushed and nothing is charged** and the run log says why.

### Limits — please read

- Returns the **first results page, about 20 hotels per search**. To get more hotels, add more specific searches (neighbourhoods, landmarks, "4-star hotels in …").
- Prices are the ones Google shows publicly at the moment of the run; they change often and may differ from the final price on a booking site.
- Some hotels show no price (e.g. sold out); for them the price fields are empty.
- Only public search pages are read. No login, no reviews text, no personal data.

### Tips

- Use a schedule (e.g. daily) and the same input to build a price history.
- Keep searches specific — "hotels in Kyoto Gion" gives a different first page than "hotels in Kyoto".

### Also from Quill Data

- **[Google Flights Cheapest Fare Monitor](https://apify.com/quilldata/google-flights)** — cheapest public Google Flights fare for a route and date; failed or empty runs are free.
- **[Tennis Scores](https://apify.com/quilldata/tennis-scores)** — ATP, WTA and Challenger results with automatic source failover.

### Support

Found a wrong field or a broken run? Open an issue on the Issues tab with your input (no personal data) and the run ID. We aim to reply within 48 hours.

This Actor is not affiliated with or endorsed by Google.

# Actor input Schema

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

Hotel search phrases sent as the public q parameter, for example hotels in Tokyo.

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

Optional stay start, YYYY-MM-DD. Sent as checkin and inside the ts date blob. Compared with the date text Google prints on each card.

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

Optional stay end, YYYY-MM-DD. Sent as checkout and inside ts. Card dates that do not match set dates_applied to false.

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

Number of adult travelers. Sent as numberOfAdults.

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

Three-letter currency code (USD, EUR, GBP, JPY…). Applies when check-in and check-out dates are set. Each row's currency field shows the currency Google actually displayed.

## `gl` (type: `string`):

Google results region, for example us, gb or de.

## `hl` (type: `string`):

Google interface language. Also used for Accept-Language.

## `maxItemsPerQuery` (type: `integer`):

How many hotels to keep from the first results page. Only the first page (about 20) is available; higher values are capped to that page.

## `requestDelaySecs` (type: `number`):

Minimum pause between live Google requests.

## Actor input object example

```json
{
  "queries": [
    "hotels in Tokyo"
  ],
  "checkIn": "2026-12-05",
  "checkOut": "2026-12-08",
  "adults": 2,
  "currency": "USD",
  "gl": "us",
  "hl": "en",
  "maxItemsPerQuery": 20,
  "requestDelaySecs": 6
}
```

# 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 Tokyo"
    ],
    "checkIn": "2026-12-05",
    "checkOut": "2026-12-08",
    "adults": 2,
    "currency": "USD",
    "gl": "us",
    "hl": "en",
    "maxItemsPerQuery": 20,
    "requestDelaySecs": 6
};

// Run the Actor and wait for it to finish
const run = await client.actor("quilldata/google-hotels").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 Tokyo"],
    "checkIn": "2026-12-05",
    "checkOut": "2026-12-08",
    "adults": 2,
    "currency": "USD",
    "gl": "us",
    "hl": "en",
    "maxItemsPerQuery": 20,
    "requestDelaySecs": 6,
}

# Run the Actor and wait for it to finish
run = client.actor("quilldata/google-hotels").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 Tokyo"
  ],
  "checkIn": "2026-12-05",
  "checkOut": "2026-12-08",
  "adults": 2,
  "currency": "USD",
  "gl": "us",
  "hl": "en",
  "maxItemsPerQuery": 20,
  "requestDelaySecs": 6
}' |
apify call quilldata/google-hotels --silent --output-dataset

```

## MCP server setup

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

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/6WMfcYlqvcRMn4OWH/builds/WrHssNpICvI46IEGT/openapi.json