# Google Maps Scraper Pro Hotels - Places (`badruddeen/google-maps-scraper-pro-hotels-places`) Actor

A powerful Google Maps scraper that supports multiple searches. Extracts business data including Name, Address, 📞 Phone, 🌐 Website, ⭐ Ratings, 📝 Reviews, Review Count 📍 and 🏨 Hotel 💰 Prices. Features smart incremental updates to skip fresh data. Great for market research and lead generation.

- **URL**: https://apify.com/badruddeen/google-maps-scraper-pro-hotels-places.md
- **Developed by:** [Badruddeen Naseem](https://apify.com/badruddeen) (community)
- **Categories:** Lead generation, Automation, Travel
- **Stats:** 3 total users, 2 monthly users, 94.1% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Maps Scraper Pro Hotels - Places

### What does Google Maps Scraper Pro Hotels - Places do?

Google Maps Scraper Pro Hotels - Places will enable you to extract comprehensive business data from [Google Maps](https://maps.google.com) more efficiently than relying on the official Google Maps API alone.

Google Maps Scraper Pro Hotels - Places can scrape:

- Business names
- Complete addresses
- Phone numbers
- Website URLs
- Star ratings
- Customer reviews and review counts
- Hotel prices
- Multiple search results in a single run

### Why scrape Google Maps?

Google Maps is one of the most visited location-based services globally, containing millions of business listings across all industries. It's an invaluable resource for market research, competitive analysis, and lead generation.

Here are just some of the ways you could use Google Maps data:

- Build comprehensive leads lists for sales and marketing campaigns
- Monitor competitor information and pricing strategies
- Conduct market research in specific geographic areas
- Track hotel availability and pricing across regions
- Analyze customer reviews and ratings for business insights
- Create location-based datasets for machine learning projects

If you would like more inspiration on how scraping Google Maps could help your business or organization, check out our [industry pages](https://apify.com/industries).

### How to scrape Google Maps

It's easy to scrape Google Maps with Google Maps Scraper Pro Hotels - Places. Just follow these few simple steps and you'll get your data in minutes.

1. Click on **Try for free**.
2. Enter the keywords or search terms you want to scrape (e.g., "hotels in New York", "restaurants near Times Square").
3. Click on **Run**.
4. When the actor has finished, preview or download your data from the **Dataset** tab.

The actor features smart incremental updates that automatically skip fresh data, making it efficient for regular scraping tasks.

### How much will it cost to scrape Google Maps?

Apify gives you $5 in free usage credits every month on the [Apify Free plan](https://apify.com/pricing). Depending on the scope of your searches, you can get a substantial number of results per month completely free.

But if you need to extract more data regularly from Google Maps, we recommend grabbing an Apify subscription. Our [$49/month Starter plan](https://apify.com/pricing) offers great value for consistent scraping needs.

For large-scale operations, the [Scale plan](https://apify.com/pricing) at $499/month provides extensive scraping capacity and advanced features.

### Results

The actor returns data in JSON format with the following structure:

```json
{
  "name": "Hotel Name",
  "address": "123 Main Street, City, State ZIP",
  "phone": "+1 (555) 123-4567",
  "website": "https://example.com",
  "rating": 4.5,
  "reviewCount": 250,
  "reviews": ["Great location!", "Excellent service"],
  "price": "$150-250 per night"
}
````

### Tips for scraping Google Maps

- Use specific search terms and locations to get more relevant results
- Leverage the incremental updates feature to avoid re-scraping existing data
- Break large geographic areas into smaller regions for more targeted data collection
- Use filters and keywords that match your specific business needs
- Monitor your API usage to optimize costs

### Is it legal to scrape Google Maps?

Note that personal data is protected by GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

We also recommend that you read our blog post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

Always review Google Maps' Terms of Service and respect robots.txt guidelines when scraping.

# Actor input Schema

## `searches` (type: `array`):

Enter Google Maps search terms. You can mix hotels and general businesses from different countries. Example: Resorts in Maldives - Hotels in Delhi India - Spa in Bali Indonesia

## `maxResultsPerSearch` (type: `integer`):

Maximum number of places to scrape per search query

## `maxReviewsPerPlace` (type: `integer`):

Number of latest reviews to extract per place (0 = disable reviews)

## `refreshAfterHours` (type: `integer`):

How old (in hours) the data must be before doing full scrape again

## `forceRescrape` (type: `boolean`):

If enabled, ignores refresh time and fully rescrapes everything (including reviews)

## `safeMode` (type: `boolean`):

When enabled, the scraper runs more carefully (slower scrolling, longer delays, fewer results). Recommended for long runs or to avoid blocks.

## `timeout` (type: `integer`):

Timeout for page loading in milliseconds

## Actor input object example

```json
{
  "searches": [
    "Hardware Stores in Turkey",
    "Cosmetics shops in Singapore",
    "Hotels in Tokyo Japan",
    "Hotels in Paris France"
  ],
  "maxResultsPerSearch": 30,
  "maxReviewsPerPlace": 5,
  "refreshAfterHours": 24,
  "forceRescrape": false,
  "safeMode": true,
  "timeout": 60000
}
```

# Actor output Schema

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("badruddeen/google-maps-scraper-pro-hotels-places").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("badruddeen/google-maps-scraper-pro-hotels-places").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call badruddeen/google-maps-scraper-pro-hotels-places --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=badruddeen/google-maps-scraper-pro-hotels-places",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper Pro Hotels - Places",
        "description": "A powerful Google Maps scraper that supports multiple searches. Extracts business data including Name, Address, 📞 Phone, 🌐 Website, ⭐ Ratings, 📝 Reviews, Review Count 📍 and 🏨 Hotel 💰 Prices. Features smart incremental updates to skip fresh data. Great for market research and lead generation.",
        "version": "0.0",
        "x-build-id": "UIvmFBON5hZgL6Rd7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/badruddeen~google-maps-scraper-pro-hotels-places/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-badruddeen-google-maps-scraper-pro-hotels-places",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/badruddeen~google-maps-scraper-pro-hotels-places/runs": {
            "post": {
                "operationId": "runs-sync-badruddeen-google-maps-scraper-pro-hotels-places",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/badruddeen~google-maps-scraper-pro-hotels-places/run-sync": {
            "post": {
                "operationId": "run-sync-badruddeen-google-maps-scraper-pro-hotels-places",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searches"
                ],
                "properties": {
                    "searches": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Enter Google Maps search terms. You can mix hotels and general businesses from different countries. Example: Resorts in Maldives - Hotels in Delhi India - Spa in Bali Indonesia",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Hardware Stores in Turkey",
                            "Cosmetics shops in Singapore",
                            "Hotels in Tokyo Japan",
                            "Hotels in Paris France"
                        ]
                    },
                    "maxResultsPerSearch": {
                        "title": "Max Results Per Search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of places to scrape per search query",
                        "default": 30
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max Reviews Per Place",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of latest reviews to extract per place (0 = disable reviews)",
                        "default": 5
                    },
                    "refreshAfterHours": {
                        "title": "Refresh After Hours",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "How old (in hours) the data must be before doing full scrape again",
                        "default": 24
                    },
                    "forceRescrape": {
                        "title": "Force Full Rescrape",
                        "type": "boolean",
                        "description": "If enabled, ignores refresh time and fully rescrapes everything (including reviews)",
                        "default": false
                    },
                    "safeMode": {
                        "title": "Safe Mode",
                        "type": "boolean",
                        "description": "When enabled, the scraper runs more carefully (slower scrolling, longer delays, fewer results). Recommended for long runs or to avoid blocks.",
                        "default": true
                    },
                    "timeout": {
                        "title": "Page Timeout (ms)",
                        "type": "integer",
                        "description": "Timeout for page loading in milliseconds",
                        "default": 60000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
