# App Store Trends & AI App-Idea Report (`flyingkiwi/app-store-trends-app-ideas`) Actor

Track Apple App Store charts in any country and category, spot rising apps, analyse recent reviews for complaints and praise, and get an AI-written report of app ideas based on unmet user needs. Uses Apple's public feeds. Pay per app and per report.

- **URL**: https://apify.com/flyingkiwi/app-store-trends-app-ideas.md
- **Developed by:** [Pete Buckthought](https://apify.com/flyingkiwi) (community)
- **Categories:** AI, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Trends & AI App-Idea Report

Find out **what's rising on the Apple App Store** in any country and category, **what users complain about** in the apps at the top, and get an **AI-written report of concrete app ideas** based on those unmet needs. Built for indie developers, product managers, app studios and investors who want ideas grounded in real chart and review data, not guesswork.

> **Data source.** Apple's public App Store RSS feeds (charts and customer reviews) and the iTunes Lookup API. No scraping of web pages, no login. This Actor is independent and **not affiliated with, endorsed or sponsored by Apple Inc.** App Store is a trademark of Apple Inc. Chart positions are Apple's own; this Actor doesn't create its own rankings.

### What does it do?

1. **Reads an App Store chart** (top free, top paid, top grossing, new free or new paid; up to 100 positions) for any of Apple's country storefronts, overall or for one category (Productivity, Health & Fitness, Finance, Games...).
2. **Tracks movement between runs.** Schedule it daily or weekly and each chart row shows `previousRank`, `rankChange` and `isNewEntry`. A simple, explainable `momentumScore` favours apps that climbed, are new to the chart, or were released in the last 90 days.
3. **Analyses the most interesting apps.** It reads their most recent reviews (up to 500 per app) and returns a recent average, star distribution, share of 1–2 star reviews, review rate, the **most common complaint and praise terms**, and a few short, **anonymised** review excerpts.
4. **Writes an app-idea report** (optional) in Markdown. An AI model writes the summary and 5–6 concrete app ideas, each with target user, the review evidence behind it, must-have features, how it could make money and the main risk. The "what users complain about", "what's rising" and caveats sections are computed directly from the data, so their numbers and quotes are real. The AI part is clearly labelled, and any quote the AI uses that doesn't match a collected review is flagged.

### Use cases

- **Indie developers:** find an underserved niche before you build.
- **Product teams:** watch competitors' ratings and complaint themes after each release.
- **App studios and agencies:** weekly market briefings per category and country.
- **Investors and analysts:** spot fast climbers and new entrants early.

### Input example

```json
{
  "country": "us",
  "chart": "top-free",
  "genre": "productivity",
  "appsToAnalyse": 8,
  "pickAppsBy": "rising",
  "reviewsPerApp": 100,
  "generateReport": true,
  "reportFocus": "ideas a solo developer could build in a month"
}
```

You can also add `appIds` (App Store IDs or app links) to analyse your own app or specific competitors alongside the chart.

### Output

- **Dataset, view "Chart & momentum":** one row per chart position, with rank movement, all-time rating and rating count, price and release date.
- **Dataset, view "App analysis":** one row per analysed app, with review statistics, complaint and praise terms, and anonymised excerpts.
- **Key-value store record `REPORT`:** the AI report as Markdown (also in the dataset as a `report` row).
- **`SUMMARY` record:** counts, timing and any reason the report was skipped.

Example app-analysis row (shortened, from a real run on the NZ Productivity chart on 27 Oct 2026):

```json
{
  "type": "app",
  "name": "Microsoft Authenticator",
  "rank": 3,
  "reviewsAnalysed": 92,
  "recentAverageRating": 1.93,
  "negativeShare": 0.739,
  "complaintTerms": [{"term": "phone", "reviews": 22}, {"term": "account", "reviews": 13}, {"term": "code", "reviews": 11}],
  "complaintExcerpts": [{"rating": 1, "title": "…", "text": "…", "version": "6.8", "date": "2026-10-20T…"}]
}
```

#### Sample report (real run, 28 Oct 2026 NZDT)

Input: `{"country": "us", "chart": "top-free", "genre": "health-fitness", "chartLimit": 50, "appsToAnalyse": 5, "reportFocus": "ideas a solo developer could build and launch in about a month"}`. Took 26 seconds. Shortened excerpt of the `REPORT` record:

> **What users complain about** *(computed from the reviews, not written by AI)*
>
> - **Planet Fitness** (#3, recent avg 1.72★ from 100 reviews, 79% negative): update (24), check (24), new (21), back (12), membership (11).
> - **Flo Cycle & Period Tracker** (#2, recent avg 2.73★ from 100 reviews, 54% negative): pay (18), free (10), money (9), subscription (8), tracking (8).
> - **Strava: Run, Bike, Walk** (#1, recent avg 3.1★ from 100 reviews, 43% negative): subscription (8), update (8), new (7), annoying (6).
>
> **App idea 1 (AI-written): "Cycle Sync Companion"**: A free, privacy-focused period tracker that offers core tracking without a subscription.
>
> - **Evidence:** Flo Cycle & Period Tracker: pay (18 reviews), free (10 reviews), money (9 reviews), subscription (8 reviews), deleted (7 reviews), paid (7 reviews), information (6 reviews).
> - **Must-haves:** Accurate cycle prediction, symptom logging, data export, no subscription for core features.
> - **Risk:** Competing with established, feature-rich (but often paid) apps.

The full report also has a summary, 4 more ideas, a "What's rising" list and caveats.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Chart app (one chart row) | $0.001 |
| App analysed (reviews + stats) | $0.02 per app |
| AI report | $0.50 per report |

**AI model usage is billed separately.** The report is written by an AI model through Apify's own OpenRouter proxy (`apify/openrouter`), which charges your Apify account the model's cost (with the default `google/gemini-2.5-flash`, about $0.01 per report on paid Apify plans in our tests; Apify charges free-plan accounts about 10 times more, roughly $0.08). A typical run (100 chart rows, 10 analysed apps, one report) costs about $0.81 plus the AI usage. A smaller run (50 chart rows, 5 analysed apps, one report) costs about $0.66. Set a maximum cost per run and the Actor stops cleanly before going over it. If the report can't be generated, you aren't charged for it.

### Good to know

- **Reviews:** Apple's feed returns at most the 500 most recent reviews per app and country, so statistics describe *recent* sentiment, not all-time ratings (use `averageRating` and `ratingCount` for those).
- **Rank changes need a previous run** for the same country, chart and category. Your first run shows `rankChange: null`; schedule the Actor to build history.
- **No downloads or revenue data:** Apple doesn't publish them, and the report says so.
- **Privacy:** reviewer names and profile links are never collected; emails, links and phone numbers are removed from review text.
- **AI report:** the AI part may contain mistakes. It only gets the data collected in the run and is told not to invent numbers; the dataset `report` row lists any `unverifiedQuotes` and whether the AI output was `truncated`.

### FAQ

**Which countries are supported?** Any App Store storefront, by its 2-letter code (us, gb, de, jp, nz, ...).

**Can I track my own app?** Yes: add it to `appIds` and schedule the Actor to see rating and complaint trends after each release.

**Can I use a different AI model?** Yes: set `aiModel` to any model ID offered through Apify's OpenRouter proxy, for example `openai/gpt-4o-mini` (cheaper, but its ideas were noticeably more generic in our tests). Output is capped at about 2,000 tokens by the proxy; if a model runs over, the report says it was cut off.

**Is it legal?** It uses Apple's public RSS feeds and Lookup API, keeps excerpts short and anonymised, and doesn't republish full review text or Apple artwork. Check that your own use follows Apple's terms and the laws that apply to you.

# Changelog

This Actor's version history is a separate document: https://apify.com/flyingkiwi/app-store-trends-app-ideas/changelog.md

# Actor input Schema

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

2-letter App Store country code, e.g. us, gb, nz, de, jp.

## `chart` (type: `string`):

Which App Store chart to read.

## `genre` (type: `string`):

App Store category. 'all' means the overall chart.

## `chartLimit` (type: `integer`):

How many chart positions to read (Apple serves up to 100).

## `appsToAnalyse` (type: `integer`):

How many apps to analyse in depth (reviews, complaints, praise). Each is charged as one 'app analysed' event.

## `pickAppsBy` (type: `string`):

'Rising' favours apps that climbed, are new to the chart, or were released recently. 'Top' takes the highest-ranked apps.

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

Optional App Store IDs or app URLs (e.g. https://apps.apple.com/us/app/notion/id1232780281) to analyse as well, such as your own app or competitors.

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

How many of the most recent reviews to read per app. Apple's feed serves up to 500.

## `generateReport` (type: `boolean`):

Write a Markdown report with rising apps, user complaints and 5-8 concrete app ideas. Needs at least 3 analysed apps. Charged as one 'report' event; the AI model usage is billed separately to your Apify account through Apify's OpenRouter proxy.

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

Any OpenRouter model ID available through Apify's OpenRouter proxy. The default is fast and cheap.

## `reportFocus` (type: `string`):

Tell the AI what you care about, e.g. 'ideas a solo developer can build in a month' or 'subscription apps for students'.

## `includeChartRows` (type: `boolean`):

Output one row per chart position with rating data and rank movement since your last run.

## Actor input object example

```json
{
  "country": "us",
  "chart": "top-free",
  "genre": "productivity",
  "chartLimit": 100,
  "appsToAnalyse": 5,
  "pickAppsBy": "rising",
  "appIds": [],
  "reviewsPerApp": 100,
  "generateReport": true,
  "aiModel": "google/gemini-2.5-flash",
  "includeChartRows": true
}
```

# Actor output Schema

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

No description

## `apps` (type: `string`):

No description

## `chart` (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 = {
    "country": "us",
    "genre": "productivity",
    "appsToAnalyse": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("flyingkiwi/app-store-trends-app-ideas").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 = {
    "country": "us",
    "genre": "productivity",
    "appsToAnalyse": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("flyingkiwi/app-store-trends-app-ideas").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 '{
  "country": "us",
  "genre": "productivity",
  "appsToAnalyse": 5
}' |
apify call flyingkiwi/app-store-trends-app-ideas --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flyingkiwi/app-store-trends-app-ideas"
        }
    }
}
```

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/zTJdhge6jIGaiMal2/builds/vPcqrgBOs67ui7cye/openapi.json