# Apple App Store Lookup — iOS App Metadata API (`accountable_eel/apple-app-store-lookup`) Actor

Look up any iOS app by App Store ID or bundle ID: name, developer, category, rating, review count, price, and version. Uses Apple's own official, free iTunes Lookup API - no scraping, no key required. Charged only for apps actually found.

- **URL**: https://apify.com/accountable\_eel/apple-app-store-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 87.5% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 successful lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Apple App Store Lookup — iOS App Metadata API

Paste a list of iOS app ids or bundle ids and get each app's live App Store record — name,
developer, category, price, rating, version history and icon — or switch to reviews mode and
get the most recent user reviews instead. This calls Apple's own public iTunes lookup and RSS
endpoints directly: no API key, no App Store Connect access, no scraping.

### Who it's for

ASO teams and app marketers use this to track a competitor's rating, price and version cadence
without opening the App Store by hand. Product teams monitoring their own listing catch a
review-bombing spike or a rating slide early by pulling reviews on a schedule instead of
checking manually. Researchers building sentiment or market-mapping datasets pull recent
reviews across a category of apps in one pass. And anyone citing an app in a report or a
comparison table can confirm in one row whether it's still live before publishing.

### Why this one

- **Apple's own endpoints, not a scrape.** `itunes.apple.com/lookup` and Apple's review RSS
  feed are public and documented — no HTML selectors to break.
- **You don't pay for apps that aren't there.** A removed app, a wrong id, or a bundle id
  that resolves to nothing comes back `found: false` and is never billed.
- **Two modes, one actor.** `details` gives you the app profile; `reviews` gives you recent
  user reviews, billed separately and only for reviews actually returned.
- **App id or bundle id.** Pass `544007664` or `com.google.ios.youtube` — both resolve.
- **Storefront-aware.** `country` picks which App Store storefront reviews come from, so you
  can compare sentiment across markets.

### What you get

The shape depends on `mode`. Field names are stable within each mode and won't be renamed
between runs.

#### Details mode fields (default)

One row per input app.

| Field | Type / format | Description |
|---|---|---|
| `query` | text | The id or bundle id exactly as submitted. |
| `found` | boolean | Whether the identifier resolved to a live App Store record. Gates billing. |
| `appId` | number | Apple's numeric track id for the app. |
| `bundleId` | text | Reverse-DNS bundle identifier, e.g. `com.google.ios.youtube`. |
| `name` | text | App name as listed. |
| `description` | text | Full App Store description. |
| `developer` | text | Seller name, falling back to the artist name. |
| `category` | text | Primary genre, e.g. `Photo & Video`. |
| `price` | number | Listed price. `0` for free apps. |
| `currency` | text | ISO currency code for `price`. |
| `ratingValue` | number | Average user rating, 1–5. |
| `ratingCount` | number | Number of ratings behind `ratingValue`. |
| `version` | text | Current version string. |
| `releaseDate` | date (ISO 8601) | When the app first shipped. |
| `currentVersionReleaseDate` | date (ISO 8601) | When the current version shipped — the freshness signal. |
| `minimumOsVersion` | text | Minimum iOS version required. |
| `storeUrl` | link | Public App Store page. |
| `icon` | link | App icon, 512px where available. |
| `scrapedAt` | date (ISO 8601) | When the lookup ran. |

#### Reviews mode fields

One row per review, up to `maxReviews` per app.

| Field | Type / format | Description |
|---|---|---|
| `appId` | number | The app the review belongs to. |
| `reviewId` | text | Apple's own id for the review. |
| `rating` | number | Star rating the reviewer gave, 1–5. |
| `title` | text | Review headline. |
| `body` | text | Review text. |
| `author` | text | Reviewer's display name. |
| `version` | text | App version the review was written against. |
| `updatedAt` | date (ISO 8601) | When the review was posted or last edited. |
| `voteCount` | number | How many people marked the review helpful. |

### Details mode vs reviews mode

The two modes bill differently and answer different questions, so picking the right one
matters before you run a big list.

**`details`** (the default) answers "what is this app" — one row per app id, billed once per
app that resolves, regardless of how much metadata comes back with it. Use it for catalog
enrichment, competitor tracking on rating and version, or confirming an app is still live.

**`reviews`** answers "what are people saying" — one row per review, billed per review
actually returned rather than per app. An app with 3 reviews costs 3 review events; an app
with `maxReviews` set to 50 but only 12 real reviews available costs 12, not 50. `country`
picks which App Store storefront the reviews come from, so the same app can return different
sentiment depending on market. There's no combined mode: a run is either details or reviews,
so pulling both for the same app list means two runs.

### Price

- **Successful lookup**: $4 per 1,000 results
- **Review returned**: $0.1 per 1,000 results

Plus a $0.0051 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

In details mode you're billed once per app that resolves. In reviews mode you're billed per
review actually returned, so an app with three reviews costs three review events, not
`maxReviews`. A removed app or a wrong id costs nothing in either mode. Run 1,000 app lookups
and, at the live FREE-tier price, that's roughly **$4 if every one resolves**; 1,000 reviews on
top of that adds about **$0.10**. There's no seat, no monthly minimum and no credits to track.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `items` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~apple-app-store-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"items":["310633997","net.whatsapp.WhatsApp"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Paste your app ids or bundle ids into `items` — one per line, mixed formats are fine.
2) Choose `mode`: leave it on `details` for app profiles, or set `reviews` for user reviews.
3) In reviews mode, set `country` for the storefront and `maxReviews` for how many to pull per
   app, most recent first.
4) Read the dataset. Misses are written as `found: false` rows so you can see what failed, and
   are never charged.

**Common ways teams use this:**

- **Track a competitor's rating and version cadence** by re-running details mode on a schedule
  and diffing `ratingValue` and `currentVersionReleaseDate`.
- **Pull recent reviews for sentiment analysis** without building an App Store scraper.
- **Compare an app's reception across markets** by running reviews mode with different
  `country` values.
- **Enrich an app catalogue** with developer, category, price and minimum OS version.
- **Check whether an app is still live** before citing it in a report or directory.

### Input

```json
{
  "items": ["544007664", "com.google.ios.youtube"],
  "mode": "details",
  "country": "us",
  "maxReviews": 50,
  "maxConcurrency": 5
}
```

`items` accepts Apple's numeric app id or a reverse-DNS bundle id, mixed freely in one run.
`mode` is `details` (default) or `reviews`. `country` is the App Store storefront code used in
reviews mode — `us`, `gb`, `de` and so on — and defaults to `us`. `maxReviews` caps how many
reviews are pulled per app, most recent first, and defaults to 50. `maxConcurrency` (default 5)
caps parallel requests; keep it conservative, since this target has no browser fallback.

### Sample output

Details mode, one row per app:

```json
{
  "query": "544007664",
  "found": true,
  "appId": 544007664,
  "bundleId": "com.google.ios.youtube",
  "name": "YouTube: Watch, Listen, Stream",
  "developer": "Google LLC",
  "category": "Photo & Video",
  "price": 0,
  "currency": "USD",
  "ratingValue": 4.7,
  "ratingCount": 12345678,
  "version": "20.33.1",
  "releaseDate": "2012-09-11T00:00:00Z",
  "currentVersionReleaseDate": "2026-08-18T00:00:00Z",
  "minimumOsVersion": "16.0",
  "storeUrl": "https://apps.apple.com/us/app/id544007664",
  "scrapedAt": "2026-08-23T21:04:47.132Z"
}
```

Reviews mode, one row per review:

```json
{
  "appId": 544007664,
  "reviewId": "11234567890",
  "rating": 4,
  "title": "Good but the ads",
  "body": "Works well, though the ad load has crept up...",
  "author": "someuser",
  "version": "20.33.1",
  "updatedAt": "2026-08-20T14:11:02Z",
  "voteCount": 12
}
```

An identifier that doesn't resolve still returns a row, and is never charged:

```json
{
  "query": "0000000000",
  "found": false,
  "status": "NOT_FOUND",
  "scrapedAt": "2026-08-23T21:04:47.132Z"
}
```

Miss rows are written so you can see exactly which identifiers failed rather than diffing your
input list against the output.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~apple-app-store-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"items":["310633997","net.whatsapp.WhatsApp"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~apple-app-store-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"items":["310633997","net.whatsapp.WhatsApp"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~apple-app-store-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"items":["{{value}}"]}`, mapping the row's value into the `items` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Apple App Store Lookup | Apify" — the agent will find and run this actor.

### Tips

- **Use `currentVersionReleaseDate`, not `releaseDate`, to judge whether an app is maintained.**
  The first ship date tells you nothing about whether anyone still works on it.
- **Reviews mode bills per review returned, so `maxReviews` is a budget dial.** Set it to 10
  for a sentiment sample instead of 50 if you're running a long app list.
- **Bundle ids are the safer input when your list came from a developer.** Numeric app ids get
  transcribed wrong; reverse-DNS ids rarely do.
- **Change `country` to compare markets.** The same app can carry very different ratings in
  different storefronts, and reviews mode reads one storefront per run.
- **Apple's review feed is recency-capped.** It surfaces recent reviews, not the full history —
  don't expect to reconstruct years of feedback from it.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`apple-app-store-lookup`) | $4 per 1,000 resolved apps, $0.10 per 1,000 reviews, $0.0051 actor start, nothing for an id that doesn't resolve | App profile or recent reviews from Apple's own public endpoints, one flat row per app or per review | Reviews are recency-capped by Apple's feed, and one storefront per run. Not a full historical review archive. |
| **automation-lab/apple-app-store-scraper** (493 users) | $0.00345 per app detail, $0.00115 per review, $0.005 start | App details and reviews with a lower per-detail price | Cheaper per app detail, notably more expensive per review — this actor is about eleven times cheaper on reviews. |
| **thewolves/appstore-reviews-scraper** (1,863 users) | See its own page | The most-used reviews-focused actor on the Store | If reviews at depth are the whole job, a dedicated reviews actor with a larger user base is worth benchmarking against this. |
| **Doing it yourself** | Your time + handling both endpoints, storefront codes, id-versus-bundle resolution and retries | The same data | This actor absorbs the two-endpoint split, the identifier resolution, the retries and the per-review billing, and hands you a flat table. |

(automation-lab's and thewolves' prices above are their published August 2026 list prices —
check their own pages before relying on a straight comparison.)

### FAQ

**Do I need an API key or App Store Connect access?**
No. Both endpoints — Apple's iTunes lookup and its review RSS feed — are public and
unauthenticated.

**What counts as "found"?**
The identifier must resolve to a live App Store record. A removed app, a wrong numeric id, or a
bundle id Apple doesn't know returns `found: false` and is never charged.

**How am I billed in reviews mode?**
Per review actually returned. An app with three reviews costs three review events regardless of
what `maxReviews` says, and an app with none costs nothing beyond the lookup.

**Can I get the full review history?**
No. Apple's public review feed is recency-capped, so you get recent reviews rather than
everything ever written. `maxReviews` caps how many of those you pull.

**Can I mix app ids and bundle ids in one run?**
Yes. Both resolve through the same lookup endpoint, so a messy list works as-is.

**Does `country` affect details mode?**
It's used for the reviews feed. App metadata comes back from the lookup endpoint, where the
record is largely storefront-independent — ratings, though, are the storefront's own.

**Can an agent run this on its own?**
Yes. It's registered with the Apify MCP server, so a Claude or Cursor agent with that MCP
connected can find "Apple App Store Lookup" and pull dataset rows back without any integration
code.

### Related actors

- [Google Play App Lookup](https://apify.com/accountable_eel/google-play-app-lookup) — the same
  profile lookup for Android apps.
- [Podcast Lookup](https://apify.com/accountable_eel/podcast-lookup) — show and episode data
  from Apple Podcasts, using the same iTunes infrastructure.
- [Telegram Channel Lookup](https://apify.com/accountable_eel/telegram-channel-lookup) — channel
  profile and subscriber counts by handle.

# Actor input Schema

## `items` (type: `array`):

One item per line — see the item shape and examples below. Only the items we actually find are charged — never per run, and never for a miss.

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

"details" returns the app profile (unchanged, default). "reviews" returns one row per customer review instead, from Apple's official reviews feed.

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

App Store storefront country code for reviews mode, e.g. "us", "gb", "de". Ignored in details mode (always "us").

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

How many reviews to fetch per app in reviews mode, most recent first. Apple returns 50 per page; higher values page through more requests. Ignored in details mode.

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

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "items": [
    "310633997",
    "net.whatsapp.WhatsApp"
  ],
  "mode": "details",
  "country": "us",
  "maxReviews": 50,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "items": [
        "310633997",
        "net.whatsapp.WhatsApp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/apple-app-store-lookup").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 = { "items": [
        "310633997",
        "net.whatsapp.WhatsApp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/apple-app-store-lookup").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 '{
  "items": [
    "310633997",
    "net.whatsapp.WhatsApp"
  ]
}' |
apify call accountable_eel/apple-app-store-lookup --silent --output-dataset

```

## MCP server setup

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

```

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/Ib0kk21daynYAj9h4/builds/OrMYdJlEK83jSIinn/openapi.json