# Apple App Store Scraper — $0.10/1K Apps (`monkey.d.scraping/app-store-price-version-snapshots`) Actor

Check Apple App Store prices, versions, ratings and release notes from app IDs or URLs. US/UK snapshots for ASO and competitor monitoring. JSON/CSV. $0.10/1,000 complete apps + $0.0003/run; platform usage during the run included.

- **URL**: https://apify.com/monkey.d.scraping/app-store-price-version-snapshots.md
- **Developed by:** [Monkey D. Scraping](https://apify.com/monkey.d.scraping) (community)
- **Categories:** Developer tools, E-commerce
- **Stats:** 1 total users, 1 monthly users, 20.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 app snapshots

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

## Apple App Store Scraper — Prices, Versions & Ratings

This Actor is not affiliated with Apple. Get Apple App Store prices, versions, ratings and release notes from a list of app IDs or URLs. Choose the US or UK storefront and export one snapshot per checked app as JSON or CSV. Built for ASO analysts, app publishers and developers monitoring a known competitor list.

**$0.10 per 1,000 complete app snapshots + $0.0003 per run. Platform usage during the run is included.** For example, 100 complete app rows in one run total $0.0103 before any post-run dataset or storage operations.

Pricing examples below describe the configured event tariff. Publisher-run event counts have been verified; a paid external customer invoice has not yet been verified.

- **Check app prices:** collect `price` and `currency` for the selected storefront. A free app returns numeric `0`.
- **Track app releases:** save `version`, `versionReleasedAt` and `releaseNotes` for comparison with your previous snapshots.
- **Follow app ratings:** collect `rating` and `ratingCount` for your ASO competitor list.

No Apple login, supplied cookies or proxy setup is required. Data comes from Apple's public app lookup. Coverage is US and UK; the Actor checks the IDs you provide. It does not collect written reviews, keyword rankings, downloads or subscription prices.

[Quick start](#quick-start) · [Example inputs](#example-inputs) · [Pricing](#pricing) · [Output](#output-and-exports) · [Use cases](#use-cases) · [FAQ](#faq)

### Quick start

1. Paste numeric IDs or HTTPS App Store app URLs into **App IDs or URLs**, one per line. The sample already contains Spotify, ChatGPT and Procreate.
2. Choose **App Store country**: United States (USD) or United Kingdom (GBP).
3. Set **Maximum apps to check**, start the run, then inspect the output and coverage summary.

| Input | What to enter | Default |
| --- | --- | --- |
| `apps` — App IDs or URLs | Numeric Apple app IDs or `https://apps.apple.com/.../id...` URLs | Three sample apps |
| `country` — App Store country | `us` for United States, `gb` for United Kingdom | `us` |
| `maxItems` — Maximum apps to check | Selected input entries to check, from 1 to 500 | 20 |

The selected country overrides the country in an app URL. Duplicate valid IDs are checked once. Budget, source and work limits can stop a run before the selected maximum.

```json
{
  "apps": ["324684580", "6448311069", "https://apps.apple.com/us/app/procreate/id425073498"],
  "country": "us",
  "maxItems": 20
}
```

The sample above checks three apps, even though the maximum is 20. Three complete snapshots cost $0.00060 including one start. A controlled test from a separate customer account on 19 October 2026 confirmed this exact event total.

### Example inputs

| Example | Apps | Country | What to inspect |
| --- | --- | --- | --- |
| [Price and version check](#quick-start) | The three apps above | US | Price, USD currency, version and rating |
| [Paid and free app comparison](#compare-paid-and-free-apps-in-the-uk) | `425073498`, `6448311069` | UK (`gb`) | GBP price and storefront availability |
| [Another storefront](#check-a-us-app-url-in-the-uk-storefront) | A US Procreate URL | UK (`gb`) | Country follows the selected input field |

All three inputs have passed private owner checks. For a ready-to-run three-app example, use these public tasks:

| Public task | Storefront | Complete-result total |
| --- | --- | --- |
| [Check US App Store Prices, Versions and Ratings](https://apify.com/monkey.d.scraping/app-store-price-version-snapshots/examples/check-app-prices-versions-us) | US, USD | $0.0006 including startup |
| [Check UK App Store Prices, Versions and Ratings](https://apify.com/monkey.d.scraping/app-store-price-version-snapshots/examples/check-app-prices-versions-gb) | UK, GBP | $0.0006 including startup |

Each task checks Spotify, ChatGPT and Procreate with a $0.001 spending cap. Prices describe app downloads, excluding subscriptions and in-app purchases. Save exports from separate runs and compare price, currency and version to identify changes; automatic change alerts are not included.

#### Compare paid and free apps in the UK

```json
{"apps":["425073498","6448311069"],"country":"gb","maxItems":2}
```

The private check on 14 October 2026 returned two complete rows: Procreate at GBP 12.99 and ChatGPT at GBP 0. Prices can change. Full-result configured tariff: $0.00050 including one start.

#### Check a US app URL in the UK storefront

```json
{"apps":["https://apps.apple.com/us/app/procreate/id425073498"],"country":"gb","maxItems":1}
```

The selected `gb` country requests the UK price even though the pasted URL contains `/us/`. This example passed a private owner check. Full-result configured tariff: $0.00040 including one start.

### Pricing

**$0.10 per 1,000 complete app snapshots + $0.0003 per run. Platform usage during the run is included.** One `app` event costs $0.00010 and is recorded after a complete `ok` app row is saved. A missing, incomplete, invalid, blocked or error row has no app event. Duplicate IDs do not acquire another app event. The platform start charge still applies to runs that return no complete apps.

| Complete app rows in one run | Result events | Start charge | Total USD |
| ---: | ---: | ---: | ---: |
| 0 | $0.00000 | $0.00030 | $0.00030 |
| 1 | $0.00010 | $0.00030 | $0.00040 |
| 3 | $0.00030 | $0.00030 | $0.00060 |
| 20 | $0.00200 | $0.00030 | $0.00230 |
| 100 | $0.01000 | $0.00030 | $0.01030 |
| 500 | $0.05000 | $0.00030 | $0.05030 |

The start fee is the same at both supported memory sizes, 128 and 256 MB.

The minimum selectable spending cap is $0.00040; it is a budget limit, not a minimum bill. The Actor has a configured $0.02 preset, which permits at most 197 complete apps with one start when applied. For API calls, explicitly pass `maxTotalChargeUsd=0.02` (or another sufficient positive cap); omitting it can make Apify use an account-based limit instead of this preset. A 500-input form limit does not imply that 500 results fit that budget. Split lists across runs only when needed: each run adds another start charge, and runs must be sequential to respect source limits. A single app may cost less with a competitor whose start price is lower. No cheapest or speed-superiority claim is made.

A controlled test from a separate customer account on 19 October 2026 confirmed one $0.0003 start and three app events totaling $0.0003. This validates billing for that sample; it is not evidence of independent customer adoption.

After a run finishes, dataset reads, downloads/exports and other storage operations can incur Apify's standard platform charges. They are separate from the run-event totals above. See [Apify's post-run storage costs](https://docs.apify.com/actors/running/actors-in-store#pricing-models).

### Output and exports

One row describes one checked app in the selected storefront at extraction time. Missing scalar fields remain `null`; missing array fields are empty arrays. Zero price and zero rating count remain zero. Original text is preserved without translation or AI.

| Data | Fields |
| --- | --- |
| Identity and developer | `appId`, `appUrl`, `name`, `bundleId`, `developer`, `developerUrl` |
| Storefront price | `country`, `price`, `currency`, `formattedPrice` |
| Releases | `version`, `versionReleasedAt`, `releasedAt`, `releaseNotes` |
| Ratings | `rating`, `ratingCount`, `currentVersionRating`, `currentVersionRatingCount` |
| App metadata | `description`, `genres`, `primaryGenre`, `minimumOsVersion`, `fileSizeBytes`, `languages`, `supportedDevices` |
| Media URLs only | `iconUrl`, `screenshotUrls` |
| Quality and provenance | `status`, `errorCode`, `sourceUrl`, `scrapedAt` |

The **Compact CSV** overview has 31 fixed columns. Four arrays use lossless JSON text in a single cell each (`genresJson`, `languagesJson`, `supportedDevicesJson`, `screenshotUrlsJson`). The **Full JSON** view preserves the 31 original fields and arrays. Raw dataset rows have 35 fields including those four CSV helpers. No image, screenshot or other media file is downloaded.

Example selected fields from a real private US check on 14 October 2026; values are a dated snapshot, not a current price promise:

```json
{
  "appId": "425073498",
  "name": "Procreate",
  "country": "us",
  "price": 12.99,
  "currency": "USD",
  "version": "5.4.14",
  "rating": 4.41913,
  "ratingCount": 50753,
  "status": "ok",
  "scrapedAt": "2026-10-14T14:54:53.775Z"
}
```

`price` is the base app price in the selected storefront currency; it excludes in-app purchases and subscription charges. Ratings are not downloads, sales or revenue. `sourceUrl` records the exact batch lookup and can contain more than one submitted ID. Dates use UTC.

### Coverage and partial results

Check **RUN_SUMMARY.complete**, **stopReason**, **statuses** and **skippedValidIds** alongside the run status. `complete: true` means the selected IDs were checked, not that every app was returned. `statuses.ok` counts complete app snapshots. A successful platform run may be intentionally partial because its budget was reached. IDs never requested do not receive invented `not_found` rows.

| Row status | Meaning |
| --- | --- |
| `ok` | Complete app snapshot; one app event after saving |
| `field_missing` | Apple returned the app but omitted a required core field |
| `not_found` | Apple did not return the ID in this lookup; not proof of removal or worldwide absence |
| `invalid_input` | Unsupported or malformed input; no external URL is fetched |
| `blocked` | Access or rate-limit response; the run stops without retrying it |
| `error` | Transport, protocol or response-contract failure |

To bound sparse or empty lists, the run permits 10 non-billable checks plus two more per complete app. It stores at most 10 invalid-input rows. A small budget-constrained batch that produces no complete apps stops after that lookup. Transport and 5xx failures have at most two attempts; blocked responses are not retried. Previously saved rows remain available after a failure. These safeguards limit work; they do not guarantee complete coverage or profitability.

#### Concurrent runs and source limits

Run jobs sequentially in the same Apify account. This Actor spaces Apple requests across its runs in that account. If a source slot stays occupied after one short wait, the run stops with `ACCOUNT_SOURCE_BUSY`; unchecked IDs receive no invented result row or app event. Previously saved rows remain available. The platform start fee can still apply when no app was checked. Wait at least five seconds before trying again, rather than repeatedly launching new runs.

This protection applies to the same Actor in one executing account. It does not coordinate different customer accounts or guarantee that Apple will never rate-limit a request. A source 429 stops the run without retrying it. Check the coverage summary before treating a run as complete.

### Use cases

- **App price monitoring for publishers:** save recurring US or UK snapshots of known apps. Compare `price` and `currency` in your spreadsheet or database; a free app remains numeric `0`.
- **Version and release-note tracking for developers:** compare `version`, `versionReleasedAt` and `releaseNotes` between datasets. Check important differences against the Store page because source versions can move backwards.
- **ASO competitor research for agencies:** collect `rating`, `ratingCount`, app descriptions and release notes for a known competitor list. Combine this with separate market signals; the Actor does not discover competitors or fetch keyword rankings.

Apify datasets provide JSON/CSV downloads, and Apify supports saved tasks, schedules and API execution. Authenticated Apify accounts use the reviewed public policy after Store publication; private execution remains owner-only. No task, schedule, spreadsheet destination or automation is created by the Actor itself. Run one instance at a time; overlapping runs may wait briefly or stop before completing their selected IDs.

For an API or AI-assisted workflow, use the same three input fields, then read the dataset and `RUN_SUMMARY`. A useful workflow instruction is: “Check these app IDs in the US storefront; return appId, name, price, currency, version, rating and scrapedAt. Report incomplete coverage and skipped IDs.” The Actor supplies data; comparisons, alerts and AI analysis run in your own workflow. External-account billing and integrations still require live verification; publisher runs are not customer invoices.

### FAQ

#### What data does this Apple App Store scraper return?

For each checked app, the snapshot includes its app ID, name, developer, storefront price and currency, version, release notes, rating and rating count when available. It also includes app metadata, media URLs, `status` and `scrapedAt`. Use JSON for original arrays or Compact CSV for a fixed 31-column spreadsheet export. Missing values remain null; availability depends on the selected US or UK storefront.

#### How do I scrape App Store prices from app IDs?

Paste numeric Apple app IDs or HTTPS `apps.apple.com` app URLs into **App IDs or URLs**. Select US or UK; each checked app returns its storefront price, currency, version and available metadata. No Apple login or supplied cookie is needed.

#### Which country does an App Store URL use?

**App Store country** selects the lookup storefront. For example, a URL containing `/us/` checked with `country: gb` returns the UK snapshot and GBP price when the app is available there. This is the source price, not a currency conversion.

#### What is the difference between App Store ratings and reviews?

Ratings are the numeric averages and counts published for the app in the selected storefront. This Actor returns those numbers when available. It does not collect individual written reviews or reviewer profiles.

#### Can I monitor App Store prices, versions and ratings every day?

Use a recurring Apify task. Keep previous datasets and match snapshots on `appId` and `country`; use `scrapedAt` for the observation time. Compare `price`, `version`, `rating` and `ratingCount` in your spreadsheet, database or API workflow. The Actor creates snapshots; it does not maintain a change-history database or send alerts.

#### Does this always return the latest App Store version?

It returns the version exposed by Apple's public lookup at collection time. In testing, a later lookup returned an earlier published version for one app; source snapshots are not guaranteed to progress monotonically. `scrapedAt` is our observation time, while `versionReleasedAt` is the release date supplied by Apple. Confirm important release changes on the app's Store page.

#### Why did an app return not_found?

Apple did not return that ID from the requested public lookup. This can reflect storefront availability or a source omission; it does not establish that the app was deleted. The Actor preserves the requested country and exact source URL, keeps missing fields null and records no app event for that row. It does not automatically repeat a missing-ID check or substitute another country. A later manual run is a new run with its own start fee.

#### Does a free app have a null price?

A published zero price is returned as `0`. `null` means the field was missing. In-app purchases and subscriptions are excluded.

#### Does this scrape reviews or search the Store by keyword?

No. It checks known app IDs and URLs. User reviews, keyword search, Google Play, downloads, revenue estimates and worldwide storefront coverage are outside its scope.

#### Can I check 500 apps in one run?

The input accepts up to 500 selected entries, but budget and source limits can stop earlier. An explicit $0.02 cap allows up to 197 complete apps at the configured price. To check a larger list, choose a sufficient positive run budget; 500 complete apps plus one start total $0.0503. The configured preset stays $0.02; API callers must pass their cap explicitly. With automatic run memory, up to 100 selected inputs use 128 MB and larger selections use 256 MB for more CPU. A manually selected run memory overrides this rule; a fixed 128 MB override can make a large run stop early. Budget, source availability and platform latency still determine how many apps are actually checked; inspect the run summary.

A publisher check on 16 October 2026 checked 500 IDs and returned 499 complete apps plus one uncharged `not_found` row in 62.198 seconds, using automatically selected 256 MB and an explicit $0.06 cap. Its nominal event total was $0.0502. That measured runtime is shared by the release candidate. The omitted ID was also absent in separate US and UK checks. Earlier runs had different results; these are dated workload measurements, not guaranteed completeness, timing or a customer invoice.

#### Is this the cheapest App Store scraper?

No universal cheapest claim is made. The proposed price is designed for recurring lists; a lower start charge or usage-only Actor can be cheaper for other workloads. Consider country coverage and extra features as well as the total bill.

#### How much would checking 100 App Store apps cost?

At the configured tariff, 100 complete app rows in one 128 MB run total $0.0103: $0.010 in app events plus $0.0003 to start. A $0.02 budget accommodates that result count; pass it explicitly in API requests. Missing or incomplete rows have no app event; post-run dataset operations are charged separately by Apify. This is a tariff example, not a verified external customer invoice.

#### Can I open the results in Excel or Google Sheets?

Download the Compact CSV view and import it into your spreadsheet. It has 31 fixed columns; list fields are JSON text inside individual cells. Choose Full JSON if your API or data workflow needs the original arrays. The Actor does not create or update a spreadsheet for you.

### Related Actors by Monkey D. Scraping

| Actor | Complementary use |
| --- | --- |
| [Google News Scraper Lite](https://apify.com/monkey.d.scraping/google-news-scraper-lite) | Search for news about an app, developer or competitor to add context to a price or release change |
| [Google Trends Keyword Analysis](https://apify.com/monkey.d.scraping/google-trends-keyword-analysis) | Check search interest in an app or brand alongside rating snapshots; search interest is separate from App Store downloads |

These are separate Actors with their own inputs and prices. They are optional follow-ups, not calls made or bundled into this Actor.

### Development

Use Node 24 LTS, `npm ci --ignore-scripts`, `npm run typecheck`, `npm test`, and `apify validate-schema`. See DEVELOPMENT.md for source limits and architecture, PPE_TESTING.md for owner billing checks, and BENCHMARK.md for the competitive and launch gates. Respect Apple's API terms and restrictions on promotional assets.

# Actor input Schema

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

Paste one numeric Apple app ID or HTTPS apps.apple.com app URL per line. Try the sample: Spotify, ChatGPT and Procreate. Duplicate IDs are checked once.

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

Choose the storefront price to check: US in USD or UK in GBP. This selection overrides the country in a pasted app URL; prices are not converted.

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

Check up to this many selected input entries, including invalid ones. Leave 20 for the first run. A $0.02 budget covers up to 197 complete apps; API callers must pass maxTotalChargeUsd explicitly. Budget or source limits can stop earlier. See the run summary for skipped IDs.

## Actor input object example

```json
{
  "apps": [
    "324684580",
    "6448311069",
    "https://apps.apple.com/us/app/procreate/id425073498"
  ],
  "country": "us",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Name, price, currency, version and status first. Use the coverage summary to assess completeness.

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

One row per checked app ID or invalid input; country, source URL and status included.

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

Check completeness, stop reason, skipped IDs and confirmed app events. Private owner pilot; event counts are not an external customer invoice.

## `csv` (type: `string`):

Arrays encoded as JSON text in one CSV cell; original arrays remain available in Full JSON.

# 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",
        "6448311069",
        "https://apps.apple.com/us/app/procreate/id425073498"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("monkey.d.scraping/app-store-price-version-snapshots").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",
        "6448311069",
        "https://apps.apple.com/us/app/procreate/id425073498",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("monkey.d.scraping/app-store-price-version-snapshots").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",
    "6448311069",
    "https://apps.apple.com/us/app/procreate/id425073498"
  ]
}' |
apify call monkey.d.scraping/app-store-price-version-snapshots --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,monkey.d.scraping/app-store-price-version-snapshots"
        }
    }
}
```

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/kziyEeqddCZugh45n/builds/Zs3fA3We1x0dIc0m8/openapi.json