# Google Hotels Scraper: Hotel Prices from All Booking Sites (`t3data/google-hotels`) Actor

Google Hotels prices for any city and dates: nightly and total price with taxes, deals, stars, rating, reviews, amenities, location and photos, plus optional prices from every booking site. Pay only for hotels you get.

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

## Pricing

from $1.50 / 1,000 hotels

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: Hotel Prices from All Booking Sites

A **Google Hotels API** with no API key and no quota. Search any city, neighborhood or landmark for your dates and get every hotel's **nightly and total price with taxes**, deals, star class, rating, reviews, amenities, location and photos. Optionally add **prices from every booking site** (Booking.com, Expedia, Agoda, the hotel's own site…). **You only pay for hotels you get.**

**Built to finish.** The most-used Google Hotels scraper fails about 1 in 4 runs (Apify Store stats, 30 days to 2026-10-28). In our benchmarks, 200 of 200 hotels came back in about 20 seconds, and failed searches are never charged.

| | |
|---|---|
| 💲 **Price** | $3 per 1,000 hotels on Apify's Free plan, down to $1.50 on paid plans. Booking-site prices are an optional +$2 per 1,000 (down to $1). Failed searches are free. |
| ⚡ **Speed** | ~200 hotels from 5 cities in about 10 seconds; with booking-site prices, ~40 hotels in about 45 seconds |
| 📥 **Input** | Locations (city, area, landmark), dates, guests, currency; or Google Hotels links for single-hotel price lookups |
| 📤 **Output** | One row per hotel: prices (before and after taxes), deal, stars, rating with breakdown, review topics, amenities, address, coordinates, phone, website, photos, booking-site prices |
| 🌍 **Coverage** | Any destination Google Hotels covers, any currency and Google edition |

### What people use it for

- **Travel price monitoring:** track rates for a city or a list of hotels and get alerted when prices drop (the `deal` field shows "28% less than usual")
- **Revenue management and competitor pricing:** see what competing hotels charge on your dates, on every booking site
- **Travel apps, agents and AI assistants:** a ready hotel-search backend with prices, ratings and links
- **Market research:** average price, rating and amenities per neighborhood or city
- **Lead lists for hospitality vendors:** hotels with phone, website and address by area

### How to use it

1. Add one or more **Locations** (e.g. "Berlin", "Shibuya Tokyo", "near Times Square").
2. Set **Check-in / Check-out**, guests and currency. Optionally turn on **booking-site prices**.
3. Click **Start**, then download as JSON, CSV or Excel, or fetch through the API.

### For AI agents and automations

- **One job:** find hotels and their prices for a place and dates (or all booking-site prices for one hotel). Minimal input: `{ "locations": ["Berlin"], "checkIn": "2026-12-10", "checkOut": "2026-12-12" }`
- **Fast enough for a single tool call:** 20–40 hotels for one city finish in a few seconds, which fits inside the Apify MCP server's default 30-second wait. For big jobs, start the run asynchronously and read the dataset when it finishes.
- **Where the results are:** dataset items (fields below). A **run summary** is in the key-value store record `OUTPUT`: `status` (`SUCCEEDED`, `PARTIAL`, `STOPPED_AT_SPEND_LIMIT`, `ABORTED`, `NO_RESULTS`, `SOURCE_UNAVAILABLE`), `results`, `errorsByCode` and a plain-English `message`.
- **Predictable billing:** pay per event. Only hotels returned are charged; error rows are free.
- **Respects "Max cost per run":** it never fetches hotels your budget can't pay for, then stops cleanly with status `STOPPED_AT_SPEND_LIMIT`. Everything fetched up to that point is kept.
- **Graceful on abort and restarts:** partial results are always kept, and a platform restart resumes without duplicates or double charges.
- **Honest failures:** if Google blocks every request or changes its format, the run fails with a clear message and you pay $0, instead of quietly returning empty results.
- Works with the **Apify MCP server** (Claude, Cursor, other agents), agentic payments, and the API.

### Input examples

Hotels in Berlin for two nights, in euros:

```json
{ "locations": ["Berlin"], "checkIn": "2026-12-10", "checkOut": "2026-12-12", "currency": "EUR", "maxHotelsPerLocation": 40 }
```

Compare booking sites for every hotel in two cities:

```json
{ "locations": ["Lisbon", "Barcelona"], "checkIn": "2026-12-10", "checkOut": "2026-12-12", "includeBookingPrices": true, "maxHotelsPerLocation": 20 }
```

Price lookup for specific hotels (paste their Google Hotels links), family of four:

```json
{ "hotels": ["https://www.google.com/travel/hotels/entity/ChgI09OS2OzFyo7JARoLL2cvMXRkdm5zZjkQAQ"], "checkIn": "2026-12-10", "checkOut": "2026-12-12", "adults": 2, "childrenAges": [6, 9] }
```

### Output

One item per hotel. From a real run (arrays shortened):

```json
{
  "type": "hotel",
  "position": 3,
  "name": "The Ritz-Carlton, Berlin",
  "hotelClass": "5-star hotel",
  "stars": 5,
  "rating": 4.6,
  "reviewCount": 3300,
  "ratingDistribution": { "5star": 2589, "4star": 343, "3star": 139, "2star": 79, "1star": 150 },
  "reviewTopics": [{ "topic": "Service", "sentiment": 0.6, "mentions": 358, "positive": 303, "negative": 43 }],
  "pricePerNight": 280.78,
  "pricePerNightWithTaxes": 321.49,
  "totalPrice": 561.55,
  "totalPriceWithTaxes": 642.98,
  "currency": "EUR",
  "deal": "28% less than usual",
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-12",
  "nights": 2,
  "adults": 2,
  "address": "Potsdamer Platz 3",
  "latitude": 52.5103836,
  "longitude": 13.3752744,
  "phone": "+49 30 337777",
  "website": "https://www.ritzcarlton.com/en/hotels/berzt-the-ritz-carlton-berlin/overview/",
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "amenities": ["Breakfast ($)", "Free Wi-Fi", "Parking ($)", "Indoor pool", "Air conditioning", "Pet-friendly", "Fitness center", "Spa"],
  "nearbyPlaces": [{ "name": "Potsdamer Platz", "travelTimes": ["1 min"] }, { "name": "Berlin Brandenburg Airport", "travelTimes": ["21 min", "28 min"] }],
  "images": ["https://lh3.googleusercontent.com/grass-cs/…"],
  "hotelId": "ChgIveLHqY3365ykARoLL2cvMTIzMjYwN3gQAQ",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChgIveLHqY3365ykARoLL2cvMTIzMjYwN3gQAQ"
}
```

With **booking-site prices** on, each hotel also gets `bookingPrices` (cheapest first) plus `cheapestProvider` and `cheapestTotalPriceWithTaxes`:

```json
"bookingPrices": [
  { "provider": "Super.com", "isOfficialSite": false, "pricePerNight": 111.17, "pricePerNightWithTaxes": 118.34, "totalPrice": 222.34, "totalPriceWithTaxes": 236.68, "bookingUrl": "https://www.google.com/travel/lodging/clk?…" },
  { "provider": "Traveluro", "isOfficialSite": false, "pricePerNight": 105.77, "pricePerNightWithTaxes": 121.12, "totalPrice": 211.55, "totalPriceWithTaxes": 242.23, "bookingUrl": "…" }
]
```

| Field | Meaning |
|---|---|
| `pricePerNight` / `pricePerNightWithTaxes` | Lowest nightly price, before and after taxes and fees |
| `totalPrice` / `totalPriceWithTaxes` | Total for the whole stay, before and after taxes |
| `deal` | Google's deal note, e.g. "28% less than usual" |
| `hotelClass`, `stars` | Official class ("4-star hotel") and its number |
| `rating`, `reviewCount`, `ratingDistribution` | Google rating, number of reviews, counts per star |
| `reviewTopics` | What reviews talk about (Service, Location, Breakfast…), with sentiment 0–1 and positive/negative counts |
| `amenities` | Amenity labels as Google shows them |
| `address`, `latitude`, `longitude`, `phone`, `website`, `googleMapsUrl` | Location and contact |
| `checkInTime`, `checkOutTime`, `description`, `nearbyPlaces`, `images` | Property details |
| `hotelId`, `googleHotelsUrl` | Google's id and page, reusable in the `hotels` input for price lookups |
| `bookingPrices`, `cheapestProvider`, `cheapestTotalPriceWithTaxes` | Every booking site's price (option) |
| `position`, `location`, `placeName`, `totalResultsForLocation` | Rank, your search, how Google understood it, and how many properties it has |

### Cost examples

| Job | Hotels | Cost (Free plan) |
|---|---|---|
| 20 hotels in one city | 20 | $0.06 |
| 5 cities × 40 hotels | 200 | $0.60 |
| 20 hotels in one city with booking-site prices | 20 | $0.10 |
| Daily price check of 100 hotels with booking sites, for a month | 3,000 | $15 |

Set **Max cost per run** to cap any run, and the actor stops cleanly at the limit.

### Integrations

- **API**: `client.actor("t3data/google-hotels").call({ locations: ["Berlin"], checkIn: "2026-12-10", checkOut: "2026-12-12" })` (JS), or `client.actor("t3data/google-hotels").call(run_input={...})` (Python). Full snippets are on the **API** tab.
- **AI agents (MCP)**: available as a tool through the Apify MCP server.
- **Scheduling**: run it daily with Apify Schedules for price tracking.
- **No-code**: Make, Zapier, n8n, Google Sheets, Slack and webhooks, through Apify integrations.
- **Export**: JSON, CSV, Excel, XML, HTML or RSS.

### Error codes (never charged)

| Code | Meaning |
|---|---|
| `LOCATION_NOT_FOUND` | Google couldn't place the location (it would have fallen back to "near you"). Use a city, area or landmark name |
| `NO_RESULTS` | No properties for that location on these dates |
| `NO_PRICES` | A looked-up hotel has no booking prices on these dates |
| `INVALID_URL` | Not a Google Hotels hotel link or id |
| `SOURCE_UNAVAILABLE` (run status) | Every request was blocked, or the source changed its format. The run fails with $0 charged; retry later |
| `BLOCKED` | Google kept refusing after every retry (rare; try again) |

### FAQ

**Which price is "the" price?** `pricePerNight` and `totalPrice` match the big number Google shows, which is the lowest offer. Taxes-included versions are next to them. With booking-site prices on, you see every site's price.

**Do prices depend on country and currency?** Yes. Google shows different sites and prices per edition. Set `country` (e.g. `gb`, `de`) and `currency` to match your market.

**Why does a city return fewer hotels than Google's total?** Google's total includes vacation rentals and places without prices for your dates. Set `maxHotelsPerLocation` higher to page further.

**Are the booking links permanent?** No. They're Google's click-through links and expire after a while. Use `hotelId` or `googleHotelsUrl` to come back to a hotel.

**Do I need a proxy or an API key?** No. Proxies are built in and included in the price. If one gets blocked, the actor switches automatically.

**Something broke?** Open an issue on the **Issues** tab with your input. Fixes usually ship within a day.

**Found it useful?** A star rating on this page helps other people find it.

### Limits

- Up to ~1,000 hotels per location. Stays of 1–30 nights.
- Prices are what Google shows at run time for the chosen edition and currency, and can change minutes later.
- Vacation rentals that appear in Google's hotel results are included when they have prices; `hotelClass` is empty for them.

### More from T3 Data

- [Google Trends Scraper](https://apify.com/t3data/google-trends): interest over time, by region, related queries, and trending now
- [Google News Scraper](https://apify.com/t3data/google-news): articles with real publisher URLs and optional full text
- [Google Ads Transparency Scraper](https://apify.com/t3data/google-ads-transparency): every ad a company runs on Google
- [YouTube Transcripts](https://apify.com/t3data/youtube-transcripts), [YouTube Comments](https://apify.com/t3data/youtube-comments), [YouTube Channel & Shorts](https://apify.com/t3data/youtube-channel)

***

*This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Google. It only accesses publicly available Google Hotels results.*

# Actor input Schema

## `locations` (type: `array`):

Cities, neighborhoods, landmarks or airports, e.g. "Berlin", "Shibuya Tokyo", "near Times Square". Each is searched like on Google Hotels.

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

Optional. Google Hotels links of specific hotels (google.com/travel/hotels/.../entity/...) or their hotelId, to get prices from every booking site for that hotel.

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

YYYY-MM-DD. Leave empty for a stay two weeks from today.

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

YYYY-MM-DD, 1-30 nights after check-in. Leave empty for 1 night.

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

Number of adult guests.

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

Optional. One age (0-17) per child, e.g. 4, 9.

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

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

## `maxHotelsPerLocation` (type: `integer`):

Hotels to collect per location, in Google's order (about 18-20 per page).

## `includeBookingPrices` (type: `boolean`):

Adds `bookingPrices` (Booking.com, Expedia, Agoda, the hotel's own site, ...) to each hotel, cheapest first. One extra request per hotel, charged as a separate event.

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

Language for names and descriptions, e.g. en, de, es, fr, ja.

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

Two-letter country of the Google edition, e.g. us, gb, de. Affects which booking sites and prices are shown.

## `maxConcurrency` (type: `integer`):

How many locations or hotels to process at the same time.

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

Apify datacenter proxy is the default: fast and cheap for Google Hotels. If it gets blocked, the actor switches to residential IPs automatically. Proxy cost is included in the price.

## Actor input object example

```json
{
  "locations": [
    "Berlin"
  ],
  "adults": 2,
  "currency": "USD",
  "maxHotelsPerLocation": 20,
  "includeBookingPrices": false,
  "language": "en",
  "country": "us",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `hotels` (type: `string`):

One item per hotel (or per looked-up hotel), plus free error rows.

## `summary` (type: `string`):

One JSON object: status (SUCCEEDED, PARTIAL, STOPPED_AT_SPEND_LIMIT, ABORTED, NO_RESULTS, SOURCE_UNAVAILABLE), results count, failed inputs by error code, and a plain-English message.

# 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 = {
    "locations": [
        "Berlin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("t3data/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 = { "locations": ["Berlin"] }

# Run the Actor and wait for it to finish
run = client.actor("t3data/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 '{
  "locations": [
    "Berlin"
  ]
}' |
apify call t3data/google-hotels --silent --output-dataset

```

## MCP server setup

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