# Google Hotels — Location Details Scraper (`simpleapi/google-hotels-scraper`) Actor

Get comprehensive hotel data from Google Hotels—listings, prices, ratings, reviews, photos, and amenities. Clean, structured output makes it perfect for travel research, dynamic pricing models, and marketplace data enrichment.

- **URL**: https://apify.com/simpleapi/google-hotels-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, Travel
- **Stats:** 37 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Google Hotels Scraper — Hotels, Nearby Attractions and Location Data

The Google Hotels — Location Details Scraper pulls hotel listings from Google Hotels/Travel search results as structured JSON — hotel name, star and guest ratings, review count, price range, amenities, address, phone, website, and GPS coordinates. For every hotel it also adds a neighborhood summary, a Google location score, and up to 23 nearby points of interest with travel times, plus a derived walkability proxy. Travel and OTA analysts, revenue management consultants, and market researchers use this location-enriched dataset to compare destinations and score competitive sets.

### What is Google Hotels — Location Details Scraper?

Google Hotels — Location Details Scraper is an Apify Actor that scrapes Google Hotels/Travel search results and each hotel's own entity page, returning one structured JSON record per hotel plus, optionally, a mirrored dataset of nearby-place rows. No Google account, API key, or Places API billing is required — the Actor requests Google's public search and hotel pages directly (with an EU consent-cookie header) and runs entirely from the input fields you set on Apify.

Key capabilities:

- Discover hotels by free-text destination — city, neighborhood, or phrase (`destinations`), with multiple destinations searched in one run
- Return core identifying and contact fields: hotel name, address, phone, website, GPS coordinates
- Return guest-trust signals: star rating, aggregate rating, review count, and a computed price range across booking providers
- Return location-context fields not in a plain hotel scrape: neighborhood name/description, a distinct Google location score, up to 23 nearby points of interest with travel time, and a derived walkability proxy score/label
- Filter by stay dates, guest count, currency, result sort order, and which nearby-place categories to keep
- Accepts both this Actor's field names and the equivalent base-schema key names (e.g. `destinations`/`searchQuery`, `hotelLimit`/`maxResults`) so JSON built for either schema runs unchanged
- Export results as JSON, CSV, Excel, or the other formats Apify's dataset view supports

### What data can I extract with Google Hotels — Location Details Scraper?

Each run pushes one dataset row per hotel. The Actor's row-building function (`extract_hotel_data` in `src/main.py`) writes the following keys; the dataset's default table view surfaces most of them plus `url`, which is present on every row but hidden from the default view:

| Field | Example Value | Use Case |
| --- | --- | --- |
| `title` | `"Prague Central Residence"` | Identify the hotel |
| `url` | `"https://www.google.com/travel/hotels/entity/CgoI8..."` | Deep link back to the live Google Hotels listing |
| `thumbnail` | `"https://lh3.googleusercontent.com/gps-cs-s/..."` | Lead image for a listing card |
| `photos` | `["https://lh3.googleusercontent.com/...", "..."]` (up to 15) | Gallery display |
| `address` | `"Politických vězňů, Prague, Czechia"` | Mapping, geocoding, NAP matching |
| `phone` | `"+420 222 210 022"` | Direct outreach to the property |
| `website` | `"https://www.praguecentralresidence.com/"` | Official booking link, bypassing OTA commission |
| `gps` | `{"lat": 50.0819, "lng": 14.4267}` | Radius search, map plotting |
| `rating` | `4.9` | Guest-satisfaction benchmarking |
| `reviews` | `8` | Review-volume weighting |
| `stars` | `4` | Category/class filtering |
| `amenities` | `["Free Wi-Fi", "Air conditioning", "Non-smoking rooms"]` | Feature-based comparison |
| `prices` | `[{"provider": "Booking.com", "price": 120, "link": "https://.../"}]` | Per-OTA price comparison |
| `priceRange` | `"120 - 145"` | Quick budget filter |
| `aboutHotel` | `"Straightforward hotel offering modern rooms near..."` | Listing summaries, AI context |
| `healthAndSafety` | `["Contactless check-in", "Mask required in common areas"]` | Policy display |
| `addressAndContact` | `{"address": "...", "phone": "...", "checkIn": "2:00 PM", "checkOut": "11:00 AM"}` | Confirm stay-policy details |
| `neighborhood` | `{"name": "New Town", "description": "...", "qualitativeRating": "Excellent"}` | Neighborhood-level context |
| `locationScore` | `4.8` | Google's own 0-5 location rating |
| `nearbyPOIs` | `[{"name": "Národní Third of May", "category": "Top Sight", "travelMinutes": 6, "travelMode": "walking", ...}]` | Proximity and itinerary analysis |
| `nearbyPOICount` | `16` | Volume of nearby attractions found |
| `proximityScore` | `92` | Walkability comparison across hotels |
| `proximityLabel` | `"Very Walkable Area"` | Quick-read walkability tag |
| `avgPoiTravelMinutes` | `7.2` | Average distance to nearby attractions |
| `searchQuery` | `"Prague hotels"` | Trace a row back to its destination search |

#### Amenities, rates and stay details

`amenities`, `prices`, and `priceRange` cover the buying-decision data: `amenities` is the raw feature list scraped from the hotel page (Wi-Fi, parking, breakfast, and similar), `prices` is an array of `{provider, price, link}` objects — one entry per booking provider (Booking.com, Expedia, Hotels.com, and others) whose deep link the Actor could parse from the search page — and `priceRange` is the computed min-max span across those providers for the `arrivalDate`/`departureDate` window you set. `aboutHotel` and `healthAndSafety` add the free-text description and listed safety policies. A revenue analyst can pull `prices` for a destination to see how a property's rate compares across OTAs for the same stay dates, without opening each provider individually.

#### Location and date targeting data

`gps`, `neighborhood`, `locationScore`, `nearbyPOIs`, `proximityScore`, and `proximityLabel` are the fields you filter and segment on. `gps` and `neighborhood` place a hotel on the map and in its local context; `locationScore` and the walkability pair let you rank hotels by how well-situated they are rather than by guest rating alone. `arrivalDate`, `departureDate`, `adultsCount`, and `childrenCount` control which stay window and party size the displayed `prices` reflect, so two runs with different dates on the same destination return comparable, date-scoped pricing.

### How does Google Hotels — Location Details Scraper differ from the official Google Places API?

Google does not publish a public API for searching live hotel rates in bulk. The closest official option, the Places API's Place Details endpoint, returns only static place data for a lodging entry — name, address, phone, hours, rating, review count — no room rates, availability, neighborhood insights, or nearby-attraction data — and it requires an API key plus a billing-enabled Google Cloud project (per Google's Places API docs, checked 2026-07-26).

| Feature | Google Places API | Google Hotels — Location Details Scraper |
| --- | --- | --- |
| Live OTA room rates | Not returned | `prices` per provider + computed `priceRange` |
| Nearby points of interest with travel time | Not included | Up to 50 `nearbyPOIs` per hotel via `maxNearbyPOIs` |
| Neighborhood context / location score | Not included | `neighborhood` object + distinct `locationScore` |
| Walkability metric | Not included | Derived `proximityScore` + `proximityLabel` |
| Setup requirement | API key + billed Google Cloud project | Apify account only; run directly with input fields |
| Destination text search | Requires separate Text Search / Place Search calls | Single `destinations` list runs multiple searches in one job |

#### Why can't I get live hotel prices from the Places API?

The Places API is built around static place records, not travel bookings — it has no endpoint for OTA rates, so it cannot answer "what does this room cost for these dates." That gap exists because Google keeps live hotel pricing inside Google Hotels/Travel's own consumer search product rather than the developer Places API. This Actor covers that gap by requesting the same Google Hotels search and entity pages a browser would load for your `destinations`, `arrivalDate`, and `departureDate`, then parsing the per-provider price links directly off that page.

Use the Places API when you need a small number of verified business-listing lookups backed by a formal Google Cloud SLA. Use this Actor when you need hotel pricing, nearby-attraction data, or location scoring across many hotels at once.

### How to use data extracted from Google Hotels?

#### Travel and OTA analysts

Run `destinations` for a target city with your real `arrivalDate`/`departureDate` window, then pull `title`, `stars`, `rating`, `priceRange`, `amenities`, and `nearbyPOIs` into a competitive-set spreadsheet. Because `prices` breaks rates out per provider, an analyst can spot which OTA undercuts the hotel's own `website` for the same dates, and use `locationScore`/`proximityScore` to explain why two similarly-rated hotels command different rates. Re-running the same `destinations` with rolled-forward dates turns this into a recurring rate-shopping workflow.

#### Revenue management and hospitality consulting agencies

Agencies working across multiple hotel clients run the same `destinations` query on a recurring basis to benchmark a client property against its actual competitive set: same neighborhood, similar `stars`, comparable `priceRange`. Because `neighborhood`, `locationScore`, and `proximityScore` are returned for every competitor in one pass, an agency can show a client exactly how their location scores against nearby alternatives, not just how their rate compares.

#### Market research and intelligence

`gps` and `neighborhood` support density mapping of hotel supply across a destination, `priceRange` supports price-distribution analysis by area or star tier, and `proximityScore`/`locationScore` let a researcher quantify how "walkable" a destination's hotel stock is overall — useful when scoping a new market or comparing two candidate cities before an expansion decision.

#### AI agents and automated pipelines

`aboutHotel`, `neighborhood.description`, and `nearbyPOIs` give a trip-planning or concierge agent grounded, current text to reason over instead of a static knowledge cutoff. An agent framework can call this Actor as a tool for a given destination and date range, then use the returned JSON directly in a recommendation or itinerary response.

### 🔼 Input sample

All 13 input parameters are optional — the Actor runs with its prefilled defaults if you change nothing.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `destinations` | No | array | Cities, neighborhoods, or search phrases. Add several to run multiple searches in one job. Same field as the base schema's `searchQuery`. | `["Prague hotels"]` |
| `hotelLimit` | No | integer | How many hotels to scrape per destination (1-5000). Same as base's `maxResults`. | `10` |
| `arrivalDate` | No | string | Check-in date, `YYYY-MM-DD`. Affects displayed pricing. Same as base's `checkInDate`. | `"2026-12-01"` |
| `departureDate` | No | string | Check-out date, `YYYY-MM-DD`, must be after arrival. Same as base's `checkOutDate`. | `"2026-12-05"` |
| `adultsCount` | No | integer | Number of adult guests (1-10). Same as base's `numberOfAdults`. | `2` |
| `childrenCount` | No | integer | Number of child guests (0-10). Same as base's `numberOfChildren`. | `0` |
| `currency` | No | string | 3-letter ISO currency code for displayed prices. Same as base's `currencyCode`. | `"EUR"` |
| `sortOrder` | No | string (enum) | Order the scraped hotels: `relevance` (default, Google's own order), `price_low_high`, `price_high_low`, `rating_high_low`, `stars_high_low`. Rows missing the sort key are placed last, never faked. | `"relevance"` |
| `includeNearbyPOIs` | No | boolean | Pull the nearby points-of-interest list from the same hotel `/location` page already fetched for amenities — no extra request. Default `true`. | `true` |
| `maxNearbyPOIs` | No | integer | Cap on nearby points of interest kept per hotel across all categories combined (0-50). `0` = unlimited. Default `23`. | `23` |
| `poiCategories` | No | array (enum items) | Which nearby-place categories to keep: `topsights`, `restaurants`, `airports`, `transit`. Default all four. | `["topsights", "restaurants", "airports", "transit"]` |
| `includeWalkabilityScore` | No | boolean | Derive a 0-100 proximity/walkability proxy + label from nearby-place travel times. Default `true`. | `true` |
| `proxyConfiguration` | No | object | Leave default for no proxy; the Actor auto-upgrades to datacenter then residential proxy only if Google blocks a request. | `{"useApifyProxy": false}` |

```json
{
  "destinations": ["Prague hotels", "Paris city center"],
  "hotelLimit": 10,
  "arrivalDate": "2026-12-01",
  "departureDate": "2026-12-05",
  "adultsCount": 2,
  "childrenCount": 0,
  "currency": "EUR",
  "sortOrder": "relevance",
  "includeNearbyPOIs": true,
  "maxNearbyPOIs": 23,
  "poiCategories": ["topsights", "restaurants", "airports", "transit"],
  "includeWalkabilityScore": true
}
```

**Common pitfall:** each unit of `hotelLimit` triggers three page fetches per hotel (search result, `/location`, `/details`), so a run of 500+ starts slow if you also leave `includeNearbyPOIs` on. Start with 10-20 while testing, and if you supply both a variant key and its base equivalent (e.g. both `arrivalDate` and `checkInDate`) in the same JSON, the base key wins.

### 🔽 Output sample

Output is a typed, normalized JSON row per hotel, exportable as JSON, CSV, or Excel from the Apify dataset. Only hotel rows are billed, under the `hotel_result` charged event; nearby-place rows mirrored into a per-run child dataset (`nearby-places-<runId>`) are pushed uncharged.

```json
{
  "thumbnail": "https://lh3.googleusercontent.com/gps-cs-s/AC9h4nq...",
  "url": "https://www.google.com/travel/hotels/entity/CgoI8dSGgJnQ3M8BEAE",
  "title": "Prague Central Residence",
  "website": "https://www.praguecentralresidence.com/",
  "address": "Politických vězňů, Prague, Czechia",
  "phone": "+420 222 210 022",
  "photos": [
    "https://lh3.googleusercontent.com/gps-cs-s/AC9h4nq1...",
    "https://lh3.googleusercontent.com/gps-cs-s/AC9h4nq2..."
  ],
  "rating": 4.9,
  "reviews": 8,
  "prices": [
    { "provider": "Booking.com", "price": 120, "link": "https://www.google.com/travel/clk?..." },
    { "provider": "Hotels.com", "price": 145, "link": "https://www.google.com/travel/clk?..." }
  ],
  "priceRange": "120 - 145",
  "stars": 4,
  "amenities": ["Free Wi-Fi", "Air conditioning", "Non-smoking rooms", "24-hour front desk"],
  "gps": { "lat": 50.0819, "lng": 14.4267 },
  "aboutHotel": "Straightforward hotel offering modern rooms near Wenceslas Square, with a 24-hour front desk.",
  "healthAndSafety": ["Contactless check-in", "Mask required in common areas"],
  "addressAndContact": {
    "address": "Politických vězňů, Prague, Czechia",
    "phone": "+420 222 210 022",
    "checkIn": "2:00 PM",
    "checkOut": "11:00 AM"
  },
  "neighborhood": {
    "name": "New Town",
    "description": "Diverse area with chain stores on Wenceslas Square & waterside bars, plus National Theatre opera.",
    "qualitativeRating": "Excellent"
  },
  "locationScore": 4.8,
  "nearbyPOIs": [
    {
      "name": "Národní Third of May",
      "category": "Top Sight",
      "rating": 4.6,
      "reviews": 312,
      "description": "Historic monument commemorating 1945 uprising",
      "travelTime": "6 min walking",
      "travelMinutes": 6,
      "travelMode": "walking"
    },
    {
      "name": "Restaurace U Dlabačů",
      "category": "Restaurant",
      "rating": 4.5,
      "reviews": 546,
      "description": "Restaurant",
      "travelTime": "5 min by taxi",
      "travelMinutes": 5,
      "travelMode": "taxi"
    }
  ],
  "nearbyPOICount": 16,
  "proximityScore": 92,
  "proximityLabel": "Very Walkable Area",
  "avgPoiTravelMinutes": 7.2,
  "searchQuery": "Prague hotels"
}
```

### How do you filter and target specific hotels?

Because `destinations` is free text rather than a fixed category list, phrasing changes result completeness — `"Prague hotels"` matches Google's general hotel search for the city, while a more specific phrase like `"Prague city center hotels"` narrows the same search toward that area first, so a broader term suits maximum coverage and a narrower one suits a specific area. Scope precision comes from `arrivalDate`/`departureDate` (which stay window the returned `prices` reflect), `adultsCount`/`childrenCount` (party size), and `currency` (which currency the price fields display in). Quality thresholds are set through `sortOrder` — sorting by `rating_high_low` or `stars_high_low` moves the best-reviewed or highest-class hotels to the top of the dataset without discarding the rest, and hotels missing that value are always placed last rather than assigned a guessed score — and through `poiCategories`, which limits nearby-attraction matching to the categories that matter for a given analysis, such as `transit` only for a commuter-focused comparison. Volume is controlled by `hotelLimit`, a hard per-destination cap from 1 to 5000 rather than a page size — there is no separate pagination parameter, and listing several `destinations` in one job simply reapplies the same `hotelLimit` to each entry independently. Toggle `includeNearbyPOIs` and `includeWalkabilityScore` off when you only need core hotel and price fields, since skipping that parsing step is the fastest way to scale a run toward the upper end of `hotelLimit`.

```json
{
  "destinations": ["Prague city center hotels"],
  "hotelLimit": 15,
  "sortOrder": "rating_high_low",
  "includeNearbyPOIs": true,
  "maxNearbyPOIs": 10
}
```

```json
{
  "destinations": ["Lisbon hotels", "Porto hotels"],
  "arrivalDate": "2026-09-10",
  "departureDate": "2026-09-14",
  "poiCategories": ["restaurants", "transit"],
  "sortOrder": "price_low_high"
}
```

```json
{
  "destinations": ["Manhattan NYC"],
  "hotelLimit": 500,
  "currency": "USD",
  "sortOrder": "price_low_high",
  "includeNearbyPOIs": false,
  "includeWalkabilityScore": false
}
```

### ▶️ Want to try other travel/property scrapers?

| Scraper | What it extracts |
| --- | --- |
| Airbnb Full Year Price Tracker Scraper | Real nightly Airbnb prices across a date range, one live request per check-in date |
| Airbnb Occupancy & Rate Analytics Scraper | Occupancy rate, monthly breakdown, and daily availability from Airbnb's public calendar |
| Airbnb Scraper: Host Full Listings | Airbnb listings with the full host block plus each host's entire listing portfolio |
| Zillow Search Scraper: Investment Analyzer | Zillow search results with cap rate, rental yield, mortgage payment and cash-flow estimates |
| Zillow Agents Finder & Reviews Scraper | Zillow agents and lenders plus individual customer reviews in a linked child dataset |

### How to extract Google Hotels data programmatically

This Actor runs as a standard Apify REST call — one endpoint, your Apify API token as the header, structured JSON back.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("simpleapi/google-hotels-location-details-scraper").call(
    run_input={
        "destinations": ["Prague hotels"],
        "hotelLimit": 20,
        "sortOrder": "rating_high_low",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["priceRange"], item["locationScore"])
```

#### MCP for AI agents

This Actor is reachable through Apify's hosted MCP server. Register it with:

```
https://mcp.apify.com?tools=simpleapi/google-hotels-location-details-scraper
```

Compatible clients include Claude Desktop, Claude Code, Cursor, and VS Code (GitHub Copilot agent mode). A trip-planning or concierge agent can call the tool for a destination and stay dates, then reason over the returned hotel, pricing, and nearby-attraction JSON directly in its response.

#### Export to spreadsheets or CRM

Use the Apify dataset's built-in CSV/Excel export and map `title` to Hotel Name, `address` to Address, `phone` to Phone, `priceRange` to Price Range, and `locationScore` to Location Score as CRM or spreadsheet columns.

### Is it legal to scrape Google Hotels?

Yes — this Actor collects publicly listed hotel and pricing information that Google itself displays openly to any visitor, without requiring a login. The records returned (hotel name, address, phone, price, amenities, location data) are business and product data rather than private personal information, so the relevant framework is Google's terms of service and general database-rights considerations rather than GDPR/CCPA. Review Google's terms of service before large-scale or commercial use, and consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### What happens to hotels that are removed or no longer listed on Google?

The Actor returns whatever Google Hotels currently serves for your `destinations` at run time — there is no separate "closed" flag. Hotel rows where title extraction fails (for example, a consent-interstitial page instead of a real hotel page) are filtered out before being pushed, so delisted or unreachable hotels simply don't appear rather than showing as blank rows.

#### Can I get nearby attractions along with the main hotel records?

Yes. `nearbyPOIs` returns up to `maxNearbyPOIs` (default 23, max 50) points of interest per hotel across the categories set in `poiCategories`, sourced from the same `/location` page fetch used for amenities. The same rows are also mirrored into an uncharged per-run child dataset (`nearby-places-<runId>`) if you want to analyze attractions independently of hotels.

#### How accurate is the price and contact data?

The Actor returns data exactly as Google Hotels displays it for your `arrivalDate`/`departureDate` at request time. Accuracy depends on how current the underlying OTA/hotel listing is; validate a price or contact detail against the linked provider before using it in a booking or outreach decision.

#### How many hotels can I get per run?

Up to 5,000 per destination, set via `hotelLimit`. Because each hotel requires three page fetches (search result, `/location`, `/details`), runtime scales with this value and with how many `destinations` you list.

#### How do I filter by walkability or nearby-attraction type?

Set `poiCategories` to only the attraction types you want matched (`topsights`, `restaurants`, `airports`, `transit`), and leave `includeWalkabilityScore` on to get a `proximityScore`/`proximityLabel` computed from the resulting travel times. Turn `includeWalkabilityScore` off if you only need the raw `nearbyPOIs` list.

#### Does Google Hotels — Location Details Scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes. It is reachable through Apify's MCP server at `https://mcp.apify.com?tools=simpleapi/google-hotels-location-details-scraper` for MCP-aware clients, and callable as a plain HTTP endpoint by any agent framework via the Apify API.

#### How does this compare to other Google Hotels scrapers?

Its distinguishing capability, verifiable in its own output schema, is that it parses neighborhood context, a distinct location score, and nearby points of interest with travel time from the same hotel page fetch used for amenities — with no extra request. This README does not cite competitor prices or speeds, since no competitor's own current listing was available to verify at the time of writing.

#### Can I use it without a Google API key or developer account?

Yes. You only need an Apify account and your run inputs — no Google account, API key, or Google Cloud billing project is required.

### Conclusion

Google Hotels — Location Details Scraper turns a Google Hotels search into structured hotel records that already carry the location context — neighborhood, location score, nearby attractions, and walkability — that a plain hotel scrape leaves out. It's built for travel and OTA analysts, revenue management and hospitality consulting agencies, and market researchers who need pricing and location quality compared across many hotels at once, with a schema that stays consistent whether you scrape 10 hotels or 5,000. Open the Input tab, add your destinations and stay dates, and click Start to get JSON, CSV, or Excel results in your Apify dataset.

# Actor input Schema

## `destinations` (type: `array`):

Cities, neighborhoods, or search phrases, e.g. 'Prague hotels', 'Paris city center', 'Manhattan NYC'. Add several to run multiple searches in one job. (Same field as the base actor's `searchQuery` — either key works.)

## `hotelLimit` (type: `integer`):

How many hotels to scrape per destination (1-5000). Each hotel gets its own nearby-attraction lookup, so start small (10-20) to test. (Same as base's `maxResults`.)

## `arrivalDate` (type: `string`):

Check-in date (YYYY-MM-DD) — affects displayed pricing. (Same as base's `checkInDate`.)

## `departureDate` (type: `string`):

Check-out date (YYYY-MM-DD), must be after arrival. (Same as base's `checkOutDate`.)

## `adultsCount` (type: `integer`):

Number of adult guests (1-10). (Same as base's `numberOfAdults`.)

## `childrenCount` (type: `integer`):

Number of child guests (0-10). (Same as base's `numberOfChildren`.)

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

3-letter ISO currency code for displayed prices: EUR, USD, GBP, etc. (Same as base's `currencyCode`.)

## `sortOrder` (type: `string`):

📶 Order the scraped hotels in the dataset. 'Relevance' keeps Google's own search-result ranking; the other options re-sort the final list by the extracted price/rating/stars (hotels missing that value are placed last, never faked).

## `includeNearbyPOIs` (type: `boolean`):

Pull the nearby points-of-interest list (top sights, restaurants, airports, transit) from Google's own hotel location page. No extra request — this page is already fetched for amenities. Turn off to skip parsing it.

## `maxNearbyPOIs` (type: `integer`):

Cap on how many nearby points of interest to keep per hotel across all categories combined. Google typically surfaces up to ~23. Set 0 for unlimited.

## `poiCategories` (type: `array`):

Which nearby-place categories to keep. Unchecking a category drops it from both the hotel row and the nearby-places dataset.

## `includeWalkabilityScore` (type: `boolean`):

Derive a 0-100 proximity/walkability proxy + label from the nearby-place travel times (share of places reachable in ≤15 minutes). Not Google's own metric — a computed convenience score.

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

Leave default to start with no proxy. The actor auto-upgrades to datacenter then residential proxy only if Google blocks a request.

## Actor input object example

```json
{
  "destinations": [
    "Prague hotels"
  ],
  "hotelLimit": 10,
  "arrivalDate": "2026-12-01",
  "departureDate": "2026-12-05",
  "adultsCount": 2,
  "currency": "EUR",
  "sortOrder": "relevance",
  "includeNearbyPOIs": true,
  "maxNearbyPOIs": 23,
  "poiCategories": [
    "topsights",
    "restaurants",
    "airports",
    "transit"
  ],
  "includeWalkabilityScore": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

# 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 = {
    "destinations": [
        "Prague hotels"
    ],
    "hotelLimit": 10,
    "arrivalDate": "2026-12-01",
    "departureDate": "2026-12-05",
    "adultsCount": 2,
    "childrenCount": 0,
    "currency": "EUR",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "destinations": ["Prague hotels"],
    "hotelLimit": 10,
    "arrivalDate": "2026-12-01",
    "departureDate": "2026-12-05",
    "adultsCount": 2,
    "childrenCount": 0,
    "currency": "EUR",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/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 '{
  "destinations": [
    "Prague hotels"
  ],
  "hotelLimit": 10,
  "arrivalDate": "2026-12-01",
  "departureDate": "2026-12-05",
  "adultsCount": 2,
  "childrenCount": 0,
  "currency": "EUR",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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