# iOS App Store Scraper (Free Metadata) (`transparent_locket/ios-app-store-reviews-scraper`) Actor

Free iOS App Store data scraper. Returns app metadata (name, version, rating average, rating count, icon, genres, price, release date) per iTunes app id across multiple countries. Reviews require App Store Connect API (paid by Apple).

- **URL**: https://apify.com/transparent\_locket/ios-app-store-reviews-scraper.md
- **Developed by:** [casper smartwater](https://apify.com/transparent_locket) (community)
- **Categories:** Developer tools, E-commerce, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## iOS App Store App Metadata Scraper — Free

**Track any iOS app's metadata over time.** Name, version, rating average, rating count, install indicator, icon, genres, price, release dates — across any country, all free, no Apple Developer account needed.

### ✨ Why this Actor

- **Free** — Apple's official API (App Store Connect) is paid + restricted to app owners. This Actor pulls public data anyone can see.
- **No login** — uses the public iTunes `/lookup` endpoint
- **Multi-country** — sweep US, UK, India, Brazil etc. in one run; see how the same app's ratings differ by market
- **Historical tracking** — schedule this daily and you have a time-series of rating + install evolution

### 🚀 Quick start

**Track Spotify across 5 countries:**

```json
{
  "appId": "324684580",
  "countries": ["us", "gb", "ca", "au", "in"]
}
````

**Just the US:**

```json
{
  "appId": "284882215",
  "countries": ["us"]
}
```

To find an app's iTunes ID, open the App Store URL — it's the digits after `id` (e.g. `apps.apple.com/us/app/spotify-music-and-podcasts/id324684580` → `324684580`).

### 📦 Output schema

| Field | Type | Notes |
|---|---|---|
| `_kind` | str | Always `"app_meta"` |
| `id` | str | iTunes ID (input) |
| `name` | str | App display name |
| `bundle_id` | str | iOS bundle identifier |
| `seller` | str | Developer / studio |
| `average_rating_current` | float | Current version average rating |
| `rating_count_current` | int | Current version rating count |
| `average_rating` | float | All-time average rating |
| `rating_count` | int | All-time rating count |
| `current_version` | str | e.g. `9.1.48` |
| `release_date` | iso8601 | When the app was first released |
| `current_version_release_date` | iso8601 | When the current version shipped |
| `track_view_url` | str | App Store URL |
| `icon` | str | High-res app icon URL |
| `genres` | array<str> | App Store categories |
| `price`, `currency` | float, str | |

### 🎯 Use cases

- **Competitor monitoring** — track rating + version of N competitor apps daily
- **Investor diligence** — rating velocity is a strong revenue signal; pair with Play Store data
- **Localization research** — see how the same app rates in different markets
- **Auto-detect new releases** — diff `current_version` daily; tweet when an app you watch ships an update
- **Pricing intelligence** — track app price changes across markets
- **App acquisition pipeline** — pre-filter potential targets by rating count + release date

### ⚙️ Input parameters

| Parameter | Type | Default | Notes |
|---|---|---|---|
| `appId` | str | — | **Required.** Digits-only iTunes ID |
| `countries` | array<str> | `["us","gb","ca","au","in","de","fr","jp","br","mx"]` | ISO 2-letter codes |
| `maxReviews` | int | 200 | Reserved for future. Currently metadata-only — see note below |
| `includeAppMeta` | bool | true | (Always returns app\_meta row; this is for parity with other scrapers) |

### ⚠️ Why metadata-only?

In 2025, Apple deprecated the public `customerreviews` RSS feed that previously powered free iOS review scraping. Reviews are now gated behind their amp-api which requires:

1. A bearer JWT token (rotates frequently, captured via headless browser)
2. Or the paid App Store Connect API (only available to app owners)

This Actor tracks the data that's still publicly accessible: **app metadata, rating averages, and rating counts**. Despite the constraint, this is surprisingly useful — rating velocity tracking + version diffing covers most "competitive intel" use cases without needing review text.

If you specifically need iOS review **text**, look into the App Store Connect API or commercial services. For everything else, this Actor is the free baseline.

### 🛠️ How it works

This Actor calls Apple's public iTunes Search/Lookup endpoint:

```
GET https://itunes.apple.com/lookup?id={appId}&country={cc}
```

This is the same endpoint anyone can hit via curl, returning structured JSON. No auth, no token, no rate-limit problems.

### 🔗 Related Actors

- **[Google Play Store Reviews Scraper](https://apify.com/transparent_locket/google-play-reviews-scraper)** — full review text + metadata for Android (no Apple-style restrictions)
- **[Reddit Subreddit + Search](https://apify.com/transparent_locket/reddit-subreddit-search-scraper)** — search for organic discussion of an app
- **[YouTube Channel + Video Scraper](https://apify.com/transparent_locket/youtube-channel-video-scraper)** — track video reviews of an app

### 💬 Support

If Apple re-opens the reviews API or you need a custom variant, email **caspersmartwater@gmail.com**.

⭐ Star this Actor.

# Actor input Schema

## `appId` (type: `string`):

Digits only, from the App Store URL. e.g. '333903271' for Twitter, '284882215' for Facebook. Visible in any apps.apple.com URL as 'id<digits>'.

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

ISO 2-letter country codes to sweep. Each country yields up to ~500 reviews due to Apple's hard limit.

## `maxReviews` (type: `integer`):

Cap on reviews fetched per country. Apple's amp-api typically allows up to a few thousand per country before pagination tokens expire.

## `includeAppMeta` (type: `boolean`):

Prepend an \_kind='app\_meta' row with name, version, rating average, icon, etc.

## Actor input object example

```json
{
  "countries": [
    "us",
    "gb",
    "ca",
    "au",
    "in",
    "de",
    "fr",
    "jp",
    "br",
    "mx"
  ],
  "maxReviews": 200,
  "includeAppMeta": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_locket/ios-app-store-reviews-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("transparent_locket/ios-app-store-reviews-scraper").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 '{}' |
apify call transparent_locket/ios-app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iOS App Store Scraper (Free Metadata)",
        "description": "Free iOS App Store data scraper. Returns app metadata (name, version, rating average, rating count, icon, genres, price, release date) per iTunes app id across multiple countries. Reviews require App Store Connect API (paid by Apple).",
        "version": "0.1",
        "x-build-id": "sfOUf0dNeKcFXQAUi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/transparent_locket~ios-app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-transparent_locket-ios-app-store-reviews-scraper",
                "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/transparent_locket~ios-app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-transparent_locket-ios-app-store-reviews-scraper",
                "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/transparent_locket~ios-app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-transparent_locket-ios-app-store-reviews-scraper",
                "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": [
                    "appId"
                ],
                "properties": {
                    "appId": {
                        "title": "iTunes App ID",
                        "type": "string",
                        "description": "Digits only, from the App Store URL. e.g. '333903271' for Twitter, '284882215' for Facebook. Visible in any apps.apple.com URL as 'id<digits>'."
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "ISO 2-letter country codes to sweep. Each country yields up to ~500 reviews due to Apple's hard limit.",
                        "default": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "in",
                            "de",
                            "fr",
                            "jp",
                            "br",
                            "mx"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per country",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap on reviews fetched per country. Apple's amp-api typically allows up to a few thousand per country before pagination tokens expire.",
                        "default": 200
                    },
                    "includeAppMeta": {
                        "title": "Include app metadata row",
                        "type": "boolean",
                        "description": "Prepend an _kind='app_meta' row with name, version, rating average, icon, etc.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
