# App Store & Google Play Reviews API (`subimpact/app-reviews-api`) Actor

iOS App Store and Google Play reviews as one JSON stream: rating, title, text, app version, date, helpful votes, developer replies, country and language. Both stores in one actor, from $0.09 per 1,000 reviews.

- **URL**: https://apify.com/subimpact/app-reviews-api.md
- **Developed by:** [subimpact](https://apify.com/subimpact) (community)
- **Categories:** Developer tools, Social media, AI
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 reviews

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## App Store & Google Play Reviews API

Pull **iOS App Store** and **Google Play** reviews as one clean JSON stream. One row per review with the
rating, title, text, app version, date, helpful votes and developer reply — from both stores, in the same
run, from the same input list.

- **Both stores, one actor.** Paste App Store URLs/ids and Google Play URLs/package names together; the
  store is detected per app.
- **No login, no API key, no account risk.** Reads the public review feeds the two stores serve to their
  own web pages.
- **Deep paging.** Google Play pages through its review RPC with continuation tokens (thousands of
  reviews per app). Apple goes up to 500 reviews per app from the sorted public feed, and past 500 through
  Apple's own deeper web endpoint.
- **Priced per delivered review.** Only real review rows are charged: reviews you filter out, apps that
  return nothing, and error rows cost nothing.

### What you get

| | |
|---|---|
| Stores | Apple App Store, Google Play |
| Unit | one dataset item per review |
| Freshness | the store's own feed — reviews published minutes ago are usually there |
| Filters | country, language, sort order, star-rating range, “since” date, per-app cap |
| Volume | up to 50,000 reviews per app, as many apps as you paste |

### Quick start

Input:

```json
{
  "apps": ["id389801252", "https://play.google.com/store/apps/details?id=com.instagram.android"],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 200
}
```

Run it (or click **Start** with the same input):

```bash
apify call YOUR_USERNAME/app-reviews-api --input '{"apps":["id389801252","com.instagram.android"],"maxReviewsPerApp":200}'
```

Accepted app references (mix and match in `apps`):

- `id389801252`, `389801252`, `https://apps.apple.com/us/app/instagram/id389801252`
- `com.instagram.android`, `https://play.google.com/store/apps/details?id=com.instagram.android`

An entry that cannot be read is reported as an uncharged error row, and the rest of the run continues.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `apps` | array | — (required) | App Store URLs/ids and/or Google Play URLs/package names. Duplicates are collapsed. |
| `country` | string | `us` | Two-letter store country (`us`, `gb`, `de`, `my`, `sg`, `in`, `jp`, `br`…). Decides which reviews exist: Apple storefront, Google Play country. |
| `language` | string | `en` | Language used for the store pages (`en`, `de`, `pt-BR`, `zh-Hans`…). Review text is always returned exactly as the reviewer wrote it. |
| `sort` | string | `newest` | `newest` or `mostRelevant` (the store's own relevance / most-helpful order). |
| `maxReviewsPerApp` | integer | `200` | Cap on delivered reviews per app, 1–50,000. The default keeps a run at about two cents. |
| `minRating` / `maxRating` | integer | — | Keep only reviews inside a star range (1–5). Filtered reviews are never charged. |
| `sinceDate` | string | — | Only reviews published on or after this ISO date, e.g. `2026-01-01`. With `sort=newest` the run stops paging as soon as it reaches older reviews. |

### Output

One dataset item per review. This is a real row from a live test run (Instagram, `us`, 2026-11-15):

```json
{
  "store": "apple",
  "appId": "389801252",
  "appName": "Instagram",
  "reviewId": "14785061938",
  "userName": "edesland",
  "rating": 1,
  "title": "complain",
  "text": "I used to enjoy sharing photos and memories on Instagram. About a year ago, Meta closed my Instagram and Facebook accounts without an explanation I could understand. I opened a new Instagram account, and now I can’t change the password. The saved password is rejected, and tapping “Forgot your password?” immediately brings up “Something went wrong, please try again.”\n\nI’m still signed in on my phone, but I’m afraid to rely on Instagram for photos I care about. If I lose access again, I don’t know how I’ll get them back. I haven’t found a support option that helps me resolve this. Meta needs a password reset that works and a way to reach someone when it fails.",
  "version": "455.0.0",
  "date": "2026-11-13T10:57:47.000Z",
  "thumbsUp": 0,
  "developerReply": null,
  "developerReplyDate": null,
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-11-14T19:32:31.672Z",
  "status": null,
  "error": null
}
```

A Google Play row from the same run, for comparison:

```json
{
  "store": "google",
  "appId": "com.instagram.android",
  "appName": "Instagram",
  "reviewId": "fd12ca1f-d50d-40aa-9ff1-2fc101ef1a12",
  "userName": "Tayoubi Sara",
  "rating": 1,
  "title": null,
  "text": "I don't have the repost bottom and I can't see who likes the reels even when I update the app",
  "version": null,
  "date": "2026-11-13T19:31:21.000Z",
  "thumbsUp": 0,
  "developerReply": null,
  "developerReplyDate": null,
  "country": "us",
  "language": "en",
  "scrapedAt": "2026-11-14T19:32:31.672Z",
  "status": null,
  "error": null
}
```

#### Field reference

| Field | Type | Source |
|---|---|---|
| `store` | string | `apple` or `google`, detected from the app reference |
| `appId` | string | Apple numeric id, or Google Play package name |
| `appName` | string | Apple: iTunes lookup `trackName`. Google: the Play page title |
| `reviewId` | string | Apple review id / Google review id — stable, usable as a primary key |
| `userName` | string | reviewer's public display name |
| `rating` | integer | 1–5 stars |
| `title` | string | review title; **null for Google Play** (Play has no review titles) |
| `text` | string | full review body, line breaks preserved |
| `version` | string | app version the reviewer was running. `null` when the reviewer hid it, and on the Apple deep path (>500 reviews), where Apple does not publish it |
| `date` | string | review publication time, ISO 8601 UTC |
| `thumbsUp` | integer | Google Play helpful-vote count; Apple helpful votes when Apple publishes them |
| `developerReply` | string | developer response text — **Google Play only** (Apple's public review feeds carry no developer responses) |
| `developerReplyDate` | string | developer response time, ISO 8601 UTC |
| `country` / `language` | string | the store country and language this run used |
| `scrapedAt` | string | when this row was collected |
| `status` / `error` | string | set only on uncharged non-review rows (bad app reference, store failure) |

### Pricing

**$0.09 per 1,000 reviews** ($0.00009 per delivered review), platform usage included. You pay only for
review rows that land in your dataset: filtered-out reviews, empty apps and error rows are free. A default
run (2 apps × 200 reviews) costs about **$0.04**, a 10,000-review pull about **$0.90**.

Charging stops automatically at your account's maximum charge per run — the actor then stops collecting
instead of delivering rows you were not charged for.

### How it works, and what it cannot do

- **Apple** reviews come from Apple's public customer-reviews feed (50 reviews per page, 10 pages =
  **500 reviews per app**), which is the only Apple source that can be sorted by date/relevance and that
  exposes the app version. If you ask for more than 500 reviews for an app, the actor switches to the same
  deeper endpoint `apps.apple.com` uses for its own review list, which pages past 500 but returns Apple's
  own ordering and no app version.
- **Apple publishes no developer responses** on those endpoints, so `developerReply` and
  `developerReplyDate` are null for `store: "apple"`.
- **Google Play** reviews come from the store's own review RPC, paged with continuation tokens, so volume
  is not limited to what the app page embeds. Play has no review titles, and some reviewers hide their app
  version — that is when `version` is null on a Play row.
- **Sort order**: `mostRelevant` is the store's own relevance ordering, which is *not* chronological. Use
  `newest` (the default) when you need recent reviews or a `sinceDate` cutoff.
- **Rate limits**: both endpoints are public and served without keys. The actor paces requests, retries
  with backoff on 429/5xx, and — if a store starts blocking its IPs — retries through a datacenter proxy.
  Very large runs (>10,000 reviews) are best split into several runs by app.
- **Reviews are public data**, but treat reviewer names as personal data under GDPR if you store them.

### Support

Found a store change, a field that stopped filling, or need another market? Open an issue on the actor's
page — store feed changes are fixed quickly.

# Actor input Schema

## `apps` (type: `array`):

Apps to pull reviews for. Paste anything that identifies an app and the store is detected automatically: App Store URLs (https://apps.apple.com/us/app/instagram/id389801252), bare Apple ids (id389801252 or 389801252), Google Play URLs (https://play.google.com/store/apps/details?id=com.instagram.android) or bare package names (com.instagram.android). Mix both stores in one run.

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

Two-letter store country: us, gb, de, my, sg, in, jp, br… The store's country decides which reviews exist (App Store storefront, Google Play country) and both stores return reviews written in every language for that country.

## `language` (type: `string`):

Language code used for the store pages and for the App Store's amp-api interface language, e.g. en, de, fr, pt-BR, zh-Hans. Review text is always returned as the reviewer wrote it.

## `sort` (type: `string`):

newest = newest reviews first (recommended with sinceDate, the run stops paging as soon as it reaches older reviews). mostRelevant = the store's own relevance / most-helpful ordering, which is not chronological.

## `maxReviewsPerApp` (type: `integer`):

Cap on delivered reviews for each app (1-50000). The default of 200 reviews per app keeps a two-app default run at about four cents. Apple: up to 500 reviews per app come from Apple's public review feed (sorted, with app version); above 500 the actor switches to Apple's deeper web endpoint, which pages past 500 but does not expose the app version.

## `minRating` (type: `integer`):

Skip reviews with fewer stars than this (1-5). Leave empty for no lower bound.

## `maxRating` (type: `integer`):

Skip reviews with more stars than this (1-5). Leave empty for no upper bound.

## `sinceDate` (type: `string`):

Only deliver reviews published on or after this date. ISO format, e.g. 2026-01-01 or 2026-01-01T00:00:00Z. With sort=newest the actor stops paging once it reaches older reviews, so it does not crawl history it will not deliver.

## Actor input object example

```json
{
  "apps": [
    "id389801252",
    "com.instagram.android"
  ],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 200
}
```

# Actor output Schema

## `results` (type: `string`):

One dataset item per review: store, appId, appName, reviewId, userName, rating, title, text, version, date, thumbsUp, developerReply, developerReplyDate, country, language, scrapedAt (plus status/error on uncharged non-review rows).

# 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 = {
    "apps": [
        "id389801252",
        "com.instagram.android"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/app-reviews-api").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 = { "apps": [
        "id389801252",
        "com.instagram.android",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("subimpact/app-reviews-api").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 '{
  "apps": [
    "id389801252",
    "com.instagram.android"
  ]
}' |
apify call subimpact/app-reviews-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,subimpact/app-reviews-api"
        }
    }
}
```

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/sek2Qss8H7Hctmt1o/builds/Hj4Iz5kRyicJkpAG7/openapi.json
