# Google Hotels Reviews Scraper (`boncross/google-hotels-reviews`) Actor

Scrape Google Hotels reviews from every source Google shows, including the hotel's own site. Just add hotel names, URLs or ids and get rating, Rooms, Service and Location scores, trip type, text, author and date. Sort, filter Google reviews by topic, or get only new ones. $1.60 per 1,000 reviews.

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

## Pricing

from $1.00 / 1,000 review-scrapeds

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

### What is Google Hotels Reviews Scraper?

A hotel's Reviews tab on Google Hotels mixes Google's own reviews with ones from Tripadvisor, Trip.com, Priceline and the hotel's site. Google Hotels Reviews Scraper returns that mixed list as rows you can sort and count, with the Rooms, Service and Location scores Google collects from each guest. Type a hotel's name or paste its Google Hotels link.

Five things it does well:

- More than one source per run. 900 reviews of three hotels came back as 794 from Google, 86 from Trip.com, 17 from Tripadvisor and 3 from elsewhere.
- Scores below the headline rating. 592 of those 900 had per-aspect scores, and 391 had Google's highlight tags.
- Quick on a long list. 32 hotels at 200 reviews each, 6,400 reviews, took 25 seconds.
- A typed name gets you the hotel you meant, or a free row saying it didn't. 13 of 14 real names resolved in our test, among them names in Japanese, Korean, Chinese and Thai, and none of 4 invented names returned a hotel.
- $1.60 per 1,000 reviews on the Free plan, $1.00 on Business. Reviews removed by a filter, duplicates and ones you've had before are free.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 27 of 27 live checks on its inputs and filters passed on 7 October 2026
- 11 hotel names run the same day, one invented: 250 reviews of the 10 real hotels
- Name check: 13 of 14 real names resolved, 4 of 4 invented refused
- A weak name match gets an uncharged row

This is the reviews actor of three. If it's prices you're after, [Google Hotels Search Scraper](https://apify.com/boncross/google-hotels-search) prices the hotels of a whole area and [Google Hotels Prices Scraper](https://apify.com/boncross/google-hotels-prices) compares the sellers of one hotel.

### Two review sources, and when to pick each

The actor reads a hotel's reviews from one of two places. You choose with "Review source".

| | All sources (default, `hotels`) | Google only (`maps`) |
|---|---|---|
| Whose reviews | Google, Tripadvisor, Trip.com, Priceline, the hotel's site | Google's own |
| Date | Google's relative wording, with a date derived from it | Exact timestamp, plus an edited flag |
| Aspect scores, highlight tags, trip type | Where Google has them | Aspect scores and trip type, where the guest gave them |
| Owner's reply and reviewer photos | Not available | Included |
| Likes, Local Guide flag, reviewer's counts | Not available | Included |
| Topic filter and text search | Work | Ignored |

Pick the default for sentiment work across sources. Pick Google only when you need to know exactly when a review was posted or whether the hotel answered it.

### How to scrape Google Hotels reviews

You don't need to write code. It's a form.

1. Open [Google Hotels Reviews Scraper](https://apify.com/boncross/google-hotels-reviews) on Apify. If you don't have an account yet, [signing up](https://console.apify.com/sign-up) is free.
2. List your hotels, one per line. "Four Seasons Hotel New York Downtown" works as typed. A Google Hotels link or an entity id works too.
3. Choose a sort order and how many reviews you want per hotel. Add a topic or a rating filter if you only want part of the picture.
4. Press Start, then download the reviews as a spreadsheet or as JSON.

### What review data do you get?

| | |
|---|---|
| 📝 Full review text | ⭐ Rating and its scale |
| Source: Google, Tripadvisor, Trip.com and others | Review id and URL |
| Rooms, Service and Location scores | Per-topic comments |
| Google's highlight tags | 🧳 Trip type and travel group |
| 👍 Likes and Local Guide flag | Topic and sort used |
| 👤 Reviewer name, profile and avatar | Reviewer's review and photo counts |
| 📅 Relative date, and a date derived from it | Exact timestamp and edited flag |
| 💬 Owner's reply | 📷 Reviewer photos |
| 🏨 Hotel name, rating and review count | Hotel rating histogram |
| Hotel sentiment by topic | 📍 Hotel address and star class |

Exact timestamps, likes, the Local Guide flag, reviewer counts, owner replies and reviewer photos come from the Google-only source.

### ⬇️ Input

The only thing you must give is a hotel. Names, Google Hotels URLs and entity ids can be mixed in one list. For a name Google doesn't recognise alone, add the city after a comma.

Start URLs is for long lists of links: it loads them from a file, a Google Sheet or a remote list, and adds them to whatever you typed under Hotels.

There are two caps. "Max reviews per hotel" (1 to 10,000, default 100) applies to each hotel separately: ten hotels at 50 each returns 500. "Maximum results for the whole run" is the ceiling for all hotels together. The run stops fetching there, and you aren't charged past it.

#### The most helpful 500 reviews of a hotel, all sources

```json
{
  "hotels": ["Four Seasons Hotel New York Downtown"],
  "maxReviewsPerHotel": 500,
  "sort": "helpful",
  "language": "en",
  "country": "us"
}
```

#### Complaints only, about one topic

```json
{
  "hotels": ["ChkIovWq7d7c9psTGg0vZy8xMWJ5eDhya2NsEAE"],
  "maxReviewsPerHotel": 300,
  "sort": "lowest",
  "topic": "Cleanliness",
  "maxRating": 2
}
```

Google applies the topic filter before anything is fetched, and reviews your rating filter removes are free.

#### Google reviews with exact timestamps, owner replies and photos

```json
{
  "hotels": ["https://www.google.com/travel/hotels/entity/ChkIovWq7d7c9psTGg0vZy8xMWJ5eDhya2NsEAE"],
  "source": "maps",
  "sort": "newest",
  "maxReviewsPerHotel": 200
}
```

#### A daily feed of new reviews across a portfolio

```json
{
  "hotels": ["The Plaza, New York", "Hotel Adlon Kempinski Berlin", "Raffles Singapore"],
  "sort": "newest",
  "maxReviewsPerHotel": 100,
  "dedupStoreName": "portfolio-reviews"
}
```

Only reviews you haven't had in an earlier run are returned and charged.

#### All inputs

| Field | Notes |
|---|---|
| `hotels`, `startUrls` | Hotels as names, links or entity ids, and the bulk loader for links. |
| `maxReviewsPerHotel`, `maxItems` | The per-hotel cap and the run-wide cap. 0 on `maxItems` means no run-wide cap. |
| `source` | `hotels` (default, all sources) or `maps` (Google only). |
| `sort` | `helpful` (default), `newest`, `highest` or `lowest`. These are Google's own orderings. `newest` returns Google reviews only, as on the site. |
| `topic` | Only reviews Google tags with a topic, in any letter case: Service, Location, Breakfast, Cleanliness, Pool, Sleep, Family friendly, Bar or lounge and so on. |
| `search` | Free-text search, like the "Search reviews" box on Google Hotels. |
| `sources` | Keep only reviews whose source contains one of these, such as `["Google"]` or `["Tripadvisor", "Trip.com"]`. Empty keeps all. |
| `minRating`, `maxRating` | Rating band on the review's own scale, usually 5. 0 is off. |
| `includeHotelInfo` | On by default. Adds the hotel's name, rating, review count, stars, address, star histogram and sentiment by topic to each review, at no extra charge. |
| `language`, `country` | Defaults `en` and `us`. Google translates reviews into the language where it can. |
| `dedupStoreName` | Names the store that remembers which reviews you've had. |
| `maxConcurrency`, `delayMs` | Request pacing. See the developer notes. |

#### For developers

- `maxReviewsPerHotel` is per hotel and `maxItems` is run-wide. Reviews arrive 100 per request.
- When a rating filter, a source filter or the dedup store keeps nothing, a hotel's scan stops after five requests in a row with no review kept, and at three times the requests its limit needs (at least 20).
- With `sort: "newest"` and a `dedupStoreName`, a hotel's list stops at the first review an earlier run returned. That's what keeps a daily feed short and cheap.
- `minRating` above `maxRating` is refused.
- `sources` is applied after fetching. `topic` is applied by Google before fetching. Both leave you paying only for the reviews you keep.
- `topic` and `search` belong to the default source. With `source: "maps"` they're ignored.
- A name is checked against the hotel Google resolves it to. A weak match writes an uncharged error row that names your input and Google's candidate. `hotel-resolved` is charged per plain name resolved. Links and entity ids skip both the name check and that fee.
- `maxConcurrency` (default `32`, 1 to 32) sets how many requests run at once, and `delayMs` (default `0`) adds a pause before each. We'd leave them alone unless a run reports errors.
- A run that Apify moves to another server, or that restarts, carries on where it stopped. No review is written or charged twice.

### ⬆️ Output

Each review is one record, and each one repeats the hotel summary, which means a single export is enough for analysis. This review is from the first example, run on 7 October 2026 on the default source.

```json
{
  "input": "Four Seasons Hotel New York Downtown",
  "entityId": "ChkIovWq7d7c9psTGg0vZy8xMWJ5eDhya2NsEAE",
  "entityUrl": "https://www.google.com/travel/hotels/entity/ChkIovWq7d7c9psTGg0vZy8xMWJ5eDhya2NsEAE",
  "hotelName": "Four Seasons Hotel New York Downtown",
  "hotelRating": 4.7,
  "hotelRatingScale": 5,
  "hotelReviewCount": 1321,
  "hotelStars": 5,
  "hotelAddress": "27 Barclay St, New York, NY 10007",
  "hotelRatingHistogram": [ { "stars": 5, "percent": 84, "count": 1084 }, { "stars": 4, "percent": 10, "count": 140 }, "…" ],
  "hotelSentiment": [ { "topic": "Wellness", "shortLabel": "Wellness", "mentions": 37, "positive": 27, "negative": 5, "positiveShare": 0.73, "highlighted": true }, "…" ],
  "id": "Ci9DQUlRQUNvZENodHljRjlvT21oQ1dsbGlhakJSVUhscFFrOXlhVTVEY1hkVlprRRAB",
  "url": null,
  "reviewId": "Ci9DQUlRQUNvZENodHljRjlvT21oQ1dsbGlhakJSVUhscFFrOXlhVTVEY1hkVlprRRAB",
  "source": "Google",
  "sourceId": -1,
  "author": "Vincent Malizia",
  "authorUrl": "https://www.google.com/maps/contrib/116499948185041340762?hl=en",
  "authorAvatar": "https://lh3.googleusercontent.com/…",
  "postedText": "2 months ago",
  "postedAt": "2026-08-08",
  "postedAtIsApproximate": true,
  "isEdited": false,
  "rating": 5,
  "ratingScale": 5,
  "text": "There’s nothing better than staying at a Four Seasons Hotel!  The room was clean and large.  Service was exceptional as usual!  Love the location! Close to Little Italy and some great shopping in SoHo.  Highly recommend this hotel. One of my favorites in NYC",
  "language": null,
  "tripTypeIds": [6, 1],
  "tripType": "Vacation",
  "travelGroup": "Family",
  "aspects": [
    { "aspect": "Rooms", "rating": 5, "ratingScale": 5 },
    { "aspect": "Service", "rating": 5, "ratingScale": 5 },
    { "aspect": "Location", "rating": 5, "ratingScale": 5 }
  ],
  "aspectComments": [],
  "highlights": ["Luxury"],
  "reviewUrl": null,
  "reviewSource": "hotels",
  "sort": "helpful",
  "topic": null,
  "scrapedAt": "2026-10-07T20:26:15.147Z"
}
```

Columns worth a note:

| Column | Meaning |
|---|---|
| `postedAt`, `postedAtIsApproximate`, `postedText` | On the Google-only source `postedAt` is an exact timestamp. On the default source Google publishes only relative wording ("a month ago", "4 weeks ago"), and `postedAt` is a date derived from it: right to the week for a recent review, to the month for an old one, with `postedAtIsApproximate` set to `true`. `postedText` always has Google's exact words. |
| `isEdited` | A review Google shows as edited. Its date is the date of the edit. |
| `aspects`, `aspectComments`, `highlights` | Default source, where Google has them. Per-topic comments are the rarest: 11% of reviews in a 275-review sample. |
| `tripType`, `travelGroup`, `tripTypeIds` | Business or Vacation, and who the guest travelled with (Family, Couple, Solo, Friends). Either can appear without the other. |
| `language` | The language code of the review text. Filled on the Google-only source, null on the default one. |
| `sourceId` | Google's number for the partner a review came from, and `-1` on Google's own reviews. Null on the Google-only source, which has no partners. |
| `url`, `reviewUrl` | The review's own link, where one is given. Tripadvisor and Trip.com reviews had one in the run above. Google's own reviews on the default source didn't. |
| `likes`, `authorLocalGuide`, `authorId`, `authorReviewCount`, `authorPhotoCount`, `postedAtMs`, `ownerResponse`, `photos` | Google-only source. |
| `reviewSource`, `sort`, `topic` | The source, order and topic the run asked for. |
| `error` | On a row for a hotel that couldn't be found, was matched too weakly, or couldn't be read. No review is charged for such a row. |

### How much does it cost to scrape Google Hotels reviews?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `hotel-resolved`, per plain name resolved to a hotel | $0.002 | $0.002 | $0.002 | $0.002 |
| `review-scraped`, per review returned | $0.0016 | $0.00144 | $0.00128 | $0.001 |

Enterprise plans pay the Business price.

**$1.60 per 1,000 reviews** on the Free plan, $1.00 on Business, with proxy usage and platform usage included. Filtered, duplicate and previously seen reviews are free.

- A full archive. One hotel by name, 5,000 reviews: $0.002 + $0.002 + 5,000 × $0.0016 = **$8.004** ($5.004 on Business).
- A daily monitor of 50 hotels by entity id with an only-new store. A day that brings 40 new reviews costs $0.002 + 40 × $0.0016 = **$0.066** ($0.042 on Business).

Each month Apify's Free plan gives you $5 of credits, which is about 3,000 reviews with this actor: thirty runs of one named hotel at 100 reviews.

### How many reviews can you get, and how fast?

Up to 10,000 reviews per hotel per run. Large hotels have thousands available.

Three hotels at 300 reviews each, measured on Apify on 26 September 2026:

| | |
|---|---|
| Reviews returned | 900: 794 Google, 86 Trip.com, 17 Tripadvisor, 3 other |
| With per-aspect scores | 592 |
| With highlight tags | 391 |

Whole runs at the default settings:

| Run | Reviews | Run time |
|---|---|---|
| 1 hotel by name, 10 reviews | 10 | 5 s (2 October 2026, two runs) |
| 5 hotels, up to 300 each | 1,500 | 7 to 19 s (2 October 2026, two runs) |
| 32 hotels, 200 each | 6,400 | 25 s (1 October 2026) |
| 150 hotels, 20 each, with hotel details | 3,000 | 69 s (2 October 2026) |

A long list keeps its pace. 150 hotels took about a minute with the hotel summary on, roughly 130 hotels a minute, and it's quicker with the summary off.

### FAQ

#### Does it include Tripadvisor and Trip.com reviews?

On the default source it does, in whatever proportion Google shows them. In the reference run 106 of 900 reviews came from third-party sites. To keep only those, put their names in "Only these sources".

#### How do I get exact review dates, owner replies and photos?

Set "Review source" to Google only. You get Google's own reviews with a timestamp, an edited flag, the owner's reply and the reviewer's photos. Third-party reviews only ever have a relative date on Google.

#### How do I get only the new reviews each day?

Give the only-new store a name, sort by newest and put the run on an Apify Schedule. Anything returned before is skipped and free, and each hotel's scan stops at the first review it already gave you.

#### Which topics can I filter by?

Google's review topics, such as Service, Location, Breakfast, Cleanliness, Pool or Sleep. They differ by hotel. The `hotelSentiment` list on each row shows which topics that hotel has, with counts.

#### I typed a hotel name and got an error row. What happened?

Google either found nothing or offered a hotel that doesn't look like yours. The row names both and costs nothing. Try the name with its city after a comma, or use the hotel's link from Google Hotels. Names in other scripts are fine: Japanese, Korean, Chinese and Thai names matched their hotels in an English run.

#### Are reviews translated?

Google translates reviews into your chosen language where it does so on the site, and keeps its "Translated by Google" prefix on them.

#### Do I need proxies, a Google account or an API key?

None of the three. Nothing is logged in to, and proxy usage is already in the price.

#### Is it legal to scrape hotel reviews?

The actor reads only what Google serves to a logged-out visitor. Reviews are public content written by other people, and reviewer names are personal data in some jurisdictions. Scraping public data is generally legal, but what you do with it is your responsibility under Google's terms and your local law.

### What it can't do

- Google decides which third-party reviews it shows and in what proportion. You get what the Reviews tab would show, not a full Tripadvisor archive.
- The default source gives relative dates only. Third-party reviews never have an exact timestamp anywhere on Google.
- Sorting by newest returns Google reviews only, which is how the site behaves.
- The Google-only source needs a hotel with a Google Maps listing. Vacation rentals have none and return an error row.
- Trip type and travel group are decoded from Google's codes. A code we don't recognise appears as `unknown(n)` with the raw ids beside it.
- `isEdited` is read from Google's own date wording in any interface language. Where the wording isn't recognised it's `null`, not a guess.
- Names are checked as text, not as locations. For a name that several hotels share, add the city or use the link.

### New reviews each morning, in your own tools

Reputation teams usually run the portfolio example on a daily schedule and send the output on. A webhook fires when the run ends, and Apify's integrations can drop the new reviews into Slack, Google Sheets, Zapier or Make. Add a maximum rating and the feed becomes an alert for bad reviews only.

To call it from code, `POST https://api.apify.com/v2/acts/boncross~google-hotels-reviews/run-sync-get-dataset-items` with the input JSON as the body. Short runs answer in that one call. For big archives, start a run and read its dataset, or use `apify-client` for Node.js or Python.

It's also a tool on the Apify MCP server (`mcp.apify.com`), under the name `google-hotels-reviews`. An agent can fetch a hotel's lowest-rated reviews and summarise what guests complain about.

### More from BonCross

- [Google Hotels Prices Scraper](https://apify.com/boncross/google-hotels-prices): Google Hotels price comparisons for any hotel and stay.
- [Google Hotels Search Scraper](https://apify.com/boncross/google-hotels-search): Google Hotels prices for a whole city or map area.
- [Google Maps Reviews Scraper](https://apify.com/boncross/google-maps-reviews): Google Maps reviews for any place using URLs, Place IDs or names.
- [ikyu.com Reviews Scraper (一休)](https://apify.com/boncross/ikyu-reviews): ikyu.com (一休) reviews for hotels and ryokan.
- [Jalan.net Reviews Scraper (じゃらん クチコミ)](https://apify.com/boncross/jalan-reviews): Jalan (じゃらん クチコミ) hotel reviews, all or only new ones.
- [Marriott Reviews Scraper](https://apify.com/boncross/marriott-reviews): Guest reviews for any Marriott hotel.

### Your feedback

Seen a review on Google that the actor didn't return, or a date that looks off? Report it on the Issues tab in Apify Console and include the hotel. We look at every report and write back there.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/google-hotels-reviews/changelog.md

# Actor input Schema

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

One hotel per entry: a Google Hotels URL (https://www.google.com/travel/hotels/entity/Ch…), a bare entity id (Ch…, as returned by the Google Hotels Search Scraper actor), or a hotel name with city ("Four Seasons Hotel New York Downtown", "Raffles Singapore").

## `startUrls` (type: `array`):

Google Hotels page addresses, with the option to load them in bulk from a file, a Google Sheet or a remote list. Use this when you have more links than you want to paste. Combined with anything in the list above.

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

Stop after this many reviews per hotel (100 per request; thousands are available for big hotels). With a rating, source or dedup filter the scan also stops after five requests in a row that keep no review, and at three times the requests the limit needs (at least 20).

## `maxItems` (type: `integer`):

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

## `source` (type: `string`):

hotels returns every source Google Hotels shows (Google, Tripadvisor, Trip.com, Priceline, the hotel's site) with relative dates, topic and text filters and 100 reviews per request. maps returns Google reviews only, with exact timestamps, an edited flag, the owner's reply and the reviewer's photos.

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

Google's own orderings. "newest" returns Google reviews only, as on the site.

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

Only reviews Google tags with this topic, in any letter case, e.g. Service, Location, Breakfast, Cleanliness, Pool, Sleep, Family friendly, Bar or lounge. The available topics for a hotel are in the Price Panel actor's sentiment section.

## `search` (type: `string`):

Free-text search, as in the "Search reviews" box on Google Hotels.

## `sources` (type: `array`):

Case-insensitive substrings, e.g. \["Google"], \["Tripadvisor", "Trip.com"]. Empty = all. Applied after fetching; you are not charged for filtered reviews.

## `minRating` (type: `number`):

Drop reviews below this rating (on the review's own scale, usually 5). 0 = off.

## `maxRating` (type: `number`):

Drop reviews above this rating. 0 = off. Use minRating/maxRating together with sort=lowest to pull complaints only.

## `includeHotelInfo` (type: `boolean`):

Fetch the property page once per hotel and add hotelName, hotelRating, hotelReviewCount, hotelStars, hotelAddress, the star histogram and the sentiment-by-topic breakdown to each review. No extra charge.

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

Google interface language code, e.g. en, ja, de. Google translates reviews into it ("Translated by Google" prefix) where it can.

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

Google market code, e.g. us, jp, gb.

## `dedupStoreName` (type: `string`):

Name of a key-value store. When set, reviews already returned in earlier runs are skipped and not charged, so a scheduled run with sort newest gives you only what is new: with sort newest, a hotel's list stops at the first review an earlier run returned.

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

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds. 0 (the default) runs as fast as the parallel limit allows.

## Actor input object example

```json
{
  "hotels": [
    "Four Seasons Hotel New York Downtown"
  ],
  "startUrls": [],
  "maxReviewsPerHotel": 100,
  "maxItems": 0,
  "source": "hotels",
  "sort": "helpful",
  "topic": "",
  "search": "",
  "sources": [],
  "minRating": 0,
  "maxRating": 0,
  "includeHotelInfo": true,
  "language": "en",
  "country": "us",
  "dedupStoreName": "",
  "maxConcurrency": 32,
  "delayMs": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

Google Hotels reviews: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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": [
        "Four Seasons Hotel New York Downtown"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/google-hotels-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": ["Four Seasons Hotel New York Downtown"] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/google-hotels-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": [
    "Four Seasons Hotel New York Downtown"
  ]
}' |
apify call boncross/google-hotels-reviews --silent --output-dataset

```

## MCP server setup

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