Pricing

from $6.00 / 1,000 apps

Try for free

Go to Apify Store

App Store & Google Play Reviews Scraper | $0.01/App, No Cap

Name: App Store & Google Play Reviews Scraper | $0.01/App, No Cap
Price: 6 USD

Try for free

Reviews, metadata and keyword rankings for iOS and Android apps, in one common schema, across every storefront. Full review sweep that does not lose reviews on the way. No login, no cookies.

Pricing

from $6.00 / 1,000 apps

Rating

0.0

(0)

Developer

Alexis Morain

Actor stats

Bookmarked

Total users

Monthly active users

10 days ago

Last modified

Categories

Developer tools

SEO tools

E-commerce

You can access the App Store & Google Play Reviews Scraper | $0.01/App, No Cap programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.2",
    "x-build-id": "TSle8DxO5mUcYzM90"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/alexmorain~app-store-play-store-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-alexmorain-app-store-play-store-scraper",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    },
    "/acts/alexmorain~app-store-play-store-scraper/runs": {
      "post": {
        "operationId": "runs-sync-alexmorain-app-store-play-store-scraper",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor and returns information about the initiated run in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/runsResponseSchema"
                }
              }
            }
          }
        }
      }
    },
    "/acts/alexmorain~app-store-play-store-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-alexmorain-app-store-play-store-scraper",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "inputSchema": {
        "type": "object",
        "properties": {
          "apps": {
            "title": "Apps",
            "type": "array",
            "description": "The apps to collect, one per line. Four accepted forms, freely mixed in the same list:<br>• an App Store numeric id: <code>310633997</code><br>• a Google Play package name: <code>com.whatsapp</code><br>• a full App Store URL: <code>https://apps.apple.com/us/app/id324684580</code><br>• a full Google Play URL: <code>https://play.google.com/store/apps/details?id=com.spotify.music</code><br><br><b>Where to find them:</b> the numeric id is at the end of any App Store URL, right after <code>id</code>. The package name is the <code>id=</code> parameter of any Google Play URL. Pasting the URL straight from your browser always works.<br><br>Anything the Actor cannot read is skipped with an explanation in the log, and the rest of the list still runs. Leave this empty only if you run in keyword-ranking mode.",
            "items": {
              "type": "string"
            }
          },
          "countries": {
            "title": "Storefronts",
            "type": "array",
            "description": "ISO 3166-1 country codes of the app stores to sweep: <code>us</code>, <code>fr</code>, <code>gb</code>, <code>de</code>, <code>jp</code>... Case does not matter.<br><br><b>Why it matters:</b> both stores are partitioned by country. A US review never appears in the French store, and an app can be ranked 3rd in one country and absent from another. One app on three storefronts means three sweeps, three sets of reviews, and three billable units.<br><br>Start with one storefront, add more once you have seen the shape of the data. Leave empty for the US storefront only.",
            "items": {
              "type": "string"
            }
          },
          "include": {
            "title": "What to collect",
            "type": "array",
            "description": "Tick each item independently.<br>• <b>Reviews</b>: every review the store serves, swept to the real end of the feed.<br>• <b>App metadata</b>: the store profile of the app, name, developer, average rating, rating count, version, genre, price, installs, description and icon.<br>• <b>Keyword rankings</b>: for each search term you give below, the ranked list of apps in that storefront, on the App Store, on Google Play or both (pick the stores in section 3).<br><br>Reviews and metadata are covered by the same single unit per app and storefront, so leaving both ticked is strictly the best value. Rankings are billed separately, per keyword, storefront and store.",
            "items": {
              "type": "string",
              "enum": [
                "reviews",
                "metadata",
                "rankings"
              ],
              "enumTitles": [
                "Reviews",
                "App metadata",
                "Keyword rankings"
              ]
            },
            "default": [
              "reviews",
              "metadata"
            ]
          },
          "mode": {
            "title": "Mode",
            "enum": [
              "all",
              "new-only"
            ],
            "type": "string",
            "description": "<b>All reviews</b> returns everything the store serves, on every run. That is what you want the first time, and for any one-off analysis.<br><br><b>New reviews only</b> keeps a persistent registry per app and storefront and returns only reviews it has never seen. Schedule it daily and you get a clean feed of new feedback instead of the same corpus again. The first run in this mode still returns the whole backlog, since nothing has been seen yet. Add a <b>Webhook URL</b> below to be called when something new comes in.",
            "default": "all"
          },
          "webhookUrl": {
            "title": "Webhook URL",
            "type": "string",
            "description": "If set, the Actor POSTs a small JSON summary to this URL at the end of the run: review count, reviews per app and storefront, dataset id, run id.<br><br>In <b>New reviews only</b> mode it is called <b>only when at least one new review came in</b>. With a daily schedule, that is a push notification: silence when nothing moved, a call when users posted something. In <b>All reviews</b> mode it is called whenever the run returned data.<br><br>Leave empty to skip it. Redirects are not followed except a 307 or 308, so paste the final URL. An unreachable webhook is logged as a warning and never fails the run. Stored encrypted, like a password, since a webhook URL often carries its own access token."
          },
          "maxReviewsPerApp": {
            "title": "Max reviews per app and storefront",
            "minimum": 1,
            "type": "integer",
            "description": "Upper bound on reviews collected for one app on one storefront.<br><br><b>It does not change the price</b>, which is per app and storefront whatever the volume, so raise it freely when you want depth. Use it to control run duration instead: <code>100</code> gives you the current mood of an app in seconds, <code>500</code> is a solid sample, several thousand walks the feed to its real end.<br><br>The sweep never stops on an apparently empty page, which is how it gets past the App Store quirk that makes RSS-based scrapers return nothing at all.",
            "default": 500
          },
          "keywords": {
            "title": "Keywords",
            "type": "array",
            "description": "Search terms to track, one per line: <code>music streaming</code>, <code>meditation</code>, <code>expense report</code>. For each term, each storefront and each store picked in <b>Ranking stores</b>, the Actor records the ranked list of apps, position by position. This is App Store and Google Play SEO tracking.<br><br>Only used when <b>Keyword rankings</b> is ticked above, so leave it empty otherwise. It works with no app in the list at all: keywords alone is a perfectly valid run.",
            "items": {
              "type": "string"
            }
          },
          "rankingDepth": {
            "title": "Ranking depth",
            "minimum": 1,
            "maximum": 200,
            "type": "integer",
            "description": "How many ranked apps to record per keyword, storefront and store. <code>10</code> answers \"who owns the top of this search\", <code>50</code> covers the realistic discovery zone, <code>200</code> is the deepest the App Store serves. <b>Google Play serves about 30 results per search</b>, so on Play you get at most that many rows whatever you set here. The price is per keyword, storefront and store, not per position, so depth is free.",
            "default": 50
          },
          "rankingStores": {
            "title": "Ranking stores",
            "type": "array",
            "description": "Which stores to search for each keyword: <b>App Store</b>, <b>Google Play</b>, or both.<br><br><b>Billing:</b> one keyword ranking unit per keyword, storefront and store that returns results. Two stores on the same keyword and storefront means two units.<br><br>When this field is left out, as in API calls and saved tasks from before it existed, only the App Store is searched, exactly like earlier versions.",
            "items": {
              "type": "string",
              "enum": [
                "apple",
                "google"
              ],
              "enumTitles": [
                "App Store",
                "Google Play"
              ]
            },
            "default": [
              "apple"
            ]
          },
          "proxyConfiguration": {
            "title": "Proxy",
            "type": "object",
            "description": "<b>Leave this off.</b> Both stores are read over plain HTTP through their public endpoints and need no proxy in normal use; enabling one only makes the run slower. Turn it on if you sweep hundreds of app-storefront pairs in a single run and start seeing rate limits in the log.",
            "default": {
              "useApifyProxy": false
            }
          }
        }
      },
      "runsResponseSchema": {
        "type": "object",
        "properties": {
          "data": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "actId": {
                "type": "string"
              },
              "userId": {
                "type": "string"
              },
              "startedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "finishedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "status": {
                "type": "string",
                "example": "READY"
              },
              "meta": {
                "type": "object",
                "properties": {
                  "origin": {
                    "type": "string",
                    "example": "API"
                  },
                  "userAgent": {
                    "type": "string"
                  }
                }
              },
              "stats": {
                "type": "object",
                "properties": {
                  "inputBodyLen": {
                    "type": "integer",
                    "example": 2000
                  },
                  "rebootCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "restartCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "resurrectCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "computeUnits": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "options": {
                "type": "object",
                "properties": {
                  "build": {
                    "type": "string",
                    "example": "latest"
                  },
                  "timeoutSecs": {
                    "type": "integer",
                    "example": 300
                  },
                  "memoryMbytes": {
                    "type": "integer",
                    "example": 1024
                  },
                  "diskMbytes": {
                    "type": "integer",
                    "example": 2048
                  }
                }
              },
              "buildId": {
                "type": "string"
              },
              "defaultKeyValueStoreId": {
                "type": "string"
              },
              "defaultDatasetId": {
                "type": "string"
              },
              "defaultRequestQueueId": {
                "type": "string"
              },
              "buildNumber": {
                "type": "string",
                "example": "1.0.0"
              },
              "containerUrl": {
                "type": "string"
              },
              "usage": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "integer",
                    "example": 1
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "usageTotalUsd": {
                "type": "number",
                "example": 0.00005
              },
              "usageUsd": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "number",
                    "example": 0.00005
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

App Store & Google Play Reviews Scraper: $0.01/App, No Cap OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for App Store & Google Play Reviews Scraper | $0.01/App, No Cap from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

App Store & Google Play Reviews Scraper | $0.01/App, No Cap API in Python

App Store & Google Play Reviews Scraper | $0.01/App, No Cap API in JavaScript

App Store & Google Play Reviews Scraper | $0.01/App, No Cap API through CLI

App Store & Google Play Reviews Scraper | $0.01/App, No Cap API

Google Play Scraper - Rankings, Reviews & App Details

haketa/google-play-scraper

Google Play scraper & API: export top-chart rankings by category & country, app reviews & ratings, full app details and ASO keyword search. Android app market intelligence, review analysis and competitor tracking — fast, no login. Pairs with an Apple App Store scraper.

Haketa

App Store Intelligence Pro - ASO & Rank Tracker

webdatalabs/app-store-intelligence-pro

Cross-store (Apple App Store + Google Play) ASO & competitor research: keyword difficulty + popularity, rank tracking, top charts, full metadata and AI review insights.

WebDataLabs

Apple App Store Plus

canadesk/apple-app-store-plus

No limits. Get details and reviews for a specific app, search by keyword or developer, retrieve top rankings, assess permissions and more!

Canadesk Support

1.0

(2)

Google Play Store Scraper

maximedupre/google-play-store-scraper

Scrape Google Play Store apps, reviews, permissions, and Data Safety disclosures from keywords, package IDs, app URLs, category pages, or developer pages. Export app metadata, ratings, prices, developers, review text, replies, source URLs, permissions, privacy disclosures, ranks, and locale fields.

Maxime Dupré

Apple App Store Scraper

maximedupre/apple-app-store-scraper

Scrape public Apple App Store app data, reviews, search results, and top charts. Export ratings, prices, developers, genres, versions, screenshots, and review text.

Maxime Dupré

App Store + Google Play Rank Tracker

constructive_calm/app-store-rank-tracker

Daily top-chart snapshots across 150+ countries for Apple App Store and Google Play — Free, Paid, Grossing. Built-in rank deltas (1d/7d/30d), top movers, new entries, dropoffs, and statistical forecasts. Per-app enrichment (ratings, reviews, dev, category).

Omar Eldeeb

5.0

(1)

BORG App Store Reviews

acid-base/borg-app-store-reviews

No API key or login required. Extract structured app store reviews data on demand — clean JSON output, run via API, schedule and monitor runs, or integrate with your stack.

Daniel Yates

📱 Google Play Store Scraper — App Reviews & Details

inexhaustible_glass/google-play-scraper

Scrape any Android app's reviews + metadata from Google Play. No login or API key. Author, rating, text, thumbs-up, date, app version, developer reply + app info (rating, installs, developer, genre). Auto-paginates to thousands. For app devs, ASO/marketers, competitor & sentiment analysis.

Hitman studio

App Store Reviews Scraper | $0.10/1K | 175 Countries

extractkit/app-store-reviews-scraper

Scrape App Store reviews and ratings for any iOS app across all 175 Apple storefronts. Star rating, review text, author, app version and country. No login, no proxies. $0.10 per 1,000 reviews.

Extract Kit

5.0

(1)

App Stores Scraper - Apple App Store & Google Play ASO

crawloop/app-stores-scraper

Scrape Apple App Store and Google Play in one run: app details, reviews, keyword search, top charts, ASO keyword ranks, developer catalogs, and monitors. Cross-store app pairs, multi-country. Fast HTTP — no browser.