# Google Maps Scraper Premium Ultra Pro (`qaseemiqbal/google-maps-scraper-premium-ultra-pro`) Actor

Scrape Google Maps business listings, contacts, ratings, reviews, images, and website details for lead generation, SEO, and market research.

- **URL**: https://apify.com/qaseemiqbal/google-maps-scraper-premium-ultra-pro.md
- **Developed by:** [Muhammad Qaseem Iqbal](https://apify.com/qaseemiqbal) (community)
- **Categories:** Lead generation, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## 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 Premium Ultra Pro 🚀🗺️

Turn Google Maps searches into clean business lists for sales, research, local SEO, competitor tracking, and market mapping.  

**Google Maps Scraper Premium Ultra Pro** helps you find businesses on Google Maps, collect useful public information about them, and export the results in a structured dataset you can download, filter, analyze, or send into your CRM. 📊✨

You can start with simple search terms like `dentist` + `Manchester, UK`, or provide Google Maps URLs, place URLs, place IDs, CIDs, FIDs, or a custom map area. The Actor can run in a very low-cost mode by default, and you can turn on richer details only when you need them. 💸✅

---

### 📍 What can you use it for?

- 🎯 **Lead generation:** build lists of local businesses with names, websites, phone numbers, emails, and social profiles.
- 🏙️ **Market research:** compare businesses across cities, neighborhoods, regions, or custom map areas.
- ⭐ **Reputation monitoring:** collect ratings, review counts, and optional review data.
- 🧭 **Local SEO research:** see which businesses appear for specific keywords and locations.
- 🕵️ **Competitor tracking:** monitor competitors, categories, locations, visibility, and customer signals.
- 🤝 **Partnership discovery:** find businesses that may be good partners, suppliers, venues, or prospects.
- 📈 **Data enrichment:** add website contact details, contact forms, social links, and structured website data.
- 🧾 **Repeatable workflows:** run the same search again later and compare fresh results.

---

### ✨ What data can it extract?

The exact fields depend on the settings you choose and what Google Maps shows for each business. In the lowest-cost mode, the Actor focuses on quick listing data. In full-detail mode, it opens individual place pages to collect richer information. 🔍

| Data type | Examples |
| --- | --- |
| 🏢 **Business details** | Business name, subtitle, category, categories, Google Maps URL, Place ID, CID, FID |
| 📍 **Location data** | Address, city, neighborhood, postal code, country code, latitude, longitude, plus code |
| ☎️ **Contact data** | Phone number, website, emails from website, extra phones from website, contact forms |
| 🌐 **Website enrichment** | Public emails, public phone numbers, social profiles, JSON-LD / structured data |
| ⭐ **Reputation data** | Rating, review count, review distribution, optional individual reviews |
| 🕒 **Business signals** | Opening hours, closed status, price bracket, popular times when available |
| 📸 **Media** | Image URLs, optional image downloads to the key-value store |
| ❓ **Extra details** | Q&A when available, additional business information, reservation/menu/booking links |
| 🧹 **Quality fields** | Search term, source location, rank, ad flag, scraped time, confidence, warnings |

---

### ⚡ Quick start

The easiest setup is a search term plus a location:

```json
{
  "searchTerms": ["dentist"],
  "locations": ["Manchester, UK"],
  "costPreset": "lowestCost",
  "maxCrawledPlacesPerSearch": 50
}
````

That tells the Actor:

- 🔎 Search Google Maps for `dentist`
- 📍 In `Manchester, UK`
- 💸 Use the cheapest default settings
- 🧾 Collect up to 50 listings for that search

***

### 💸 Built for low-cost scraping

This Actor is designed to be cheap to run by default. The default `costPreset` is `lowestCost`, which keeps browser time, proxy usage, and storage usage low. 🧠💰

In the default mode:

- ✅ `detailMode` is usually `listingOnly`
- ✅ The Actor saves results directly from the Google Maps search list where possible
- ✅ It skips extra place-page visits unless richer details are needed
- ✅ Apify Proxy is off by default
- ✅ Browser images, media, and fonts are blocked by default
- ✅ Reviews, images, Q\&A, popular times, and website crawling are off by default
- ✅ Concurrency and retries stay conservative to avoid waste

Use `balanced` or `maximumCoverage` when you want richer results and are happy to spend more runtime. 🚀

***

### 🧭 Input options

You can use one or more of these discovery methods:

| Input option | Best for |
| --- | --- |
| 🔎 **Search terms** | Business types such as `restaurant`, `dentist`, `plumber`, `hotel`, `law firm` |
| 🌍 **Locations** | Cities, towns, neighborhoods, counties, regions, or countries |
| 🔗 **Google Maps search URLs** | Reusing a Maps search you already opened in your browser |
| 📌 **Google Maps place URLs** | Extracting specific businesses directly |
| 🆔 **Place IDs, CIDs, or FIDs** | Running known business identifiers |
| 🗺️ **Custom GeoJSON area** | Searching inside a custom point, polygon, or multi-polygon area |

#### 🔎 Search terms

Use clear business categories or keywords. A good list has related but not identical terms.

✅ Good example:

```json
["restaurant", "bar", "cafe", "pub", "ice cream shop"]
```

⚠️ Less useful example:

```json
["restaurant", "restaurants", "best restaurant", "restaurant near me"]
```

Very similar terms can increase runtime without adding many new results. Keep your list focused. 🎯

#### 🧩 Category filters

Category filters help narrow the results after extraction. They are useful when a broad search brings back unrelated businesses.

For example, if you search for `lawyer`, you might filter by:

```json
["Family law attorney", "Divorce lawyer", "Immigration attorney"]
```

Tip: Google Maps categories can be very specific, so strict filters may exclude useful results. Start broad, then tighten the filters if needed. 🧠

#### 🗺️ Custom map areas

You can search a custom area with GeoJSON. For a simple circle, use a `Point` with `radiusKm`:

```json
{
  "searchTerms": ["coffee shop"],
  "customGeolocation": {
    "type": "Point",
    "coordinates": [-0.1276, 51.5072],
    "radiusKm": 3
  },
  "costPreset": "balanced",
  "detailMode": "full"
}
```

Coordinates must be in this order: `[longitude, latitude]`. 📌

***

### 🧪 Example setups

#### 💸 Cheapest lead list

Great for fast prospecting when you mainly need names and Maps URLs.

```json
{
  "searchTerms": ["dentist"],
  "locations": ["Manchester, UK"],
  "costPreset": "lowestCost",
  "detailMode": "listingOnly",
  "maxCrawledPlacesPerSearch": 50,
  "maxTotalPlaces": 250
}
```

#### 📞 Business contacts from websites

Use this when you want emails, extra phone numbers, contact forms, and social profiles from business websites.

```json
{
  "searchTerms": ["accountant"],
  "locations": ["Birmingham, UK"],
  "costPreset": "balanced",
  "detailMode": "full",
  "contactEnrichment": {
    "enabled": true,
    "crawlWebsite": true,
    "maxPagesPerWebsite": 3,
    "useProxyForWebsiteEnrichment": false,
    "extractEmails": true,
    "extractPhones": true,
    "extractSocialProfiles": true,
    "extractContactForms": true
  },
  "maxTotalPlaces": 500
}
```

#### ⭐ Reviews for selected places

Use direct place URLs when you already know which businesses you want to inspect.

```json
{
  "placeUrls": ["https://www.google.com/maps/place/Example+Business/..."],
  "detailMode": "full",
  "includeReviews": true,
  "reviewsSort": "newest",
  "maxReviewsPerPlace": 100,
  "includeReviewerPersonalData": false
}
```

#### 📸 Images and popular times

Use this only when richer place data matters more than the lowest cost.

```json
{
  "searchTerms": ["hotel"],
  "locations": ["Liverpool, UK"],
  "costPreset": "balanced",
  "detailMode": "full",
  "includeImages": true,
  "maxImagesPerPlace": 5,
  "includePopularTimes": true,
  "maxTotalPlaces": 100
}
```

***

### ⬆️ Output

When the run finishes, open the **Output** or **Storage** tab in Apify. You can view, filter, and download the results as JSON, CSV, Excel, XML, RSS, or HTML. 📥

#### 📊 Main dataset: places

The default dataset contains one row per business. This is the main file most users will download.

Example row:

```json
{
  "recordType": "place",
  "title": "City Centre Dental & Implant Clinic - Manchester",
  "categoryName": "Dental clinic",
  "address": "Manchester, UK",
  "phone": "+44...",
  "website": "https://example.com",
  "rating": 4.8,
  "reviewsCount": 250,
  "emails": ["hello@example.com"],
  "socialProfiles": ["https://www.linkedin.com/company/example"],
  "searchTerm": "dentist",
  "locationQuery": "Manchester, UK",
  "rank": 1,
  "url": "https://www.google.com/maps/place/...",
  "scrapedAt": "2026-06-15T08:07:18.396Z"
}
```

Some values may be `null` when Google Maps does not show them, when a business does not publish them, or when you use the cheaper listing-only mode. ✅

#### 🧾 Additional datasets

The Actor can also create named datasets:

| Dataset | What it contains |
| --- | --- |
| 📍 `default` | Main business/place records |
| ⭐ `reviews` | One row per review when review extraction is enabled |
| 👤 `leads` | Lead records from enrichment providers or available place data |
| 📸 `images` | One row per image URL when image extraction is enabled |
| 📋 `run-summary` | Final counts, warnings, dataset names, and run information |

#### 🧠 Run summary

The `OUTPUT` record gives you a quick run summary:

- 🔎 Searches planned and started
- 🧾 Candidates found
- 📍 Places saved
- ⭐ Reviews saved
- 📸 Images saved
- 🌐 Website pages crawled
- ⚠️ Failed requests and warnings

***

### 🛠️ Useful settings explained

| Setting | Plain-English meaning |
| --- | --- |
| `costPreset` | Choose how much detail and coverage you want versus how cheaply you want to run |
| `detailMode` | Use `listingOnly` for cheap search-list results or `full` for richer place pages |
| `maxCrawledPlacesPerSearch` | Limit how many listings are collected from each search |
| `maxTotalPlaces` | Limit the total number of unique businesses saved |
| `includeReviews` | Save reviews into a separate reviews dataset |
| `includeImages` | Save image URLs into a separate images dataset |
| `contactEnrichment` | Visit business websites to find public contact details |
| `proxyConfiguration` | Use Apify Proxy when Google blocks requests or when you need proxy geolocation |
| `excludeClosed` | Skip businesses marked as closed when that status is detected |
| `dedupeStrategy` | Decide how aggressively repeated businesses are merged |

***

### 🌟 Tips for better results

- 🎯 Start with a small test run before scraping thousands of places.
- 💸 Use `lowestCost` first, then switch to `balanced` if you need more details.
- 🔎 Use specific search terms like `orthodontist`, `vegan restaurant`, or `wedding photographer`.
- 🌍 Break very large regions into smaller locations for cleaner coverage.
- 🧩 Use category filters carefully so you do not remove good results by accident.
- 🧾 Set `maxTotalPlaces` to control spending on bigger jobs.
- 🌐 Turn on website contact enrichment only when you need emails, forms, or social links.
- 🛡️ Enable Apify Proxy for larger runs or when Google Maps blocks access.

***

### ❓ FAQ

#### How does Google Maps Scraper Premium Ultra Pro work? 🗺️

It opens Google Maps, searches for the keywords and locations you provide, collects visible business listings, removes duplicates, and saves the results into Apify datasets. If you enable full-detail mode or optional enrichments, it can also open place pages and business websites to collect more information. 🤖

#### What is the difference between `listingOnly` and `full` mode? ⚖️

`listingOnly` is the cheapest mode. It collects what is available from the Google Maps search results list and skips individual place pages when possible.

`full` mode opens each business page. It can collect richer details, but it usually costs more because it takes more browser time. 💸

#### Can it scrape multiple cities in one run? 🌍

Yes. Add multiple values to `locations`, such as:

```json
["London, UK", "Manchester, UK", "Birmingham, UK"]
```

The Actor combines each search term with each location. More locations usually means more runtime, so use limits when testing. 🧪

#### Can it extract emails? 📧

Yes, when website contact enrichment is enabled. The Actor can visit business websites and look for public emails, phone numbers, contact forms, social profiles, and structured website data.

Emails are not guaranteed because many businesses do not publish them publicly. 🔎

#### Can it extract Google reviews? ⭐

Yes. Turn on `includeReviews`, use `detailMode: "full"`, and choose how many reviews you want with `maxReviewsPerPlace`.

Reviewer personal data is disabled by default. Only enable it if you have a lawful reason to process that data. 🛡️

#### Can it download images? 📸

Yes. Turn on `includeImages` to save image URLs. If you also enable `downloadImagesToKeyValueStore`, images can be downloaded to the key-value store. Downloading images increases storage and bandwidth usage. 💾

#### Why are some fields empty? 🤔

Some fields may be empty because:

- Google Maps did not show the information
- The business did not publish it
- The page layout changed
- The Actor was running in low-cost listing-only mode
- A website blocked enrichment crawling

This is normal for public web data. The `dataQuality` field can help you understand partial records. ✅

#### Can I connect the results to other tools? 🔗

Yes. Apify datasets can be downloaded or connected to workflows using Apify integrations, webhooks, the Apify API, Make, Zapier, Google Sheets, CRMs, databases, and other automation tools. ⚙️

#### Is it legal to scrape Google Maps? ⚖️

Web scraping laws and platform terms vary by country and use case. This Actor is designed for public business information, and sensitive reviewer personal data is disabled by default.

You are responsible for using the data lawfully, respecting privacy rules, intellectual-property rules, Google’s terms, and any regulations that apply to your use case. 🛡️

***

### 🧑‍💻 For developers

You can run this Actor through the Apify Console, Apify API, schedules, webhooks, or integrations.

Local development commands:

```bash
npm install
npm test
npm run typecheck
npm run build
```

***

### 🏁 Summary

**Google Maps Scraper Premium Ultra Pro** gives you a flexible way to collect public Google Maps business data without manually copying results one by one. Start cheap, test small, scale carefully, and turn on richer features only when they are worth the extra cost. 🚀📍💼

# Actor input Schema

## `searchTerms` (type: `array`):

Business categories or keywords to search on Google Maps.

## `locations` (type: `array`):

Cities, regions, neighborhoods, or countries to combine with each search term.

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

Direct Google Maps search URLs to crawl.

## `placeUrls` (type: `array`):

Direct Google Maps place URLs to extract.

## `placeIds` (type: `array`):

Known Google place identifiers. Place IDs are converted to Maps search URLs.

## `customGeolocation` (type: `object`):

Point, Polygon, or MultiPolygon GeoJSON. Coordinates must be \[longitude, latitude]. For Point, set radiusKm.

## `costPreset` (type: `string`):

Controls default limits and crawl depth. Lowest cost minimizes browser/proxy time and outputs listing rows unless detail-only features are requested.

## `detailMode` (type: `string`):

Listing-only mode skips Google Maps detail pages for search results and is the cheapest mode. Full mode opens each place detail page.

## `categoryFilters` (type: `array`):

Optional category names used after extraction.

## `categoryFilterMode` (type: `string`):

Use broad matching for recall or exact matching for stricter output.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Maximum listing candidates collected from each search job.

## `maxTotalPlaces` (type: `integer`):

Global cap for unique place detail extractions.

## `includeReviews` (type: `boolean`):

Extract one review per row into the reviews dataset.

## `reviewsSort` (type: `string`):

Sort order used when opening the Google Maps reviews panel.

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

Maximum number of reviews to extract for each place when review extraction is enabled.

## `onlyNewSince` (type: `string`):

Optional ISO date cutoff for reviews.

## `includeReviewerPersonalData` (type: `boolean`):

Disabled by default. Enable only when you have a lawful basis for processing reviewer personal data.

## `includeImages` (type: `boolean`):

Extract image URLs for each place into the images dataset.

## `maxImagesPerPlace` (type: `integer`):

Maximum number of image URLs to save per place when image extraction is enabled.

## `blockResourceTypes` (type: `array`):

Resource types to block in Playwright to reduce bandwidth, proxy usage, and rendering cost. Images are automatically allowed when image extraction is enabled.

## `downloadImagesToKeyValueStore` (type: `boolean`):

Download extracted images into the key-value store. This increases bandwidth and storage cost.

## `includePopularTimes` (type: `boolean`):

Try to extract popular-times and live-busyness signals from the place detail page.

## `includeQa` (type: `boolean`):

Try to extract public questions and answers from the place detail page.

## `enableRecursiveTiling` (type: `boolean`):

Split GeoJSON areas into multiple map searches for better coverage. This increases runtime cost.

## `minTileRadiusKm` (type: `number`):

Smallest radius used when generating GeoJSON search tiles.

## `excludeClosed` (type: `boolean`):

Skip businesses detected as temporarily or permanently closed.

## `dedupeStrategy` (type: `string`):

Controls how aggressively duplicate places are detected across overlapping searches.

## `contactEnrichment` (type: `object`):

Crawl business websites for public emails, phones, contact forms, social profiles, and JSON-LD.

## `leadEnrichment` (type: `object`):

Reserved provider interface for paid decision-maker enrichment.

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

Apify proxy configuration. Residential or Google SERP-capable proxy groups are recommended for large runs.

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

Maximum number of browser requests processed at the same time.

## `maxRequestRetries` (type: `integer`):

Maximum retry attempts for failed crawler requests.

## `maxSearchScrolls` (type: `integer`):

Maximum scroll attempts per search page. Lower values reduce browser runtime and proxy bandwidth.

## `stopSearchAfterNoNewResultsScrolls` (type: `integer`):

Stop scrolling when this many consecutive scrolls add no new place URLs.

## `saveDebugArtifacts` (type: `boolean`):

Save extra debug artifacts for troubleshooting. This can increase storage cost.

## `logLevel` (type: `string`):

Minimum log level written during the Actor run.

## Actor input object example

```json
{
  "searchTerms": [
    "dentist"
  ],
  "locations": [
    "Manchester, UK"
  ],
  "startUrls": [],
  "placeUrls": [],
  "placeIds": [],
  "costPreset": "lowestCost",
  "detailMode": "listingOnly",
  "categoryFilters": [],
  "categoryFilterMode": "broad",
  "maxCrawledPlacesPerSearch": 50,
  "maxTotalPlaces": 250,
  "includeReviews": false,
  "reviewsSort": "newest",
  "maxReviewsPerPlace": 10,
  "includeReviewerPersonalData": false,
  "includeImages": false,
  "maxImagesPerPlace": 3,
  "blockResourceTypes": [
    "image",
    "media",
    "font"
  ],
  "downloadImagesToKeyValueStore": false,
  "includePopularTimes": false,
  "includeQa": false,
  "enableRecursiveTiling": false,
  "minTileRadiusKm": 1,
  "excludeClosed": false,
  "dedupeStrategy": "balanced",
  "contactEnrichment": {
    "enabled": false,
    "crawlWebsite": false,
    "maxPagesPerWebsite": 1,
    "useProxyForWebsiteEnrichment": false,
    "extractEmails": true,
    "extractPhones": true,
    "extractSocialProfiles": true,
    "extractContactForms": true,
    "validateEmails": false
  },
  "leadEnrichment": {
    "enabled": false
  },
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 1,
  "maxRequestRetries": 1,
  "maxSearchScrolls": 4,
  "stopSearchAfterNoNewResultsScrolls": 2,
  "saveDebugArtifacts": false,
  "logLevel": "INFO"
}
```

# Actor output Schema

## `places` (type: `string`):

Default dataset with one normalized place record per unique business.

## `summary` (type: `string`):

Final run summary stored in the default key-value store.

## `keyValueStore` (type: `string`):

Debug artifacts and output metadata when enabled.

# 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 = {
    "searchTerms": [
        "dentist"
    ],
    "locations": [
        "Manchester, UK"
    ],
    "startUrls": [],
    "placeUrls": [],
    "placeIds": [],
    "categoryFilters": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("qaseemiqbal/google-maps-scraper-premium-ultra-pro").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 = {
    "searchTerms": ["dentist"],
    "locations": ["Manchester, UK"],
    "startUrls": [],
    "placeUrls": [],
    "placeIds": [],
    "categoryFilters": [],
}

# Run the Actor and wait for it to finish
run = client.actor("qaseemiqbal/google-maps-scraper-premium-ultra-pro").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 '{
  "searchTerms": [
    "dentist"
  ],
  "locations": [
    "Manchester, UK"
  ],
  "startUrls": [],
  "placeUrls": [],
  "placeIds": [],
  "categoryFilters": []
}' |
apify call qaseemiqbal/google-maps-scraper-premium-ultra-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper Premium Ultra Pro",
        "description": "Scrape Google Maps business listings, contacts, ratings, reviews, images, and website details for lead generation, SEO, and market research.",
        "version": "0.1",
        "x-build-id": "RbLCdloNTAzqHhWTM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qaseemiqbal~google-maps-scraper-premium-ultra-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qaseemiqbal-google-maps-scraper-premium-ultra-pro",
                "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/qaseemiqbal~google-maps-scraper-premium-ultra-pro/runs": {
            "post": {
                "operationId": "runs-sync-qaseemiqbal-google-maps-scraper-premium-ultra-pro",
                "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/qaseemiqbal~google-maps-scraper-premium-ultra-pro/run-sync": {
            "post": {
                "operationId": "run-sync-qaseemiqbal-google-maps-scraper-premium-ultra-pro",
                "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",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Business categories or keywords to search on Google Maps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, neighborhoods, or countries to combine with each search term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Maps search URLs",
                        "type": "array",
                        "description": "Direct Google Maps search URLs to crawl.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "placeUrls": {
                        "title": "Google Maps place URLs",
                        "type": "array",
                        "description": "Direct Google Maps place URLs to extract.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place IDs, CIDs, or FIDs",
                        "type": "array",
                        "description": "Known Google place identifiers. Place IDs are converted to Maps search URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "customGeolocation": {
                        "title": "Custom GeoJSON area",
                        "type": "object",
                        "description": "Point, Polygon, or MultiPolygon GeoJSON. Coordinates must be [longitude, latitude]. For Point, set radiusKm."
                    },
                    "costPreset": {
                        "title": "Cost preset",
                        "enum": [
                            "lowestCost",
                            "balanced",
                            "maximumCoverage",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Controls default limits and crawl depth. Lowest cost minimizes browser/proxy time and outputs listing rows unless detail-only features are requested.",
                        "default": "lowestCost"
                    },
                    "detailMode": {
                        "title": "Place detail mode",
                        "enum": [
                            "listingOnly",
                            "full"
                        ],
                        "type": "string",
                        "description": "Listing-only mode skips Google Maps detail pages for search results and is the cheapest mode. Full mode opens each place detail page.",
                        "default": "listingOnly"
                    },
                    "categoryFilters": {
                        "title": "Category filters",
                        "type": "array",
                        "description": "Optional category names used after extraction.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryFilterMode": {
                        "title": "Category filter mode",
                        "enum": [
                            "broad",
                            "exact",
                            "anyContainsAllWords"
                        ],
                        "type": "string",
                        "description": "Use broad matching for recall or exact matching for stricter output.",
                        "default": "broad"
                    },
                    "maxCrawledPlacesPerSearch": {
                        "title": "Max places per search",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum listing candidates collected from each search job.",
                        "default": 50
                    },
                    "maxTotalPlaces": {
                        "title": "Max total places",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Global cap for unique place detail extractions.",
                        "default": 250
                    },
                    "includeReviews": {
                        "title": "Extract reviews",
                        "type": "boolean",
                        "description": "Extract one review per row into the reviews dataset.",
                        "default": false
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "newest",
                            "highestRanking",
                            "lowestRanking",
                            "mostRelevant"
                        ],
                        "type": "string",
                        "description": "Sort order used when opening the Google Maps reviews panel.",
                        "default": "newest"
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract for each place when review extraction is enabled.",
                        "default": 10
                    },
                    "onlyNewSince": {
                        "title": "Only reviews since",
                        "type": "string",
                        "description": "Optional ISO date cutoff for reviews."
                    },
                    "includeReviewerPersonalData": {
                        "title": "Include reviewer personal data",
                        "type": "boolean",
                        "description": "Disabled by default. Enable only when you have a lawful basis for processing reviewer personal data.",
                        "default": false
                    },
                    "includeImages": {
                        "title": "Extract images",
                        "type": "boolean",
                        "description": "Extract image URLs for each place into the images dataset.",
                        "default": false
                    },
                    "maxImagesPerPlace": {
                        "title": "Max images per place",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of image URLs to save per place when image extraction is enabled.",
                        "default": 3
                    },
                    "blockResourceTypes": {
                        "title": "Block browser resources",
                        "type": "array",
                        "description": "Resource types to block in Playwright to reduce bandwidth, proxy usage, and rendering cost. Images are automatically allowed when image extraction is enabled.",
                        "default": [
                            "image",
                            "media",
                            "font"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "downloadImagesToKeyValueStore": {
                        "title": "Download images",
                        "type": "boolean",
                        "description": "Download extracted images into the key-value store. This increases bandwidth and storage cost.",
                        "default": false
                    },
                    "includePopularTimes": {
                        "title": "Extract popular times",
                        "type": "boolean",
                        "description": "Try to extract popular-times and live-busyness signals from the place detail page.",
                        "default": false
                    },
                    "includeQa": {
                        "title": "Extract Q&A",
                        "type": "boolean",
                        "description": "Try to extract public questions and answers from the place detail page.",
                        "default": false
                    },
                    "enableRecursiveTiling": {
                        "title": "Enable GeoJSON tiling",
                        "type": "boolean",
                        "description": "Split GeoJSON areas into multiple map searches for better coverage. This increases runtime cost.",
                        "default": false
                    },
                    "minTileRadiusKm": {
                        "title": "Minimum tile radius",
                        "minimum": 0.1,
                        "maximum": 50,
                        "type": "number",
                        "description": "Smallest radius used when generating GeoJSON search tiles.",
                        "default": 1
                    },
                    "excludeClosed": {
                        "title": "Exclude closed businesses",
                        "type": "boolean",
                        "description": "Skip businesses detected as temporarily or permanently closed.",
                        "default": false
                    },
                    "dedupeStrategy": {
                        "title": "Dedupe strategy",
                        "enum": [
                            "strict",
                            "balanced",
                            "aggressive"
                        ],
                        "type": "string",
                        "description": "Controls how aggressively duplicate places are detected across overlapping searches.",
                        "default": "balanced"
                    },
                    "contactEnrichment": {
                        "title": "Website contact enrichment",
                        "type": "object",
                        "description": "Crawl business websites for public emails, phones, contact forms, social profiles, and JSON-LD.",
                        "default": {
                            "enabled": false,
                            "crawlWebsite": false,
                            "maxPagesPerWebsite": 1,
                            "useProxyForWebsiteEnrichment": false,
                            "extractEmails": true,
                            "extractPhones": true,
                            "extractSocialProfiles": true,
                            "extractContactForms": true,
                            "validateEmails": false
                        }
                    },
                    "leadEnrichment": {
                        "title": "Premium lead enrichment",
                        "type": "object",
                        "description": "Reserved provider interface for paid decision-maker enrichment.",
                        "default": {
                            "enabled": false
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Residential or Google SERP-capable proxy groups are recommended for large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of browser requests processed at the same time.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum retry attempts for failed crawler requests.",
                        "default": 1
                    },
                    "maxSearchScrolls": {
                        "title": "Max search scrolls",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum scroll attempts per search page. Lower values reduce browser runtime and proxy bandwidth.",
                        "default": 4
                    },
                    "stopSearchAfterNoNewResultsScrolls": {
                        "title": "Stop after no-new-result scrolls",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Stop scrolling when this many consecutive scrolls add no new place URLs.",
                        "default": 2
                    },
                    "saveDebugArtifacts": {
                        "title": "Save debug artifacts",
                        "type": "boolean",
                        "description": "Save extra debug artifacts for troubleshooting. This can increase storage cost.",
                        "default": false
                    },
                    "logLevel": {
                        "title": "Log level",
                        "enum": [
                            "DEBUG",
                            "INFO",
                            "WARNING",
                            "ERROR",
                            "OFF"
                        ],
                        "type": "string",
                        "description": "Minimum log level written during the Actor run.",
                        "default": "INFO"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```