You can access the Google Maps Reviews Scraper - Exact Dates, Replies & Photos programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "QmIFGyfCn9KRMChdM"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/parseforge~google-maps-reviews-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~google-maps-reviews-scraper/runs": {
      "post": {
        "operationId": "runs-sync-parseforge-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/parseforge~google-maps-reviews-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-parseforge-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 URLs",
            "type": "array",
            "description": "Place links copied from Google Maps (the long /maps/place/... URL, a maps.app.goo.gl share link, a ?cid= link, or a /maps/search/... link).",
            "items": {
              "type": "object",
              "required": [
                "url"
              ],
              "properties": {
                "url": {
                  "type": "string",
                  "title": "URL of a web page",
                  "format": "uri"
                }
              }
            }
          },
          "placeIds": {
            "title": "Place IDs",
            "type": "array",
            "description": "Google place IDs (ChIJ...), feature IDs (0x...:0x...) or CID numbers, one per line.",
            "items": {
              "type": "string"
            }
          },
          "searchTerms": {
            "title": "Search terms",
            "type": "array",
            "description": "Find places by what they are, like \"pizza\" or \"dentist\". Each term returns up to \"Max places per search\" places, and their reviews.",
            "items": {
              "type": "string"
            }
          },
          "location": {
            "title": "Location",
            "type": "string",
            "description": "Where to search, like \"Austin, TX\" or \"Madrid, Spain\". Added to every search term."
          },
          "maxItems": {
            "title": "Max Items",
            "minimum": 1,
            "maximum": 1000000,
            "type": "integer",
            "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
          },
          "maxReviewsPerPlace": {
            "title": "Max reviews per place",
            "minimum": 1,
            "maximum": 1000000,
            "type": "integer",
            "description": "Stop each place after this many reviews. Leave empty for every review Google shows."
          },
          "maxPlacesPerSearch": {
            "title": "Max places per search",
            "minimum": 1,
            "maximum": 200,
            "type": "integer",
            "description": "How many places each search term (or /maps/search/ URL) contributes. Google returns about 20 places per page.",
            "default": 5
          },
          "sort": {
            "title": "Sort reviews by",
            "enum": [
              "newest",
              "mostRelevant",
              "highestRating",
              "lowestRating"
            ],
            "type": "string",
            "description": "Google's review order. \"Only reviews newer than\" always uses newest first.",
            "default": "newest"
          },
          "reviewsNewerThan": {
            "title": "Only reviews newer than",
            "type": "string",
            "description": "A date (2026-01-31) or a window (\"30 days\", \"6 months\", \"1 year\"). The run stops reading a place once it reaches older reviews."
          },
          "starRatings": {
            "title": "Star ratings",
            "type": "array",
            "description": "Keep only reviews with these ratings. Leave empty for all. With highest or lowest sort the run stops a place as soon as the ratings run out of range.",
            "items": {
              "type": "string",
              "enum": [
                "1",
                "2",
                "3",
                "4",
                "5"
              ],
              "enumTitles": [
                "1 star",
                "2 stars",
                "3 stars",
                "4 stars",
                "5 stars"
              ]
            }
          },
          "reviewTextContains": {
            "title": "Review text contains",
            "type": "array",
            "description": "Keep only reviews whose text (or its translation) contains at least one of these words. Google has no review search for signed-out visitors, so the Actor reads the reviews and filters them itself.",
            "items": {
              "type": "string"
            }
          },
          "onlyWithText": {
            "title": "Only reviews with text",
            "type": "boolean",
            "description": "Skip star-only reviews.",
            "default": false
          },
          "onlyWithOwnerResponse": {
            "title": "Only reviews the owner answered",
            "type": "boolean",
            "description": "Keep only reviews that carry a response from the business.",
            "default": false
          },
          "language": {
            "title": "Language",
            "enum": [
              "en",
              "es",
              "es-419",
              "fr",
              "de",
              "it",
              "pt-BR",
              "pt-PT",
              "nl",
              "pl",
              "ru",
              "uk",
              "tr",
              "ar",
              "he",
              "hi",
              "id",
              "ja",
              "ko",
              "zh-CN",
              "zh-TW",
              "th",
              "vi",
              "sv",
              "da",
              "no",
              "fi",
              "cs",
              "el",
              "hu",
              "ro"
            ],
            "type": "string",
            "description": "Reviews written in another language come with Google's translation into this one in textTranslated. The original text is always kept.",
            "default": "en"
          },
          "concurrency": {
            "title": "Places in parallel",
            "minimum": 1,
            "maximum": 10,
            "type": "integer",
            "description": "How many places are read at the same time.",
            "default": 3
          },
          "proxyConfiguration": {
            "title": "Proxy",
            "type": "object",
            "description": "Off by default: Google answers these requests directly. If Google starts refusing, the run switches to Apify Proxy on its own.",
            "default": {
              "useApifyProxy": false
            }
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Google Maps Reviews Scraper - Dates, Replies & Photos OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Google Maps Reviews Scraper - Exact Dates, Replies & Photos from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Google Maps Reviews Scraper - Exact Dates, Replies & Photos API in Python

Google Maps Reviews Scraper - Exact Dates, Replies & Photos API in JavaScript

Google Maps Reviews Scraper - Exact Dates, Replies & Photos API through CLI

Google Maps Reviews Scraper - Exact Dates, Replies & Photos API

Google Maps Scraper

compass/crawler-google-places

Extract data from thousands of Google Maps locations and businesses, including reviews, reviewer details, images, contact info, including full name, email, and job title, opening hours, prices & more. Export data, run via API, schedule and monitor runs, or integrate with other tools.

Compass

658K

4.7

(1,818)

Google Maps Reviews Scraper - Text, Ratings & Exact Dates

delicious_zebu/google-maps-store-review-scraper

Scrape Google Maps store reviews fast — API-based, no browser. Extract review text, exact dates, star ratings, reviewer profiles, Local Guide status, photos, per-service ratings, owner responses, and store review keywords. Export to JSON, CSV, or Excel.

Zebu Data

731

5.0

(38)

Advanced Google Maps Reviews Scraper

slash-scrape/advanced-google-maps-reviews-scraper

This actor lets you collect Google Maps reviews by place ID or Maps URL. Get review text, star rating, date, and author fields when present; optional photo URLs and reviewer profile details. Headless + “See more” supported on the current build.

slash scrape

495

3.0

(1)

Google Maps Scraper: Places, Hours, Popular Times & Leads

parseforge/google-maps-scraper

Scrape Google Maps places by search, area, URL or place ID: phone, website, rating, reviews, hours, popular times and emails. Export CSV, Excel, JSON or XML.

ParseForge

Google Maps Search Scraper

web_wanderer/google-business-search-scraper

Easily scrape Google Maps search results at scale. This Google Maps Scraper extracts business names, addresses, phone numbers, websites, ratings, reviews count, business hours, service options, place attributes, and coordinates for any business type. Export data in JSON, CSV, Excel, or via API.

Billy

Google Maps Reviews Scraper

curious_coder/google-maps-reviews-scraper

Scrape reviews from google maps business. Get review text, author details, date, likes, photos, etc

Curious Coder

Google Maps AI Reviews Analyzer

louisdeconinck/google-maps-ai-reviews-analyzer

Turn raw Google Maps reviews into actionable business strategies by automatically extracting customer personas, sentiment analysis, and SEO insights with AI.

Louis Deconinck

Google Maps Reviews Scraper

seemuapps/google-maps-reviews-scraper

Scrape all Google Maps reviews for any place — reviewer, rating, text, date, photos, owner replies — from a place URL or search. One row per review.

Seemu Scraping

Google Maps Reviewer Geo Profile API

johnvc/google-maps-reviewer-geo-profile-api

Infer a Google Maps reviewer's home region from their review history. Clusters review coordinates into a standardized home-region guess (city/state/country + ISO codes), a confidence score, and a local-vs-travel footprint. One row per reviewer, for reviewer vetting and fraud research. MCP-ready.

John

5.0

(2)

Google Maps Photos Scraper — Batch places

scrape.badger/google-maps-photos-scraper

Scrape Google Maps photos at scale. Batch input: pass one or many place_ids / data_ids in a single run — no need to configure a separate task per place. Each photo is pushed as its own dataset record stamped with the source place_id. Cheapest photos-only actor on Apify.