# Google Hotels Scraper: Prices, Ratings & Deals (`leathered_latch/google-hotels-scraper`) Actor

Live hotel and vacation-rental prices from Google Hotels for any city and dates: nightly rate, total price, rating, reviews, amenities and deal flag. A Google Hotels API you pay per property.

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

## Pricing

$3.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 Scraper: prices, ratings, deals and vacation rentals

Pull hotel and vacation-rental listings from Google Hotels for any city. You get the nightly price, the total with taxes and fees, guest rating, review count, star class, amenities, and Google's "less than usual" deal flag. Set your own check-in and check-out dates, or leave them empty to get Google's default dates.

You pay only for properties actually delivered. A failed search costs nothing.

### What you get

| Field | Example |
|---|---|
| `name` | Inn on the Riverwalk |
| `type` | `hotel` or `vacation_rental` |
| `pricePerNight` | 150 |
| `totalPrice` | 349 (taxes and fees included) |
| `nights` | 2 |
| `rating` / `reviewCount` | 4.7 / 221 |
| `hotelClass` | 3 (star class) |
| `dealLabel` / `vsUsualPercent` | DEAL / 23 (23% less than usual) |
| `amenities` | Breakfast, Free Wi-Fi, Free parking, Pet-friendly |
| `propertyKind`, `sleeps`, `bedrooms`, `bathrooms` | Apartment, 6, 2, 1 (rentals) |
| `googleEntityId`, `googleUrl` | Stable ID and a link to the property on Google |
| `location`, `checkIn`, `checkOut`, `currency`, `scrapedAt` | What you asked for, and when |

Every row is a flat record, so it opens cleanly in Excel or Google Sheets.

#### Sample output

```json
{
  "location": "San Antonio, TX",
  "name": "Inn on the Riverwalk",
  "type": "hotel",
  "pricePerNight": 150,
  "totalPrice": 349,
  "nights": 2,
  "currency": "USD",
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-22",
  "rating": 4.7,
  "reviewCount": 221,
  "hotelClass": 3,
  "dealLabel": "DEAL",
  "vsUsualPercent": 23,
  "amenities": [
    "Breakfast",
    "Free Wi-Fi",
    "Free parking",
    "Air conditioning",
    "Pet-friendly",
    "Kitchen in rooms",
    "Kid-friendly",
    "Smoke-free property"
  ],
  "googleEntityId": "ChgIor-1m9-Nl6bmARoLL2cvMXRkZGI4NDUQAQ",
  "scrapedAt": "2026-10-09T03:40:46.200Z"
}
```

### Quick start

1. Type one or more cities in **Locations**, one per line. "City, State" or "City, Country" works best.
2. Add check-in and check-out dates if you want prices for a specific stay.
3. Set **Max results per location**. Google shows about 18 properties per search, so for larger numbers the scraper runs extra searches (by star class, budget and amenities) and removes duplicates. You never pay twice for the same property.
4. Click **Start**. In testing, three cities at 100 properties each finished in about 25 seconds.

The default input (San Antonio, 20 results) runs as-is, so you can see the output before changing anything.

### Use cases

- **Track hotel prices for a city** ahead of a trip, an event or a conference.
- **Compare a hotel's rate with nearby competitors** for revenue management.
- **Find the cheapest well-rated hotels** by filtering on `rating` and `pricePerNight` in your spreadsheet.
- **Spot deals** with `vsUsualPercent`, which comes straight from Google's own price history.
- **Research vacation rentals** with bedroom, bathroom and guest counts.
- **Feed travel apps and AI agents** with fresh price data through the API.

### What happens when something goes wrong

Most scraper complaints come from runs that say "success" and hand back nothing, or the wrong thing. This one tells you.

- **Google doesn't recognise your location?** Google quietly swaps in hotels near wherever the request came from. This scraper catches that, returns nothing for that location, and charges nothing. The run summary tells you what Google showed instead, so you can fix the spelling.
- **A search fails after retries?** You aren't charged, and the run summary says which one failed.
- **Fewer results than you asked for?** Some small towns only have a dozen properties. The summary says how many Google had.

Look for the `RUN_SUMMARY` record in the run's key-value store for a per-location report.

### Input

| Field | Required | Notes |
|---|---|---|
| `locations` | yes | List of places. Example: `["San Antonio, TX", "Lisbon, Portugal"]` |
| `checkIn`, `checkOut` | no | `YYYY-MM-DD`. Give both or neither. Check-out must be after check-in. |
| `adults` | no | Default 2 |
| `currency` | no | 3-letter code, default `USD` |
| `maxResultsPerLocation` | no | 1 to 150, default 20 |

### Pricing

Pay per property delivered, plus Apify's small start fee per run. There's no monthly fee from us. Set a maximum cost per run in Apify and the scraper stops cleanly when it hits your limit.

### FAQ

**Do I need a Google account or an API key?**
No. The scraper reads Google Hotels' public search results.

**Are the prices live?**
Yes. Every row is fetched at the moment you run it, and `scrapedAt` records the time. Hotel prices move fast, so re-run before relying on a number.

**Why don't I get exactly the hotels I see in my browser?**
Google personalises results by location and sign-in. This scraper searches as a signed-out US visitor, which keeps runs consistent and comparable.

**Can I get more than 150 properties for one city?**
Split the city into neighbourhoods (for example "Downtown Chicago" and "O'Hare, Chicago") and run them together. Duplicates across them are not removed, so dedupe on `googleEntityId`.

**Does it scrape booking sites like Expedia or Booking.com?**
No. It returns what Google Hotels shows, which already aggregates many of those sites.

**Something broke. What now?**
Open an issue on this page with the location and dates you used. I answer issues within a day.

### Limitations

- Prices are what Google displays. The final price on a booking site can differ.
- Google shows a mix of hotels and rentals that changes with the dates you pick.
- Review counts above 1,000 can be rounded on Google's list (for example 2,700 for "2.7K").
- US English results only for now.

### Export or use as an API

Download any run's results from the **Storage** tab as CSV, Excel, JSON or XML.

To call it from your own code, send your input to Apify's API and get the rows back in one request:

```
POST https://api.apify.com/v2/acts/leathered_latch~google-hotels-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN
```

It also plugs into Make, Zapier and n8n through Apify's integrations, and AI agents can find and run it through Apify's MCP server.

### Your responsibility

How you use the output is your call, and so is the legal side of it. Copyright still covers any text or images you republish. The source site's own terms apply too. If you're unsure about a use, check with a lawyer first.

If you own content that shows up in these results and want it handled differently, open an issue on the Issues tab. We answer within 14 days.

### Data source and credit

Every row comes from Google Hotels (Google LLC). We don't own this data, and we don't take credit for it. The prices, ratings and hotel details belong to the hotels and Google.

This tool reads only what Google shows to any logged-out visitor. No logins, no private data. Each row keeps a link back to the page it came from (the `googleUrl` field), so you can check any result and credit the source when you use it.

Not affiliated with, endorsed by or sponsored by Google. All names and trademarks belong to their owners.

### Changelog

- **0.1** First release. Hotels and vacation rentals, deal flags, deep search up to 150 per location, wrong-location protection.

# Actor input Schema

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

Cities or areas to search, one per line. Example: San Antonio, TX

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

Optional. Format YYYY-MM-DD, e.g. 2026-11-20. Leave empty to get Google's default dates.

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

Optional. Format YYYY-MM-DD. Must be after check-in.

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

Number of adult guests. Default 2.

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

3-letter currency code. Default USD.

## `maxResultsPerLocation` (type: `integer`):

How many properties to return per location (1–150). Above 18, the scraper runs extra searches (by star class, budget, amenities) and removes duplicates. You pay only for unique results delivered.

## Actor input object example

```json
{
  "locations": [
    "San Antonio, TX"
  ],
  "adults": 2,
  "currency": "USD",
  "maxResultsPerLocation": 20
}
```

# Actor output Schema

## `results` (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 = {
    "locations": [
        "San Antonio, TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leathered_latch/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": ["San Antonio, TX"] }

# Run the Actor and wait for it to finish
run = client.actor("leathered_latch/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": [
    "San Antonio, TX"
  ]
}' |
apify call leathered_latch/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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