# Google Hotels Scraper (Prices, Ratings, Reviews) (`neatfeeds/google-hotels-scraper`) Actor

Search Google Hotels for any city or area and dates: get nightly prices, star class, rating, review counts and breakdown, coordinates, website, photos and Google links. Fast, no browser.

- **URL**: https://apify.com/neatfeeds/google-hotels-scraper.md
- **Developed by:** [Neatfeeds](https://apify.com/neatfeeds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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 (Prices, Ratings, Reviews)

Search **Google Hotels** for any city, neighbourhood or free query, with optional **check-in/check-out dates** and **number of adults**, and get structured results: **nightly price**, **star class**, **rating**, **review count and 1–5 star breakdown**, **coordinates**, **official website**, **photos** and the **Google hotel link**.

**Price: $3.00 per 1,000 hotels** ($0.003 per hotel) + $0.00005 per run. One search of 20 hotels costs about $0.06.

### Why this actor

- **One currency, your choice.** Set `currency` (`USD`, `EUR`, `GBP`, `JPY`…) and every price in the run uses it, whatever country the proxy exits from. Hotels Google prices in another currency are skipped, not mixed in.
- **No browser.** One HTTP request per search, with automatic proxy rotation when Google blocks: fast runs, low cost.
- **Prices for your dates.** Check-in, check-out and adults go into the search; `checkIn`/`checkOut` in the output are the dates Google actually priced, so you can verify them.
- **More than the price.** Star class, rating, review count with the 1–5 star breakdown, coordinates, website, photos and Google Maps IDs in one item.
- **Organic results only.** Sponsored hotels are excluded; `position` is the organic rank.

### What you can use it for

- Hotel price monitoring and rate parity checks for specific dates.
- Market research: compare ratings, review volume and pricing across a destination.
- Travel apps and AI agents that need live hotel options with coordinates.
- Lead lists of hotels with their website, by city or area.

### Input

Only `locations` is required.

| Field | What it does |
|---|---|
| `locations` (required) | One search each: `Rome`, `Trastevere, Rome`, `hotels near the Colosseum`. |
| `checkIn`, `checkOut` | Dates in `YYYY-MM-DD`. Leave empty for Google's default dates. |
| `adults` | Guests; prices depend on it (default 2). |
| `language`, `country` | Google edition (`en` + `us` by default). |
| `currency` | 3-letter ISO code for every price in the run (`USD` by default; `EUR`, `GBP`, `JPY`…). |
| `maxResultsPerSearch` | Up to 20 hotels per search. |
| `maxResults` | Total cap (default 500). |
| `proxyConfiguration` | Apify Proxy by default; use residential if many searches get blocked. |

Example:

```json
{
  "locations": ["Rome", "Milan"],
  "checkIn": "2026-12-01",
  "checkOut": "2026-12-04",
  "adults": 2,
  "currency": "EUR"
}
```

### Output (one item per hotel)

```json
{
  "searchLocation": "Rome",
  "position": 1,
  "name": "Salotto Monti | BZAR hotels",
  "hotelClass": "3-star hotel",
  "stars": 3,
  "rating": 4.6,
  "reviewCount": 475,
  "ratingBreakdown": { "1": 10, "2": 8, "3": 25, "4": 90, "5": 342 },
  "pricePerNight": 110,
  "priceText": "€110",
  "currency": "EUR",
  "checkIn": "2026-12-01",
  "checkOut": "2026-12-04",
  "adults": 2,
  "latitude": 41.89,
  "longitude": 12.49,
  "description": "…",
  "website": "https://…",
  "countryCode": "IT",
  "googleHotelUrl": "https://www.google.com/travel/hotels/entity/…",
  "propertyToken": "…",
  "googleMapsFeatureId": "0x…:0x…",
  "images": ["https://lh3.googleusercontent.com/…"],
  "scrapedAt": "2026-10-19T20:10:00.000Z"
}
```

| Field | Meaning |
|---|---|
| `searchLocation`, `position` | The search this hotel came from and its organic rank in it. |
| `name`, `hotelClass`, `stars` | Hotel name, Google's class label and the star number. |
| `rating`, `reviewCount`, `ratingBreakdown` | Google rating (1–5), number of reviews and count per star. |
| `pricePerNight`, `priceText`, `currency` | Nightly price as a number, as displayed, and its ISO currency. |
| `checkIn`, `checkOut`, `adults` | The dates Google priced and the guests searched. |
| `latitude`, `longitude`, `countryCode` | Location of the hotel. |
| `description`, `website`, `images` | Google's short description, official website and photo URLs. |
| `googleHotelUrl`, `propertyToken`, `googleMapsFeatureId` | Google Hotels page and IDs to match the hotel in other Google data. |
| `scrapedAt` | When the hotel was collected. |

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Hotel returned | $0.003 ($3.00 per 1,000) |
| Run start | $0.00005 |

Examples:

- One city search, 20 hotels: 20 × $0.003 + $0.00005 ≈ **$0.06**
- A city split into 10 neighbourhoods, 200 hotels: **$0.60**
- Daily price check of 20 hotels for one destination: about **$1.80 per month**

### FAQ

**How do I cap what a run costs?**
Set a maximum cost per run in the run options (or with `maxTotalChargeUsd` via the API). The actor stops cleanly when the limit is reached and keeps every hotel collected so far. `maxResults` caps the number of hotels as well.

**Why are some fields `null` or some hotels missing?**
Fields Google does not show for a hotel (for example a price when there is no offer for your dates) are `null`. If Google prices some hotels in a different currency than the one you chose (an unsupported code), those hotels are skipped and not billed, with a warning in the log. A search that Google keeps blocking is reported in the log and skipped; the run continues with the others.

**How do I cover a whole city?**
Google shows about 20 hotels per search. Run several neighbourhood or area searches (`Trastevere, Rome`, `Monti, Rome`…) in one run.

**Can I call it from code, an AI agent or an automation tool?**
Yes. Run it through the [Apify API](https://docs.apify.com/api/v2) and get the dataset in the same call:

```bash
curl -X POST "https://api.apify.com/v2/acts/Neatfeeds~google-hotels-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["Rome"], "checkIn": "2026-12-01", "checkOut": "2026-12-04", "currency": "EUR"}'
```

It also works with Apify schedules, webhooks and integrations such as Make, Zapier and n8n, and with AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Notes

- Data comes from Google Hotels public search pages. You are responsible for how you use it.

# Actor input Schema

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

One Google Hotels search per entry: a city ("Rome"), a neighbourhood ("Trastevere, Rome") or a free query ("hotels near the Colosseum"). Each search returns up to ~20 hotels; split big cities into neighbourhoods for more coverage.

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

YYYY-MM-DD. Leave empty for Google's default dates. Requires check-out.

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

YYYY-MM-DD, after check-in.

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

Number of adult guests (prices depend on it).

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

Google interface language, e.g. en, it, de. English is the most reliable for date parsing.

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

Two-letter Google edition, e.g. us, gb, it.

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

3-letter ISO code for all prices, e.g. USD, EUR, GBP, JPY. Every hotel in the run is priced in this currency, whatever the proxy location.

## `maxResultsPerSearch` (type: `integer`):

Up to 20 hotels per location.

## `maxResults` (type: `integer`):

Stop after this many hotels in total (each hotel is one billed result).

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

Google blocks repeated requests from one IP. Apify Proxy rotates IPs automatically; switch to residential proxies if you see many blocked searches.

## Actor input object example

```json
{
  "locations": [
    "Rome"
  ],
  "adults": 2,
  "language": "en",
  "country": "us",
  "currency": "USD",
  "maxResultsPerSearch": 20,
  "maxResults": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset items in the "Hotels" view: searchLocation, position, name, stars, rating, reviewCount, priceText, checkIn, checkOut, googleHotelUrl.

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

Every dataset item with all fields.

# 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": [
        "Rome"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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