# Google Maps Reviews Scraper (`qaseemiqbal/google-maps-reviews-scraper`) Actor

Scrape public Google Maps reviews, ratings, reviewer details, owner replies, images, and place data for reputation monitoring and research.

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

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 Reviews Scraper 🌍⭐

Collect public reviews from Google Maps places and turn them into clean, downloadable data. This Actor helps you gather review text, star ratings, reviewer details, owner replies, review images, place information, and run summaries from one location or many locations at once. 🚀

Use it for reputation monitoring, competitor research, customer feedback analysis, local SEO research, franchise reporting, and market research. 📊💬🏪

### What Is Google Maps Reviews Scraper? 🤔

Google Maps Reviews Scraper is an Apify Actor that opens Google Maps places, reads publicly visible reviews, and saves the results into an Apify dataset. You can then download the data as JSON, CSV, Excel, XML, HTML, or connect it to your favorite tools with Apify integrations. 📥

You do not need to write code to use it. Add your Google Maps places, choose how many reviews you want, press **Start**, and download the results when the run finishes. ✅

### What Can You Extract? 🧲

This Actor can collect the most useful review and place details shown on Google Maps.

| Review data ⭐ | Place and extra data 📍 |
| --- | --- |
| 📝 Review text | 🏷️ Place name |
| 🌟 Star rating | 📍 Address and coordinates |
| 📅 Review date shown by Google | 🧭 Category, score, and review count |
| 🧑 Reviewer name and profile URL | 🆔 Place ID, CID, and FID where available |
| 🧳 Local Guide status | 🏪 Open, temporarily closed, or permanently closed status |
| 💬 Owner response text and date | 🖼️ Main place image URL |
| 👍 Likes / helpful votes when visible | 📊 Optional sentiment, keywords, and complaint categories |
| 🖼️ Review image URLs when enabled | 🧾 Run summary and debug files |

### Common Use Cases 💡

- ⭐ **Reputation management**: Track what customers say about your business locations.
- 🏪 **Franchise and multi-location reporting**: Compare reviews across branches, stores, hotels, restaurants, or clinics.
- 🕵️ **Competitor research**: See what people praise or complain about at competing businesses.
- 📈 **Market research**: Find patterns in customer expectations by city, category, or region.
- 🧠 **Sentiment analysis**: Export reviews for analysis in spreadsheets, BI tools, or AI workflows.
- 🚨 **Review monitoring**: Schedule runs to find new negative or unanswered reviews.
- ✍️ **Marketing research**: Discover phrases customers use to describe products, service, food, rooms, staff, or location.

### How To Scrape Google Maps Reviews 🛠️

1. 🔗 Add one or more Google Maps place URLs, review URLs, search URLs, Place IDs, CIDs, or FIDs.
2. 🔢 Choose how many reviews you want per place.
3. 🎚️ Pick optional filters such as stars, date range, reviews with text, Local Guides, images, or unanswered reviews.
4. ▶️ Click **Start**.
5. 📦 Open the **Dataset** tab to view and download your results.
6. 📤 Export to JSON, CSV, Excel, XML, HTML, or connect the dataset to another app.

### Input Options ⬇️

You can provide targets in several easy ways:

- 🌐 **Google Maps URLs**: Paste one or more place, review, or search URLs.
- 📋 **Bulk targets**: Paste many targets, one per line.
- 🆔 **Google Place IDs**: Use Place IDs if you already have them.
- 🧭 **CID / FID targets**: Use Google Maps internal IDs when available.
- 📚 **Input dataset**: Load targets from another Apify dataset.

#### Popular Settings 🎛️

| Setting | What it does |
| --- | --- |
| `maxReviewsPerPlace` | Limits how many reviews are collected from each place. Great for controlling cost. 💸 |
| `maxTotalReviews` | Sets one global review limit across all places. 🧮 |
| `reviewsOrigin` | Choose Google reviews, all visible sources, or third-party sources where available. 🌐 |
| `sortBy` | Sort by newest, most relevant, highest rating, or lowest rating. 🔃 |
| `dateFrom` / `dateTo` | Collect reviews in a date range. Works with `sortBy = "newest"`. 📅 |
| `minStars` / `maxStars` | Keep only reviews in a star range. ⭐ |
| `onlyReviewsWithText` | Skip rating-only reviews. 📝 |
| `onlyLocalGuides` | Keep only Local Guide reviews when visible. 🧳 |
| `onlyUnansweredReviews` | Find reviews without owner replies. 🚨 |
| `incrementalMode` | Save only reviews that were not collected before. Useful for scheduled monitoring. 🔁 |
| `includeReviewImages` | Include image URLs from reviews. Disabled by default to save bandwidth. 🖼️ |
| `analysisMode` | Add optional sentiment, keywords, urgency, complaint categories, and response suggestions. 🧠 |

### Example Input 🧪

Scrape the newest 50 Google reviews from one place:

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Yellowstone+National+Park/"
    }
  ],
  "maxReviewsPerPlace": 50,
  "reviewsOrigin": "google",
  "sortBy": "newest"
}
````

Monitor new low-star reviews that have not received an owner response:

```json
{
  "placeIds": ["ChIJVVVVVVXlUVMRu-GPNDD5qKw"],
  "maxReviewsPerPlace": 500,
  "minStars": 1,
  "maxStars": 2,
  "onlyUnansweredReviews": true,
  "includeOwnerResponses": true,
  "sortBy": "newest",
  "incrementalMode": true,
  "stateKey": "daily-negative-review-monitor"
}
```

Paste many places at once:

```json
{
  "bulkInput": "Eiffel Tower Paris\nYellowstone National Park\nStarbucks Times Square New York",
  "maxReviewsPerPlace": 25,
  "sortBy": "newest"
}
```

### Output ⬆️

Results are saved in the Apify **Dataset**. Each review is stored as one row, so it is easy to view, filter, export, or connect to other tools. 📊

You can download the results as:

- 🧾 JSON
- 📄 CSV
- 📗 Excel
- 🧱 XML
- 🌐 HTML

#### Example Output Record 📦

```json
{
  "recordType": "review",
  "title": "Yellowstone National Park",
  "address": "United States",
  "categoryName": "National park",
  "totalScore": 4.8,
  "reviewsCount": 44015,
  "reviewId": "example-review-id",
  "stars": 5,
  "text": "Beautiful place and unforgettable views.",
  "publishAt": "2 weeks ago",
  "publishedAtDate": "2026-06-01",
  "reviewerName": "Example Reviewer",
  "reviewerUrl": "https://www.google.com/maps/contrib/example",
  "isLocalGuide": true,
  "hasOwnerResponse": false,
  "reviewImageUrls": [],
  "location": {
    "lat": 44.427963,
    "lng": -110.588455
  },
  "scrapedAt": "2026-06-15T10:00:00.000Z",
  "extractionStatus": "OK"
}
```

The Actor can also save place-level status records when a place has no saved reviews, plus error records if a target cannot be processed. This makes large runs easier to audit. 🔎

### Cost-Friendly Defaults 💸

This Actor is designed to avoid surprise costs. By default, it uses conservative settings that are suitable for testing and everyday review collection:

- 🐢 Low default concurrency, so it does not open too many browser pages at once.
- 🔢 A default review limit per place, so runs do not scroll forever.
- 🖼️ Review images, detailed ratings, translations, and extra context are optional.
- 🚫 Low-cost page loading can block unnecessary images, fonts, media, ads, analytics, and tracking requests.
- 📦 Dataset writes are batched where possible.
- 🧾 Run summaries are saved without excessive storage writes.

For richer data, you can enable more fields or switch page asset loading from **Cheapest** to **Balanced** or **Full**. Start small, check the output, then increase limits when you are happy with the setup. 🌱

### How Many Reviews Can It Scrape? 🔢

The Actor can collect reviews from one place or many places. The exact number of available reviews can vary because Google Maps changes what it shows based on the place, language, country, review source, sort order, filters, and session quality. 🌐

For best results:

- ✅ Start with a small test run.
- ✅ Use direct Google Maps place URLs or Place IDs when possible.
- ✅ Keep `sortBy` set to `newest` when using date filters.
- ✅ Use `maxReviewsPerPlace` to control run length.
- ✅ Use Apify Proxy or reliable proxies for production runs.
- ✅ Schedule incremental runs if you only need new reviews over time.

### Important Notes ⚠️

- 📅 Date filters work only with `sortBy = "newest"`.
- 🏨 For hotels and similar places, `reviewsOrigin = "google"` is usually the best choice for Google-native reviews.
- 🌍 Google Maps is dynamic, so results may differ by region, language, proxy, and Google UI changes.
- 🔐 The Actor collects publicly visible information. It does not log in to private Google accounts.
- 🧪 For large projects, run a small sample first to confirm that the target format and settings work as expected.

### FAQ ❓

#### Can I scrape many Google Maps places at once? 🗺️

Yes. Add multiple URLs, paste targets into the bulk input, provide Place IDs, or load targets from an Apify dataset.

#### Can I download the reviews to Excel or CSV? 📗

Yes. After the run finishes, open the dataset and export it as CSV, Excel, JSON, XML, or HTML.

#### Can I collect only bad reviews? 🚨

Yes. Use `minStars` and `maxStars`. For example, set `minStars` to `1` and `maxStars` to `2` to collect only 1-star and 2-star reviews.

#### Can I monitor only new reviews? 🔁

Yes. Enable `incrementalMode`. The Actor will remember reviews it has already saved for the configured state key and output only new ones in future runs.

#### Can I find reviews without owner responses? 💬

Yes. Enable `onlyUnansweredReviews` and keep owner responses enabled. This is useful for customer support and reputation management workflows.

#### Can I get review images? 🖼️

Yes. Turn on `includeReviewImages`. It is disabled by default because loading and saving image URLs can increase runtime and bandwidth.

#### Can I analyze review sentiment? 🧠

Yes. Use `analysisMode` to add optional local analysis such as sentiment, keywords, urgency, complaint categories, and suggested response drafts.

#### Can I connect the results to other apps? 🔌

Yes. Apify datasets can be used with Apify integrations, webhooks, API clients, Google Sheets workflows, Make, Zapier, BI tools, and many other systems.

### Tips For Better Results 🌟

- 🔗 Prefer direct Google Maps place URLs or Place IDs.
- 🧪 Test 1-3 places before running hundreds of targets.
- 📅 Use newest sorting for monitoring and date filtering.
- 💸 Keep review limits low while testing.
- 🖼️ Enable images only when you really need them.
- 🧾 Check the run summary after each run.
- 🛠️ Enable debug artifacts only when troubleshooting.

### Troubleshooting 🧯

If you get fewer reviews than expected:

- 🔍 Confirm the place has public reviews on Google Maps.
- 🎚️ Check your filters. Star, date, text, image, Local Guide, and owner-response filters can reduce output.
- 📅 If using dates, make sure `sortBy` is `newest`.
- 🌐 Try a different target format, such as a Place ID or direct place URL.
- 🧭 Use reliable proxies for larger production runs.
- 🧪 Run a small test with fewer filters to confirm the place can be opened and read.

If a place returns no saved reviews, the Actor can still write a status record when `outputEmptyPlaces` is enabled. For troubleshooting, enable `saveDebugArtifacts` to save screenshots and page HTML. 🧰

### Ready To Start? 🚀

Add your Google Maps places, choose your review limit, click **Start**, and turn public Google Maps reviews into structured data you can search, filter, download, and analyze. ⭐📍📊

# Actor input Schema

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

Google Maps URLs to scrape. Supports place URLs, review URLs, and search URLs containing a place ID.

## `bulkInput` (type: `string`):

Optional newline-separated Google Maps URLs, Place IDs, CIDs, or FIDs.

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

Optional list of Google Place IDs.

## `cidFids` (type: `array`):

Optional list of Google Maps CID/FID targets.

## `inputDatasetId` (type: `string`):

Optional Apify Dataset ID containing targets.

## `inputDatasetTargetField` (type: `string`):

Field in the input dataset that contains Google Maps URL or Place ID.

## `requestQueueName` (type: `string`):

Optional named request queue for resumed or distributed runs.

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

Maximum number of reviews to collect for each place. Set to 0 for best-effort all available reviews.

## `maxTotalReviews` (type: `integer`):

Global cap across all places. Set to 0 for no global cap.

## `reviewsOrigin` (type: `string`):

Choose Google-native reviews for highest Google review coverage. All reviews may include third-party sources where shown by Google Maps.

## `sortBy` (type: `string`):

Newest is recommended, especially when using date filters or incremental mode.

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

Optional ISO date YYYY-MM-DD. Only supported with Sort reviews by = Newest.

## `dateTo` (type: `string`):

Optional ISO date YYYY-MM-DD. Only supported with Sort reviews by = Newest.

## `minStars` (type: `integer`):

Minimum star rating to include in the output.

## `maxStars` (type: `integer`):

Maximum star rating to include in the output.

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

Language code used for Google Maps UI and translated text where available.

## `countryCode` (type: `string`):

Optional two-letter country code hint for localization.

## `includePlaceDetails` (type: `boolean`):

Include place title, URL, address, category, score, review count, coordinates, and closure flags.

## `includeReviewerDetails` (type: `boolean`):

Include reviewer name, profile URL, reviewer ID, review count, Local Guide status, and photo URL.

## `includeOwnerResponses` (type: `boolean`):

Extract owner response text and response date when visible.

## `includeReviewImages` (type: `boolean`):

Extract URLs of images attached to reviews. Disabled by default to reduce runtime and bandwidth.

## `includeReviewContext` (type: `boolean`):

Extract extra review context such as visit metadata when visible. Disabled by default for lower cost.

## `includeDetailedRatings` (type: `boolean`):

Extract category-level ratings such as service, rooms, location, food, or atmosphere when visible.

## `includeTranslations` (type: `boolean`):

Extract original and translated review text where Google Maps displays translations.

## `onlyReviewsWithText` (type: `boolean`):

Skip rating-only reviews and include only reviews with text or translated text.

## `onlyReviewsWithImages` (type: `boolean`):

Include only reviews that contain one or more image URLs.

## `onlyLocalGuides` (type: `boolean`):

Include only reviews from Local Guides when that status is visible.

## `onlyUnansweredReviews` (type: `boolean`):

Include only reviews without an owner response.

## `minLikesCount` (type: `integer`):

Include only reviews with at least this many likes.

## `incrementalMode` (type: `boolean`):

Only output reviews that were not seen in previous runs for the configured state key.

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

Optional key namespace for persisted seen review IDs. Defaults to actor name plus normalized target list hash.

## `deduplicateWithinRun` (type: `boolean`):

Skip duplicate review IDs encountered during the same Actor run.

## `deduplicateAcrossRuns` (type: `boolean`):

Skip review IDs stored in previous run state. Automatically enabled when incremental mode is enabled.

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

Maximum number of Google Maps places processed in parallel. Lower values are cheaper and use less memory.

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

Maximum retry attempts for a failed place request.

## `navigationTimeoutSecs` (type: `integer`):

Maximum seconds to wait for initial Google Maps page navigation.

## `requestHandlerTimeoutSecs` (type: `integer`):

Maximum seconds to spend processing one place.

## `sameDomainDelaySecs` (type: `integer`):

Delay between Google Maps page requests in seconds.

## `maxIdleScrolls` (type: `integer`):

Stop scrolling after this many scroll attempts add no new review cards.

## `resourceLoadMode` (type: `string`):

Cheapest blocks images, fonts, media, stylesheets, ads, analytics, and tracking requests. Balanced keeps stylesheets for UI reliability. Full only blocks obvious nonessential media.

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

Select proxies to use. Apify Proxy is recommended for reliable scraping.

## `outputEmptyPlaces` (type: `boolean`):

Write a place status record when no reviews are saved for a place.

## `outputFormatMode` (type: `string`):

Choose flat records for CSV-friendly output or nested records for structured data consumers.

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

Save screenshot and HTML debug files after final extraction failures.

## `debugLog` (type: `boolean`):

Enable verbose logging for troubleshooting.

## `analysisMode` (type: `string`):

Optional local review enrichment with sentiment, keywords, complaint categories, and response suggestions.

## `analysisLanguage` (type: `string`):

Language for premium analysis output.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Yellowstone+National+Park/"
    }
  ],
  "inputDatasetTargetField": "url",
  "maxReviewsPerPlace": 50,
  "maxTotalReviews": 0,
  "reviewsOrigin": "google",
  "sortBy": "newest",
  "minStars": 1,
  "maxStars": 5,
  "language": "en",
  "includePlaceDetails": true,
  "includeReviewerDetails": true,
  "includeOwnerResponses": true,
  "includeReviewImages": false,
  "includeReviewContext": false,
  "includeDetailedRatings": false,
  "includeTranslations": false,
  "onlyReviewsWithText": false,
  "onlyReviewsWithImages": false,
  "onlyLocalGuides": false,
  "onlyUnansweredReviews": false,
  "minLikesCount": 0,
  "incrementalMode": false,
  "deduplicateWithinRun": true,
  "deduplicateAcrossRuns": false,
  "maxConcurrency": 1,
  "maxRequestRetries": 1,
  "navigationTimeoutSecs": 45,
  "requestHandlerTimeoutSecs": 90,
  "sameDomainDelaySecs": 0,
  "maxIdleScrolls": 2,
  "resourceLoadMode": "cheapest",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "outputEmptyPlaces": true,
  "outputFormatMode": "flat",
  "saveDebugArtifacts": false,
  "debugLog": false,
  "analysisMode": "none",
  "analysisLanguage": "en"
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

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

No description

## `debugFiles` (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 = {
    "startUrls": [
        {
            "url": "https://www.google.com/maps/place/Yellowstone+National+Park/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("qaseemiqbal/google-maps-reviews-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 = {
    "startUrls": [{ "url": "https://www.google.com/maps/place/Yellowstone+National+Park/" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("qaseemiqbal/google-maps-reviews-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/place/Yellowstone+National+Park/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call qaseemiqbal/google-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Reviews Scraper",
        "description": "Scrape public Google Maps reviews, ratings, reviewer details, owner replies, images, and place data for reputation monitoring and research.",
        "version": "1.0",
        "x-build-id": "7cGhkBI5mMgJwvio2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qaseemiqbal~google-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qaseemiqbal-google-maps-reviews-scraper",
                "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-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-qaseemiqbal-google-maps-reviews-scraper",
                "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-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-qaseemiqbal-google-maps-reviews-scraper",
                "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": {
                    "startUrls": {
                        "title": "Google Maps place or review URLs",
                        "type": "array",
                        "description": "Google Maps URLs to scrape. Supports place URLs, review URLs, and search URLs containing a place ID.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "bulkInput": {
                        "title": "Bulk targets",
                        "type": "string",
                        "description": "Optional newline-separated Google Maps URLs, Place IDs, CIDs, or FIDs."
                    },
                    "placeIds": {
                        "title": "Google Place IDs",
                        "type": "array",
                        "description": "Optional list of Google Place IDs.",
                        "items": {
                            "type": "string",
                            "minLength": 8
                        }
                    },
                    "cidFids": {
                        "title": "CID/FID targets",
                        "type": "array",
                        "description": "Optional list of Google Maps CID/FID targets.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "cid": {
                                    "title": "CID",
                                    "type": "string",
                                    "description": "Google Maps customer ID / CID."
                                },
                                "fid": {
                                    "title": "FID",
                                    "type": "string",
                                    "description": "Google Maps feature ID / FID."
                                },
                                "title": {
                                    "title": "Place title",
                                    "type": "string",
                                    "description": "Optional place title for logs and output."
                                }
                            },
                            "additionalProperties": false
                        }
                    },
                    "inputDatasetId": {
                        "title": "Input dataset ID",
                        "type": "string",
                        "description": "Optional Apify Dataset ID containing targets."
                    },
                    "inputDatasetTargetField": {
                        "title": "Input dataset target field",
                        "type": "string",
                        "description": "Field in the input dataset that contains Google Maps URL or Place ID.",
                        "default": "url"
                    },
                    "requestQueueName": {
                        "title": "Named request queue",
                        "type": "string",
                        "description": "Optional named request queue for resumed or distributed runs."
                    },
                    "maxReviewsPerPlace": {
                        "title": "Maximum reviews per place",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each place. Set to 0 for best-effort all available reviews.",
                        "default": 50
                    },
                    "maxTotalReviews": {
                        "title": "Maximum total reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Global cap across all places. Set to 0 for no global cap.",
                        "default": 0
                    },
                    "reviewsOrigin": {
                        "title": "Reviews origin",
                        "enum": [
                            "google",
                            "all",
                            "third_party_best_effort"
                        ],
                        "type": "string",
                        "description": "Choose Google-native reviews for highest Google review coverage. All reviews may include third-party sources where shown by Google Maps.",
                        "default": "google"
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "most_relevant",
                            "highest_rating",
                            "lowest_rating"
                        ],
                        "type": "string",
                        "description": "Newest is recommended, especially when using date filters or incremental mode.",
                        "default": "newest"
                    },
                    "dateFrom": {
                        "title": "Published from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional ISO date YYYY-MM-DD. Only supported with Sort reviews by = Newest."
                    },
                    "dateTo": {
                        "title": "Published until",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional ISO date YYYY-MM-DD. Only supported with Sort reviews by = Newest."
                    },
                    "minStars": {
                        "title": "Minimum stars",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum star rating to include in the output.",
                        "default": 1
                    },
                    "maxStars": {
                        "title": "Maximum stars",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum star rating to include in the output.",
                        "default": 5
                    },
                    "language": {
                        "title": "Google Maps language",
                        "pattern": "^[a-z]{2,3}(-[A-Z]{2})?$",
                        "type": "string",
                        "description": "Language code used for Google Maps UI and translated text where available.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "pattern": "^[A-Z]{2}$",
                        "type": "string",
                        "description": "Optional two-letter country code hint for localization."
                    },
                    "includePlaceDetails": {
                        "title": "Include place details",
                        "type": "boolean",
                        "description": "Include place title, URL, address, category, score, review count, coordinates, and closure flags.",
                        "default": true
                    },
                    "includeReviewerDetails": {
                        "title": "Include reviewer details",
                        "type": "boolean",
                        "description": "Include reviewer name, profile URL, reviewer ID, review count, Local Guide status, and photo URL.",
                        "default": true
                    },
                    "includeOwnerResponses": {
                        "title": "Include owner responses",
                        "type": "boolean",
                        "description": "Extract owner response text and response date when visible.",
                        "default": true
                    },
                    "includeReviewImages": {
                        "title": "Include review images",
                        "type": "boolean",
                        "description": "Extract URLs of images attached to reviews. Disabled by default to reduce runtime and bandwidth.",
                        "default": false
                    },
                    "includeReviewContext": {
                        "title": "Include review context",
                        "type": "boolean",
                        "description": "Extract extra review context such as visit metadata when visible. Disabled by default for lower cost.",
                        "default": false
                    },
                    "includeDetailedRatings": {
                        "title": "Include detailed ratings",
                        "type": "boolean",
                        "description": "Extract category-level ratings such as service, rooms, location, food, or atmosphere when visible.",
                        "default": false
                    },
                    "includeTranslations": {
                        "title": "Include translations",
                        "type": "boolean",
                        "description": "Extract original and translated review text where Google Maps displays translations.",
                        "default": false
                    },
                    "onlyReviewsWithText": {
                        "title": "Only reviews with text",
                        "type": "boolean",
                        "description": "Skip rating-only reviews and include only reviews with text or translated text.",
                        "default": false
                    },
                    "onlyReviewsWithImages": {
                        "title": "Only reviews with images",
                        "type": "boolean",
                        "description": "Include only reviews that contain one or more image URLs.",
                        "default": false
                    },
                    "onlyLocalGuides": {
                        "title": "Only Local Guides",
                        "type": "boolean",
                        "description": "Include only reviews from Local Guides when that status is visible.",
                        "default": false
                    },
                    "onlyUnansweredReviews": {
                        "title": "Only unanswered reviews",
                        "type": "boolean",
                        "description": "Include only reviews without an owner response.",
                        "default": false
                    },
                    "minLikesCount": {
                        "title": "Minimum likes count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Include only reviews with at least this many likes.",
                        "default": 0
                    },
                    "incrementalMode": {
                        "title": "Incremental mode",
                        "type": "boolean",
                        "description": "Only output reviews that were not seen in previous runs for the configured state key.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Optional key namespace for persisted seen review IDs. Defaults to actor name plus normalized target list hash."
                    },
                    "deduplicateWithinRun": {
                        "title": "Deduplicate within run",
                        "type": "boolean",
                        "description": "Skip duplicate review IDs encountered during the same Actor run.",
                        "default": true
                    },
                    "deduplicateAcrossRuns": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip review IDs stored in previous run state. Automatically enabled when incremental mode is enabled.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of Google Maps places processed in parallel. Lower values are cheaper and use less memory.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum retry attempts for a failed place request.",
                        "default": 1
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation timeout",
                        "minimum": 10,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum seconds to wait for initial Google Maps page navigation.",
                        "default": 45
                    },
                    "requestHandlerTimeoutSecs": {
                        "title": "Place processing timeout",
                        "minimum": 30,
                        "maximum": 1800,
                        "type": "integer",
                        "description": "Maximum seconds to spend processing one place.",
                        "default": 90
                    },
                    "sameDomainDelaySecs": {
                        "title": "Same-domain delay",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Delay between Google Maps page requests in seconds.",
                        "default": 0
                    },
                    "maxIdleScrolls": {
                        "title": "Maximum idle scrolls",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Stop scrolling after this many scroll attempts add no new review cards.",
                        "default": 2
                    },
                    "resourceLoadMode": {
                        "title": "Page asset loading",
                        "enum": [
                            "cheapest",
                            "balanced",
                            "full"
                        ],
                        "type": "string",
                        "description": "Cheapest blocks images, fonts, media, stylesheets, ads, analytics, and tracking requests. Balanced keeps stylesheets for UI reliability. Full only blocks obvious nonessential media.",
                        "default": "cheapest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to use. Apify Proxy is recommended for reliable scraping.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "outputEmptyPlaces": {
                        "title": "Output empty places",
                        "type": "boolean",
                        "description": "Write a place status record when no reviews are saved for a place.",
                        "default": true
                    },
                    "outputFormatMode": {
                        "title": "Output format mode",
                        "enum": [
                            "flat",
                            "nested"
                        ],
                        "type": "string",
                        "description": "Choose flat records for CSV-friendly output or nested records for structured data consumers.",
                        "default": "flat"
                    },
                    "saveDebugArtifacts": {
                        "title": "Save debug artifacts",
                        "type": "boolean",
                        "description": "Save screenshot and HTML debug files after final extraction failures.",
                        "default": false
                    },
                    "debugLog": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable verbose logging for troubleshooting.",
                        "default": false
                    },
                    "analysisMode": {
                        "title": "Analysis mode",
                        "enum": [
                            "none",
                            "basic",
                            "advanced"
                        ],
                        "type": "string",
                        "description": "Optional local review enrichment with sentiment, keywords, complaint categories, and response suggestions.",
                        "default": "none"
                    },
                    "analysisLanguage": {
                        "title": "Analysis language",
                        "pattern": "^[a-z]{2,3}(-[A-Z]{2})?$",
                        "type": "string",
                        "description": "Language for premium analysis output.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```