# App Store Review Intelligence: Sentiment & Competitor Gaps (`datasignalslab/app-store-review-intelligence`) Actor

App Store review intelligence: aspect sentiment, emerging issues and competitor comparison from Apple App Store reviews. Pay per app.

- **URL**: https://apify.com/datasignalslab/app-store-review-intelligence.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 app 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 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

## App Store Review Intelligence: Aspect Sentiment and Competitor Comparison

**Turn raw App Store reviews into product decisions.** Give one or more iOS App Store app IDs - yours and your competitors' - and get aspect-based sentiment, top complaints and praise, emerging issues, and a side-by-side competitor feature-gap comparison across countries and languages. This actor reads public App Store reviews and returns the analysis layer that product managers, ASO teams, and growth teams actually act on, not a raw review dump.

Most review tools analyze only your own app and run on $49 to $599 per month subscriptions. This is a self-serve, pay-per-use alternative that also analyzes competitors, so you see exactly where each app wins or loses on the topics users care about.

### Why this is different

Other tools dump raw reviews and leave the hard part to you. This one does the work:

- **Aspect-based sentiment, not a vague overall score.** Every review is bucketed into concrete topics (stability/crashes, performance/speed, ui/ux/design, price/billing, login/account, ads, features, support, updates, content/library) and scored per topic.
- **Competitor comparison built in.** Pass multiple app IDs and get a per-aspect table showing each app's average rating side by side. This is the gap most incumbents miss: they only let you see your own app.
- **Emerging issues, caught early.** It compares the recent half of reviews against the older half and flags any aspect whose rating has dropped by 0.7 stars or more, so a new crash or billing problem surfaces before it tanks your overall rating.
- **Language-agnostic by design.** Sentiment comes from the star rating, which is universal, so multi-country pulls work in any language with no translation model. Text is used only to detect which aspects a review is about.
- **Real customer quotes.** Each top complaint ships with a quote from the most negative matching review, plus a direct App Store link.

### Who it's for

App developers tracking their own quality, product managers prioritizing the next sprint, ASO and growth teams hunting for positioning angles, and competitive-intelligence analysts who need fast insight on apps they do not own.

### Use cases

- "Where is my app losing to a competitor?" Run your app ID alongside two rivals and read the per-aspect comparison table to find the exact topics where you trail.
- "What are users complaining about most right now?" Pull a single app and read top_complaints with quotes to feed your bug backlog and roadmap.
- "Is a recent update making things worse?" Check emerging_issues to spot aspects whose sentiment is sliding in recent reviews.
- "What should my App Store listing emphasize?" Read top_praise to learn which strengths to lead with in your ASO copy.
- "How does sentiment differ by market?" Add several country codes to compare how users in different regions rate the same app.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `appIds` | array | yes | - | One or more numeric iOS App Store app IDs (e.g. `324684580` for Spotify). Add competitors for a side-by-side comparison. |
| `countries` | array | no | `["us"]` | Two-letter App Store country codes to pull reviews from (e.g. `us`, `gb`, `nl`, `de`). Multi-country means multi-language. |
| `pagesPerCountry` | integer | no | `3` | Review pages to fetch per country (50 reviews per page, max 10). |
| `minMentions` | integer | no | `3` | Minimum times an aspect must be mentioned before it is reported (1 to 20). |

### Output

One `app_analysis` item is pushed per app, and one `comparison` item is added when you pass two or more apps.

```json
{
  "type": "app_analysis",
  "app_id": "324684580",
  "name": "Spotify - Music and Podcasts",
  "total_reviews": 300,
  "avg_rating": 4.0,
  "aspects": [
    { "aspect": "price/billing", "mentions": 41, "avg_rating": 3.71, "pct_negative": 22.0 },
    { "aspect": "ads", "mentions": 33, "avg_rating": 3.98, "pct_negative": 18.2 },
    { "aspect": "ui/ux/design", "mentions": 52, "avg_rating": 4.29, "pct_negative": 9.6 }
  ],
  "top_complaints": ["price/billing", "ads"],
  "top_praise": ["ui/ux/design", "content/library"],
  "emerging_issues": ["stability/crashes (-1.5 star recent)"],
  "examples": {
    "price/billing": "(1 stars) Premium keeps charging me after I cancelled and support never replied."
  },
  "app_store_url": "https://apps.apple.com/app/id324684580"
}
````

The `comparison` item holds `apps` (the list of app names) and `by_aspect`, a per-aspect map of each app's average rating. For example, Spotify (4.0 stars) vs YouTube Music (2.1 stars) breaks down as price/billing 3.71 vs 1.53, ads 3.98 vs 2.02, and ui/ux/design 4.29 vs 1.96, so you see which app wins on each topic.

### What it measures

- **Aspect sentiment.** Per aspect, the average star rating of matching reviews, the number of mentions, and the percentage of negative reviews (rating of 2 or below).
- **Top complaints and praise.** Aspects below the app's overall average become complaints; those at or above become praise, each capped at the five strongest.
- **Emerging issues.** Aspects whose recent-half rating dropped 0.7 stars or more versus the older half (requires at least 20 reviews and 3 mentions in each half).
- **Competitor comparison.** A per-aspect rating table across every app you submit, so feature gaps are obvious at a glance.

Sentiment is derived from the star rating attached to each review, so it is language-agnostic and works across countries without translation. The review text is used only to classify which aspects a review talks about.

### Use with AI agents and automation

This actor is built to be called as a live tool, not just run by hand.

- **AI agents and LLMs.** Wire it into LangChain or LlamaIndex, or expose it through the Apify MCP server so assistants such as Claude, ChatGPT, or Cursor can call it directly and pull fresh review intelligence mid-conversation.
- **No-code automation.** Trigger it from Zapier or Make to drop analyses into a sheet, a Slack channel, or a roadmap tool.
- **Pipelines and webhooks.** Use Apify webhooks and the API to run it on demand or on a schedule and get clean JSON, ready to feed dashboards or downstream models.

### Pricing

Pay-per-event: you are charged once per app analyzed, with no subscription. A three-app competitor comparison is three charges. You pay only for the apps you actually analyze.

### Data source and compliance

Reviews come from Apple's official App Store customer-reviews RSS feed, a public endpoint that needs no login or API key. Requests are rate-limited and respectful. The actor reads only public review content; the only personal data involved is the review author display name that Apple already shows publicly. Use the output for research and product decisions.

### FAQ

**Can an AI agent call this automatically?**
Yes. Expose it through the Apify MCP server and an assistant like Claude or ChatGPT can call it as a tool, or integrate it through LangChain or LlamaIndex in your own agent.

**How is sentiment calculated?**
From star ratings, not text. The average rating of reviews mentioning an aspect is its sentiment score, which is why the analysis works in any language with no translation step.

**Does it work for languages other than English?**
Yes. Add more country codes to pull reviews from those regions. Because sentiment is rating-based, scores stay comparable across languages, and the aspect keyword list already covers several languages.

**Can I analyze a competitor's app?**
Yes. The reviews are public, so you can submit any iOS app ID, including apps you do not own, and compare several at once.

**How many reviews does it read?**
Up to 50 reviews per page and up to 10 pages per country, so roughly 500 recent reviews per country per app, sorted most-recent first.

*Keywords: app store reviews, app review analysis, aspect sentiment, aspect-based sentiment, ASO, app store optimization, competitor comparison, competitor app analysis, review sentiment analysis, product feedback, iOS app reviews, customer sentiment, app intelligence.*

Data is provided for research and product decisions. This actor is not affiliated with or endorsed by Apple.

# Actor input Schema

## `appIds` (type: `array`):

One or more numeric iOS App Store app IDs (e.g. 324684580 for Spotify). Add competitors to get a side-by-side feature-gap comparison.

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

Two-letter App Store country codes to pull reviews from (multi-country = multi-language). E.g. us, gb, nl, de.

## `pagesPerCountry` (type: `integer`):

Review pages to fetch per country (50 reviews/page, ~max 10).

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

An aspect must be mentioned at least this many times to be reported.

## Actor input object example

```json
{
  "appIds": [
    "324684580",
    "1017492454"
  ],
  "countries": [
    "us"
  ],
  "pagesPerCountry": 3,
  "minMentions": 3
}
```

# 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 = {
    "appIds": [
        "324684580",
        "1017492454"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasignalslab/app-store-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 = {
    "appIds": [
        "324684580",
        "1017492454",
    ],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("datasignalslab/app-store-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 '{
  "appIds": [
    "324684580",
    "1017492454"
  ],
  "countries": [
    "us"
  ]
}' |
apify call datasignalslab/app-store-review-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Review Intelligence: Sentiment & Competitor Gaps",
        "description": "App Store review intelligence: aspect sentiment, emerging issues and competitor comparison from Apple App Store reviews. Pay per app.",
        "version": "0.1",
        "x-build-id": "aflA5fdOxJHDpd9Pn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasignalslab~app-store-review-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasignalslab-app-store-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/datasignalslab~app-store-review-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-datasignalslab-app-store-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/datasignalslab~app-store-review-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-datasignalslab-app-store-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": [
                    "appIds"
                ],
                "properties": {
                    "appIds": {
                        "title": "App Store app IDs",
                        "type": "array",
                        "description": "One or more numeric iOS App Store app IDs (e.g. 324684580 for Spotify). Add competitors to get a side-by-side feature-gap comparison.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "Two-letter App Store country codes to pull reviews from (multi-country = multi-language). E.g. us, gb, nl, de.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pagesPerCountry": {
                        "title": "Pages per country",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Review pages to fetch per country (50 reviews/page, ~max 10).",
                        "default": 3
                    },
                    "minMentions": {
                        "title": "Minimum mentions per aspect",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "An aspect must be mentioned at least this many times to be reported.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
