# App Review Analyzer: AI Pain Points & Insights (`jaclfruit_296/audience-radar-actor`) Actor

Analyze App Store, Google Play reviews and YouTube comments with AI. Get pain points, user questions, objections and exact wording, each linked to the original review.

- **URL**: https://apify.com/jaclfruit_296/audience-radar-actor.md
- **Developed by:** [Huy Tran](https://apify.com/jaclfruit_296) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/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

## Audience Radar: App Review & Comment Insights

Turn what real users write about a topic into a research brief you can act on.
Audience Radar reads **App Store reviews, Google Play reviews and YouTube comments**
for any topic, then uses AI to pull out:

- **Pain points**: what frustrates people, with a severity score and mention count.
- **Frequently asked questions**: what people want to know, with intent and urgency.
- **Objections**: why people hesitate, cancel or leave a 1-star review.
- **Exact wording**: phrases copied word for word, ready for ads, landing pages and App Store copy.
- **Strategy recommendation**: opportunities, answers to the top objections, and copy lines built on the audience's own words.

Every insight links back to the review or comment it came from, so you can check it yourself.

### Who it is for

- App founders and product managers checking a niche before building.
- ASO and growth teams looking for keywords and copy that match how users talk.
- Marketers and content teams who need real questions to answer.

### How to use it

1. Type a **topic**, for example `sleep meditation`, `habit tracker` or `budget app`.
2. Pick your **sources** and **country**.
3. Click **Start**. A default run reads 5 apps per store and analyses up to 120 reviews per platform.
4. Open the **Insights** table in the Output tab, or download it as CSV, Excel or JSON.
5. Open **STRATEGY.html** in the key-value store for the strategy report.

#### Already have reviews? Analyse your own data

Put the ID of any Apify dataset in **Analyse your own dataset**, for example the output of
another review or comment scraper. Audience Radar skips collection and only runs the analysis.
It finds the text field automatically (`text`, `review`, `content`, `body`, `comment`…), or you can name it.

### Input example

```json
{
  "topic": "sleep meditation",
  "sources": ["app_store", "google_play"],
  "country": "us",
  "outputLanguage": "English",
  "maxAppsPerSource": 5,
  "reviewsPerApp": 50,
  "maxReviewsPerPlatform": 120,
  "includeStrategy": true
}
```

### Output example

One row per insight:

```json
{
  "type": "pain_point",
  "insight": "Subscription feels too expensive",
  "detail": "Users like the content but cancel when the trial converts to a yearly plan.",
  "category": "",
  "score": 85,
  "frequency": 12,
  "platform": "app_store",
  "platformLabel": "App Store",
  "evidenceQuote": "Love the sleep stories but $69 a year is way too expensive…",
  "evidenceUrl": "https://apps.apple.com/us/app/id571800810?see-all=reviews",
  "evidenceSource": "Calm",
  "evidenceRating": 2,
  "topic": "sleep meditation",
  "language": "English"
}
```

`type` is one of `pain_point`, `question`, `objection`, `phrase`.
The run summary (`OUTPUT` in the key-value store) lists the apps and videos read, counts per platform,
and any source that failed.

### Pricing

You pay per event:

| Event | When it is charged |
|---|---|
| Review analysed | Each review or comment sent to the AI |
| Strategy report | Each strategy recommendation written |

Set a **maximum charge per run** and the Actor analyses only as many reviews as your limit allows.
Reviews that fail analysis are not charged.

### Data sources and limits

- **App Store**: Apple's public search and customer-review feeds. Apple returns about 500 recent reviews per app and country at most.
- **Google Play**: public Google Play pages via the open-source `google-play-scraper` library. If Google changes its pages, this source can fail; the run continues with the other sources.
- **YouTube**: YouTube Data API v3 with your own free API key. A key has a daily quota of 10,000 units, enough for roughly 80 runs.
- Insights are generated by AI from the collected text. Check the linked evidence before making important decisions.

### Privacy

The Actor only reads public reviews and comments. Collected text is used only to produce your report and is not used to train AI models.

# Actor input Schema

## `topic` (type: `string`):

What your audience talks about, for example "sleep meditation" or "habit tracker". Used to search apps and videos. Leave empty only when you analyse your own dataset.

## `sources` (type: `array`):

Where to collect reviews and comments. YouTube needs a YouTube Data API key below.

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

Two-letter country code for store search and reviews, for example us, gb, de.

## `storeLanguage` (type: `string`):

Two-letter language code for Google Play reviews, for example en, de, fr.

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

Language of the insights and strategy. The audience's exact words are always kept as written.

## `maxAppsPerSource` (type: `integer`):

How many top apps (or videos) to read for each source.

## `reviewsPerApp` (type: `integer`):

Reviews (or comments) to collect per app or video. The App Store feed returns about 500 at most.

## `maxReviewsPerPlatform` (type: `integer`):

How many reviews per platform are sent to the AI. Critical (1-3 star) reviews go first. This is what you pay for per review.

## `maxInsightsPerType` (type: `integer`):

Maximum pain points, questions, objections and phrases kept for each platform.

## `includeStrategy` (type: `boolean`):

Adds an AI strategy report (saved as STRATEGY.html in the key-value store).

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

ID of an Apify dataset with reviews or comments, for example the output of another scraper. When set, the Actor skips collection and only analyses this data.

## `datasetTextField` (type: `string`):

Field that holds the review text. Leave empty to detect it automatically (text, review, content, body, comment…).

## `maxDatasetItems` (type: `integer`):

Maximum number of rows read from your dataset. Only used when a dataset ID is set.

## `youtubeApiKey` (type: `string`):

Needed only for YouTube comments. Create one free in Google Cloud Console.

## Actor input object example

```json
{
  "topic": "sleep meditation",
  "sources": [
    "app_store",
    "google_play"
  ],
  "country": "us",
  "storeLanguage": "en",
  "outputLanguage": "English",
  "maxAppsPerSource": 5,
  "reviewsPerApp": 50,
  "maxReviewsPerPlatform": 120,
  "maxInsightsPerType": 5,
  "includeStrategy": true,
  "maxDatasetItems": 1000
}
```

# Actor output Schema

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

Pain points, questions, objections and exact phrases, each with an evidence quote and a link to the source.

## `strategy` (type: `string`):

AI strategy recommendation in HTML, built from the insights. Present when the strategy option is on.

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

Apps and videos read, items per platform, insight counts, source errors and AI usage.

# 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 = {
    "topic": "sleep meditation"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jaclfruit_296/audience-radar-actor").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 = { "topic": "sleep meditation" }

# Run the Actor and wait for it to finish
run = client.actor("jaclfruit_296/audience-radar-actor").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 '{
  "topic": "sleep meditation"
}' |
apify call jaclfruit_296/audience-radar-actor --silent --output-dataset

```

## MCP server setup

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

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/8hHPf6ZMWJiRb9SOy/builds/BaG4BHNViodg8wToz/openapi.json