# Google Hotel Reviews Scraper: Topics, Replies, Partner Sites (`arcadium/google-hotel-reviews`) Actor

Google hotel reviews for hotel links or names: rating, text, translation, date, trip type, room/service/location scores, owner reply; $0.54 per 1,000 reviews. Partner-site reviews and topic breakdown included. No reviewer names, free error rows, only-new mode.

- **URL**: https://apify.com/arcadium/google-hotel-reviews.md
- **Developed by:** [Arcadium Data](https://apify.com/arcadium) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.27 / 1,000 reviews

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 Hotel Reviews Scraper

Give it Google Hotels links or hotel names and it returns every guest review Google shows for each hotel as clean JSON: rating, text in the original language plus Google's translation, date, trip type and party (vacation or business; solo, couple, family, friends), the rooms/service/location scores, the hotel's reply, and the partner-site reviews Google lists next to its own (Tripadvisor, Trip.com, ...). Each hotel also gets a free summary row with its star histogram and Google's topic breakdown. $0.54 per 1,000 reviews; you only pay for the reviews you get back.

It is for hotel and revenue teams who watch their own reviews and their competitive set, reputation and review-analytics tools that need Google's hotel reviews in bulk, and analysts who study what guests say about a city's hotels. It reads Google's own data endpoint (no browser): up to 200 reviews per request, so the 4,761 reviews of a large hotel take under a minute.

### Use with AI agents

Returns Google hotel reviews for hotel links or names: one row per review (rating, text, translation, date, trip type, aspect scores, owner reply, source site) plus a free hotel summary row (rating, histogram, topics with positive and negative mentions, partner sites). Agents can call it through the Apify MCP server (`https://mcp.apify.com`, open source as `apify/actors-mcp-server`) as `arcadium/google-hotel-reviews`: the input schema is read from the actor, the result is a dataset of JSON rows.

Input example for "the latest 50 Google reviews of the Ritz Paris":

```json
{
  "hotels": ["Ritz Paris"],
  "maxReviewsPerHotel": 50
}
```

And for "what do guests complain about at these two hotels, newest first, Google reviews only":

```json
{
  "hotels": ["https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ", "Hotel Adlon Kempinski Berlin"],
  "sort": "lowest",
  "reviewSource": "google",
  "maxReviewsPerHotel": 100
}
```

What comes back: `review` rows (charged), one free `hotel-summary` row per hotel, one free `coverage` row per hotel (Google's stated total vs delivered, and why reading stopped) and a free `error` row for a hotel that could not be read. Filter on the `rowType` field. An error row carries `rowType: "error"`, a `code` (`invalid_input`, `not_found`, `no_match`, `filter_unsupported`, `blocked` or `unavailable`), a `message` and the `input` it is about. Retry on `blocked` and `unavailable` later; do not retry the other codes with the same input.

Cost of the calls above: 50 reviews at $0.54 per 1,000 is about $0.03; 200 reviews about $0.11. Each run adds a $0.0005 start fee (512 MB). Paid Apify plans pay less per review.

### What you get

**Review row** (`rowType: "review"`), the shared review shape of all our review actors:

| Field | What it holds |
| --- | --- |
| `reviewId` | `GoogleHotels___<Google post id>`, the same in every language. Use it to deduplicate between runs. |
| `productName`, `productUrl`, `entityId` | The hotel, its Google Hotels link and Google's token for it (reuse it in `hotels`). |
| `ratingOverall` | 1 to 5. Partner ratings are scaled to 5 (raw value in `extras.rawRating`, `extras.rawScale`). |
| `ratings` | The scores the guest gave per aspect: `rooms`, `service`, `location` (1 to 5), when given. |
| `text` | The review as written, in its original language. `null` for rating-only reviews. |
| `date` | Approximate date `YYYY-MM-DD`. Google shows "3 months ago"; `extras.datePrecision` says how exact it is. |
| `vendorResponse` | The hotel's reply in its original language (greetings and signatures with names are redacted). |
| `reviewUrl` | Partner reviews: the review on Tripadvisor, Trip.com, ... Google reviews have no public link (`null`). |
| `extras.source`, `extras.sourceType` | `Google` or the partner site; `google` or `partner`. |
| `extras.textTranslated`, `extras.translatedTo` | Google's translation into your `language` when the review is in another language. |
| `extras.tripType`, `extras.travellerType` | `vacation` / `business`; `solo` / `couple` / `family` / `friends`, when the guest said. |
| `extras.visitMonth`, `extras.highlights`, `extras.topicComments` | Month of the stay (`2026-09`); tags the guest picked ("Luxury", "Great view"); short answers per topic (`{ topic: "Rooms", text: "Spotless" }`). |
| `extras.ownerResponseDate`, `extras.ownerResponseTranslated` | Approximate reply date; Google's translation of the reply. |
| `extras.dateText`, `extras.edited`, `extras.photoCount` | Google's own date wording, whether the review was edited, number of guest photos (no photo links). |

Output example:

```json
{
  "rowType": "review",
  "platform": "googlehotels",
  "productName": "Ritz Paris",
  "entityId": "ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ",
  "reviewId": "GoogleHotels___Ci9DQUlRQUNvZENodHljRjlvT25GSlZXbzJkV1Z0VTNwdmVGTXRVblUxY2s5aE1WRRAB",
  "ratingOverall": 4,
  "ratings": { "rooms": 3, "service": 4, "location": 3 },
  "date": "2026-10-16",
  "text": "이곳은 아름다운스파 수영장 레스토랑 노을을 볼수있는곳 까지있어서 너무아름다워요 고급프랑스느낌",
  "vendorResponse": "Cher [name],\n\nThank you for taking the time to share your wonderful feedback. ...\n\nKind regards,\n\n[name]\n Directrice d'hôtel, Ritz Paris",
  "language": null,
  "extras": {
    "source": "Google",
    "sourceType": "google",
    "dateText": "6 days ago",
    "datePrecision": "day",
    "textTranslated": "This place is so beautiful, with a lovely spa, swimming pool, restaurant, and even a spot to watch the sunset. It has a luxurious French feel.",
    "translatedTo": "en",
    "tripType": "vacation",
    "travellerType": "couple",
    "visitMonth": "2026-10",
    "highlights": ["Luxury", "Romantic"],
    "ownerResponseDate": "2026-10-17",
    "photoCount": 0
  }
}
```

**Hotel summary row** (`rowType: "hotel-summary"`, free, one per hotel; switch off with `includeHotelSummary: false`):

| Field | What it holds |
| --- | --- |
| `rating`, `reviewCount`, `ratingHistogram` | Google rating, number of Google reviews, share and count per star. |
| `topics` | Google's topic breakdown: `{ name, shortName, mentions, positive, negative, sentiment, polarity }` for topics such as Location, Service, Breakfast, Couples, Safety. |
| `partnerSites` | Review sites Google lists for the hotel with their own rating and review count: `{ name, providerId, rating, ratingScale, reviewCount, url }`. |
| `hotelClass`, `address`, `countryCode`, `latitude`, `longitude` | Star class and location. |

```json
{
  "rowType": "hotel-summary",
  "productName": "Ritz Paris",
  "rating": 4.6,
  "reviewCount": 4649,
  "ratingHistogram": { "5": { "percent": 86, "count": 3931 }, "1": { "percent": 5, "count": 238 } },
  "topics": [
    { "name": "Bar or lounge", "shortName": "Bar", "mentions": 150, "positive": 110, "negative": 22, "sentiment": 0.502, "polarity": 1 }
  ],
  "partnerSites": [
    { "name": "Tripadvisor", "providerId": 100532569, "rating": 4.5, "ratingScale": 5, "reviewCount": 1073, "url": "https://www.tripadvisor.com/Hotel_Review-g187147-d188728-r1078308347" }
  ]
}
```

### Input

```json
{
  "hotels": ["https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ", "Park Hyatt Tokyo"],
  "maxReviewsPerHotel": 500,
  "sort": "newest",
  "reviewSource": "all",
  "language": "en",
  "dateFrom": "6 months"
}
```

| Field | What it does |
| --- | --- |
| `hotels` | Google Hotels / Travel links, entity tokens (`Ch...`), hotel names with the city, or Google Maps place links (read by name). A name Google cannot match to a hotel gives a free `no_match` row. |
| `maxReviewsPerHotel` | Reviews per hotel, up to 50,000. |
| `sort` | `newest`, `most_helpful`, `highest`, `lowest` (Google's own orders). |
| `reviewSource` | `all`, `google` (Google's own reviews) or `partners` (the Tripadvisor, Trip.com, ... reviews Google shows). |
| `topic` | Only reviews about one of the hotel's topics, e.g. `Location`, `Breakfast`, `Couples`. |
| `dateFrom` | Only reviews from this date on (`YYYY-MM-DD` or `30 days`, `6 months`). Approximate, see Limitations. |
| `language`, `country` | Interface language (translations and date wording) and market. |
| `includeHotelSummary` | The free summary row per hotel. On by default. |
| `onlyNewReviews`, `stateKey`, `markEdited` | Monitoring: only reviews not delivered before under the same key; optionally re-deliver edited ones. |
| `includeErrorRows`, `includeCoverageRows` | The free error and coverage rows. On by default. |

Input names of other Google review actors are accepted as they are (`hotelUrls`, `startUrls`, `startUrl`, `hotelNames`, `maxReviews`, `maxItems`, `reviewsSort`, `sortBy`, `reviewsOrigin`, `reviewsStartDate`, `languageCode`, `countryCode`), so an existing input can be pasted in.

### Use from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("arcadium/google-hotel-reviews").call(run_input={
    "hotels": ["Hotel Arts Barcelona", "W Barcelona"],
    "maxReviewsPerHotel": 300,
    "sort": "newest",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("rowType") == "review" and row["ratingOverall"] <= 2:
        print(row["productName"], row["date"], row["extras"].get("textTranslated") or row["text"])
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('arcadium/google-hotel-reviews').call({
  hotels: ['Bellagio Las Vegas'],
  onlyNewReviews: true,
  stateKey: 'bellagio-daily',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.rowType === 'hotel-summary').map((r) => r.topics.slice(0, 5)));
```

### Pricing

You pay per review delivered, at the price of your Apify plan. Summary, coverage and error rows and repeats in only-new mode are free.

| Apify plan | Per 1,000 reviews |
| --- | --- |
| Free | $0.54 |
| Starter (Bronze) | $0.41 |
| Scale (Silver) | $0.36 |
| Business (Gold) | $0.27 |
| Platinum | $0.18 |
| Diamond | $0.14 |

Plus a one-off $0.001 per GB of memory when a run starts.

Set a maximum cost per run in the Apify run options and the actor stops before it goes over.

### Use cases

- Reputation monitoring: new Google reviews of your hotels every morning (`onlyNewReviews`), with the reply status of each.
- Competitive set: compare topic sentiment (breakfast, service, location) of your hotel with the five hotels next door.
- Review analytics: thousands of reviews per hotel with trip type and aspect scores, translated into one language.
- Reply quality: which reviews got an answer, how fast (`extras.ownerResponseDate`), in which language.

### Limitations

- Google shows review dates only as "3 months ago" or "a year ago", so `date` is approximate: to the day for the last week, then to the week, month or year (`extras.datePrecision`). The date filter and only-new mode work with these dates. Dates are read for English, German, French, Spanish, Italian, Portuguese and Dutch; other `language` values leave `date` empty (the original wording is in `extras.dateText`).
- Partner sites appear with the sample of reviews Google shows (e.g. 109 of 1,073 Tripadvisor reviews of a large hotel), not their full review list. For all Tripadvisor or Booking.com reviews use a source actor.
- Google does not state the review language; `language` is `null`. A translated review has `extras.translatedTo`.
- Topic filters use Google's topic list of each hotel; mention counts in the summary also count reviews the list does not return, so a topic filter can return fewer reviews than the topic's `mentions`.
- The actor reads Google over Apify's shared datacenter proxy. When Google rate-limits that pool, the run retries with short pauses and, if the limit persists, stops and reports the remaining hotels as free `blocked` error rows. Run again later.

### Privacy

Reviewer names, profile links, avatars and photo links are never collected into the output. The reviewer's display name is only used, in memory, to remove it from the review and reply texts; greetings and signatures in replies ("Dear ...", "Kind regards, ...") are redacted to `[name]`, and emails and phone numbers are removed from all texts.

### FAQ

**How do I find a hotel's entity token?**
It is the `entityId` of any row and the `Ch...` part of a Google Hotels link (`/travel/hotels/entity/<token>`). A hotel name with the city works too; the actor checks that Google's match shares a word with your name and reports `no_match` otherwise.

**Why are there more reviews than Google's review count?**
`reviewCount` counts Google reviews only. With `reviewSource: "all"` the partner-site reviews Google shows come on top.

**Why is `text` in Korean when I asked for English?**
`text` is always the original. The English version is in `extras.textTranslated`.

**Something looks wrong in the output. Who do I tell?**
Open an issue on the actor page with the run link. We read them all.

# Actor input Schema

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

Hotels to read: a Google Hotels or Google Travel link such as https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ, the entity token alone (the Ch... part, also the entityId of every row), a hotel name with its city such as "Hotel Adlon Kempinski Berlin", or a Google Maps place link (read by its name). Each hotel returns its reviews plus one free summary row.

## `maxReviewsPerHotel` (type: `integer`):

Reviews to return for each hotel, 1 to 50,000, for example 500. Google pages up to 200 reviews per request; big hotels have 5,000+.

## `sort` (type: `string`):

Order of the reviews as Google sorts them. Newest first is needed for the date filter to stop early and for only-new-reviews mode.

## `reviewSource` (type: `string`):

Google's own reviews, the reviews of partner sites Google shows for the hotel (Tripadvisor, Trip.com, Expedia, ...), or both. Partner sites appear with a sample of their reviews and a link to each.

## `topic` (type: `string`):

Only reviews about one topic Google lists for the hotel, for example "Location", "Breakfast", "Couples" or "Service". A hotel without that topic returns a free error row that lists its topics.

## `dateFrom` (type: `string`):

Only reviews on or after this date: YYYY-MM-DD or a relative span such as "30 days" or "6 months"; empty = no filter. Google shows review dates as "3 months ago", so dates are approximate to the day, week, month or year (see extras.datePrecision).

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

Interface language as a code such as en, de, fr or pt-BR. Reviews in other languages come with Google's translation into this language in extras.textTranslated; the text field keeps the original. Dates are read for en, de, fr, es, it, pt and nl.

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

Market as a two-letter country code, for example us, gb or de. It changes which partner sites Google lists.

## `includeHotelSummary` (type: `boolean`):

Add one free row per hotel (rowType 'hotel-summary'): Google rating, review count, star histogram, the topic breakdown (mentions, positive, negative, sentiment) and the partner sites with their own rating and review count.

## `onlyNewReviews` (type: `boolean`):

Return only reviews not delivered by a previous run with the same state key (newest first is used automatically).

## `stateKey` (type: `string`):

Name of the saved state used by only-new-reviews mode. Use different keys for independent monitors. Example: weekly-monitoring.

## `markEdited` (type: `boolean`):

With 'Only new reviews': also deliver reviews seen before whose text or rating changed in the last 7 days, marked extras.changeType 'edited'. Edited reviews are charged like new ones.

## `includeErrorRows` (type: `boolean`):

Add a free row (rowType 'error') for each hotel that could not be read, with a machine-readable code.

## `includeCoverageRows` (type: `boolean`):

Add one free row with rowType 'coverage' per hotel: the review total Google states, how many were delivered, why paging ended and whether anything is missing. Not charged.

## `maxRetries` (type: `integer`):

How often a failed request is retried before the hotel is skipped.

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

Optional override with your own proxy URLs. By default the actor uses datacenter proxies, which Google serves; Apify proxy groups given here are ignored.

## Actor input object example

```json
{
  "hotels": [
    "https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ",
    "Hotel Adlon Kempinski Berlin"
  ],
  "maxReviewsPerHotel": 20,
  "sort": "newest",
  "reviewSource": "all",
  "language": "en",
  "country": "us",
  "includeHotelSummary": true,
  "onlyNewReviews": false,
  "stateKey": "default",
  "markEdited": true,
  "includeErrorRows": true,
  "includeCoverageRows": true,
  "maxRetries": 4
}
```

# Actor output Schema

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

All rows of this run in the default dataset.

## `view_overview` (type: `string`):

No description

## `view_ratings` (type: `string`):

No description

## `view_translations` (type: `string`):

No description

## `view_owner` (type: `string`):

No description

## `view_summaries` (type: `string`):

No description

## `view_errors` (type: `string`):

No description

## `record_stats` (type: `string`):

Requests, data volume, retries and cost per result for this run.

## `record_product` (type: `string`):

Hotel profiles: Google rating, star histogram, topic breakdown, partner sites, address and coordinates.

# 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 = {
    "hotels": [
        "https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ",
        "Hotel Adlon Kempinski Berlin"
    ],
    "maxReviewsPerHotel": 20,
    "sort": "newest",
    "reviewSource": "all",
    "language": "en",
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("arcadium/google-hotel-reviews").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 = {
    "hotels": [
        "https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ",
        "Hotel Adlon Kempinski Berlin",
    ],
    "maxReviewsPerHotel": 20,
    "sort": "newest",
    "reviewSource": "all",
    "language": "en",
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("arcadium/google-hotel-reviews").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 '{
  "hotels": [
    "https://www.google.com/travel/hotels/entity/ChUImcGKtLfWgL9OGgkvbS8wNTZuODEQAQ",
    "Hotel Adlon Kempinski Berlin"
  ],
  "maxReviewsPerHotel": 20,
  "sort": "newest",
  "reviewSource": "all",
  "language": "en",
  "country": "us"
}' |
apify call arcadium/google-hotel-reviews --silent --output-dataset

```

## MCP server setup

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

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/L92TtuIZXzd19pJRB/builds/ehhfyMcByfWiEdn4k/openapi.json