# App Store Scraper + ASO Intelligence | Appalize (`appalize/appalize-app-market-intelligence`) Actor

Research apps, reviews, keywords, search ranks, charts and localization across Apple App Store storefronts. Optional Appalize market context. No API key required.

- **URL**: https://apify.com/appalize/appalize-app-market-intelligence.md
- **Developed by:** [Appalize](https://apify.com/appalize) (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 app records

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 Scraper + ASO Intelligence | Appalize

Research Apple App Store apps across 36 country storefronts. Collect app metadata, reviews, keyword suggestions, observed search positions, charts, developer portfolios and localization comparisons. No App Store Connect credentials or Appalize API key required.

### Choose an operation

| Mode | What you receive | One result |
| --- | --- | --- |
| `app-details` | Metadata, screenshots, ratings, price and text-length audit | App × country |
| `search` | App results in Apple's observed search order | Search result |
| `reviews` | Dated, rated, deduplicated public reviews | Review |
| `keyword-discovery` | Autocomplete suggestions; optional A–Z expansion | Seed × country |
| `rank-check` | Target app positions and checked depth | Keyword × country |
| `top-charts` | Top free or paid chart | Chart entry |
| `developer-apps` | Developer's public app portfolio | App × country |
| `localization-audit` | Text and screenshot comparison against first country | App × country |
| `appalize-profile` | Public Appalize catalog context | App |

### Quick start

```json
{"mode":"app-details","apps":["324684580"],"countries":["us","tr"],"maxItems":10}
```

Use numeric Apple IDs, bundle IDs or HTTPS App Store URLs. The `countries` field chooses the storefront even when an input URL contains another country. Up to 100 apps, 25 keywords and 10 countries. `platform` may be omitted; only `ios` is accepted.

```json
{"mode":"rank-check","apps":["324684580"],"keywords":["spotify","music"],"countries":["us"],"resultsPerQuery":100}
```

```json
{"mode":"reviews","apps":["324684580"],"countries":["us"],"maxReviewsPerApp":100,"minRating":1,"maxRating":2,"reviewSort":"recent"}
```

For developer portfolios use `developerIds`, for example `["324684583"]`. For charts use `chart: "top-free"` or `"top-paid"`. Localization requires at least two countries; the first is the baseline.

### Output and integrations

Results go to the default dataset, available as JSON, CSV, Excel and other Apify exports. Nested fields are best preserved with JSON. Each row includes `recordType`, `appId`, `country`, `source`, `fetchedAt`, `schemaVersion` and a stable `recordId`. `RUN-SUMMARY` records counts, partial failures and source error codes.

Call `appalize/appalize-app-market-intelligence` through the Apify API, schedules, Make, n8n or Apify's MCP integration. Pass your own Apify token through the client configuration, never inside Actor input.

### Coverage and interpretation

- Search positions retain Apple's source order; device, language, timing and personalization can change results. Missing apps have `rank: null` and a checked depth.
- Autocomplete is not measured keyword volume, difficulty or popularity.
- Reviews are a public RSS sample, limited to 10 pages / 500 per app and storefront. Historical completeness is not guaranteed.
- Top charts are limited to 100 entries. Search depth is at most 200.
- Matching localization text is a review signal; it does not prove a missing translation. In-app languages do not establish store-listing localization.
- Optional Appalize public catalog estimates have unknown observation date, market and period. These remain explicitly null and are not verified downloads or revenue. Standalone catalog mode requires `countries: ["us"]` but represents the catalog, not US performance.
- Unavailable fields remain null. Failed source requests are reported, not silently converted to empty facts.

### Cost control and reliability

`maxItems` caps emitted results across all inputs. Source retries are bounded. Processing is serial, with checkpoints and deduplication during a run; a crash between dataset publication and checkpoint persistence can still repeat a record, so consumers can deduplicate by `recordId` within that run.

Commercial event mapping is prepared for app records, reviews, keyword seeds, rank checks, localization and catalog profiles. **Use the live Pricing tab for current charges. Proposed prices in development documents are not active prices.** No external LLM or Appalize credentials are required.

### More Appalize tools

- **App Store Product Page Intelligence:** privacy labels, IAP display prices, subtitle, version history, ratings histogram and snapshot changes.
- **App Store Competitor Benchmark:** explicit app-cohort comparisons.
- **App Store Review Insights:** star distributions, version/month summaries and traceable theme mentions.

Built by [Appalize](https://appalize.com). For a reproducible issue, include the run ID and non-sensitive input in the Actor Issues tab.

# Actor input Schema

## `mode` (type: `string`):

One operation per run. See README for billing units and data limits.

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

Numeric Apple IDs, Apple bundle IDs, or HTTPS App Store URLs. Required for app details, reviews, rank check, localization and Appalize profiles.

## `keywords` (type: `array`):

Required for search, keyword discovery and rank check. Up to 25 seed keywords.

## `developerIds` (type: `array`):

Required for developer portfolios. Numeric Apple artist IDs.

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

Up to 10 storefronts. Every input is processed in each country. First country is localization baseline. Appalize profiles use \["us"] and contain catalog-level estimates.

## `language` (type: `string`):

Optional language code, such as en, tr or de. Omit to use country defaults. Do not force one language when comparing localizations.

## `maxItems` (type: `integer`):

Hard cap across all inputs and countries. A rank check or keyword seed is one result with nested data.

## `resultsPerQuery` (type: `integer`):

Search depth, keyword suggestions or developer apps per query. Top charts are capped at 100.

## `maxReviewsPerApp` (type: `integer`):

Filtered, deduplicated review limit. Public feeds may expose fewer; up to 10 pages are checked.

## `reviewSort` (type: `string`):

Most recent or most helpful reviews.

## `minRating` (type: `integer`):

Include reviews at or above this rating.

## `maxRating` (type: `integer`):

Include reviews at or below this rating.

## `since` (type: `string`):

Optional ISO timestamp, for example 2026-09-01T00:00:00Z. Reviews without dates are excluded when filtering.

## `expandKeywords` (type: `boolean`):

Keyword discovery only. Adds 26 alphabet queries per seed/country. Suggestions are deduplicated. This is autocomplete, not measured search volume.

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

Public top free or top paid chart. No grossing fallback.

## `includeAppalize` (type: `boolean`):

App details and localization only. Adds public Appalize catalog signals when available. Included in the app result price. Estimate period and country are unknown and explicitly null.

## Actor input object example

```json
{
  "mode": "app-details",
  "apps": [
    "324684580"
  ],
  "keywords": [],
  "developerIds": [],
  "countries": [
    "us"
  ],
  "maxItems": 100,
  "resultsPerQuery": 20,
  "maxReviewsPerApp": 100,
  "reviewSort": "recent",
  "minRating": 1,
  "maxRating": 5,
  "expandKeywords": false,
  "chart": "top-free",
  "includeAppalize": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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": [
        "324684580"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("appalize/appalize-app-market-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": ["324684580"] }

# Run the Actor and wait for it to finish
run = client.actor("appalize/appalize-app-market-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": [
    "324684580"
  ]
}' |
apify call appalize/appalize-app-market-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,appalize/appalize-app-market-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/hwm9h0zRHnOnMfSOZ/builds/XKkZ7nNmv8n6tkYpf/openapi.json