> For the complete documentation index, see [llms.txt](https://docs.pullbay.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pullbay.com/documentation/guides/how-to-guides-for-google-maps/how-to-fetch-google-maps-reviews-from-a-place-url.md).

# How to Fetch Google Maps Reviews from a Place URL

Google Maps reviews are one of the most useful sources for understanding customer feedback, local reputation, and competitor performance. But manually reading reviews from Google Maps does not work well when you need structured review data for dashboards, reports, or monitoring workflows.

Pullbay’s Google Maps Reviews endpoint lets you fetch reviews for a place using the full Google Maps place URL.

{% hint style="warning" %}

## Important: Reviews Require `placeUrl`, Not `fid`

Pullbay’s Google Maps API uses different identifiers for different endpoints:

* `fid` is used for `GET /google-maps/place/{fid}`
* `placeUrl` is used for `GET /google-maps/place/reviews`

The reviews endpoint requires the full Google Maps place URL. Do not pass an FID to the reviews endpoint.
{% endhint %}

## Endpoint

```
GET https://dashboard.pullbay.com/api/google-maps/place/reviews

Authorization: Bearer YOUR_API_KEY
```

## Parameters

| Parameter | Type    | Required | Description                              |
| --------- | ------- | -------- | ---------------------------------------- |
| placeUrl  | string  | Yes      | Full Google Maps place URL               |
| maxItems  | integer | No       | One-shot bulk pull, 1–500 results        |
| cursor    | string  | No       | Cursor returned by the previous response |

`maxItems` and `cursor` are mutually exclusive. Use one or the other in a request.

## Approaches

{% tabs %}
{% tab title="Fetch Reviews with maxItems" %}
Use `maxItems` when you want a simple one-shot pull.

```python
import requests

API_KEY = "YOUR_API_KEY"

BASE_URL = "https://dashboard.pullbay.com/api"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

place_url = "https://www.google.com/maps/place/example-place-url"

params = {
    "placeUrl": place_url,
    "maxItems": 100
}

response = requests.get(
    f"{BASE_URL}/google-maps/place/reviews",
    headers=headers,
    params=params
)

response.raise_for_status()

data = response.json()
reviews = data.get("data", [])
credits = data.get("pricing", {}).get("creditsCharged")

print(f"Fetched {len(reviews)} reviews")
print(f"Credits charged: {credits}")

for review in reviews:
    print(review.get("stars"), review.get("dateIso"))
    print(review.get("reviewer", {}).get("name"))
    print(review.get("text"))
    print("---")
```

### When to use this

Use this approach when you need up to 500 reviews in a single request and do not need to continue with cursor pagination.
{% endtab %}

{% tab title="Cursor Pagination for More Review Pulls" %}
The reviews endpoint uses cursor-style pagination. The response can include `pagination.cursor`. Pass that cursor in the next request to continue.

```python
import requests

API_KEY = "YOUR_API_KEY"

BASE_URL = "https://dashboard.pullbay.com/api"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

place_url = "https://www.google.com/maps/place/example-place-url"

all_reviews = []
cursor = None

while True:
    params = {
        "placeUrl": place_url
    }

    if cursor:
        params["cursor"] = cursor
    else:
        params["maxItems"] = 100

    response = requests.get(
        f"{BASE_URL}/google-maps/place/reviews",
        headers=headers,
        params=params
    )

    response.raise_for_status()

    data = response.json()
    reviews = data.get("data", [])

    all_reviews.extend(reviews)

    print(f"Fetched {len(reviews)} reviews")

    cursor = data.get("pagination", {}).get("cursor")

    if not cursor:
        break

print(f"Total reviews fetched: {len(all_reviews)}")
```

{% endtab %}
{% endtabs %}

## Useful Review Fields

A Google Maps review can include:

| Field                 | Description                                   |
| --------------------- | --------------------------------------------- |
| id                    | Review ID                                     |
| link                  | Permalink to the review                       |
| text                  | Review body                                   |
| stars                 | Rating from 1 to 5                            |
| date                  | Posted timestamp in Unix milliseconds         |
| dateIso               | Posted timestamp in ISO 8601 format           |
| likes                 | Number of likes on the review, nullable       |
| photos                | Photo URLs attached to the review             |
| reviewer.name         | Reviewer display name                         |
| reviewer.url          | Reviewer Google Maps profile URL              |
| reviewer.totalReviews | Total reviews written by the reviewer         |
| reviewer.totalPhotos  | Total photos uploaded by the reviewer         |
| ownersResponse        | Owner response object, empty object when none |
| details               | Free-form review metadata                     |

## Client-Side Filtering by Rating

The API does not document a server-side rating filter for reviews. If you want only low-rating reviews, fetch reviews first and filter by stars in your own code.

```python
low_rating_reviews = [
    review for review in reviews
    if review.get("stars") in [1, 2]
]

print(f"Low-rating reviews: {len(low_rating_reviews)}")
```

## Export Reviews to CSV

```python
import csv

with open("google_maps_reviews.csv", "w", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(
        file,
        fieldnames=[
            "id",
            "stars",
            "dateIso",
            "reviewerName",
            "reviewerUrl",
            "text",
            "likes",
            "link"
        ]
    )

    writer.writeheader()

    for review in reviews:
        reviewer = review.get("reviewer") or {}

        writer.writerow({
            "id": review.get("id"),
            "stars": review.get("stars"),
            "dateIso": review.get("dateIso"),
            "reviewerName": reviewer.get("name"),
            "reviewerUrl": reviewer.get("url"),
            "text": review.get("text"),
            "likes": review.get("likes"),
            "link": review.get("link")
        })

print("Saved reviews to google_maps_reviews.csv")
```

## Deduplication

If you fetch reviews repeatedly, store the review id and use it as a unique key.

```python
seen_review_ids = set()
unique_reviews = []

for review in all_reviews:
    review_id = review.get("id")

    if review_id and review_id not in seen_review_ids:
        seen_review_ids.add(review_id)
        unique_reviews.append(review)
```

## Credit Considerations

Each request is billed independently. The exact credit charge is returned in:

```python
data["pricing"]["creditsCharged"]
```

Credit cost is dynamic, so read it from every response instead of assuming a fixed rate.

## Troubleshooting

| Problem                  | Possible Cause                    | Fix                                               |
| ------------------------ | --------------------------------- | ------------------------------------------------- |
| 400 Bad request          | Missing or invalid placeUrl       | Make sure you pass the full Google Maps place URL |
| 400 Bad request          | maxItems and cursor used together | Use only one per request                          |
| 402 Insufficient credits | Not enough credits                | Check Pullbay account credits                     |
| 404 Not found            | Review set not found              | Verify the place URL                              |
| No cursor returned       | No continuation cursor available  | Stop pagination                                   |

## Next Steps

After fetching Google Maps reviews, you can:

* Store reviews in a database
* Deduplicate reviews by id
* Filter client-side by stars
* Track new reviews over time
* Combine reviews with place details from the fid endpoint


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.pullbay.com/documentation/guides/how-to-guides-for-google-maps/how-to-fetch-google-maps-reviews-from-a-place-url.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
