# Review Monitor: Google Maps, Tripadvisor & Trustpilot (`vncntlabs/review-monitor`) Actor

Get new reviews from Google Maps, Tripadvisor and Trustpilot in one clean format: rating, text, date, owner reply and a rating snapshot per business. Newest first, rating and date filters, and an only-new mode for scheduled review alerts. Pay per review.

- **URL**: https://apify.com/vncntlabs/review-monitor.md
- **Developed by:** [VNCNT Labs](https://apify.com/vncntlabs) (community)
- **Categories:** Lead generation, Marketing, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Review Monitor: Google Maps, Tripadvisor & Trustpilot

Get reviews from **Google Maps**, **Tripadvisor** and **Trustpilot** in **one clean format**: star rating, title, review text (plus the original text when Google translated it), publish time, the business owner's reply, photo count, review link and platform extras (Google's review highlights, Tripadvisor's visit date, Trustpilot's verified flag). Every business also gets a **rating snapshot**: current rating, total review count, star distribution where the platform shows it, and in monitoring mode the **change since the last check**.

Reviews come **newest first**. Filter by **stars** (for example 1-2 stars for complaint alerts) and by **date** (`7 days`, `2026-10-01`), and switch on **only-new-reviews** mode to run it as a scheduled review alert where you only pay for new reviews.

Built for:

- **Local businesses, hotels, restaurants and agencies**: watch every location's new reviews and rating in one feed, reply faster to bad ones.
- **E-commerce and SaaS brands**: Trustpilot reviews next to Google reviews for support, product and marketing teams.
- **Analysts, AI and data teams**: clean review datasets for sentiment analysis, competitor research and reporting.

You pay **per review delivered** plus a small fee **per business checked**. Businesses that can't be found, failed requests, reviews removed by your filters and (in only-new mode) reviews you already received are free.

### What you get

| Row (`type`) | What's in it | Charged |
|---|---|---|
| `review` | `platform`, `businessName`, `rating`, `title`, `text`, `originalText`, `language`, `publishedAt` (UTC), `ownerResponse`, `ownerResponseAt`, `photosCount`, `reviewUrl`, `reviewId`, `highlights` (Google), `dateOfVisit` (Tripadvisor), `verified` (Trustpilot), `position`, `businessUrl` | `review` |
| `business` | one per business: `status`, `businessName`, `address`, `rating`, `totalReviews`, `ratingDistribution` (Tripadvisor), `placeId`/`cid` (Google), reviews delivered, average stars of the delivered reviews, newest/oldest review time; in only-new mode `ratingChange` and `totalReviewsChange` since the previous check | `business` when the business was found |
| `skipped` | inputs that couldn't be used and why | free |

**Reviewer names are left out by default.** Reviewer names, profile links and locations are personal data, and most monitoring and analysis jobs don't need them. If you do (for example to reply to reviewers), turn on **Include reviewer names and profiles** and you'll also get `reviewerName`, `reviewerProfileUrl`, `reviewerReviewsCount`, `reviewerLocation` and Google's `localGuide`. Only turn it on if you have a lawful basis to process that data.

### Input examples

The latest 100 reviews of a restaurant on Google and Tripadvisor, and a shop on Trustpilot:

```json
{
  "googlePlaces": ["https://www.google.com/maps/place/Joe's+Pizza+Broadway/data=!4m6!3m5!1s0x89c259ab3c1ef289:0x3b67a41175949f55!8m2"],
  "tripadvisorUrls": ["https://www.tripadvisor.com/Attraction_Review-g60763-d105127-Reviews-Central_Park-New_York_City_New_York.html"],
  "trustpilotDomains": ["zappos.com"]
}
```

Negative-review alert for all your locations, scheduled every hour, only new 1-2 star reviews:

```json
{
  "googlePlaces": ["ChIJifIePKtZwokRVZ-UdRGkZzs", "Joe's Pizza Carmine St, New York"],
  "maxRating": 2, "onlyNewReviews": true, "monitorId": "my-locations-bad-reviews"
}
```

Everything from the last 30 days:

```json
{ "trustpilotDomains": ["asos.com"], "reviewsNewerThan": "30 days", "maxReviewsPerBusiness": 1000 }
```

**Tips**

- **Google Maps**: paste the place's Google Maps link (desktop URL or `maps.app.goo.gl` share link), a place ID (`ChIJ…`) or `Business name, City`. Links and place IDs are exact; names are matched by Google, so check `businessName` and `address` in the business row.
- **Tripadvisor**: paste the page link of the hotel, restaurant or attraction (it contains `_Review-g…-d…`, any country domain). Search by name isn't offered because it can return the wrong place.
- **Trustpilot**: the company's website domain (`zappos.com`) or its Trustpilot page.
- **Only new reviews**: the Actor remembers delivered review IDs in your Apify account (key-value store `review-monitor`), one history per setup, or per **Monitor name** if you set one. The first run returns the latest reviews as a baseline; later runs return only new ones. Each check reads the newest page first and looks deeper only when that whole page is new, so frequent checks stay quick.
- **Star filters on Google and Trustpilot** are applied to the newest reviews: the Actor reads the latest ~50 and only goes deeper when enough of them match. For a 4.8-star place, a 1-star filter may return only a few reviews. Tripadvisor filters on its side.
- Platform limits: Trustpilot pages hold 20 reviews and Google may translate reviews into your chosen language (the original is in `originalText`).

### Output example (one review)

```json
{
  "type": "review", "platform": "google", "businessName": "Joe's Pizza Broadway",
  "businessUrl": "https://www.google.com/maps?cid=4280570365733019477", "position": 1,
  "reviewId": "Ci9DQUlRQUNvZENodHljRjlvT2sxS1MwRmlaM2hwU21RM2VVUnFkMWhhUjBGTGJIYxAB",
  "rating": 5.0, "title": null, "text": "Great pizza 🍕", "originalText": null, "language": "en",
  "publishedAt": "2026-10-17T05:31:50Z", "timeAgo": "7 hours ago", "ownerResponse": null, "ownerResponseAt": null,
  "photosCount": 0, "reviewUrl": "https://www.google.com/maps/reviews/data=!4m8!14m7!1m6!2m5!1sCi9DQUlR...",
  "highlights": [{"feature": "Order type", "value": "Take out"}, {"feature": "Price per person", "value": "$10–20"},
                 {"feature": "Food", "value": "5"}, {"feature": "Service", "value": "5"}],
  "dateOfVisit": null, "verified": null, "chargedEvents": ["review"], "scrapedAt": "2026-10-17T13:00:51Z"
}
```

The dataset has three views: **Overview**, **Reviews (all fields)** and **Businesses (rating snapshot)**. Export to CSV, Excel or JSON, or connect it to Slack, email, Zapier or Make with Apify integrations for instant alerts.

### Pricing (pay per event)

| Event | When it is charged |
|---|---|
| Actor start | once per run |
| `business` | once per business that was found and checked (its rating snapshot row) |
| `review` | one review delivered |

You are not charged for:

- businesses that couldn't be found, failed requests and skipped inputs;
- reviews removed by your star or date filters;
- in only-new mode, reviews already delivered by earlier runs;
- anything beyond your run's maximum charge. The run stops cleanly and lists what it didn't process.

**Apify free plan:** 3 businesses and 50 reviews per business per run. Any paid Apify plan unlocks up to 100 businesses and 1,000 reviews per business.

### FAQ

**How fresh is it?** Every run reads the platforms live, newest first. In monitoring mode a review usually appears in the first run after it's published on the platform.

**Can I get all reviews of a business?** Up to 1,000 of the newest per business per run. For more, split by star rating or run again with `reviewsNewerThan`.

**Why are reviewer names off?** Privacy by default: names and profile links identify people, and you rarely need them to track ratings or read feedback. Turn them on per run if you need them.

**Is this an official API?** No. This Actor uses DataForSEO's licensed Business Data API and is not affiliated with or endorsed by Google, Tripadvisor or Trustpilot. Review texts belong to their authors and platforms.

# Actor input Schema

## `googlePlaces` (type: `array`):

One per line: the business's Google Maps link (best: open it on Google Maps and copy the URL or the share link), a place ID (<code>ChIJ…</code>), or <code>Business name, City</code>. Names are matched by Google, so check businessName in the results.

## `tripadvisorUrls` (type: `array`):

One per line: the Tripadvisor page of a hotel, restaurant or attraction (contains <code>\_Review-g…-d…</code>), any Tripadvisor country domain.

## `trustpilotDomains` (type: `array`):

One per line: the company's website domain (<code>zappos.com</code>) or its Trustpilot page (<code>trustpilot.com/review/zappos.com</code>).

## `maxReviewsPerBusiness` (type: `integer`):

Newest first, up to 1000. In only-new mode this is the most new reviews returned per business per run.

## `minRating` (type: `integer`):

Only reviews with at least this many stars.

## `maxRating` (type: `integer`):

Only reviews with at most this many stars, e.g. 2 for negative-review alerts.

## `reviewsNewerThan` (type: `string`):

Optional: a date (<code>2026-10-01</code>) or a period (<code>7 days</code>, <code>24 hours</code>, <code>2 weeks</code>, <code>3 months</code>).

## `country` (type: `string`):

Google Maps only: the Google edition used to look the place up.

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

Google Maps only: language code (en, de, es, pt-BR...). Google may translate reviews into this language; the original text is kept in originalText when available.

## `onlyNewReviews` (type: `boolean`):

For scheduled runs: remembers the reviews delivered before and returns only new ones, plus each business's rating and review-count change since the last check. The first run returns the latest reviews as a baseline. History is kept in your Apify account (key-value store 'review-monitor').

## `monitorId` (type: `string`):

Optional. Name the monitor to keep its history stable when you edit the list, e.g. <code>my-restaurants</code>.

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

Off by default: reviewer names, profile links and locations are personal data and are left out. Turn on only if you need them (for example to reply to reviewers) and have a lawful basis to process them.

## Actor input object example

```json
{
  "googlePlaces": [
    "https://www.google.com/maps/place/Joe's+Pizza+Broadway/data=!4m6!3m5!1s0x89c259ab3c1ef289:0x3b67a41175949f55!8m2"
  ],
  "maxReviewsPerBusiness": 100,
  "minRating": 1,
  "maxRating": 5,
  "country": "United States",
  "language": "en",
  "onlyNewReviews": false,
  "includeReviewerDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `businesses` (type: `string`):

No description

## `all` (type: `string`):

No description

## `summary` (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 = {
    "googlePlaces": [
        "https://www.google.com/maps/place/Joe's+Pizza+Broadway/data=!4m6!3m5!1s0x89c259ab3c1ef289:0x3b67a41175949f55!8m2"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/review-monitor").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 = { "googlePlaces": ["https://www.google.com/maps/place/Joe's+Pizza+Broadway/data=!4m6!3m5!1s0x89c259ab3c1ef289:0x3b67a41175949f55!8m2"] }

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/review-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "googlePlaces": [
    "https://www.google.com/maps/place/Joe'\''s+Pizza+Broadway/data=!4m6!3m5!1s0x89c259ab3c1ef289:0x3b67a41175949f55!8m2"
  ]
}' |
apify call vncntlabs/review-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vncntlabs/review-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ctivA8QBnfM82pVCq/builds/xhi4ERYdHHEYn8qbt/openapi.json