# Google Hotels Scraper: Prices, Ratings and Deals

> Google Hotels Scraper is an Apify actor (API) by CheapAPI Labs. Hotel prices for your dates, deals, stars, ratings, reviews and photos for any city. It costs $0.45 per 1,000 hotels on the Apify Free plan and $0.30 on Gold, plus $0.003 per search, billed through your Apify account with no API key. Compared with the most used Google Hotels actor on Apify Store (about 600 users): 1,000 hotels from 10 searches costs about $0.33 to $0.48 plus Apify platform usage here and about $1.01 there (Apify Store listing prices, checked September 2026). The cheapest per result Google Hotels actor charges about $0.10 plus usage, which is lower.

- Page: https://cheapapilabs.com/actors/google-hotels-scraper/
- Run on Apify: https://apify.com/cheapapi/google-hotels-scraper
- Publisher: CheapAPI Labs (Apify username cheapapi)
- Main price: $0.45 per 1,000 hotels on Free, $0.30 on Gold
- Our prices updated: 2026-10-30

## Prices per event (USD)

| Event | Free | Bronze | Silver | Gold |
|---|---:|---:|---:|---:|
| Hotel | $0.00045 | $0.00045 | $0.00038 | $0.0003 |
| Search | $0.003 | $0.003 | $0.003 | $0.003 |
| Search without hotels | $0.0023 | $0.0023 | $0.0023 | $0.0023 |

Platinum and Diamond pay the Gold price. Apify platform usage: billed separately by Apify.

## Call it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/cheapapi~google-hotels-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"destinations":["Paris"],"checkIn":"14 days","checkOut":"2 days","adults":2,"maxHotelsPerSearch":20,"priceCalendarDays":1}'
```

## Example output row

```json
{
  "id": "2c1598dc324d2dd4",
  "destination": "Paris",
  "calendarDay": 1,
  "position": 1,
  "hotelName": "HÔTEL RACHEL",
  "hotelId": "ChcItvPT1vS7lvkNGgsvZy8xdGRtZDV0bhAB",
  "hotelClass": null,
  "rating": 3.2,
  "reviewsCount": 430,
  "pricePerNight": 61,
  "totalPrice": 122,
  "priceBeforeDiscount": null,
  "currency": "USD",
  "isDeal": true,
  "discountPercent": null,
  "discountText": "30% less than usual",
  "hasPrice": true,
  "checkIn": "2026-10-13",
  "checkOut": "2026-10-15",
  "nights": 2,
  "adults": 2,
  "children": 0,
  "guests": 2,
  "amenities": null,
  "isSponsored": false,
  "latitude": 48.882678,
  "longitude": 2.4036894,
  "mapsUrl": "https://www.google.com/maps/search/?api=1&query=48.882678,2.4036894",
  "imageUrl": "https://lh3.googleusercontent.com/gps-cs-s/ANWiy9SJDU1Bx4FyERemybnZ-qO7UOUJG69CO9UwSJaM-oh2k9ZtkfBrSx5cYbnoUBCwh5eOulSqAid2upXJBOxyquX3hapLIvajlY56GGzsqXFkTl2q5K7O6uIcvJq-oPxFcgSz3qoB=s287-w287-h192-n-k-no-v1",
  "images": [
    "https://lh3.googleusercontent.com/gps-cs-s/ANWiy9SJDU1Bx4FyERemybnZ-qO7UOUJG69CO9UwSJaM-oh2k9ZtkfBrSx5cYbnoUBCwh5eOulSqAid2upXJBOxyquX3hapLIvajlY56GGzsqXFkTl2q5K7O6uIcvJq-oPxFcgSz3qoB=s287-w287-h192-n-k-no-v1",
    ""
  ],
  "hotelUrl": "https://www.google.com/travel/hotels/entity/ChcItvPT1vS7lvkNGgsvZy8xdGRtZDV0bhAB?hl=en&gl=us&curr=USD",
  "searchUrl": "https://www.google.com/travel/search?q=Paris&hl=en&gl=US&",
  "searchKeyword": "Paris",
  "country": "US",
  …
}
```

## Fields

One row per hotel (per check in date in price calendar mode). Full field definitions are also in the dataset schema (visible in the Console "Output" tab).

| Field | Type | Example |
|---|---|---|
| `id` | string | `2c1598dc324d2dd4` (stable row ID: same hotel + destination + dates + guests + currency → same ID in every run) |
| `destination` | string | `Paris` (your input) |
| `calendarDay` | number | `1` (price calendar: 1 = first check in date, 2 = next day, …; always 1 in a normal search) |
| `position` | number | `1` (rank on Google Hotels) |
| `hotelName` | string | `HÔTEL RACHEL` |
| `hotelId` | string | `ChcItvPT1vS7lvkNGgsvZy8xdGRtZDV0bhAB` (Google's hotel ID) |
| `hotelClass` | number \| null | `4` (stars; `null` if Google shows no star class, as in the example below) |
| `rating` | number | `3.2` (guest rating out of 5) |
| `reviewsCount` | number | `430` |
| `pricePerNight` | number \| null | `61` (lowest price shown for the stay, per night) |
| `totalPrice` | number \| null | `122` (price per night × nights) |
| `priceBeforeDiscount` | number \| null | `null` (a number such as `87` when Google shows the undiscounted price) |
| `currency` | string | `USD` |
| `isDeal` | boolean | `true` when Google shows a discount or deal |
| `discountPercent` | number \| null | `null` (a number such as `30` when Google states it) |
| `discountText` | string \| null | `30% less than usual` |
| `hasPrice` | boolean | `false` when no price is shown (e.g. sold out) |
| `checkIn` / `checkOut` | string | `2026-10-13` / `2026-10-15` |
| `nights` | number | `2` |
| `adults` / `children` / `guests` | number | `2` / `0` / `2` |
| `amenities` | string[] \| null | `null` (or e.g. `["pool","free_wifi"]`), the amenities you filtered by (every hotel returned has them) |
| `isSponsored` | boolean | `false` (true for hotel ads) |
| `latitude` / `longitude` | number | `48.882678` / `2.4036894` |
| `mapsUrl` | string | Google Maps link |
| `imageUrl` / `images` | string / string[] | main photo / all photos on the result card |
| `hotelUrl` | string | Google Hotels page of the hotel |
| `searchUrl` | string | the Google Hotels search the row comes from |
| `searchKeyword` | string | the search as Google ran it |
| `country` / `language` | string | `US` / `en` |
| `scrapedAt` | string | ISO timestamp |

Optional fields, added **only when Google includes them in the hotel list** (most searches do not have them): `offers` (price per booking site), `pricesByDate`, `ratingDistribution`, `reviewTopics`, `otherSitesRatings`. Do not rely on them. The **Extras** view in the Output tab shows them next to the hotel name and lead price.

Output tab views: **Hotels** (overview with photos), **Prices & deals**, **Price calendar**, **Locations** and **Extras**.

## Compared with alternatives

Typical run: **1,000 hotels from 10 searches** (e.g. 10 cities × 100 hotels) in one run. Prices are the lowest–highest plan price. For this Actor, Apify platform usage is billed separately by Apify (at the default 256 MB a small run typically uses about $0.001 to $0.005) on top of the price shown.

| Alternative | Price for this run | Start fee | Platform usage | Prices per booking site |
|---|---|---|---|---|
| Most used Google Hotels Actor on the Store (~600 users) | ~$1.01 on every plan ($1.00 per 1,000 hotels + $0.005 per run) | $0.005 | not charged separately | ✗ (not advertised) |
| Most active Google Hotels Actor (~580 users, ~510 of them in the last 30 days) | $2.99 to $4.99 | none | not charged separately | ✗ (not advertised) |
| Per page Actor (~480 users) | ~$0.73 to $1.03 (about 50 result pages of ~20 hotels at $0.014 to $0.02 per page, + $0.02 setup per run, + $0.00001 per hotel) | $0.02 setup | not charged separately | ✗ (not advertised) |
| Cheapest per result Actor (~510 users) | ~$0.10 **+ platform usage you pay separately** | $0.00005 | billed separately | ✗ (not advertised) |
| Low price per result Actor (~40 users) | ~$0.09 to $0.10 | $0.00005 | not charged separately | ✗ (not advertised) |
| OTA price comparison Actor (~120 users) | $22.50 to $25.00 **+ platform usage you pay separately** | $0.00005 | billed separately | ✓ |
| Actor with booking site (OTA) rates (~85 users) | $3.20 to $4.00, plus $0.0041 to $0.005 per booking site price lookup | none | not charged separately | ✓ |
| **This Actor** | **$0.33 to $0.48 + platform usage billed separately by Apify** (about $0.001 to $0.005 for a small run) | **none** | billed separately | only when Google shows them in the list (see "Extras" view) |

Prices from public Apify Store listings (event prices and whether the listing bills platform usage to the user), checked September 2026.

**At realistic scale**, daily price monitoring of 15 cities × 100 hotels for 30 days (45,000 hotel rows, 450 searches): **$21.60 on Free/Bronze, $18.45 on Silver, $14.85 on Gold+** in event fees, plus platform usage (estimated at roughly $0.01 per run, about $0.30 a month). The same volume costs about $45 with the most used Actor and $135 to $225 with the most active one.

Honest note: the two cheapest per result Actors charge less per hotel than we do (one of them bills platform usage separately, like this Actor). Most of the larger Actors do not bill platform usage separately; even so, this Actor stays well below them for this run. The per page Actor's cost depends on how many hotels Google puts on each result page. Here you can cap the event fees with **Max cost per run**, and you get the price calendar (up to 60 check in dates per run) and per date lowest/median prices.

**When to choose another Actor:** if the lowest possible price per hotel matters more than the price calendar and per date summaries, the cheapest per result Actors cost less; if you need the full price list from every booking site for each hotel (rate parity, OTA comparison), choose one of the OTA rate Actors above.

## Not included

- **Price from every booking site (rate ladder)**, the hotel list shows one lead price per hotel. When Google includes site prices in the list, they appear in `offers` (Extras view); we do not open each hotel page to fetch them.
- **Review texts**, rows have the rating and review count only. For hotel review texts use [TripAdvisor Reviews Scraper](https://cheapapilabs.com/actors/tripadvisor-reviews-scraper/).
- **Hotel phone, website, opening details and top reviews**, use [Google Maps Scraper Plus](https://cheapapilabs.com/actors/google-maps-scraper-plus/) with a query like "hotels in Paris".
- **Room types, hotel descriptions and full amenity lists**, not in the Google Hotels list view.
- **Google web search rankings for hotel keywords**, use [Google SERP Scraper](https://cheapapilabs.com/actors/google-serp-scraper/).
- **Flights and vacation packages**, not covered.

## Limits

- Up to 140 hotels per destination and search; run several searches (different areas, sort orders or price ranges) for more.
- Prices are the ones Google Hotels shows in its list for the given dates and guests; they can change minutes later and may exclude some taxes and fees depending on the country.
- `totalPrice` is calculated as price per night × nights; the booking site's final total can differ.
- No per booking site rate ladder, review texts, hotel descriptions or full amenity lists.
- Price calendar: each date is a separate search, so a 30-date calendar costs about 30× a single search and Google may return slightly different hotel sets per date.
- Stays are limited to 30 nights and 6 guests per search.
- Economy processing is slower (up to ~45 minutes); it is only used for very large runs unless you choose it.

## FAQ

**Is there a limit on the Apify Free plan?**
Yes: up to $0.25 of this Actor's results per calendar month, enough to try it. Apify pays developers nothing for Free plan usage while our data costs are real, so this keeps the Actor sustainable. Runs that reach the allowance stop cleanly and keep everything collected so far; the allowance resets on the 1st of the month. Any paid Apify plan has no limit.

**Is it legal to scrape Google Hotels?**
The Actor collects publicly visible hotel listings and prices, no personal data, no login. Always check the terms that apply to you and use the data responsibly; consult a lawyer if you are unsure.

**How fresh is the data?**
Every run collects the results live at the time of the run, for the dates and guests you entered.

**Why did I get fewer hotels than "Max hotels per destination"?**
Google returns at most about 140 hotels per search, and filters (price, class, rating, amenities, free cancellation) or small destinations can leave fewer. Sold out hotels may appear without a price (`hasPrice: false`). You only pay for the hotels delivered.

**Is `pricePerNight` per room or per person?**
It is the price Google Hotels shows per night for your party (adults and children), usually the lowest offer across booking sites. `totalPrice` is that nightly price × the number of nights.

**How does the price calendar work and what does it cost?**
Set `priceCalendarDays` to N: the Actor searches the same stay (same number of nights, guests and filters) for N consecutive check in dates starting at your check in date. You get one row per hotel per date and pay for each date like a normal search ($0.003 + the hotel rows; a date with no hotels costs $0.0023). Example: 1 city × 30 dates × 20 hotels = $0.27 to $0.36. Use `hotelId` + `checkIn` to build a price by date table.

**Why do the check in dates in the rows differ from my input?**
Rows show the dates Google actually priced. If Google has no availability for your exact dates it may show its nearest alternative, compare `checkIn`/`checkOut` with your input.

**Why was I charged $0.0023 for a search without hotels?**
The search was run for your destination and dates, but Google had no hotel matching them (sold out, too many filters, a price calendar date with no availability) or answered "no data". Running a search has a real cost whether or not it finds hotels, so it is charged at a reduced fee instead of the $0.003 search fee. Loosen the filters or check the destination spelling to avoid empty searches. Searches rejected because of invalid input are free. If a whole block of up to 50 searches gets no answer from the data source, those searches are charged the same reduced fee (they may have been run, and they are never sent twice), and the run continues with the next block; after two such blocks in a row the run stops and the remaining searches cost nothing.

**Is Apify platform usage included, and how do I limit my spending?**
Platform usage is billed separately by Apify (at the default 256 MB a small run typically uses about $0.001 to $0.005; very large or economy runs use more, each run's usage is shown in Apify Console). To cap the event fees, set **Max cost per run** in the run options: the Actor never starts searches it cannot pay for and stops before exceeding your limit.

**Can I monitor prices over time?**
Yes, save your input as a Task and add an Apify Schedule (e.g. daily). Each run is a fresh, complete snapshot (price monitoring needs every hotel every time, so there is no "only new hotels" mode). Join runs by `id` (same hotel and same stay) or by `hotelId` + `checkIn` (with relative dates like `"14 days"` the stay moves with the run date). For a price change alert, compare `pricePerNight` of the same `id` between the last two runs, e.g. in Google Sheets or with a webhook that runs your script.

**How is the Actor tested?**
Automated unit tests cover input validation, the search options sent for each input, and the mapping of results to rows (prices, deals, dates, stable IDs, optional fields, dataset schema). End to end tests run the whole Actor against a simulated data service and check delivered rows, charged events, the stop at **Max cost per run** (partial results are kept), failed or empty searches (charged only when the search was actually run) and invalid input. Separate tests check that every search pays for its own data cost on every plan in the worst case. Google can change what it shows, so report anything unexpected on the Issues tab.

**Where do I get help?**
Open an issue on the Actor's Issues tab in Apify Console with your run ID, we read and answer every issue.