Apple App Store Product API

The API for fetching full Apple App Store product details by App Store ID. Built for AI agents, MCP clients, ASO tools, and product research.

Pass any Apple App Store ID (or App Store URL) and get back a complete, structured product record: title, developer, description, version history, price, ratings and rating distribution, screenshots, in-app purchases, supported languages, privacy cards, and sample reviews. Works across 50+ country stores. One API call, one App Store ID, one rich JSON record.

This API is fully MCP (Model Context Protocol) ready with one-click setup for Claude Code (free trial), Claude Cowork (free trial), and Claude.ai Chat. AI agents can discover it, call it, and chain it with the rest of the Apple App Store API family without glue code.

---

AI Agent and MCP Integration

The fastest path to use this API is through the Apify MCP server. Once connected, Claude or any other MCP-compatible AI agent can discover this API and invoke it directly from a natural-language prompt. No SDK, no manual REST plumbing, no client glue.

The Apify MCP server hosts three discovery tools (search-actors, fetch-actor-details, add-actor) that let agents find this API on the fly and register it as a callable tool. Pick the setup that matches your Claude surface.

Option 1: Claude Code (terminal CLI)

The single-command setup, and a clean way to try Claude Code on a free trial. Open your terminal and run:

$claude mcp add apify -- npx -y @apify/actors-mcp-server

Then add your Apify API token (one time):

$claude mcp add apify -e APIFY_TOKEN=your_apify_token_here -- npx -y @apify/actors-mcp-server

Get your token at https://console.apify.com/account/integrations?fpr=9n7kx3.

Prefer to edit config by hand? Open ~/.claude.json and add:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "your_apify_token_here" }
    }
  }
}

Restart Claude Code (start a free trial at https://claude.ai/referral/uIlpa7nPLg), then try a prompt like:

Use the Apple App Store Product API to get full details for Spotify (App Store ID 324684580) in the US store.

Claude will discover this API via search-actors, register it as a tool, and call it.

Option 2: Claude Cowork (web)

Claude Cowork (free trial) uses the hosted Apify MCP endpoint over HTTP. No local install required.

1. Open Cowork.
2. Go to Settings > Connectors > Add custom connector.
3. Fill in:
   • Name: Apify
   • Remote MCP URL: https://mcp.apify.com
   • Authentication: Bearer token (paste your Apify API token).
4. Save and enable the connector.

Once connected, the Apify tools appear in the tool drawer. Try a prompt:

Use the App Store product API to get full details for these App Store URLs: https://apps.apple.com/us/app/spotify/id324684580 and https://apps.apple.com/us/app/duolingo/id570060128. Compare their ratings and pricing.

Cowork supports dynamic tool discovery, so once Claude finds this API in a session, it stays registered as a named tool for the rest of the conversation. Subsequent prompts reuse it without re-discovery.

Option 3: Claude.ai Chat (Connectors)

Same hosted MCP endpoint, configured through the standard Claude.ai UI.

1. Open https://claude.ai.
2. Click your profile, then Settings > Connectors > Add custom connector.
3. Fill in:
   • Name: Apify
   • Remote MCP URL: https://mcp.apify.com
   • Authentication: Bearer token (your Apify API token).
4. Save. Toggle the connector on at the start of any chat where you want App Store product data.

Then prompt as normal:

Use the Apple App Store product API on Apify to fetch the full product page for Spotify in the UK store. Show version history and supported languages.

Option 4: Direct REST API (ChatGPT, n8n, Zapier, custom GPTs)

Skip MCP entirely with a single REST API call. Useful for custom GPT actions, Zapier flows, n8n pipelines, or any HTTP client.

curl -X POST \
  "https://api.apify.com/v2/acts/johnvc~apple-app-store-product-api/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"product_ids": ["324684580"], "country": "us"}'

For ChatGPT custom GPT actions, import the Apify OpenAPI spec as a custom action. Once added, ChatGPT can call this API from any custom GPT.

Full Apify MCP documentation

MCP Discovery Phrases

These are the natural-language phrasings an AI agent is likely to use when it searches for a tool that solves "fetch full Apple App Store product details." If you are building or evaluating an agent, you can pre-warm tool selection by including any of these in your system prompt or tool catalog. They are also the phrasings we tune actor.json to rank on for the Apify MCP search-actors discovery tool.

• "Apple App Store product API"
• "iOS app details API by App Store ID"
• "App Store metadata API"
• "Apple App Store app information API"
• "API to fetch App Store app details, pricing, screenshots"
• "iOS app version history API"
• "Apple App Store sample reviews API"
• "App Store privacy and data disclosures API"
• "Apple App Store in-app purchases lookup API"

Chained-Workflow Example: search then fetch

This API is designed to compose with the Apple App Store Search API. A typical agent workflow:

Use the App Store search API to find "meditation" apps in the US store, take the top 3 results, then use the App Store product API to fetch full details (version history, screenshots, IAPs, privacy cards) for each. Summarize the differences.

Both APIs share the same app_id key, so the agent can hand the IDs straight from the search call into the product call. See The Apple App Store API Family below for the full integration map.

---

What You Can Extract

Every dataset item is one App Store product, flat and ready for analysis.

Field	Description
app_id	Numeric App Store ID.
title	Official app title shown on the App Store.
snippet	Short tagline.
developer_name, developer_link	Developer name and App Store developer page URL.
age_rating	Content rating (e.g. 4+, 12+).
rating_average, rating_count	Average star rating and total rating count.
rating_distribution	Breakdown of ratings into 1-star through 5-star buckets.
price_text	Displayed price string (e.g. Get, $2.99).
in_app_purchases_available	Boolean indicator of whether IAPs are offered.
logo	Logo / icon URL.
description_text	Full long-form app description.
iphone_screenshots, ipad_screenshots	Arrays of screenshot links with sizes.
version_history	Array of {release_version, release_notes, release_date} entries.
review_examples	Sample user reviews shown on the product page: rating, username, date, title, text, and any developer reply.
privacy_description, privacy_policy_link, privacy_cards	Apple privacy disclosures and the developer's privacy policy URL.
seller, copyright	Legal entity behind the app and copyright text.
size_text	App size as displayed on the store (e.g. 759.4 MB).
category	Primary App Store category.
compatibility	Per-device-class compatibility entries (iPhone, iPad, Mac, etc.) with OS requirements.
supported_languages_text	Comma-separated list of supported languages.
in_app_purchases	Array of {name, price} IAP entries.
supports	Features the app supports (Family Sharing, Siri, Wallet, etc.).
featured_in	Editorial placements.
you_may_also_like, more_by_this_developer	Recommendation lists (optional, off by default).
link	Direct apps.apple.com URL for the product.
lookup_country, lookup_timestamp	Echo of the country store queried and ISO timestamp.

---

The Apple App Store API Family

This API is the middle link in a three-API family, all keyed on the same app_id:

API	Purpose	Input	Output
Apple App Store Search API	Find apps by keyword.	Search term + country	Many apps (search results).
Apple App Store Product API (this API)	Get full details for one app.	One or more App Store IDs + country	One full product record per ID.
Apple App Store Reviews API	Get paginated reviews for one app.	App Store ID + country + sort	Many reviews per app.

Search API ──► app_id ──► Product API ──► full product details
                     └──► Reviews API ──► paginated reviews

Agents typically chain them: search for candidates, pick the IDs they care about, then fan out to the product API and the reviews API. Pricing is per-record across the family, so you only pay for what you actually fetch.

---

Use Cases

• AI agent context: Feed real App Store product data into LLM prompts for grounded answers about iOS apps.
• Competitive product research: Compare two or more apps side-by-side on pricing, IAPs, screenshots, version cadence, and supported languages.
• ASO deep dives: Inspect the full long-form description, release notes cadence, and screenshot order for top-ranked apps in a category.
• Pricing intelligence: Snapshot price, IAP catalog, and price-localization across multiple country stores for the same app.
• Version history audit: Watch a rival app's release cadence and notes over time.
• Privacy and data disclosure research: Pull structured privacy cards to study what data developers declare collecting.
• Editorial placement tracking: See which apps are currently featured by Apple's editorial team and what placements they hold.
• Recommendation graph mining: Crawl you_may_also_like to map app affinities (when include_related_apps is on).

---

🔌 Integrations: Automate App Store Product Data and Pricing Intelligence

A single run answers one question: what does this app look like right now? The real value comes from running the Apple App Store Product API on a schedule and piping each fresh product record into the tools you already use. That is how a one-shot lookup becomes a monitoring pipeline for ratings, release cadence, and pricing intelligence. The Apify platform integrations overview lists every destination this API can feed.

Tasks and schedules (the core recipe)

Save one task per thing you want to watch (for example a "Spotify US product record" task, or a "top meditation apps" batch), then attach a schedule so it reruns on its own. From the Actor's Actions menu, choose Schedule, and set a cron expression:

• 0 7 * * * runs every day at 7 AM.
• 0 */6 * * * runs every six hours.
• 0 9 * * 1 runs every Monday morning.

One schedule can trigger many tasks at once, so a single daily schedule can refresh every app you track. The Featured Tasks below are ready-to-run starting points.

n8n, Make, and Zapier

Wire the Actor into a no-code workflow with the Apify n8n integration: a Schedule Trigger, then the Apify Actor node, then a Filter (for example a rating that dropped, or a new version that shipped), then a Slack or email node. The same four-step pattern works in Make and Zapier.

Store the history in Supabase

To build a price and ratings history you can query later, run the Actor and bulk-insert the flat output rows into your own database. This snippet uses the apify-client and Supabase Python packages, the real Actor ID johnvc/apple-app-store-product-api, and real output field names:

from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("YOUR_SUPABASE_URL", "YOUR_SUPABASE_KEY")

run_input = {"product_ids": ["324684580", "570060128"], "country": "us"}
run = apify.actor("johnvc/apple-app-store-product-api").call(run_input=run_input)

rows = []
for item in apify.dataset(run["defaultDatasetId"]).iterate_items():
    rows.append({
        "app_id": item.get("app_id"),
        "title": item.get("title"),
        "rating_average": item.get("rating_average"),
        "rating_count": item.get("rating_count"),
        "price_text": item.get("price_text"),
        "lookup_country": item.get("lookup_country"),
        "lookup_timestamp": item.get("lookup_timestamp"),
    })

supabase.table("app_store_products").insert(rows).execute()

Run it on the same schedule and each row becomes a timestamped snapshot you can chart over time.

MCP and AI agents

Every field this API returns is tuned for natural-language tool discovery, so an AI agent can call it directly through the Apify MCP server. See the AI Agent and MCP Integration section at the top of this README for one-click setup in Claude, Cursor, and other MCP clients. An agent can then answer a question like "has Duolingo shipped a new version this week, and did its rating move?" without any glue code.

Webhooks

For anything custom, add an Apify webhook on the ACTOR.RUN.SUCCEEDED event to push each finished run into your own endpoint, queue, or serverless function.

---

Input Parameters

Parameter	Type	Required	Default	Description
product_ids	array of strings	yes	(none)	One or more App Store IDs or App Store URLs. Each entry yields one dataset row. Min 1, max 100 per run.
country	string	no	us	Two-letter country code (ISO 3166-1 alpha-2, lowercase). 50+ stores supported.
include_reviews_sample	boolean	no	true	Include the sample reviews Apple shows on the product page. Set false to slim the row.
include_related_apps	boolean	no	false	Include you_may_also_like and more_by_this_developer recommendation lists.
output_file	string	no	auto	Optional local JSON filename. Used for local development only.

---

Example Inputs

Single app by numeric ID

{
  "product_ids": ["324684580"]
}

Single app via App Store URL

{
  "product_ids": ["https://apps.apple.com/us/app/spotify/id324684580"]
}

The API parses the ID out of the URL automatically.

Batch lookup

{
  "product_ids": [
    "324684580",
    "570060128",
    "https://apps.apple.com/us/app/notion/id1232780281"
  ],
  "country": "us"
}

Localized store (UK)

{
  "product_ids": ["324684580"],
  "country": "gb"
}

Slim output (no sample reviews, no related apps)

{
  "product_ids": ["324684580"],
  "include_reviews_sample": false,
  "include_related_apps": false
}

Full output (everything on)

{
  "product_ids": ["324684580"],
  "include_reviews_sample": true,
  "include_related_apps": true
}

---

Example API Output

Each dataset item is one App Store product:

{
  "app_id": 324684580,
  "title": "Spotify: Music and Podcasts",
  "snippet": "Songs & Playlists For You",
  "developer_name": "Spotify",
  "developer_link": "https://apps.apple.com/us/developer/spotify/id324684583",
  "age_rating": "12+",
  "rating_average": 4.8,
  "price_text": "Get",
  "logo": "https://...logo.png",
  "description_text": "With Spotify, you can listen to music and play millions of songs and podcasts for free...",
  "iphone_screenshots": [
    {"link": "https://...iphone1.png", "size": "1284x2778"}
  ],
  "ipad_screenshots": [
    {"link": "https://...ipad1.png", "size": "2048x2732"}
  ],
  "version_history": [
    {"release_version": "9.0.40", "release_notes": "We're always making changes and improvements to Spotify...", "release_date": "2026-05-05"}
  ],
  "rating_distribution": {
    "5_star": 35028124,
    "4_star": 2780888,
    "3_star": 854840,
    "2_star": 312515,
    "1_star": 799640
  },
  "review_examples": [
    {
      "rating": "5",
      "username": "MusicLover88",
      "review_date": "04/15/2026",
      "review_title": "Best music app",
      "review_text": "I have been using Spotify for years and the discovery features keep getting better...",
      "response_text": null
    }
  ],
  "privacy_description": "The developer indicated that the app's privacy practices may include...",
  "privacy_policy_link": "https://www.spotify.com/legal/privacy-policy/",
  "privacy_cards": [
    {"title": "Data Used to Track You", "description": "...", "categories": ["Identifiers", "Usage Data"]}
  ],
  "seller": "Spotify",
  "size_text": "264.1 MB",
  "category": "Music",
  "compatibility": [
    {"device": "iPhone", "requirement": "Requires iOS 15.0 or later"}
  ],
  "supported_languages_text": "English, French, German, Japanese, Korean, Spanish",
  "copyright": "© 2026 Spotify AB",
  "supports": [
    {"title": "Family Sharing", "description": "Up to six family members can use this app..."}
  ],
  "featured_in": [],
  "link": "https://apps.apple.com/us/app/id324684580",
  "lookup_country": "us",
  "lookup_timestamp": "2026-05-12T04:32:20"
}

---

Pricing

Transparent pay-per-event API call pricing. You only pay for products you actually fetch.

Event	Cost	When charged
setup	$0.02	Once at the start of each run.
result	$0.02	Per App Store product returned.

Cost estimates

Use case	Products returned	Approx. cost
One app lookup	1	$0.04
Batch of 10 apps	10	$0.22
Batch of 50 apps	50	$1.02
Batch of 100 apps (per-run cap)	100	$2.02

No monthly subscription. No hidden fees. Stop the run at any time and pay only for what was already returned.

---

How to Get Started

1. Create an Apify account at https://apify.com?fpr=9n7kx3 if you do not have one.
2. Open the actor page on the Apify store and click Try for free.
3. Set the input (only product_ids is required) and click Start.
4. Watch the run live in the Apify console, then download results as JSON, CSV, Excel, or RSS once it finishes.
5. Optional: connect via MCP (see top of this README) to call the API directly from Claude or any AI agent.
6. Prefer code? Clone the example repo and cookbook on GitHub for Python quick-starts and MCP setup walkthroughs covering the whole Apple App Store API family.

---

🔗 Related Tools

Building an App Store data or pricing intelligence pipeline? These tools from the same catalog pair well with full product records:

• Apple App Store Search API: find apps by keyword in any country store, then hand the App Store IDs straight into this product API.
• Apple App Store Reviews API: pull full paginated user reviews for any app when the sample reviews here are not enough.
• Google Shopping API: extend pricing intelligence beyond the App Store to retail product prices and deals across the web.

For contrast, older single-purpose App Store scrapers on the Store, such as easyapi/app-store-reviews-scraper (rated about 1.4 out of 5 across its reviews), cover one narrow data type and return inconsistent fields. This API is actively maintained and returns a complete, structured product record for every App Store ID in a single call.

---

FAQ

What counts as a valid product_id?

Any numeric Apple App Store ID (e.g. 324684580) or any App Store URL that contains /id<digits> (e.g. https://apps.apple.com/us/app/spotify/id324684580). The API parses the ID out of URLs automatically.

Can I get all the reviews for an app?

This API returns the sample reviews Apple shows on the product page (typically three). For full paginated reviews, use the dedicated Apple App Store Reviews API in this family. Both APIs share the same app_id, so you can chain them.

Can I look up Apple Music tracks, podcasts, or movies with this API?

Not in v1. This API focuses on the app product type. Music, podcasts, and movies can be added in v2 if there is demand, so file a feature request on the actor page.

Does the same App Store ID return different data in different countries?

Yes. Price, availability, localized text, and the sample reviews are all country-dependent. Set country to query the right regional store. Run the same ID across multiple country values to compare.

What happens if I pass an invalid ID or a URL the API cannot parse?

That entry is skipped with an error record pushed to the dataset, and the other entries in the batch continue. The setup fee is still charged once, but no result fee is charged for the failed entry.

How do I batch fetch many apps?

Pass an array of up to 100 IDs in product_ids. Each entry is fetched sequentially with a short delay to be polite to the source. Each successful fetch is one result charge.

Does this work with AI agents and MCP?

Yes. Setup instructions for Claude Code (free trial), Claude Cowork (free trial), and Claude.ai Chat are at the top of this README. The API surface, parameter names, and output shape are tuned for natural-language tool discovery.

Which country stores are supported?

50+ stores including US, UK, CA, AU, DE, FR, JP, KR, BR, MX, IN, and more. See the country parameter dropdown for the full list.

Can I schedule this Apple App Store Product API?

Yes, and this is where the API earns its keep. Any input you can run once you can run on a schedule. Save your input as a task, open the Actor's Actions menu, choose Schedule, and set a cron expression: 0 7 * * * for every day at 7 AM, 0 */6 * * * for every six hours, or 0 9 * * 1 for Monday mornings. One schedule can drive many tasks at once, so a single daily run can refresh every app you track and build a ratings, version, and price history over time. The Integrations section above has the full monitoring recipe.

Should I use an API or a web scraper for App Store data?

They solve the same problem from two angles. Apple's own endpoints are rate limited, quota bound, and thin on fields such as version history, privacy cards, and in-app purchases. This Actor gives you that missing data either as a no-code web scraper you run from the console or as a clean API endpoint you call yourself, with no quota to manage. If you want a primer on the underlying technique, see web scraping. Either way the output shape is identical.

Can I integrate this App Store Scraper with other apps?

Yes. Through Apify integrations the Actor connects to almost any cloud service: send results to Slack, automate flows with Make or Zapier, or fire an Apify webhook on ACTOR.RUN.SUCCEEDED for custom actions. The Integrations section above walks through each recipe.

Can I use the Apple App Store Product API from code?

Yes. The Apify API gives programmatic access to run the Actor, schedule it, and fetch datasets, and the apify-client package is available for both Node.js and Python. See the Supabase snippet in the Integrations section for a working Python example.

Can I use this API through an MCP Server?

Yes. The Actor can be added as a tool to any MCP client (Claude, Cursor, and others) through the hosted Apify MCP server. Point your client at https://mcp.apify.com/?tools=actors,docs,johnvc/apple-app-store-product-api to expose it directly. For a terminal setup, Claude Code (free trial) connects in one command, as shown at the top of this README. See the Apify MCP docs for details.

How can I collect other App Store data?

Pair this product API with the rest of the family: use the Apple App Store Search API to discover apps by keyword, then the Apple App Store Reviews API for full paginated reviews. All three share the same app_id, so an agent can chain them end to end. Data comes straight from the public Apple App Store.

What is pricing intelligence and how does this API support it?

Pricing intelligence is the practice of tracking competitors' prices and packaging so you can position your own. For iOS apps that means watching the displayed price, the in-app purchase catalog, and how both change across country stores and over time. Run this API on a schedule across the apps you care about and each result is a timestamped price snapshot you can compare and chart.

What does "AI agent context" mean for this API?

AI agent context is the real, grounded data you feed a large language model so its answers are based on facts rather than guesses. Passing a full App Store product record into a prompt lets an agent reason about an app's pricing, ratings, and features accurately, which is why this API's field names and output shape are tuned for natural-language tool discovery.

Is it legal to collect App Store data?

This API returns publicly visible product information from App Store pages. As with any collection of public data, follow the source's terms and applicable law; Apify's overview of the legality of web scraping is a good starting point.

---

Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

• Get Apple App Store app details by App ID - Pull a full product record for one app: developer, description, price, ratings, screenshots, in-app purchases, and sample reviews.
• Compare competitor iOS apps on price and features - Look up a set of competing apps in one run and compare them side by side.
• Track an iOS app's ratings and version history - Monitor an app's ratings and release cadence, including full version history.
• Get Full iOS App Details in Claude via MCP - full App Store product data in Claude (free trial available) over MCP: price, ratings, version history, in-app purchases, and privacy cards.

---

Where the Data Comes From

Every row this API returns is read from one place: the public product page an app already has on the Apple App Store. The title, developer, price string, rating distribution, version history, in-app purchase catalog, screenshots, and Apple's privacy cards are all visible to anyone who opens that listing in a browser. This API reads the page for a given App Store ID and hands it back as one flat JSON row instead of a wall of markup.

A note on affiliation: this is an independent API. It is not built by, endorsed by, or connected to Apple Inc., and it is not an official Apple endpoint. It reads publicly visible listings and returns them as structured data, nothing more.

How is this different from checking the App Store by hand?

Opening an App Store product page and reading it yourself works fine for one app. It stops working at ten. The details worth researching are the ones buried furthest down the page: the full version_history array, the in_app_purchases list with a price on each entry, the 1-star through 5-star rating_distribution, and the privacy_cards Apple requires developers to declare. This API pulls all of it for up to 100 App Store IDs in a single run and stamps every row with lookup_timestamp, so you have something you can diff against next week's run.

Which storefront does a single run read?

Exactly one. The country parameter is set once per run, so every ID in that run is fetched from the same regional store, and each row echoes the choice back in lookup_country. Prices and localized text differ from one regional Apple App Store storefront to the next, so a regional price comparison means running the same IDs a second time with a different country value and comparing the two datasets. No single run returns several countries at once.

Last Updated: 2026.07.14