# App Store Intelligence (`hllerdgn80/app-store-intelligence`) Actor

Track any iOS App Store app's rating, price, version, release notes and chart rank over time, or search the Store by keyword. Uses only Apple's own public JSON endpoints (iTunes Lookup/Search API + Marketing Tools chart feed) — no login, no scraping.

- **URL**: https://apify.com/hllerdgn80/app-store-intelligence.md
- **Developed by:** [Halil Erdogan](https://apify.com/hllerdgn80) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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 Intelligence - iOS app rating, price and rank tracker

Track any iPhone/iPad app's App Store rating, price, version history and
chart position — or search the Store by keyword and pull back every match
with its numbers in one table. Built for indie developers watching their own
app, marketers scouting a category before they build, and ASO people who
need a competitor's rating and price without opening the App Store by hand.

### What it does

Give it a list of apps — a numeric App Store ID, a bundle ID
(`com.spotify.client`), or a plain `apps.apple.com` link — and for each one
it returns:

- current average rating and total rating count
- price (and currency), whether it changed since your last run if you keep
  re-running this Actor and comparing datasets
- current version number, the date that version was released, and its
  release notes (what the developer says changed)
- category, supported languages, minimum iOS version, screenshot count
- optionally, the app's exact position in Apple's own public Top Free / Top
  Paid / Top Grossing chart, overall or inside one category

Or skip the app list and use **keyword search** instead: give it a search
term like `"budget planner"` and it returns every matching app in the Store
with the same numbers, so you can see the whole competitive field at once —
who is #1, what they charge, how many ratings they have.

### Why this and not the App Store website

The App Store app and website show you one app's page at a time, with no
export button. Checking ten competitors' ratings by hand means ten browser
tabs. This Actor turns that into one CSV/JSON table you can open in a
spreadsheet, or a scheduled run in Apify that emails you a diff every week.

### How to track a competitor's app over time

1. Find the app's numeric ID: open its App Store link, e.g.
   `https://apps.apple.com/us/app/spotify/id324684580` — the ID is the
   digits after `id`.
2. Put that ID (or several, one per line) in **Apps**.
3. Run the Actor once now, and again next week (manually, or on an Apify
   schedule). Compare the two datasets — the field that usually moves first
   is `rating_count_all` (more reviews coming in) and `version` /
   `current_version_release_date` (a new release shipped).
4. Turn on **Also check chart rank** if the app you're watching is popular
   enough to be in a Top 100 overall chart; it adds the app's exact chart
   position to the row, at no extra charge.

### How to scout a whole category before you build

1. Leave **Apps** empty.
2. Put your idea's keyword in **Search by keyword**, e.g. `"habit tracker"`.
3. Run it. The result is one row with a `results` list: every matching app,
   its price, rating and rating count. Sort that list in a spreadsheet by
   `rating_count_all` — the apps at the top are your real competition; the
   ones with very few ratings and old versions are the gap you might fill.

### Sample output

A single app lookup (`apps: ["284882215"]`, `country: "us"`):

```json
{
  "input": "284882215",
  "status": "ok",
  "app_id": 284882215,
  "bundle_id": "com.facebook.Facebook",
  "name": "Facebook",
  "developer": "Meta Platforms, Inc.",
  "category": "Social Networking",
  "price": "free",
  "rating_avg_all": 4.4,
  "rating_count_all": 15234981,
  "version": "500.0",
  "current_version_release_date": "2026-09-20T07:00:00Z",
  "release_notes": "Bug fixes and performance improvements.",
  "minimum_os_version": "15.0",
  "languages": ["EN", "ES", "FR"],
  "app_store_url": "https://apps.apple.com/us/app/facebook/id284882215",
  "country": "us",
  "fetched_at": "2026-09-27T10:00:00+00:00",
  "error": null
}
```

With `trackChartRank: true`, each row gets a `chart_rank` object:

```json
"chart_rank": {
  "status": "ok",
  "chart": "top-free",
  "country": "us",
  "chart_size_checked": 100,
  "rank": 4,
  "in_chart": true
}
```

A keyword search (`searchTerm: "habit tracker"`) returns one row with a
`results` array of matching apps, each shaped like the object above.

### Input fields

| Field | What it does |
|---|---|
| `apps` | One App Store ID, bundle ID or link per line. |
| `appsText` | Paste a bigger list at once (comma/semicolon/newline separated). |
| `searchTerm` | If set, ignores `apps` and searches the Store by keyword instead. |
| `searchLimit` | How many apps a keyword search returns (max 200). |
| `country` | App Store storefront, e.g. `us`, `gb`, `tr`, `de`. Prices and chart rank are per-country. |
| `trackChartRank` | Also look up the app's position in Apple's public overall chart feed. |
| `chart` | `top-free`, `top-paid` or `top-grossing`. |
| `chartLimit` | How deep into the overall chart to search (max 100 — see FAQ). |
| `maxConcurrency` | How many apps are checked at once. |

### FAQ

**Is this legal / does it break Apple's rules?**
Yes — it only calls two of Apple's own public JSON endpoints that anyone's
browser or app already calls: the iTunes Search/Lookup API
(`itunes.apple.com/lookup`, `itunes.apple.com/search`) and Apple's official
Marketing Tools chart feed (`rss.applemarketingtools.com`). Both are
documented by Apple, need no API key, no login and no App Store scraping —
this Actor never opens the App Store app or website itself.

**Can I filter the chart to one category (Games, Finance, …)?**
Not in this version. Apple's public chart feed does publish per-category
charts on its own website, but every per-category URL pattern we tried
against the feed returned 404 on 27.09.2026 — so rather than ship a
feature that silently returns the wrong (overall) chart, this Actor only
offers the overall chart and says so plainly. It may be added once a
working category path is confirmed.

**Why is `rank` empty even though `trackChartRank` is on?**
The app is simply outside the chart size you checked (`chartLimit`, max
100 — Apple's own public feed becomes unreliable past that size in live
testing). Most apps are not in a Top 100 overall chart; that's normal, not
an error.

**Can I get review text, not just the rating number?**
No — the public Lookup API returns the rating average and count, not
individual review text. Getting review text would need the customer
reviews RSS feed per app, which this Actor does not call in this version;
it may be added as a separate, clearly priced feature later.

**Does a free app cost anything to check?**
The event `app-checked` is charged once per app row that was actually
found (`status: "ok"`) — regardless of whether the app itself is free or
paid in the Store. Rows that error, aren't found, or are invalid input are
never charged.

**What happens with a bad or removed app ID?**
The row comes back with `status: "not_found"` and an `error` message, and
is not charged.

**Can I check the same app in several countries at once?**
Run the Actor once per country (App Store data — price, availability,
chart rank — is different per storefront), or run several jobs in
parallel with different `country` values.

### Related Actors

- **Tech Stack Detector** — see the CMS, JavaScript framework and analytics
  behind any website's homepage, from the same account (`hllerdgn80`).

# Actor input Schema

## `apps` (type: `array`):

One per line: a numeric App Store ID (e.g. 284882215), a bundle ID (e.g. com.facebook.Facebook), or a full apps.apple.com link. Duplicates are removed.

## `appsText` (type: `string`):

Paste many apps at once: one per line (commas, semicolons and tabs also separate entries). Combined with the list above.

## `searchTerm` (type: `string`):

If set, the Actor ignores the app list above and instead searches the Store for this keyword (e.g. 'budget planner'), returning the matching apps as one row. Leave empty to look up the apps list instead.

## `searchLimit` (type: `integer`):

Only used with 'search by keyword'.

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

Two-letter App Store storefront country code, e.g. us, gb, tr, de. Prices, availability and chart rank are per-country.

## `trackChartRank` (type: `boolean`):

For each app found, also checks Apple's official public chart feed (Marketing Tools) and reports its rank if it appears there. Adds one extra request per app; does not add to the charged event.

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

Only used when 'Also check chart rank' is on.

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

How many top positions of the overall chart to search for the app. Apple's public feed becomes unreliable above 100, so this Actor caps it at 100.

## `maxConcurrency` (type: `integer`):

How many apps to look up in parallel.

## Actor input object example

```json
{
  "apps": [
    "284882215",
    "310633997",
    "com.spotify.client"
  ],
  "searchLimit": 20,
  "country": "us",
  "trackChartRank": false,
  "chart": "top-free",
  "chartLimit": 100,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (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 = {
    "apps": [
        "284882215",
        "310633997",
        "com.spotify.client"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hllerdgn80/app-store-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 = { "apps": [
        "284882215",
        "310633997",
        "com.spotify.client",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("hllerdgn80/app-store-intelligence").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 '{
  "apps": [
    "284882215",
    "310633997",
    "com.spotify.client"
  ]
}' |
apify call hllerdgn80/app-store-intelligence --silent --output-dataset

```

## MCP server setup

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

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/SPassdfrnLKgViaZC/builds/dkxrnvyLiIEw2gvn7/openapi.json