App Store Scraper

App Store Scraper is an Apify actor that extracts App Store app metadata, reviews and similar apps by App Store ID, bundle ID, developer ID or App Store URL. App lookups cost $0.0003 each, or $0.40 per 1,000 apps.

The App Store Scraper runs 6 query types, accepts 15 input fields, returns 45 structured fields per app, and bills through 6 charge events. Every price below is a per-event charge with no subscription and no monthly minimum.

What Does the App Store Scraper Extract?

The App Store Scraper runs 6 query types. Four query types resolve apps, and two query types attach extra data to an app that is already resolved.

Query Type	Description
App Lookup (by ID or URL)	Fetches full app detail metadata for a single app identified by its numeric App Store ID or an App Store app URL.
App Lookup (by Bundle ID)	Fetches full app detail metadata for a single app identified by its iOS bundle identifier.
Developer Apps	Lists every app published by a given developer ID or App Store developer page URL.
Keyword Search	Searches the App Store for a term, with page-by-page pagination.
Similar Apps	Fetches similar/related apps for a resolved app. Optional add-on enabled per query.
Reviews	Fetches paginated user reviews for a resolved app. Optional add-on enabled per query.

Similar Apps and Reviews are add-ons rather than standalone queries. Both attach their results to the app's dataset item instead of producing separate top-level items.

Which App Store Identifiers Does the App Store Scraper Accept?

The App Store Scraper accepts 5 input identifiers: term, startUrls, appIds, bundleIds and developerIds. Each identifier maps to a different way of naming an app on the App Store.

• appIds takes numeric App Store IDs, such as 389801252, and looks apps up directly without a full URL.
• bundleIds takes iOS bundle identifiers, such as com.crunchyroll.sfduel.
• developerIds takes numeric developer IDs and returns every application published by each developer.
• startUrls takes App Store or iTunes detail URLs, covering app detail pages and developer pages.
• term takes a keyword and searches the App Store for matching apps.

App Store Scraper needs at least one of these five inputs to build a query.

Who Uses the App Store Scraper?

Listed below are the 8 roles that run App Store Scraper against App Store data.

• ASO managers track keyword search results per storefront country, then read trackName, primaryGenreName and averageUserRating for every app ranking on a term.
• App publishers monitor their own version, currentVersionReleaseDate and releaseNotes alongside the same fields for competing apps.
• Competitive intelligence analysts pull a rival's full catalog through developerIds and compare price, formattedPrice and contentAdvisoryRating across the portfolio.
• Product managers collect reviews for a resolved app and read rating, title and review to locate defects and feature requests by app version.
• Market researchers size a category by paginating Keyword Search across a term and aggregating userRatingCount and averageUserRating.
• Machine learning teams assemble app metadata and review corpora from trackName, releaseNotes and the reviews array for classification and sentiment models.
• Investment analysts track averageUserRatingForCurrentVersion and currentVersionScore over repeated runs to observe reception of each release.
• Agencies run App Store Scraper across client portfolios by supplying multiple appIds or bundleIds in one run.

What Does the App Store Scraper Cost?

The App Store Scraper charges 6 event types. App lookups and developer queries cost $0.0003, reviews cost $0.005 per page, keyword search costs $0.005 per query regardless of page count, similar apps cost $0.00015, and every returned item adds $0.0001.

Query Type	Charge Event	Price
App Lookup (by ID or URL)	app-query	$0.0003
App Lookup (by Bundle ID)	app-query	$0.0003
Developer Apps	developer-query	$0.0003
Keyword Search (per query)	search-query	$0.005
Similar Apps	similar-query	$0.00015
Reviews (per page)	review-query	$0.005

Every returned item is also charged dataset-item: $0.0001. A paying account's items from a keyword search's first results page are exempt from the dataset-item charge.

App Store Scraper Cost Examples

The table below prices 7 scenarios against the rate card above. Each row multiplies the charge events triggered by the run.

Scenario	Charge Events	Calculation	Total Cost
1 app lookup by App Store ID	1 app-query + 1 dataset-item	$0.0003 + $0.0001	$0.0004
1 app lookup by bundle ID, with similar apps	1 app-query + 1 similar-query + 1 dataset-item	$0.0003 + $0.00015 + $0.0001	$0.00055
1,000 app lookups by App Store ID	1,000 app-query + 1,000 dataset-item	(1,000 × $0.0003) + (1,000 × $0.0001)	$0.40
A 3-page keyword search returning 150 apps (50 per page), free account	1 search-query + 150 dataset-item	$0.005 + (150 × $0.0001)	$0.020
The same 3-page keyword search, paying account (page 1's 50 apps exempt)	1 search-query + 100 dataset-item	$0.005 + (100 × $0.0001)	$0.015
1 app with 5 pages of reviews	1 app-query + 5 review-query + 1 dataset-item	$0.0003 + (5 × $0.005) + $0.0001	$0.0254
1 developer query returning 12 apps	1 developer-query + 12 dataset-item	$0.0003 + (12 × $0.0001)	$0.0015

App Store Scraper Unit Economics

The 8 figures below are derived from the rate card above. Volume figures exclude dataset-item charges except where the row states otherwise.

Metric	Value
Cost per app lookup, including its dataset item	$0.0004
App lookups per $1, including dataset items	2,500
Cost per 1,000 app lookups, including dataset items	$0.40
Cost per keyword search query, any number of pages	$0.005
Keyword searches per $1, any number of pages	200
Cost of the similar-apps add-on, per app	$0.00015
Ratio between the cheapest and most expensive charge event	1 : 50
Share of a single app lookup's cost taken by dataset-item	25%

Reviews are the only per-page charge, on review-query at $0.005 per page, which makes endPage the field that controls review cost. Keyword search charges search-query once per run no matter how many pages endPage allows, so pagination depth no longer multiplies that charge. endPage still governs how many search-result items are fetched and therefore how many dataset-item charges a search run accrues, except that a paying account's first page of search results is exempt from dataset-item. A review page costs 16.7 times an app lookup, so a run with deep review pagination is priced by its page count rather than its app count.

How Is the App Store Scraper Configured?

The App Store Scraper exposes 15 input fields covering targets, localization, pagination, add-ons and output mapping.

Name	Type	Description
term	String	Keyword to search for on the App Store.
startUrls	Array	App Store or iTunes detail URLs.
appIds	Array	Numeric App Store IDs to look up directly, without needing a full URL.
bundleIds	Array	Bundle identifiers to look up directly (e.g. com.crunchyroll.sfduel).
developerIds	Array	Numeric developer IDs. Returns every application published by each developer.
mode	String	Optional override of the execution path.
country	String	App Store storefront country.
lang	String	Response language. Defaults to the storefront country's language if omitted.
page	Integer	First page number to request from the search endpoint.
endPage	Integer	Last page number the actor should request, for both search-result pagination and, when includeReviews is enabled, per-app review pagination. Default: unbounded (the actor keeps paging until the provider returns an empty page or maxItems is reached).
includeReviews	Boolean	When true, fetches reviews for every resolved app and attaches them to the app's dataset item.
reviewsSort	String	Sort order used when fetching reviews. Only applies when includeReviews is true.
includeSimilarApps	Boolean	When true, fetches similar/related apps for every resolved app and attaches them to the app's dataset item.
maxItems	Integer	Maximum number of top-level application items the run will output. Default is all.
customMapFunction	String	Function applied to each item right before it is pushed to the dataset. On error the original item is still pushed unchanged and a warning is logged.

mode accepts search and lookup. Omitting mode lets the actor select the execution path from the identifiers supplied.

Which Input Rules Does the App Store Scraper Enforce?

The App Store Scraper enforces 7 usage constraints covering URL shape, mode requirements and custom mapping.

Rule	Why
startUrls entries must be http/https URLs on an apple hostname.	Only Apple's own App Store domains are supported as lookup sources; anything else is skipped with a warning.
A startUrls entry must be an app detail page (path contains /id and /app/) or a developer page (path contains /id and /developer/).	Only these two page shapes can be parsed into a resolvable query; other App Store page types are skipped with a warning.
When mode is search, term must be non-empty.	Search mode has no other way to know what to search for.
When mode is lookup, at least one of appIds, startUrls, bundleIds, or developerIds must be provided.	Lookup mode needs at least one target identifier to resolve.
When mode is omitted, at least one of appIds, startUrls, bundleIds, developerIds, or term must be provided.	The actor needs at least one usable input to build any query from.
customMapFunction is rejected if its source contains new Date, 1970, or Date.now.	Prevents the custom function from being used for strict date filtering/operations.
customMapFunction must be a plain synchronous function that returns a non-null object (not async, not a generator, not a Promise).	Guarantees deterministic per-item mapping without being able to break the run; on rejection the run continues with unmodified items.

A rejected customMapFunction does not stop the run. The run continues and pushes items unmodified.

How Do You Run an App Store Scraper Keyword Search?

A keyword search needs 4 settings: term, country, page and endPage. The App Store Scraper requests the search endpoint from the page number and stops at endPage, at maxItems, or when the provider returns an empty page.

{
  "term": "photo editor",
  "mode": "search",
  "country": "us",
  "page": 1,
  "endPage": 5,
  "maxItems": 200
}

How Do You Look Up Apps with the App Store Scraper by App Store ID or Bundle ID?

Lookup mode resolves apps from identifiers instead of a keyword. Supply appIds, bundleIds, developerIds or startUrls, and combine them in a single run.

{
  "mode": "lookup",
  "appIds": ["389801252"],
  "bundleIds": ["com.crunchyroll.sfduel"],
  "developerIds": ["284882218"],
  "startUrls": [
    "https://apps.apple.com/us/app/sample-photo-app/id389801252"
  ],
  "country": "us",
  "lang": "en"
}

How Does the App Store Scraper Collect App Store Reviews?

The App Store Scraper collects reviews when includeReviews is set to true. Reviews are fetched for every resolved app, paginated per app, and attached to that app's dataset item in the reviews array. reviewsSort sets the review sort order and applies only while includeReviews is true. endPage caps per-app review pagination in the same run where it caps search-result pagination.

{
  "mode": "lookup",
  "appIds": ["389801252"],
  "includeReviews": true,
  "reviewsSort": "mostRecent",
  "endPage": 3
}

How Does the App Store Scraper Collect Similar Apps?

The App Store Scraper collects similar apps when includeSimilarApps is set to true. Related apps are fetched for every resolved app and attached to that app's dataset item in the similarApps array. A failure in the similar-apps step leaves the main app item intact, because that step is skipped independently of the app query.

Which Fields Does the App Store Scraper Output?

The App Store Scraper outputs 45 fields per app, covering identifiers, naming, artwork, genre, technical requirements, release history, pricing, developer attribution, ratings, screenshots and the two add-on arrays.

App Store Scraper App Object

Name	Type
inputSource	Object
wrapperType	String
kind	String
trackId	String
collectionId	String
bundleId	String
trackName	String
collectionName	String
trackCensoredName	String
collectionCensoredName	String
trackViewUrl	String
collectionViewUrl	String
artworkUrl60	String
artworkUrl100	String
artworkUrl512	String
artworkUrl600	String
primaryGenreName	String
primaryGenreId	String
genres	Array
genreIds	Array
contentAdvisoryRating	String
languageCodesISO2A	Array
fileSizeBytes	String
minimumOsVersion	String
releaseDate	String
currentVersionReleaseDate	String
releaseNotes	String
version	String
price	Number
formattedPrice	String
currency	String
artistId	String
artistName	String
artistViewUrl	String
sellerUrl	String
averageUserRating	Number
userRatingCount	Number
averageUserRatingForCurrentVersion	Number
currentVersionScore	Number
screenshotUrls	Array
ipadScreenshotUrls	Array
appletvScreenshotUrls	Array
supportedDevices	Array
similarApps	Array
reviews	Array

inputSource records which flow produced the item and which identifier it came from, which keeps items traceable when one run mixes lookup and search queries.

App Store Scraper Output Example

{
    "inputSource": {
        "flow": "lookup-app",
        "sourceId": "389801252"
    },
    "wrapperType": "track",
    "kind": "software",
    "trackId": "389801252",
    "collectionId": "389801252",
    "bundleId": "com.example.photoapp",
    "trackName": "Sample Photo App",
    "collectionName": "Sample Photo App",
    "trackCensoredName": "Sample Photo App",
    "collectionCensoredName": "Sample Photo App",
    "trackViewUrl": "https://apps.apple.com/us/app/sample-photo-app/id389801252",
    "collectionViewUrl": "https://apps.apple.com/us/app/sample-photo-app/id389801252",
    "artworkUrl60": "https://is1-ssl.mzstatic.com/image/thumb/example/60x60.png",
    "artworkUrl100": "https://is1-ssl.mzstatic.com/image/thumb/example/100x100.png",
    "artworkUrl512": "https://is1-ssl.mzstatic.com/image/thumb/example/512x512.png",
    "artworkUrl600": "https://is1-ssl.mzstatic.com/image/thumb/example/600x600.png",
    "primaryGenreName": "Photo & Video",
    "primaryGenreId": "6008",
    "genres": ["Photo & Video", "Social Networking"],
    "genreIds": ["6008", "6005"],
    "contentAdvisoryRating": "12+",
    "languageCodesISO2A": ["EN", "ES"],
    "fileSizeBytes": "215678976",
    "minimumOsVersion": "15.0",
    "releaseDate": "2018-04-02T07:00:00Z",
    "currentVersionReleaseDate": "2026-08-20T07:00:00Z",
    "releaseNotes": "Bug fixes and performance improvements.",
    "version": "9.4.1",
    "price": 0,
    "currency": "USD",
    "artistId": "284882218",
    "artistName": "Sample Inc.",
    "artistViewUrl": "https://apps.apple.com/us/developer/sample-inc/id284882218",
    "sellerUrl": "https://www.example.com",
    "averageUserRating": 4.5,
    "userRatingCount": 128340,
    "averageUserRatingForCurrentVersion": 4.6,
    "currentVersionScore": 892,
    "screenshotUrls": [
        "https://is1-ssl.mzstatic.com/image/thumb/example/screenshot1.png",
        "https://is1-ssl.mzstatic.com/image/thumb/example/screenshot2.png"
    ],
    "ipadScreenshotUrls": [],
    "appletvScreenshotUrls": [],
    "supportedDevices": ["iPhone13,1", "iPhone13,2"],
    "similarApps": [
        {
            "trackId": "123456789",
            "bundleId": "com.example.anotherphotoapp",
            "trackName": "Another Photo App",
            "trackViewUrl": "https://apps.apple.com/us/app/another-photo-app/id123456789",
            "price": 0,
            "currency": "USD"
        }
    ],
    "reviews": [
        {
            "id": "10234567890",
            "userName": "jdoe",
            "title": "Great app!",
            "review": "Really enjoy using this every day.",
            "rating": 5,
            "version": "9.4.0",
            "updated": "2026-08-15T10:32:00Z"
        }
    ]
}

Which Errors Does the App Store Scraper Report?

The App Store Scraper reports 23 error codes. 20 of the 23 codes are non-terminal, covering per-query failures that skip one app, one developer query or one page and leave the rest of the run alive. 3 codes terminate the run: C098, C099 and C100.

The 20 non-terminal codes split into 6 recovery behaviors:

• 6 codes (C001, C002, C003, C008, C009, C010) skip one app and push no dataset item for it.
• 4 codes (C004, C005, C011, C012) skip only the similar-apps step and leave the main app item intact.
• 4 codes (C006, C007, C013, C014) stop review pagination for one app and keep every review already collected.
• 3 codes (C015, C016, C017) skip one developer query and push no items for it.
• 2 codes (C018, C020) skip one keyword search page.
• 1 code (C019) pushes an error item and retries the request after a short delay, up to the configured retry limit.

Error Code	Cause	Behavior
C001	Request for an app (by App ID) failed.	The app is skipped; no dataset item is pushed for it.
C002	Request for an app (by App ID) returned an empty response.	The app is skipped; no dataset item is pushed for it.
C003	No app was found for the given App ID.	The app is skipped; no dataset item is pushed for it.
C004	Request for an app's similar apps failed.	The similar-apps step for that app is skipped; the main app item is unaffected.
C005	Request for an app's similar apps returned an empty response.	The similar-apps step for that app is skipped; the main app item is unaffected.
C006	Request for a page of an app's reviews failed.	Review pagination for that app stops; reviews collected so far are kept.
C007	Request for a page of an app's reviews returned an empty response.	Review pagination for that app stops; reviews collected so far are kept.
C008	Request for an app (by Bundle ID) failed.	The app is skipped; no dataset item is pushed for it.
C009	Request for an app (by Bundle ID) returned an empty response.	The app is skipped; no dataset item is pushed for it.
C010	No app was found for the given Bundle ID.	The app is skipped; no dataset item is pushed for it.
C011	Request for a bundle's similar apps failed.	The similar-apps step for that app is skipped; the main app item is unaffected.
C012	Request for a bundle's similar apps returned an empty response.	The similar-apps step for that app is skipped; the main app item is unaffected.
C013	Request for a page of a bundle's reviews failed.	Review pagination for that app stops; reviews collected so far are kept.
C014	Request for a page of a bundle's reviews returned an empty response.	Review pagination for that app stops; reviews collected so far are kept.
C015	Request for a developer's apps failed.	The developer query is skipped; no items are pushed for it.
C016	Request for a developer's apps returned an empty response.	The developer query is skipped; no items are pushed for it.
C017	No apps were found for the given Developer ID.	The developer query is skipped; no items are pushed for it.
C018	Request for a keyword search page failed.	That search page is skipped.
C019	The backend rate limit was exceeded (HTTP 429).	An error item is pushed to the dataset, the request is retried after a short delay, up to the configured retry limit.
C020	A keyword search page returned an empty response.	That search page is skipped.
C098	An unhandled promise rejection occurred anywhere in the run.	The error is logged and tracked, and the actor exits immediately.
C099	An uncaught exception occurred anywhere in the run.	The error is logged and tracked, and the actor exits immediately.
C100	The run failed to initialize.	The actor exits immediately.

Which App Store Scraper Questions Come Up Most Often?

Does the App Store Scraper need an App Store URL?

No. The App Store Scraper resolves apps from appIds, bundleIds or developerIds without a full URL. startUrls is one of five accepted identifiers rather than a requirement.

Which App Store URLs does the App Store Scraper accept?

The App Store Scraper accepts http and https URLs on an apple hostname, in two page shapes: an app detail page whose path contains /id and /app/, and a developer page whose path contains /id and /developer/. Other App Store page types are skipped with a warning.

Can the App Store Scraper search the App Store by keyword?

Yes. Set term to the keyword and mode to search. The search endpoint is requested page by page, starting at page and ending at endPage.

Does the App Store Scraper charge search-query for every page of a keyword search?

No. search-query is charged once per keyword search run, no matter how many pages endPage allows. dataset-item still applies to the apps returned from every page, except that a paying account's first results page is exempt from that charge.

Which App Store storefront does the App Store Scraper use?

country sets the App Store storefront country for the run.

Which language does the App Store Scraper return?

lang sets the response language. Omitting lang returns the storefront country's language.

How many apps does the App Store Scraper return?

maxItems sets the maximum number of top-level application items a run outputs. The default is all.

How far does the App Store Scraper paginate?

endPage sets the last page requested. Pagination is unbounded by default, and the actor keeps paging until the provider returns an empty page or maxItems is reached.

Why did the App Store Scraper reject my customMapFunction?

A customMapFunction is rejected on two conditions: its source contains new Date, 1970 or Date.now, or it is not a plain synchronous function returning a non-null object. Async functions, generators and Promises are rejected. The run continues with unmodified items.

What happens when the App Store Scraper finds no matching app?

The app is skipped and no dataset item is pushed for it. The App Store Scraper reports C003 for an App Store ID with no match and C010 for a bundle ID with no match.

What happens when the App Store Scraper hits a rate limit?

The App Store Scraper reports C019 on HTTP 429, pushes an error item to the dataset, and retries the request after a short delay, up to the configured retry limit.

Does the App Store Scraper discard reviews when a review page fails?

No. Review pagination for that app stops and the reviews collected so far are kept. This applies to C006, C007, C013 and C014.

Can the App Store Scraper return similar apps and reviews on the same item?

Yes. includeSimilarApps and includeReviews both attach their results to the app's dataset item, in the similarApps and reviews arrays.

Which App Store Scraper failures stop the whole run?

Three error codes stop the run: C098 for an unhandled promise rejection, C099 for an uncaught exception, and C100 for a failed initialization. Every other code skips one query and continues.

Where Do You Get App Store Scraper Support?

The App Store Scraper is published by epctex. Visit epctex.com to see all available products. For custom integrations, reach out through the chat box on epctex.com. For support, contact business@epctex.com.