# App Store Review Analyzer: Feature Roadmap (`technicaldost/app-review-feature-roadmap`) Actor

Collect public Apple App Store review feeds or import reviews, then group feature requests, usability complaints and recurring issues into an evidence-linked roadmap research report.

- **URL**: https://apify.com/technicaldost/app-review-feature-roadmap.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** AI, Social media
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$250.00 / 1,000 evidence reports

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

## App Store Review Feature Roadmap

Prioritize recurring review complaints and feature requests before a product-planning session. Each finding retains evidence, review counts and transparent heuristic priority factors.

### Import a ready-to-run workflow

Use the tested starter inputs in [n8n JSON](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/apple-review-roadmap.n8n.json?attachment=true) or the [Make blueprint](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/apple-review-roadmap.make.json?attachment=true). [Setup instructions](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/README.md?attachment=true) explain import, credentials, output fields and recovery. [Download both platforms as a ZIP](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/integration-workflows.zip?attachment=true).

Select your own Apify credential after importing and run manually first. The templates set a $1 maximum run budget, check run success and preserve useful output. The $1 setting is a ceiling, not a fixed charge. Source availability and provider execution limits still apply. No recurring schedule or external destination is enabled by these files.

### First run

**Live sample: $0.25 per completed report.** Replace the example Apple app ID with your app’s numeric ID, choose its storefront, and run. Leaving the example selected fetches real public reviews for app ID 310633997. The demo checkbox does not make this live sample free.

```json
{
  "demoMode": false,
  "sourceType": "app-store",
  "appIds": [
    "310633997"
  ],
  "country": "us",
  "maxPages": 1,
  "maxRecords": 40
}
```

Native collection is limited to public Apple App Store customer-review feeds. Feed coverage varies by app and storefront.

### Analyze your own data

Use a numeric Apple App Store app ID and storefront country, or import app reviews. Public Apple review feeds provide a bounded sample; complete historical coverage and Google Play are not supported.

For an existing dataset, select it with the dataset picker in the input form. The API equivalent is below; replace the placeholder before running:

```json
{
  "demoMode": false,
  "sourceType": "dataset",
  "datasetIds": [
    "YOUR_APP_REVIEW_DATASET_ID"
  ],
  "maxRecords": 1000,
  "maxInsights": 20
}
```

You can instead paste objects into `records`. Each record should contain `text` and its original `sourceUrl`; optional fields include `id`, `platform`, `brand`, `location`, `rating`, `date`, `likes` and `title`. Supplied sources override synthetic demo mode. Dataset reads do not rerun the collector. Any separate upstream collection workflow is outside this report price.

### What comes back

One report row in the default dataset contains an `insights` array, analyzed-record count and finding count. The output links also provide `REPORT.md` and `REPORT.json` in the key-value store. Use JSON to preserve nested evidence; use the Markdown report for review.

Each roadmap finding includes evidence, request examples and priority factors such as sample reach, low ratings and matched severity phrases. Acceptance checklists are research templates, not validated product requirements.

### Record limits and sample comparison

`maxRecords` caps raw current records examined at 1–1,000 before deduplication and filtering. `maxInsights` caps findings at 1–30. A small or unmatched batch can return fewer findings, including zero. The fee is per delivered report, not per finding.

Supply `previousDatasetId` to compare the current batch with earlier raw review records. This describes differences between supplied samples, not a verified chronological trend. Do not pass a dataset containing completed reports.

### Pricing

**$0.25 per delivered report**, covering at most 1,000 current raw records. This includes analysis of inline records, existing datasets or native Apple reviews. The actor uses one `report-delivered` event and no additional dataset-row event. See the Pricing tab for the current platform price.

Synthetic previews on the imported-data workflows have no report-event fee. The App Store live sample uses actual reviews and the normal $0.25 report price.

### Method and recurring use

Analysis uses deterministic English phrase/rating rules and text grouping; no generative AI model is called. Scores and draft actions are research aids. Sarcasm, negation, uncommon phrasing and multilingual text can be misclassified. Inspect supporting evidence before acting. Topics can overlap, so their percentages must not be added together. Samples do not establish market-wide demand, product capabilities or future business results.

Use the Actor API or Apify MCP with the same input schema. Imported datasets are snapshots; provide fresh source data for repeated analysis. This actor does not directly scrape YouTube, Reddit or Google Maps or start third-party collectors. No external model key is required.

### Local run

Requires Node.js 22 or newer. Run `npm ci`, then `npm start`. The Dockerfile uses `apify/actor-node:22`.

# Actor input Schema

## `demoMode` (type: `boolean`):

This App Store workflow uses live Apple reviews when no data source is supplied. That live sample costs $0.25 per completed report, even when this checkbox is enabled. Replace the example app ID with your own.

## `records` (type: `array`):

Use a numeric Apple App Store app ID and storefront country, or import app reviews. Public Apple review feeds provide a bounded sample; complete historical coverage and Google Play are not supported. Supported optional fields include id, date, rating and likes.

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

Select your existing source dataset from the picker. It is read with READ permission; its collector is not rerun.

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

Choose Apple App Store public reviews for native feeds, or imported datasets/records for your existing reviews. Live and imported reports cost $0.25 each.

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

Numeric Apple App Store app IDs, as strings. Uses public customer-review feeds; feed availability and historical coverage vary by app and storefront.

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

Two-letter Apple storefront country code. Only used for app-store collection; analysis rules are optimized for English text.

## `maxPages` (type: `integer`):

Maximum review-feed pages requested per app; the source can return fewer pages. The overall record cap still applies.

## `maxRecords` (type: `integer`):

Maximum raw source records read/examined across this run, before deduplication and filtering. Launch limit is 1,000. This is not a guarantee of 1,000 unique reviews or insights.

## `maxInsights` (type: `integer`):

Upper limit on ranked findings inside the single report. Results can be fewer when the supplied evidence does not support additional findings.

## `brand` (type: `string`):

Optional label for the business/product under study. For competitor comparison, provide a brand on each record to preserve distinct groups; service records can also provide location.

## `previousDatasetId` (type: `string`):

Optional prior raw review dataset for the App Roadmap sample comparison. Results compare supplied samples, not a verified time trend. Do not select a completed-report dataset.

## Actor input object example

```json
{
  "demoMode": true,
  "sourceType": "app-store",
  "appIds": [
    "310633997"
  ],
  "country": "us",
  "maxPages": 2,
  "maxRecords": 1000,
  "maxInsights": 20
}
```

# Actor output Schema

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

No description

## `markdown` (type: `string`):

No description

## `dataset` (type: `string`):

No description

# 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": [
        "310633997"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/app-review-feature-roadmap").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": ["310633997"] }

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/app-review-feature-roadmap").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 '{
  "appIds": [
    "310633997"
  ]
}' |
apify call technicaldost/app-review-feature-roadmap --silent --output-dataset

```

## MCP server setup

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

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/AH4m44VTv1oQTdoWe/builds/gzrv2mWEkn3RyQaTZ/openapi.json