Google Reviews API: Official vs 3rd-Party APIs for Review Extraction

TL;DR

1. I explored both official and third-party Google Reviews APIs to see what actually works for large-scale review extraction.
2. Google offers two official APIs. The Google Business Profile API is great for managing your own verified listings.
3. The Google Places API gives you only a few public reviews and isn’t useful for real data collection.
4. Neither of them works at scale, so I tested third-party APIs built for that purpose.
5. Lobstr.io is the most scalable, affordable, and data-rich option, but it runs asynchronously.
6. Outscraper and SerpAPI are the best synchronous APIs for real-time results, though they cost more and return less data.

Why? Thanks to vibe coding, everyone can be a dev now.

But without proper API guides though, you’re left guessing.

If you’re a seasoned dev, you’ll probably hack your way through. But if you’re a newbie or a vibe coder, good luck navigating the scattered mess of resources and docs online.

That’s why I’m writing this guide to give you a clear, no-BS breakdown of the official Google Review API and the 3rd APIs that actually make review extraction work at scale.

Let’s look at the official one first.

Does Google offer a reviews API?

Yes, Google offers 2 APIs to work with reviews data.

1. Google Business Profile APIs
2. Google Places API

Let’s explore them one by one.

Google Business Profile API (aka Google my business API)

This is Google’s official API for managing your own listings. If you manage a Google Business Profile, this API lets you:

1. List all reviews
2. Get a specific review
3. Fetch reviews from multiple locations
4. Reply to a review
5. Delete your reply

How to access it?

First, you’ve got to own or manage the business inside your Google Business Profile account. This API doesn’t work for public listings or competitors.

The API is not directly available in Google console’s API library. So to access it:

1. Open the Google Cloud Console and create a project.
2. Find your Project Number under Project Info.
3. Go to the GBP API Contact Form, pick Application for Basic API Access, and fill it out.
4. Use an email that’s listed as an owner or manager on the GBP.
5. Wait for Google’s reply.

Once approved, enable the Business Profile APIs in your project and set up OAuth 2.0. Configure the consent screen and use this scope:

https://www.googleapis.com/auth/business.manage
f

How to use it?

You can read the full documentation of the API and feed it to GPT or Claude to get ready to go code.

Here are some example cURL requests for reference:

To view reviews of a single location:

curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://mybusiness.googleapis.com/v4/accounts/{accountId}/locations/{locationId}/reviews"
f

This returns the following data:

1. Review text
2. Total reviews count
3. Average rating score
4. Pagination token

To view reviews of all locations you manage:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d '{
    "locationNames": [
      "accounts/{accountId}/locations/{locationId}"
    ],
    "pageSize": 10,
    "orderBy": "updateTime desc",
    "ignoreRatingOnlyReviews": false
  }' \

  "https://mybusiness.googleapis.com/v4/accounts/{accountId}/locations:batchGetReviews"
f

This will return:

1. Place name
2. Review text

How much does it cost?

1. The Business Profile API is free.
2. No billing, no per-request costs.

What are the limitations?

You already know that this API works only for your own locations, which means you can’t collect reviews of other’s listings.

Plus Google’s approval is required before anything works.

Then we have the rate limits. You can send 300 queries per minute.

Plus you can’t create or edit user reviews, only manage your replies. You can’t touch customer review text.

The Google reviews API that actually lets you collect other places’ reviews is Places API.

Google Places API

The Google Places API gives you public info about all places listed on Google Maps. Names, addresses, ratings, reviews etc.

You can use it to extract a limited set of reviews and metadata about any business, even ones you don’t own.

How to access it?

You’ll need a Google Cloud project with the Places API enabled.

1. Open the Google Cloud Console.
2. Create or select a project.
3. Go to the APIs Library and search for Places API (New).
4. Enable it.
5. In the Credentials menu, create an API key.

How to use it?

To learn full usage of this API, you can read the official documentation of Places API.

Here’s a sample request:

curl -X GET \
  -H "Content-Type: application/json" \
  -H "X-Goog-Api-Key: YOUR_API_KEY" \
  -H "X-Goog-FieldMask: name,formattedAddress,rating,userRatingsTotal,reviews" \
  "https://places.googleapis.com/v1/places/PLACE_ID"
f

In response, each review object includes the author name, profile URL, rating, text, and timestamps.

How much does it cost?

1. The Places API runs on pay-as-you-go pricing.
2. Base cost: $25 per 1,000 Place Details requests (with reviews).

Volume discounts kick in as usage grows, and pricing goes as low as $2.30 per 1k requests beyond 5 million per month.

You get $200 in free monthly credits, good for about 8,000 Place Details calls.

What are the limitations?

It’s an official public API, but it comes with some real limits.

Firstly, there’s a cap on the number of reviews you can collect. You can only collect 5 reviews per place, which is nothing.

Secondly there’s an API rate limit of 600 requests per minute. But this won’t even matter because 5 reviews is literally too low.

So yeah, this one's a waste too if you’re planning to collect Google reviews at scale.

So what’s the alternative? Simple, use a 3rd party API.

Which one’s best? Let’s have a look…

The Alternative: Lobstr.io Google Reviews API

Lobstr.io is a cloud-based scraping platform built for large-scale data extraction. It packs 20+ ready scrapers, and one of them focuses entirely on Google Reviews.

You can use it through a simple no-code dashboard or go straight for the API if you’re a nerd.

Features

1. Collect every review from any Google Maps listing within minutes
2. Capture over 30 key data points per review
3. Add unlimited Google Maps listings to your tasks
4. Use its Google Maps listings scraper to pull business details and verified contact info
5. Download data as JSON or CSV
6. Export directly to Google Sheets, S3, or receive results by email
7. Get real-time alerts using webhooks
8. Runs entirely in the cloud so your IP stays hidden
9. Schedule scrapes for automated collection, monitoring, and notifications
10. No hidden costs for proxies, captchas, or infrastructure

Pricing

1. Starts at $1 per 1,000 reviews
2. Drops to $0.5 per 1,000 reviews at higher volumes

You only pay for what you get. No charges for empty responses or failed runs.

It scales well too. You can pull up to 1.6 million reviews per month without needing an enterprise plan.

How to use Lobstr.io’s Google Reviews Scraper API?

This is a quick walkthrough. If you want the full picture, read the documentation. You can find examples of using the Google reviews scraper too.

Let’s start with authentication.

Authentication

The only thing you need is your API key. Log in to your Lobstr.io dashboard, grab your key, and you’re set.

Here’s how to test it with curl:

curl --location 'https://api.lobstr.io/v1/me' \
--header 'Authorization: Token <api_key>'
f

Next, we need to set up a squid.

Setting up a Squid

A squid is just an instance of the scraper.

You don’t create one every time... only when you want to monitor something new like a keyword, a location, or a separate workflow. Otherwise, reuse the same one.

As I said earlier, Lobstr.io has 20+ crawlers, so each one has its own crawler hash. You can pull the list from:

curl --location 'https://api.lobstr.io/v1/crawlers' \
--header 'Authorization: Token <api_key>'
f

But to save your time, here’s Google Reviews Scraper’s crawler hash.

e625ce52e98a6d4d1b53ef36dff7dacb
f

Here’s how it looks with curl:

curl --location 'https://api.lobstr.io/v1/squids' \
--header 'Authorization: Token <your_api_key>' \
--header 'Content-Type: application/json' \
--data '{
    "crawler": "e625ce52e98a6d4d1b53ef36dff7dacb"
}'
f

Now the Squid is ready to use. Next, let’s specify input and adjust the crawler's behavior.

Input and crawler behavior

Once your squid is ready, you need to feed it something to chew on. That’s the input.

A task is basically a Google place URL you want to scrape reviews from.

Could be a single Google Maps listing, or a batch of them.

To add tasks, call:

POST https://api.lobstr.io/v1/tasks
f

You only need two things: your squid hash and the URLs. Here’s an example cURL request:

curl --location 'https://api.lobstr.io/v1/tasks' \
--header 'Authorization: Token <api_key>' \
--data-raw '{
    "tasks": [
        {
            "url": "https://maps.google.com/?cid=1357935577401699828"
        },
        {
            "url": "https://www.google.com/maps/place/La+Tour+d'\''Argent/@48.8499542,2.3524796,17z"
        }
    ],
    "squid": "<your_squid_hash>"
}'
f

If you’ve got a big list of Google places, use the bulk endpoint instead:

POST https://api.lobstr.io/v1/tasks/upload

You can upload a CSV, TXT, or TSV file. It’s way faster and convenient than sending hundreds of POSTs.

Now, the second part: crawler behavior. This is where you tell the scraper how to run.

You can tweak the following parameters to adjust your crawler’s behavior:

1. sort_by — sort reviews by newest, most relevant, or highest rating
2. hours_back — only fetch reviews from the last N hours
3. max_results — how many reviews to collect per run
4. language — which language to pull reviews in
5. functions.short_link — whether to include short review links
6. concurrency — how many bots you want running at once

Here’s a sample update to set those up:

curl --location 'https://api.lobstr.io/v1/squids/<squid_hash>' \
--header 'Authorization: Token <api_key>' \
--data '{
    "concurrency": 1,
    "params": {
        "sort_by": "newest",
        "hours_back": null,
        "max_results": 20,
        "language": "English (United States)",
        "functions": {
            "short_link": false
        }
    },
    "timezone": "Europe/Paris"
}'
f

Running your crawler and fetching reviews

Here's an example:

curl --location 'https://api.lobstr.io/v1/runs' \
--header 'Authorization: Token <api_key>' \
--header 'Content-Type: application/json' \
--data '{
    "squid": "<your_squid_hash>"
}'
f

How to check run progress?

You can check run progress by polling:

GET https://api.lobstr.io/v1/runs/<run_hash>/stats
f

It shows how many tasks finished, failed, or are still cooking. You can also use webhooks to get run status if you don’t want to keep polling this endpoint.

curl --location 'https://api.lobstr.io/v1/delivery?squid=<squid_hash>' \
--header 'Authorization: Token <api_key>' \
--data '{
    "webhook_fields": {
        "url": "https://your-webhook.com/endpoint",
        "is_active": true,
        "retry": false,
        "events": {
            "run.running": false,
            "run.paused": true,
            "run.done": false,
            "run.error": true
        }
    }
}'
f

P.S. You'll be using the same run ID to get results in the next step.

Speaking of results... you can download your reviews dataset as JSON or CSV.

How to download reviews?

If you want the output as JSON, call:

curl --location 'https://api.lobstr.io/v1/results?run=<run_hash>' \
--header 'Authorization: Token <api_key>'
f

That returns the full dataset in JSON format. If you prefer CSV, use this instead:

curl --location 'https://api.lobstr.io/v1/runs/<run_hash>/download' \
--header 'Authorization: Token <api_key>'
f

You’ll get a temporary download link. Open it in your browser and download the CSV.

If you don’t want to pull data manually every time, automate it.

Lobstr lets you send results straight to Google Sheets, S3, or SFTP. You can also schedule exports for daily or weekly collection.

And that’s it.

You can explore more about the API in docs, integrate with n8n or build your own applications on top of it.

Before I wrap this up, let’s talk about limitations... because every API has them, and Lobstr.io is no different.

Limitations

First is the rate limit. Just like any other API, Lobstr.io also has per-endpoint rate limits.

1. /v1/squids and /v1/runs endpoints allow around 120 requests per minute.
2. /v1/tasks gives you roughly 90 requests per minute.
3. /v1/results is capped at 2 requests per second.

But the second limitation will be a turn off for many. It’s async.

You don’t send a request and get data back instantly. You start a run, wait for it to finish, and then fetch results.

That’s great for scale and stability, but not if you need quick, synchronous responses.

So I’m also including some sync APIs you can explore.

Best synchronous Google Reviews APIs

After trying different Google reviews APIs, I found the following 2 worth mentioning:

1. SerpAPI
2. Outscraper

Let me give you a quick overview of both.

SerpAPI

Features

1. Filter reviews by language
2. Sort by rating score
3. Search reviews using a text query
4. Collect 20+ attributes for each review
5. Output in JSON
6. Access other Google data like search results and Maps listings

Pricing

1. Starts at $1.5 per 1,000 reviews
2. Drops to $0.9 per 1,000 when you scale

Failed requests aren’t charged, but empty responses still count as valid requests.

Limitations

1. No bulk listing endpoint like Lobstr.io
2. Needs a data ID or place ID instead of the listing URL
3. It also paginates results, so you can’t collect all reviews in a single request

Outscraper

Features

1. Extract around 15 data points for each review
2. Scrape reviews from all listings by search query or a single listing by name or Google ID
3. Filter by region or language
4. Export in CSV, JSON, or XLSX
5. Search reviews by topic using query filters

Pricing

1. Starts at $3 per 1,000 reviews
2. At higher volumes, drops to about $1 per 1,000

Limitations

1. The search query endpoint can be unreliable
2. You can’t use URLs directly, and pinpointing listings by name isn’t always accurate.Using Google IDs adds another request, which costs extra
3. No built-in scheduling, so you’ll have to automate runs yourself

Now before wrapping up, let me make it easier for you to decide which API you need.

Which Google Business Reviews API is best for me?

If you just want to manage your own Google reviews programmatically or through an automation tool, go with the Google Business Profile API.

It’s official, stable, and designed for that exact use case.

What about Google Places API? Skip it. It’s not built for reviews, so makes no sense for any serious setup.

If your goal is to build a review analytics or monitoring tool, then one of the third-party APIs is what you want.

Lobstr.io is the most scalable, affordable and data-rich option, and easily the best value for large workloads.

SerpAPI and Outscraper return less data, cost a bit more, but run synchronously, so you get results instantly.

But what’s the difference between synchronous and asynchronous APIs?

Synchronous vs asynchronous APIs

Let’s clear this up properly.

A synchronous API works in real time. You send a request and wait for the response in the same connection. Once it’s done, you get your data.

An asynchronous API works in the background. You send a request, it starts a job, and you fetch the results later once it’s processed.

Here’s how they actually differ:

In short,

Use Synchronous APIs: when you need real-time data, quick user responses, or smaller datasets. Ideal for dashboards, one-off lookups, or simple widgets.

Use Asynchronous APIs: when you’re scraping at scale, monitoring many listings, or running scheduled review collections. Perfect for backend workflows and automation.

Now before wrapping up, let me answer some FAQs.

FAQs

Where to get the Place ID?

You can get a Place ID using the Google Maps Place Search or Place Autocomplete endpoints.

Can I integrate Google My Business reviews into my website’s frontend using an API?

Yes, you can use the Google Business Profile API to fetch reviews for locations you own or manage, then render them on your site.

Can I automate the retrieval of Google reviews using an API?

Absolutely. That’s exactly what APIs like Lobstr.io are built for.

You can schedule the scraper, automate exporting results to Google Sheets or S3, and even set up webhooks for real-time updates.

Conclusion