# App Review Intelligence (`crashlattice57/app-review-intelligence`) Actor

Turn App Store reviews into intelligence: rating trends, which app version tanked your score, and AI-mined themes (top complaints, praises, feature requests) with competitor head-to-head.

- **URL**: https://apify.com/crashlattice57/app-review-intelligence.md
- **Developed by:** [MooreIQ](https://apify.com/crashlattice57) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 review analyzeds

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/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## App Review Intelligence

App Review Intelligence is an app store review analyzer that turns recent Apple App Store reviews into actionable app review insights, including rating trends, version impact, AI-mined themes, and competitor comparisons.

### What it does

Enter an app name, App Store URL, or numeric ID. The actor pulls recent reviews from Apple's free feed, calculates deterministic rating metrics, and optionally uses AI to group review language into concrete complaints, praises, feature requests, and bugs.

Use the report to answer questions such as:

- Is the app's recent rating improving or declining compared with its lifetime rating?
- Which released version had the worst rating impact?
- What do users repeatedly love, hate, or ask for?
- How does the app compare with a competitor?

### Who it's for

- Mobile app product and engineering teams
- Product managers and user research teams
- App Store Optimization agencies
- Indie developers and app founders
- Competitive intelligence and market research teams

### What you get

Each run produces:

- An app summary with the app identity, lifetime rating, recent rating, and rating velocity trend
- The worst-performing app version based on review ratings
- Mined complaints, praises, feature requests, and bugs, each with a count and example quote
- One row per analyzed review for filtering or downstream analysis
- One row per identified theme for prioritization and reporting
- A head-to-head comparison when a competitor app is supplied

### How the AI theme mining works

1. **Pull recent reviews.** The actor retrieves recent reviews from Apple's free review feed for the selected country.
2. **Calculate rating evidence.** Deterministic analysis produces the rating distribution, month-over-month rating velocity, and rating impact by app version.
3. **Cluster specific review themes.** AI groups recurring language into complaints, praises, feature requests, and bugs, then returns a count and representative quote for each theme. Themes stay specific, such as “too many ads between songs,” rather than broad labels such as “advertising.”
4. **Connect feedback to decisions.** The report combines theme counts with version impact and, when requested, a competitor head-to-head so teams can see what changed and where the competitor gap is largest.

For example, verified Spotify themes included “too many ads between songs,” “downloaded music won't play offline,” and “add Apple payment support.”

### Inputs

| Field | What it does | Default |
| --- | --- | --- |
| `app` | Required. App name, Apple App Store URL, or numeric App Store ID to analyze. | Required |
| `maxReviews` | Maximum number of recent reviews to pull and analyze, from 20 to 500. | `200` |
| `mineThemes` | Uses AI to cluster reviews into complaints, praises, feature requests, and bugs. | `true` |
| `country` | Two-letter App Store country code used to select the regional review feed. | `us` |
| `store` | Review source. The current supported value is the Apple App Store. | `apple` |
| `competitorApp` | Optional app name, App Store URL, or ID for a head-to-head comparison. | Empty |

### Pricing

App Review Intelligence uses pay-per-event pricing. There is no monthly subscription.

| Event | Price | When it is charged |
| --- | ---: | --- |
| Actor start | $0.00005 | Once when a run starts |
| `review-analyzed` | $0.001 per review | For each review analyzed. This is the primary usage event. |
| `app-report` | $0.75 per app | For each app report produced |

A typical one-app run costs under $1. For example, analyze 1 app with 200 reviews ≈ $0.20 + $0.75 = ~$0.95, plus the negligible actor-start event. Because the review data source is free, you pay for the analysis you use rather than a recurring AppFollow or Appbot subscription.

### Example

Input:

```json
{"app":"Notion","maxReviews":200}
````

Illustrative review output row:

```json
{
  "type": "review",
  "app": "Notion",
  "rating": 2,
  "version": "4.19.0",
  "title": "Search is slower after the update",
  "date": "2026-07-12",
  "author": "sample-user",
  "themeCategory": "complaints",
  "theme": "search became slower after the update"
}
```

The dataset also includes summary and theme rows with recent versus lifetime rating, rating velocity, worst version, theme counts, example quotes, and competitor findings when requested.

### FAQ

#### Which app stores are supported?

The actor currently analyzes the Apple App Store. Set `store` to `apple`.

#### How many reviews can I analyze?

Choose between 20 and 500 recent reviews per app with `maxReviews`. The default is 200.

#### Is the review data official and legal to use?

Reviews are pulled from Apple's free public review feed. You are responsible for using the resulting data in accordance with Apple's terms and the laws that apply to your use case.

#### How are themes generated?

When `mineThemes` is enabled and AI access is configured, the actor clusters recurring review language into complaints, praises, feature requests, and bugs. Each theme includes a count and an example quote. If AI access is unavailable, deterministic rating metrics still run and theme mining is skipped.

#### Can I compare two apps?

Yes. Provide `competitorApp` as an app name, App Store URL, or ID to request a head-to-head view of rating trends, version impact, and theme gaps.

#### Which countries are available?

Use the `country` input with a two-letter App Store country code, such as `us`, `gb`, `ca`, or `au`. Availability depends on the app and reviews present in Apple's regional feed.

# Actor input Schema

## `app` (type: `string`):

App to analyze, for example Notion, https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281, or 1232780281.

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

How many recent reviews to pull and analyze.

## `mineThemes` (type: `boolean`):

Use AI to cluster reviews into complaints, praises, and feature requests — added in a later version.

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

Two-letter App Store country code.

## `store` (type: `string`):

Review source; more stores will be added later.

## `competitorApp` (type: `string`):

Optional second app for a head-to-head comparison, added later.

## Actor input object example

```json
{
  "app": "Notion",
  "maxReviews": 50,
  "mineThemes": true,
  "country": "us",
  "store": "apple",
  "competitorApp": ""
}
```

# Actor output Schema

## `reviews` (type: `string`):

Analyzed reviews, mined themes, and the summary

# 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 = {
    "app": "Notion",
    "maxReviews": 50,
    "mineThemes": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("crashlattice57/app-review-intelligence").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 = {
    "app": "Notion",
    "maxReviews": 50,
    "mineThemes": False,
}

# Run the Actor and wait for it to finish
run = client.actor("crashlattice57/app-review-intelligence").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 '{
  "app": "Notion",
  "maxReviews": 50,
  "mineThemes": false
}' |
apify call crashlattice57/app-review-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Review Intelligence",
        "description": "Turn App Store reviews into intelligence: rating trends, which app version tanked your score, and AI-mined themes (top complaints, praises, feature requests) with competitor head-to-head.",
        "version": "0.0",
        "x-build-id": "VJ3y56YClEoy6yRoN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crashlattice57~app-review-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crashlattice57-app-review-intelligence",
                "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/crashlattice57~app-review-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-crashlattice57-app-review-intelligence",
                "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/crashlattice57~app-review-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-crashlattice57-app-review-intelligence",
                "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",
                "required": [
                    "app"
                ],
                "properties": {
                    "app": {
                        "title": "App name, App Store URL, or ID",
                        "type": "string",
                        "description": "App to analyze, for example Notion, https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281, or 1232780281."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 20,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many recent reviews to pull and analyze.",
                        "default": 200
                    },
                    "mineThemes": {
                        "title": "Mine themes",
                        "type": "boolean",
                        "description": "Use AI to cluster reviews into complaints, praises, and feature requests — added in a later version.",
                        "default": true
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter App Store country code.",
                        "default": "us"
                    },
                    "store": {
                        "title": "Review source",
                        "enum": [
                            "apple"
                        ],
                        "type": "string",
                        "description": "Review source; more stores will be added later.",
                        "default": "apple"
                    },
                    "competitorApp": {
                        "title": "Competitor app",
                        "type": "string",
                        "description": "Optional second app for a head-to-head comparison, added later.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```