Skip to content
    ↑↓ to choose · Enter to open

    · 17 min read

    Google Maps Reviews Scraper: Up to 1,000 Free Results a Month (2026)

    By CrawlerBros Engineering Team

    Extract public Google Maps reviews across 53 fields in the main review output group, or switch to author mode to capture reviewer history across 16 profile fields. Runs cost $5.00 per 1,000 results on the free plan, collecting star ratings, raw review text, relative dates, and owner responses without needing login cookies or browser profiles. This Actor is built for analysts, reputation managers, and local market researchers tracking public business feedback. It is not for anyone needing buyer contact details like personal email addresses or phone numbers, which Google Maps reviews do not include.

    Try it: open Google Maps Reviews Scraper on Apify, sign in on the free plan and run the prefilled example.

    Can you try Google Maps Reviews Scraper before paying?

    Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Google Maps Reviews Scraper a month, before run-start charges and platform usage.

    The example request further down caps maxReviews at 10, so a first run returns at most 10 results and costs at most $0.05 in result charges. That is enough to see the real shape of the data before deciding anything.

    Google Maps Reviews Scraper was last updated on 2026-09-27. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 686,269 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

    What does it cost to run Google Maps Reviews Scraper?

    Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.02 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

    Apify plan Per result Per 1,000 results
    FREE $0.005 $5.00
    BRONZE $0.00433 $4.33
    SILVER $0.00367 $3.67
    GOLD $0.003 $3.00
    PLATINUM $0.003 $3.00
    DIAMOND $0.003 $3.00

    The main driver of result charges is maxReviews, which sets the target number of items written to your dataset. Keeping maxReviews small during initial pipeline setup limits your usage while verifying field structure. You can run the default input example capped at 10 reviews to inspect output formatting for at most $0.05 in result charges on the free plan.

    How do you run Google Maps Reviews Scraper from the API?

    None of its 9 controls is strictly required, so the defaults below produce a valid run on their own. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

    Call the synchronous endpoint to start a run and receive dataset items in one request:

    curl -X POST "https://api.apify.com/v2/acts/crawlerbros~google-maps-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"place","placeUrl":"https://www.google.com/maps/place/Masjid+al-Haram/@21.423663,39.8227848,17z/data=!4m14!1m7!3m6!1s0x15c204b74d3fb493:0x55d1f94f8e094785!2sMasjid+al-Haram!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm!3m5!1s0x15c204b74d3fb493:0x55d1f94f8e094785!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm?entry=ttu&g_ep=EgoyMDI2MDIyNS4wIKXMDSoASAFQAw%3D%3D","contributorUrls":["https://www.google.com/maps/contrib/102461194647441801965/reviews"],"contributorUrl":"https://www.google.com/maps/contrib/102461194647441801965/reviews","maxReviews":10,"sortBy":"newest","language":"en","proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"],"apifyProxyCountry":"US"}}'

    The same run from Python, using the official client:

    from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "place",
  "placeUrl": "https://www.google.com/maps/place/Masjid+al-Haram/@21.423663,39.8227848,17z/data=!4m14!1m7!3m6!1s0x15c204b74d3fb493:0x55d1f94f8e094785!2sMasjid+al-Haram!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm!3m5!1s0x15c204b74d3fb493:0x55d1f94f8e094785!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm?entry=ttu&g_ep=EgoyMDI2MDIyNS4wIKXMDSoASAFQAw%3D%3D",
  "contributorUrls": [
    "https://www.google.com/maps/contrib/102461194647441801965/reviews"
  ],
  "contributorUrl": "https://www.google.com/maps/contrib/102461194647441801965/reviews",
  "maxReviews": 10,
  "sortBy": "newest",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": True,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}

run = client.actor("crawlerbros~google-maps-reviews-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

    And from Node.js:

    import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "place",
  "placeUrl": "https://www.google.com/maps/place/Masjid+al-Haram/@21.423663,39.8227848,17z/data=!4m14!1m7!3m6!1s0x15c204b74d3fb493:0x55d1f94f8e094785!2sMasjid+al-Haram!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm!3m5!1s0x15c204b74d3fb493:0x55d1f94f8e094785!8m2!3d21.423658!4d39.8253597!16zL20vMDI0aGJm?entry=ttu&g_ep=EgoyMDI2MDIyNS4wIKXMDSoASAFQAw%3D%3D",
  "contributorUrls": [
    "https://www.google.com/maps/contrib/102461194647441801965/reviews"
  ],
  "contributorUrl": "https://www.google.com/maps/contrib/102461194647441801965/reviews",
  "maxReviews": 10,
  "sortBy": "newest",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}

const run = await client.actor('crawlerbros~google-maps-reviews-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

    That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

    Which Google Maps Reviews Scraper inputs matter, and which can you skip?

    The primary control is mode, which toggles between location reviews (place) and reviewer profile histories (author). For place runs, supply either placeUrl or placeId along with your target maxReviews limit. Controls like language and sortBy should be left on defaults for a first test unless you need specific localizations or sorting.

    • mode (string): What to scrape. "place" collects reviews for one business or location; "author" collects everything one Google reviewer has reviewed. Default: "place".
    • placeUrl (string): Full URL of the Google Maps business/place page to scrape reviews from (mode=place).
    • placeId (string): Canonical Google Place ID beginning with ChIJ (mode=place). Use this instead of placeUrl when available.
    • contributorUrls (array): One or more Google Maps contributor profile URLs or bare numeric contributor IDs (mode=author). Profile, reviews, photos and place links are all accepted and normalized to the reviewer's reviews page.
    • contributorUrl (string): A single Google Maps contributor profile URL or bare numeric contributor ID (mode=author). Equivalent to one entry in contributorUrls.
    • maxReviews (integer): Maximum number of reviews to extract. Set higher for more complete coverage. In author mode Google publishes only about ten of a reviewer's most recent reviews, so higher values do not yield more rows. Default: 50.
    • sortBy (string): Order in which to retrieve reviews (mode=place). Default: "newest".
    • language (string): Language for Google Maps interface and review text. Default: "en".
    • proxyConfiguration (object): The actor hardcodes Apify RESIDENTIAL for place-review harvesting and lets Apify rotate residential IPs per request. It retries with a fresh browser/proxy configuration and keeps direct access as a bounded final fallback. You may select a two-letter proxy country; proxy group and useApifyProxy are not user-overridable.

    Fixed-choice controls: mode accepts place (Place reviews (one business or location)), author (Author mode (everything one reviewer has reviewed)); sortBy accepts relevant (Most Relevant), newest (Newest First), highest_rating (Highest Rating First), lowest_rating (Lowest Rating First); language accepts 11 values (default en), including en (English), es (Spanish), fr (French), de (German).

    What does Google Maps Reviews Scraper return?

    Returned records provide structured review text, ratings, relative dates, and business owner responses suitable for sentiment monitoring and competitor benchmark analysis. They do not contain private user contact information or verified calendar dates when Google only shows relative time strings.

    Output Fields

    • recordType: string - review in place mode, authorReview in author mode
    • reviewId: string - Unique review identifier when exposed
    • reviewerName: string - Name of the reviewer (place mode)
    • reviewerAvatarUrl: string - URL of the reviewer's profile picture (place mode)
    • reviewerProfileUrl: string - URL of the reviewer's public profile (place mode)
    • reviewerSubtitle: string - Google's subtitle under the reviewer name, e.g. Local Guide level, review and photo counts (place mode)
    • reviewerLocalGuideLevel: integer - Reviewer's Local Guide level parsed from the subtitle (place mode)
    • reviewerTotalReviews: integer - Reviewer's published review total parsed from the subtitle (place mode)
    • reviewerPhotoCount: integer - Number of photos on the reviewer's profile parsed from the subtitle (place mode)
    • reviewerEmoji: string - Emoji Google shows next to the reviewer's name (place mode)
    • rating: integer - Star rating (1-5)
    • reviewText: string - Full review text
    • reviewLanguage: string - Language code Google reports for the review text (place mode)
    • originalReviewLanguage: string - Original language code when Google shows a translated review (place mode)
    • reviewDateOriginal: string - Date text exactly as Google displayed it
    • reviewDate: string - Absolute date only when Google exposed one directly
    • isEdited: boolean - Set when Google marks the review as edited
    • likesCount: integer - Helpful/like count only when published
    • businessName: string - Name of the business (place mode)
    • businessRating: number - Overall business star rating (place mode)
    • businessTotalReviews: integer - Total number of reviews for the business (place mode)
    • businessCategory: string - Business category (place mode)
    • businessAddress: string - Business street address (place mode)
    • contributorId: string - Reviewer's public numeric ID (author mode)
    • contributorName: string - Reviewer's display name (author mode)
    • contributorAvatarUrl: string - Reviewer's profile picture (author mode)
    • contributorProfileUrl: string - Reviewer's public reviews page (author mode)
    • contributorLocalGuideLevel: integer - Reviewer's Local Guide level (author mode)
    • contributorPoints: integer - Reviewer's public contribution points (author mode)
    • contributorTotalReviews: integer - Reviewer's published review total (author mode)
    • placeName: string - Place the reviewer reviewed (author mode)
    • placeAddress: string - Address of the reviewed place (author mode)
    • position: integer - Position of the review in the reviewer's list (author mode)
    • reviewPhotoUrls: array - Photo URLs attached to the review (author mode)
    • reviewPhotoCount: integer - Number of photos attached to the review (author mode)
    • videosInReview: integer - Number of directly labelled video controls Google exposes on this review card
    • photosInReview: array - Photo URLs attached to the review (place mode)
    • ownerResponseText: string - Owner reply, when the place replied
    • ownerResponseDate: string - Owner reply date converted to an absolute date, when resolvable
    • ownerResponseDateOriginal: string - Owner reply date text exactly as Google displayed it
    • contextLabels: array - Public context labels shown on the review (author mode)
    • mentionedItems: array - Public item or aspect chips Google highlights in the review
    • isVerified: boolean - Set when Google marks the review with a verified badge
    • visitDate: string - Visit date text Google shows on the review, e.g. "Visited in May"
    • placeId: string - Canonical Google Place ID beginning with ChIJ, when Google exposes one (place and author modes)
    • featureId: string - Legacy feature/CID token (0x…:0x…), when Google exposes one (place and author modes)
    • placeUrl: string - Google Maps place URL
    • sourceUrl: string - Source Google Maps URL for the row
    • sortBy: string - Requested review order for the row (relevant, newest, highest_rating, lowest_rating); place mode only
    • sortConfirmed: boolean - true only when the requested order was confirmed from Google's own panel; false when rows were emitted but the requested order could not be confirmed. Place mode only
    • sortStatus: string - Short form of sortConfirmed: confirmed or unconfirmed. Place mode only
    • order: integer - Position of the review in results (0-based, place mode)
    • scrapedAt: string - ISO 8601 timestamp of when the data was scraped

    Sample Author-Mode Output

    • recordType (e.g. authorReview)
    • contributorId (e.g. 102461194647441801965)
    • contributorName (e.g. Hilarie Sant)
    • contributorAvatarUrl
    • contributorProfileUrl (e.g. https://www.google.com/maps/contrib/102461194...)
    • contributorLocalGuideLevel (e.g. 3)
    • contributorPoints (e.g. 154)
    • contributorTotalReviews (e.g. 9)
    • placeName (e.g. Especially For You Your Downtown Florist)
    • placeAddress (e.g. 221 W 400 S, Salt Lake City, UT 84101, United...)
    • rating (e.g. 5)
    • reviewText (e.g. Thank you for the absolutely beautiful flower...)
    • reviewDateOriginal (e.g. 2 weeks ago)
    • position (e.g. 1)
    • sourceUrl (e.g. https://www.google.com/maps/contrib/102461194...)
    • scrapedAt (e.g. 2026-09-14T12:00:00+00:00)

    These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

    How do you build the workflow end to end?

    Open Google Maps Reviews Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

    1. Set mode to place or author to establish whether you are querying a location or a reviewer profile.
    2. Provide a placeUrl or canonical placeId for place mode, or populate contributorUrls with public reviewer profile links for author mode.
    3. Configure maxReviews to set your extraction target, noting that author mode caps out around ten reviews due to Google interface limits.
    4. Set sortBy to your preferred ordering such as newest or lowest_rating, and choose a language code to standardize the review text.
    5. Run the Actor using default proxy settings and review the initial dataset items to ensure recordType matches your selected mode.
    6. Check sortConfirmed on output records in place mode to verify whether Google honored your requested review sorting order.

    How do you apply it? Three worked playbooks

    These are Google Maps Reviews Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

    Use case 1: Location feedback monitoring

    Outcome: Monitor customer feedback for a business or location.

    Configure: Set mode to place, set placeId to ChIJabtoT7hlwokRLECK0SW3_8I, set sortBy to newest, and set maxReviews to 50.

    Working method: Execute a run with sortBy set to newest to collect recent customer feedback for a target location, then evaluate owner response fields for missing replies.

    Deliverable: A dataset of review records containing rating, reviewText, reviewDateOriginal, and ownerResponseText.

    Stop condition: Halt execution if the run reports zero returned records for a known location.

    Use case 2: Competitor rating analysis

    Outcome: Compare review themes and ratings across competitors.

    Configure: Set mode to place, pass the target business link into placeUrl, set sortBy to lowest_rating, and set maxReviews to 100.

    Working method: Run separate requests across multiple competitor place URLs using lowest_rating order to isolate common customer complaints.

    Deliverable: Comparative datasets containing rating, reviewText, and businessName for each competitor.

    Stop condition: Halt execution if sortStatus returns unconfirmed across consecutive competitor targets.

    Use case 3: Contributor review history

    Outcome: Follow prolific reviewers and see everything they have reviewed across places.

    Configure: Set mode to author, set contributorUrls to ["https://www.google.com/maps/contrib/102461194647441801965/reviews"], and set maxReviews to 10.

    Working method: Supply a list of public contributor profile URLs to collect recent place ratings and comments made by specific reviewer IDs.

    Deliverable: A dataset of authorReview items containing placeName, placeAddress, rating, and reviewText.

    Stop condition: Halt execution if a contributor profile returns zero rows due to private reviewer settings.

    What breaks, and how do you design around it?

    • Google Maps can expose a smaller anonymous review window than the place's aggregate review count. Place mode starts with a hardcoded Apify RESIDENTIAL session, retries with a new pinned Residential session, then has a bounded direct fallback. It reports an under-fetch if those cookieless acquisitions still miss the requested target; that is a detected failure, not a claim that the underlying data is unavailable.
    • The scraper extracts reviews visible on Google Maps - private or filtered reviews are not accessible
    • Google may advertise a large aggregate review count while exposing only a smaller anonymous review window. The actor opens Google's public More reviews control and reports only the reviews it actually observes, without padding.
    • Author mode returns at most about ten reviews per profile. Google's public reviewer pages expose only the most recent handful of reviews with no way to page further; this is a Google limit, not a bug, and the actor reports only the reviews it actually observes.
    • A reviewer's absolute review dates are not published. Google shows only relative labels such as "2 weeks ago", so author-mode rows keep that label in reviewDateOriginal and never invent a calendar date.

    When Google Maps limits how many historical reviews are visible anonymously, set realistic maxReviews limits to account for public under-fetching. In author mode, Google's public reviewer pages show only about ten recent reviews, so design your ingestion pipelines around this ten-row limit per profile rather than expecting complete historical review archives.

    When should you not use Google Maps Reviews Scraper?

    Do not use this Actor if you require verified B2B lead contact details like business email addresses or phone numbers alongside review metadata. In those cases, use Google Maps Leads Scraper to extract business listings enriched with contact information crawled from company websites. If you only need core place profiles like business ratings, overall review totals, and store categories without individual review text, Google Maps Scraper provides a faster payload.

    What should you check before trusting the output?

    • Verify that recordType contains review for place mode runs or authorReview for author mode runs.
    • Check that placeId starts with ChIJ; if Google returns a legacy token instead, verify it is recorded under featureId.
    • Confirm that reviewText is present on non-empty ratings, as rating-only entries legitimately omit text.
    • Monitor reviewDateOriginal to ensure relative date strings like '2 weeks ago' are captured when reviewDate is null.

    None of this proves a record is correct. It gives a scheduled Google Maps Reviews Scraper run defined points where it should stop instead of quietly passing bad data downstream.

    Frequently asked questions

    How much does it cost to extract 1,000 Google Maps reviews?

    It costs $5.00 per 1,000 results on Apify's free plan. Higher paid plan tiers pay less per result. Apify's free plan includes $5.00 of monthly usage with no credit card required, which covers up to 1,000 results.

    Why does author mode return only about ten reviews per profile?

    Google's public reviewer pages only expose about ten of a reviewer's most recent reviews anonymously with no way to page further. This is a limit of what Google publishes, so the Actor reports what Google exposes.

    Are relative dates like '2 weeks ago' converted to calendar dates?

    No. Relative date strings are preserved exactly as Google displays them in the reviewDateOriginal field. The Actor does not guess calendar dates unless Google exposes an absolute date directly.

    What happens if my requested sorting order cannot be applied?

    When an explicit sorting order cannot be confirmed through Google's controls, the run reports the ignored sort and emits unconfirmed ordering status on the returned records.

    Do I need to supply Google cookies or log in?

    No. The Actor extracts public review data using fresh browser sessions without requiring account logins, saved cookies, or personal profiles.

    Where to go next

    When you are ready to run it, open Google Maps Reviews Scraper on Apify; the free plan covers up to 1,000 results a month.

    Start with the Google Maps Reviews Scraper Actor page for the current input schema, pricing tier, and run history.

    It is part of the Google Maps Scraping Suite, which puts every related Actor on one page with its price and run history.

    If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

    Other Actors we maintain for related data:

    Related guides:

    Resources

    • Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-27.

    • Actor last updated by its maintainers on 2026-09-27.

    • Run outcome figures cover the 30 day public window ending 2026-09-27.

    • Google Maps Reviews Scraper on Apify

    Featured actors

    Google Maps Reviews Scraper

    Extract detailed reviews from any Google Maps business page. This scraper retrieves reviewer information, ratings, review text, dates, likes, and owner responses.

    Run on Apify ↗