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:

   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

{
  "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:

{
  "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:

{
  "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:

{
  "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.

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 — the same profile lookup for Android apps.
• Podcast Lookup — show and episode data from Apple Podcasts, using the same iTunes infrastructure.
• Telegram Channel Lookup — channel profile and subscriber counts by handle.