# Review Insights AI – Complaints, Bugs & Feature Requests (`yck69/review-insights`) Actor

Turns customer reviews into ranked complaints, bugs, feature requests and praise, with share of reviews, trends, app versions and real quotes. Reads App Store reviews directly, and Amazon, Google Play, Google Maps or Trustpilot reviews from any scraper's dataset or a CSV.

- **URL**: https://apify.com/yck69/review-insights.md
- **Developed by:** [yck](https://apify.com/yck69) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review analyseds

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 Insights AI – Complaints, Bugs & Feature Requests

Turn hundreds or thousands of customer reviews into a **ranked list of what people complain about, what breaks, what they ask for and what they love**. Each topic shows how many reviews mention it, its average rating, whether it is rising, which app version it started in, and real quotes.

- **App Store**: reads reviews directly. Give an app link, ID or name and up to 1,000 reviews per country are fetched.
- **Amazon, Google Play, Google Maps, Trustpilot, Booking, Yelp…**: point it at the dataset of any review scraper, or connect it as an integration so every scraper run gets analysed automatically.
- **Your own data**: CSV, JSON or JSON Lines exports from a helpdesk, survey tool or shop back office, or pasted reviews.
- **Competitor benchmark**: analyse several apps or products together and compare every topic side by side ("Subscription hard to cancel: Babbel 4.7%, Duolingo 0%").
- **Shareable report**: a clean HTML page with the overview, every topic and its quotes.
- **Optional AI summaries**: short titles, a one-line summary and a suggested action per topic, plus an executive summary.

Works in English, French, German, Spanish, Italian, Portuguese and Dutch, and still groups reviews in other languages.

### What data can you get?

<table>
<tr><td>🏷️ Topic type: complaint, bug, request, praise</td><td>📝 Topic title and keywords</td><td>🔢 Reviews mentioning it</td></tr>
<tr><td>📊 Share of all reviews</td><td>⭐ Average rating</td><td>😊 Sentence sentiment</td></tr>
<tr><td>📈 Trend: rising, falling, stable</td><td>📱 First app version affected</td><td>💬 Representative quotes</td></tr>
<tr><td>🆚 Same topic at competitors</td><td>🤖 Optional AI summary and action</td><td>🧾 Shareable HTML report</td></tr>
</table>

### How to use it

1. Click **Try for free** at the top of this page.
2. Add **App Store apps** (link, ID or name), or the **dataset ID** of any review scraper (Amazon, Google Play, Google Maps, Trustpilot…).
3. Optionally add competitors, a date range and AI summaries.
4. Click **Start**.
5. Open the **REPORT** in the key-value store, or download the topics as JSON, CSV or Excel.

### Who it is for

- **App makers and product managers**: what to fix first, what users ask for, what an update broke.
- **Amazon sellers and brands**: recurring defects, sizing or quality issues, what buyers praise, so listings and products can improve.
- **Agencies and consultants**: a client-ready review audit in minutes, including competitors.
- **Local businesses and chains**: what Google Maps reviewers say about service, waiting times, prices or cleanliness.

### Input examples

**One App Store app**

```json
{ "appStoreApps": ["https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"] }
```

**Benchmark against competitors, in the US and UK stores**

```json
{ "appStoreApps": ["Duolingo", "Babbel", "Busuu"], "countries": ["us", "gb"], "maxReviews": 1000 }
```

**Only reviews of the last 60 days, with AI summaries in French**

```json
{ "appStoreApps": ["https://apps.apple.com/fr/app/sncf-connect/id343889987"], "lastDays": 60, "aiProvider": "apify", "reportLanguage": "French" }
```

**Amazon product reviews** – run any Amazon reviews scraper from Apify Store, then pass its dataset ID. Reviews are grouped per product (ASIN):

```json
{ "datasetIds": ["aBcDeFgHiJkLmNoPq"] }
```

**Google Play, Google Maps or Trustpilot reviews** – same thing with that scraper's dataset. Field names are detected automatically. If detection picks the wrong fields, map them:

```json
{ "datasetIds": ["aBcDeFgHiJkLmNoPq"], "fieldMapping": { "text": "reviewBody", "rating": "stars", "date": "reviewDate", "product": "placeName" } }
```

**Every scraper run, automatically** – in the scraper's **Integrations** tab, add "Run Actor" → Review Insights AI. Each finished scrape is analysed, no input needed.

**Your own export (CSV, JSON or JSON Lines)**

```json
{ "fileUrls": ["https://example.com/exports/reviews-2026-q3.csv"], "productName": "My shop" }
```

**Quick test with pasted reviews** (start a line with a rating to include it)

```json
{
  "reviews": [
    "2 | The app crashes every time I open my cart",
    "5 | Love the new design, checkout is much faster",
    "3 | Good prices but delivery takes too long",
    "1 | Crashes on login since the last update",
    "4 | Please add Apple Pay"
  ],
  "productName": "My shop app",
  "minMentions": 1
}
```

**AI with your own Anthropic key**

```json
{ "appStoreApps": ["Notion"], "aiProvider": "anthropic", "anthropicApiKey": "sk-ant-...", "aiModel": "claude-haiku-5-5" }
```

### Output

<p align="center"><img src="https://api.apify.com/v2/key-value-stores/zT1EJ1dwSrsWcMvrQ/records/review-insights--output.jpg" width="80%" alt="Output example"></p>

Every run also saves a shareable **REPORT** page:

One row per topic and product, ranked by the share of reviews that mention it. A real example (Babbel, compared with Duolingo, 300 reviews each, October 2026):

```json
{
    "product": "Babbel - Language Learning",
    "type": "complaint",
    "rank": 1,
    "title": "Subscription status and cancellation hidden",
    "keywords": ["subscription"],
    "mentions": 14,
    "sharePercent": 4.7,
    "avgRating": 1.5,
    "trend": { "direction": "rising", "recentSharePercent": 6.3, "previousSharePercent": 3.9, "recentFrom": "2026-09-23" },
    "versions": { "firstSeen": "22.6.0", "byVersion": [{ "version": "22.18.0", "mentions": 2, "sharePercent": 8 }] },
    "examples": [
        { "quote": "You can’t even see your subscription status in the app, much less find a way to cancel.", "rating": 2, "date": "2026-08-04T14:00:31.000Z", "version": "22.7.0" }
    ],
    "aiSummary": "Reviewers cannot see their subscription status or find how to cancel in the app, and some say they are cancelling.",
    "aiAction": "Add a visible in-app subscription page that shows plan status and has a clear cancel option.",
    "comparison": [{ "product": "Duolingo: Learn Languages", "mentions": 0, "sharePercent": 0 }]
}
```

| Field | Meaning |
|---|---|
| `type` | `complaint`, `bug` (malfunction or defect), `request` (feature request or suggestion) or `praise` |
| `title`, `keywords` | What the topic is about |
| `mentions`, `sharePercent` | Reviews mentioning the topic, and their share of all reviews of the product |
| `avgRating`, `sentiment` | Average star rating of those reviews, and the model's sentiment of the sentences themselves (1–5) |
| `trend` | Share in the last 30 days of data vs before: `rising`, `falling` or `stable` (needs 45+ days of reviews) |
| `versions` | App reviews: first version the topic appears in, and its share in each of the latest versions |
| `examples` | Up to 3 representative quotes, with the full review, rating, date and version |
| `comparison` | When several products are analysed: the same topic's share in the others |
| `aiTitle`, `aiSummary`, `aiAction` | With AI turned on |

The key-value store also holds:

- **REPORT**: the HTML report, ready to share.
- **SUMMARY**: per product, the rating distribution, average rating by month and by app version, the mix of opinions, and the AI executive summary.

### How it works

1. Each review is split into separate opinions: "Great app, but too many ads" gives one praise and one complaint.
2. A multilingual model trained on product reviews scores each opinion from 1 to 5 stars, with the review's own rating as context. Requests ("please add…", "j'aimerais…") and malfunctions ("keeps crashing", "stürzt ab") are recognised in 7 languages.
3. Opinions are turned into meaning vectors and grouped with similar ones, so "too many ads", "an ad after every lesson" and "ads everywhere" end up in one topic.
4. Each topic is labelled with its most distinctive words and its clearest short quote, then counted: share of reviews, average rating, trend and versions.
5. With AI on, a language model rewrites each topic as a short title, a summary and a suggested action, writes an executive summary and drops vague groups. Counts and quotes always come from step 4, so the AI cannot invent numbers.

The language models run inside the Actor: your reviews are not sent anywhere unless you turn on AI.

### Pricing

| Event | Price |
|---|---|
| Review analysed | $0.0005 ($0.50 per 1,000 reviews) |
| Insights report, per product | $0.02 |

Example: 1,000 App Store reviews of one app cost $0.52. Platform usage is included.

**AI summaries (optional)** are billed separately. With **Apify AI** they go on your Apify account at the model's list price on paid Apify plans: in our tests a report cost roughly $0.05 to $0.15 with the default Claude Opus 5.5, and under a cent with `anthropic/claude-haiku-5.5`. The free Apify plan pays about 10 times more. With **Anthropic** your own API key is billed by Anthropic.

### Good to know

- **App Store**: Apple's public review feed gives up to 500 most recent and 500 most helpful reviews per country. Add countries to go further, or use another source for the full history.
- **Amazon and Google Play** reviews are not fetched by this Actor: use any scraper from Apify Store and pass its dataset, or connect this Actor as its integration.
- **Speed**: about 3 minutes for 1,000 reviews (long reviews take longer). Up to 10,000 reviews per product.
- **Small samples**: topics need repeated mentions. Below about 50 reviews, expect only a few topics, or lower **Minimum mentions**.
- **Spending limit**: if you set a maximum cost per run, the most recent reviews that fit are analysed.

### More Actors from this developer

### FAQ

##### Can I use it through the API, Make, Zapier or Google Sheets?

Yes. Every run can be started and read through the [Apify API](https://docs.apify.com/api/v2) (JavaScript and Python clients, CLI, MCP), and Apify integrations connect it to Make, Zapier, n8n, Google Sheets, Slack, webhooks and more.

##### Is it legal to use this data?

The Actor only reads public or official open data and doesn't log in anywhere. Check the source's licence and your local rules (for example GDPR when data concerns people) for your use case; if in doubt, ask a lawyer.

##### Something isn't working, or you need another field?

Open an issue on the **Issues** tab: feedback is read and answered.

# Actor input Schema

## `appStoreApps` (type: `array`):

App Store links, app IDs or app names. Reads up to 500 recent and 500 most helpful reviews per country. Add competitors to compare them topic by topic.

## `countries` (type: `array`):

Two-letter store codes (us, gb, fr, de…), read in order until the maximum is reached. Empty: the country in the app link, else us.

## `datasetIds` (type: `array`):

Dataset IDs from any review scraper (Amazon, Google Play, Google Maps, Trustpilot, Booking, Yelp…). Text, rating, date, product and version fields are detected automatically.

## `fileUrls` (type: `array`):

CSV, JSON or JSON Lines files with one review per row, e.g. an export from a helpdesk, survey or e-commerce back office.

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

One review per line. Start with a rating to include it: "2 | The app crashes when I log in".

## `productName` (type: `string`):

Name used for datasets, files and pasted reviews that have no product field.

## `fieldMapping` (type: `object`):

Only if detection picks the wrong fields: {"text": "reviewBody", "rating": "stars", "date": "reviewDate", "product": "asin"}. Also: title, version, id, url, country. Dotted paths work ("rating.value").

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

The most recent reviews are kept. 1,000 reviews take about 3 minutes.

## `lastDays` (type: `integer`):

Keep reviews published in the last N days.

## `publishedAfter` (type: `string`):

Keep reviews published on or after this date.

## `maxTopicsPerType` (type: `integer`):

Most-mentioned topics kept for each type (complaints, bugs, requests, praise).

## `minMentions` (type: `integer`):

A topic needs at least this many reviews.

## `aiProvider` (type: `string`):

Optional: an AI model turns each topic into a short title, a one-line summary and a suggested action, writes an executive summary and drops vague topics. Counts and quotes always come from the analysis.<br><b>Apify AI</b>: billed to your Apify account at the model's list price on paid plans (about 10 times more on the free plan). With the default Claude Opus 5.5 a report costs roughly $0.05 to $0.15; with anthropic/claude-haiku-5.5 under a cent.<br><b>Anthropic</b>: your own API key, billed by Anthropic.

## `anthropicApiKey` (type: `string`):

Used only with the Anthropic option.

## `aiModel` (type: `string`):

Default: Claude Opus 5.5 (anthropic/claude-opus-5.5 with Apify AI, claude-opus-5-5 with your key). Claude Haiku 5.5 (anthropic/claude-haiku-5.5 or claude-haiku-5-5) costs far less. With Apify AI, any OpenRouter model ID works.

## `reportLanguage` (type: `string`):

Quotes stay in their original language.

## Actor input object example

```json
{
  "appStoreApps": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "maxReviews": 300,
  "maxTopicsPerType": 10,
  "minMentions": 2,
  "aiProvider": "none",
  "reportLanguage": "English"
}
```

# Actor output Schema

## `report` (type: `string`):

Shareable HTML report.

## `insights` (type: `string`):

One row per topic and product.

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

Overview per product: ratings, months, versions, AI summary.

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

Every field, with quotes and version breakdowns.

# 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 = {
    "appStoreApps": [
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
    ],
    "maxReviews": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("yck69/review-insights").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 = {
    "appStoreApps": ["https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"],
    "maxReviews": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("yck69/review-insights").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 '{
  "appStoreApps": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "maxReviews": 300
}' |
apify call yck69/review-insights --silent --output-dataset

```

## MCP server setup

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

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/83agyUU9EUHhLn0Qf/builds/pWEr2k1tZG5hfA0lC/openapi.json
