# Review Intelligence Analyzer (`signalforge_labs/review-intelligence-analyzer`) Actor

Turn customer reviews into sentiment, themes, pain points, feature requests, competitor mentions, evidence quotes, and prioritized actions. Accepts direct input or any Apify dataset and exports JSON, Markdown, and HTML.

- **URL**: https://apify.com/signalforge\_labs/review-intelligence-analyzer.md
- **Developed by:** [SignalForge Labs](https://apify.com/signalforge_labs) (community)
- **Categories:** AI, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Review Intelligence Analyzer

Turn raw customer reviews into an action-ready product and marketing report—without reading thousands of comments manually.

The Actor accepts review objects pasted directly into the input, loaded from any authorized Apify dataset, or collected in one click from Google Maps and YouTube through established source Actors. It automatically detects common fields from Google Maps, Amazon, app-store, social-comment, and generic review scraper outputs.

### One-click sources

Choose `Google Maps reviews` or `YouTube comments`, add URLs, and run. The Actor calls the selected source Actor under the current user's Apify account, waits for its dataset, and analyzes the returned reviews or comments automatically.

- Google Maps uses `compass/google-maps-reviews-scraper`.
- YouTube uses `streamers/youtube-comments-scraper`.
- Source Actor pricing is separate and is shown by Apify before the run.
- Personal reviewer data is disabled for Google Maps source calls because the analysis only needs review text and ratings.

### What you get

- sentiment totals and per-review sentiment
- recurring themes with mention share and net sentiment
- prioritized pain points with evidence quotes and source URLs
- feature-request clusters
- tracked competitor mentions
- positive themes that can become marketing angles
- ranked product or operational actions
- JSON dataset plus Markdown and standalone HTML reports

Basic analysis is deterministic, multilingual, fast, and needs no external AI key. English and Simplified Chinese are supported in the first release.

### Input options

Use either or both:

1. `reviews`: an array of review objects.
2. `datasetId`: the ID of an existing Apify dataset.

Common text fields such as `text`, `reviewText`, `content`, `comment`, and `body` are detected automatically. Use `textField`, `ratingField`, or `urlField` when your input uses custom nested fields.

#### Example

```json
{
  "reviews": [
    {
      "text": "Fast delivery and excellent quality. I would buy again.",
      "rating": 5,
      "url": "https://example.com/review/1"
    },
    {
      "text": "The app crashes often. Please add offline mode.",
      "rating": 2,
      "url": "https://example.com/review/2"
    }
  ],
  "competitorNames": ["Competitor A"],
  "outputLanguage": "en"
}
```

### Outputs

- Default dataset: one summary row followed by normalized, analyzed review rows.
- `OUTPUT`: complete report as JSON.
- `REPORT.md`: portable Markdown report.
- `REPORT.html`: browser-ready executive report.

### Best workflow

1. Choose a one-click source, paste URLs, and run; or provide an existing dataset/direct review list.
2. Add competitor names if useful.
3. Run the Actor and download the report.

### Privacy

The Actor processes only the input supplied to the run. It does not send review content to an external AI provider and does not require third-party credentials.

### Limits

The first version uses explainable keyword and rating signals. Sarcasm, implicit context, and highly specialized terminology may need manual review. Evidence quotes and source links are included so every important conclusion can be checked quickly.

# Actor input Schema

## `sourceType` (type: `string`):

Choose a source Actor to collect reviews/comments automatically. Source Actor charges are billed separately by Apify. Select Direct input / dataset to use the fields below without calling another Actor.

## `sourceUrls` (type: `array`):

Add Google Maps place URLs or YouTube video URLs matching the selected one-click source.

## `sourceMaxItems` (type: `integer`):

Maximum reviews or comments requested from the selected source Actor for each URL.

## `sourceSort` (type: `string`):

Newest and top work for both sources. Highest and lowest are used for Google Maps reviews.

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

Paste review objects. Common fields such as text, reviewText, content, comment, rating, stars, url, and reviewUrl are detected automatically.

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

Optional dataset ID. Items from it are appended to reviews pasted above.

## `textField` (type: `string`):

Optional dot-path such as review.text. Leave empty for automatic detection.

## `ratingField` (type: `string`):

Optional dot-path such as review.rating.

## `urlField` (type: `string`):

Optional dot-path containing the evidence URL.

## `competitorNames` (type: `array`):

Optional competitor or alternative names to track in reviews.

## `maxItems` (type: `integer`):

Maximum number of reviews to analyze in one run.

## `evidencePerTheme` (type: `integer`):

Number of representative review quotes to keep for each detected theme.

## `outputLanguage` (type: `string`):

Language used for report labels and recommendations.

## Actor input object example

```json
{
  "sourceType": "none",
  "sourceUrls": [],
  "sourceMaxItems": 100,
  "sourceSort": "newest",
  "reviews": [
    {
      "text": "Fast delivery and excellent quality. I would buy again.",
      "rating": 5,
      "url": "https://example.com/review/1"
    },
    {
      "text": "The app crashes often. Please add offline mode.",
      "rating": 2,
      "url": "https://example.com/review/2"
    }
  ],
  "competitorNames": [],
  "maxItems": 5000,
  "evidencePerTheme": 3,
  "outputLanguage": "en"
}
```

# Actor output Schema

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

A summary record followed by normalized, sentiment-labeled review records.

## `htmlReport` (type: `string`):

A browser-ready executive report with themes, evidence, pain points, and recommended actions.

## `markdownReport` (type: `string`):

A portable report for Notion, documentation, email, or AI workflows.

## `jsonReport` (type: `string`):

The complete structured intelligence report for API integrations.

# 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 = {
    "reviews": [
        {
            "text": "Fast delivery and excellent quality. I would buy again.",
            "rating": 5,
            "url": "https://example.com/review/1"
        },
        {
            "text": "The app crashes often. Please add offline mode.",
            "rating": 2,
            "url": "https://example.com/review/2"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalforge_labs/review-intelligence-analyzer").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 = { "reviews": [
        {
            "text": "Fast delivery and excellent quality. I would buy again.",
            "rating": 5,
            "url": "https://example.com/review/1",
        },
        {
            "text": "The app crashes often. Please add offline mode.",
            "rating": 2,
            "url": "https://example.com/review/2",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("signalforge_labs/review-intelligence-analyzer").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 '{
  "reviews": [
    {
      "text": "Fast delivery and excellent quality. I would buy again.",
      "rating": 5,
      "url": "https://example.com/review/1"
    },
    {
      "text": "The app crashes often. Please add offline mode.",
      "rating": 2,
      "url": "https://example.com/review/2"
    }
  ]
}' |
apify call signalforge_labs/review-intelligence-analyzer --silent --output-dataset

```

## MCP server setup

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

```

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/skOFATZDFdQbYpPr8/builds/FhF3Rg42i2mfbMAZv/openapi.json