# Local Review Intelligence Monitor (`geneius/local-review-intelligence-monitor`) Actor

Analyze Google Maps, Yelp, TripAdvisor, or other local-business reviews into complaint themes, praise themes, urgency scores, and owner-response actions.

- **URL**: https://apify.com/geneius/local-review-intelligence-monitor.md
- **Developed by:** [Gene](https://apify.com/geneius) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Local Review Intelligence Monitor

Turn raw local-business reviews into **complaint themes, praise themes, urgency scores, and owner-response actions**. This Actor is designed for Google Maps, Yelp, TripAdvisor, Booking, Facebook, and other review records collected by Apify Actors or supplied inline.

Instead of returning another spreadsheet of review text, it gives agencies and operators a clean action dataset: what customers complain about, what they praise, which reviews need attention, and what to do next.

<!-- revenue-machine:workflow-hub:start -->
### Workflow Hub

See the public [review intelligence workflow](https://geneiusk.github.io/apify-actor-powerhouse-hub/review-intelligence.html) for the scraper dataset -> analyzer path, demo story, and links across the review-intelligence Actors. Local SEO teams can start from the [local review response queue use case](https://geneiusk.github.io/apify-actor-powerhouse-hub/local-review-response-queue.html). For the first run, use that sample path and the [proof GIF](https://geneiusk.github.io/apify-actor-powerhouse-hub/assets/local-review-proof.gif) showing local reviews becoming a response queue.
<!-- revenue-machine:workflow-hub:end -->

### What You Learn

- Which reviews are positive, negative, or mixed
- Which themes keep appearing: service, wait time, price, quality, delivery, availability, and experience
- Which complaints deserve urgent follow-up
- Which positive reviews can become local landing-page or ad proof
- What action to take for each review

### Use Cases

- Weekly reputation monitoring for local SEO clients
- Multi-location complaint triage for franchises
- Owner-response prioritization for agencies
- Local landing-page proof mining from positive reviews
- Review exports to Google Sheets, Slack, dashboards, or reporting decks

### Input

You can provide reviews inline or pass an Apify `datasetId` from another review scraper.

```json
{
  "businessName": "Northstar Dental",
  "sourceName": "Google Maps",
  "reviews": [
    {
      "rating": 1,
      "text": "The staff was rude and the wait was terrible.",
      "authorName": "Example Customer",
      "date": "2026-05-01"
    }
  ],
  "maxReviews": 100,
  "includeRawReview": true
}
````

### Output

Each dataset item is one analyzed review:

```json
{
  "status": "succeeded",
  "recordIndex": 1,
  "billingEventName": "local-review-analyzed",
  "businessName": "Northstar Dental",
  "sourceName": "Google Maps",
  "rating": 1,
  "sentimentLabel": "negative",
  "sentimentScore": -100,
  "detectedThemes": ["service", "wait_time"],
  "complaintThemes": ["service", "wait_time"],
  "urgencyScore": 95,
  "recommendedAction": "Audit staff response patterns for Northstar Dental; service complaints are driving visible review risk.",
  "analyzedAt": "2026-05-12T12:00:00+00:00"
}
```

The run also writes a `SUMMARY` key-value-store record with analyzed counts, sentiment counts, theme counts, and the charge event name.

### FAQ

#### Does this scrape review sites?

No. It analyzes review records you provide inline or through an Apify dataset from another Actor. It is designed for Google Maps, Yelp, TripAdvisor, Booking, Facebook, and similar local-review records.

#### What input do I need for the first run?

Use the Store example with `businessName`, `sourceName`, and one or more review records. Review text is required; ratings improve sentiment and urgency scoring.

#### What do I get back?

One dataset item per analyzed review, including sentiment, detected themes, urgency, and recommended next action. The run also writes a `SUMMARY` record.

#### Who is this for?

Local SEO agencies, reputation managers, franchises, and multi-location operators that need recurring review triage and reporting.

#### When is it commercially chargeable?

The configured paid event is `local-review-analyzed` at `$0.015`, scheduled for 2026-05-26T21:05:10Z. Run a small paid smoke after activation before promoting high-volume use.

### Pricing

Default monetization model: pay per event.

Recommended chargeable event:

- Event name: `local-review-analyzed`
- Event meaning: one successfully analyzed review
- Store price: `$0.015` per analyzed review
- Pricing activation: scheduled for `2026-05-26T21:05:10Z`

Successful rows are pushed only after the charge path allows the event. Run a paid smoke after the scheduled activation time before promoting the listing.

### Limitations

- This MVP analyzes review records; it does not scrape Google Maps, Yelp, TripAdvisor, or Booking directly.
- Review source schemas vary. The Actor recognizes common fields such as `text`, `reviewText`, `rating`, `stars`, `authorName`, and `date`.
- Theme detection is deterministic and intentionally explainable. It is built for reliable monitoring, not black-box sentiment theater.

### Automation And Agent Use

- Run a review scraper first, then pass its dataset ID to this Actor.
- Schedule weekly analysis for each client or location group.
- Send negative high-urgency reviews to Slack or a ticketing queue.
- Append `sentimentLabel`, `detectedThemes`, and `recommendedAction` to Google Sheets for client reporting.

### Local Development

```bash
python3 -m pip install -r requirements.txt
ACTOR_TEST_PAY_PER_EVENT=true apify run --purge --input-file examples/smoke-input.json
```

# Actor input Schema

## `businessName` (type: `string`):

Business, branch, franchise group, or client name used in recommendations.

## `sourceName` (type: `string`):

Source label for the input reviews, such as Google Maps, Yelp, TripAdvisor, or Booking.

## `reviews` (type: `array`):

Optional review records. Each record should include review text and may include rating, author, date, URL, or business name.

## `datasetId` (type: `string`):

Optional Apify dataset ID containing review records from another Actor.

## `maxReviews` (type: `integer`):

Safety cap for analyzed reviews in one run.

## `datasetItemLimit` (type: `integer`):

Maximum number of records to load from the source dataset.

## `includeRawReview` (type: `boolean`):

When enabled, dataset items include the original review text.

## `failOnInvalidRecord` (type: `boolean`):

When enabled, the Actor fails on the first invalid review record instead of returning partial error records.

## Actor input object example

```json
{
  "businessName": "Northstar Dental",
  "sourceName": "Google Maps",
  "reviews": [
    {
      "rating": 1,
      "text": "The staff was rude and the wait was terrible.",
      "authorName": "Example Customer",
      "date": "2026-05-01"
    }
  ],
  "maxReviews": 100,
  "datasetItemLimit": 100,
  "includeRawReview": true,
  "failOnInvalidRecord": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items with one row per analyzed review, including sentiment, urgency, themes, and recommended action.

## `summary` (type: `string`):

Run-level summary with analyzed review count, failures, charge event name, and sentiment/theme counts.

# 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 = {
    "businessName": "Northstar Dental",
    "sourceName": "Google Maps",
    "reviews": [
        {
            "rating": 1,
            "text": "The staff was rude and the wait was terrible.",
            "authorName": "Example Customer",
            "date": "2026-05-01"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("geneius/local-review-intelligence-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 = {
    "businessName": "Northstar Dental",
    "sourceName": "Google Maps",
    "reviews": [{
            "rating": 1,
            "text": "The staff was rude and the wait was terrible.",
            "authorName": "Example Customer",
            "date": "2026-05-01",
        }],
}

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

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

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

```

## CLI example

```bash
echo '{
  "businessName": "Northstar Dental",
  "sourceName": "Google Maps",
  "reviews": [
    {
      "rating": 1,
      "text": "The staff was rude and the wait was terrible.",
      "authorName": "Example Customer",
      "date": "2026-05-01"
    }
  ]
}' |
apify call geneius/local-review-intelligence-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=geneius/local-review-intelligence-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Review Intelligence Monitor",
        "description": "Analyze Google Maps, Yelp, TripAdvisor, or other local-business reviews into complaint themes, praise themes, urgency scores, and owner-response actions.",
        "version": "0.1",
        "x-build-id": "3JtWcD0VXMjBbLe8P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/geneius~local-review-intelligence-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-geneius-local-review-intelligence-monitor",
                "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/geneius~local-review-intelligence-monitor/runs": {
            "post": {
                "operationId": "runs-sync-geneius-local-review-intelligence-monitor",
                "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/geneius~local-review-intelligence-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-geneius-local-review-intelligence-monitor",
                "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": {
                    "businessName": {
                        "title": "Business or location name",
                        "type": "string",
                        "description": "Business, branch, franchise group, or client name used in recommendations."
                    },
                    "sourceName": {
                        "title": "Review source",
                        "type": "string",
                        "description": "Source label for the input reviews, such as Google Maps, Yelp, TripAdvisor, or Booking.",
                        "default": "Google Maps"
                    },
                    "reviews": {
                        "title": "Inline review records",
                        "minItems": 1,
                        "type": "array",
                        "description": "Optional review records. Each record should include review text and may include rating, author, date, URL, or business name."
                    },
                    "datasetId": {
                        "title": "Source dataset ID",
                        "minLength": 1,
                        "type": "string",
                        "description": "Optional Apify dataset ID containing review records from another Actor."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Safety cap for analyzed reviews in one run.",
                        "default": 100
                    },
                    "datasetItemLimit": {
                        "title": "Dataset item limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to load from the source dataset.",
                        "default": 100
                    },
                    "includeRawReview": {
                        "title": "Include raw review text",
                        "type": "boolean",
                        "description": "When enabled, dataset items include the original review text.",
                        "default": true
                    },
                    "failOnInvalidRecord": {
                        "title": "Fail on invalid record",
                        "type": "boolean",
                        "description": "When enabled, the Actor fails on the first invalid review record instead of returning partial error records.",
                        "default": 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
                                    }
                                }
                            },
                            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
