# App Store & Google Play Reviews Scraper (`maged120/app-store-reviews-scraper`) Actor

Scrape reviews from Apple App Store and Google Play in one run. Supports bulk app lists, country/language filtering, and developer response data.

- **URL**: https://apify.com/maged120/app-store-reviews-scraper.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Categories:** Developer tools, Integrations, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does App Store & Google Play Reviews Scraper do?

**Collect app reviews from Apple App Store and Google Play in a single run.** Paste any mix of App Store and Play Store URLs, set how many reviews you want, and get a clean structured dataset with ratings, review text, dates, app versions, and developer responses — ready to download as JSON, CSV, or Excel.

Run it on a schedule to monitor your own app or track competitors. Connect to Zapier, Make, or any API to pipe reviews into Slack, Sheets, or your data warehouse automatically.

### Why use this scraper?

- **Both stores, one run.** No need to maintain two separate scrapers or stitch datasets together manually.
- **Bulk support.** Paste 50 app URLs at once — each gets processed independently with its own review count.
- **Developer responses included.** Know when a developer replied to a review and what they said.
- **No account required.** Works out of the box for any publicly listed app.
- **Recurring monitoring.** Schedule daily or weekly runs to track review volume, average rating drift, and sentiment changes over time.

**Who uses this data:**
- Mobile product teams tracking user feedback and bug reports
- ASO (App Store Optimization) agencies benchmarking client apps against competitors
- Customer success teams triaging negative reviews for follow-up
- Investors doing due diligence on app quality and user satisfaction
- Marketers pulling voice-of-customer quotes for copy and messaging

### How to use

1. Open the **Input** tab in Apify Console
2. Paste one or more App Store or Play Store URLs into **App URLs**
3. Set **Max reviews per app** — up to 500 for Apple, higher for Google Play
4. Set **Country** (e.g. `us`, `gb`, `de`) and **Language** if needed
5. Click **Start** and wait for the run to finish
6. Open the **Output** tab to view results, or download as JSON/CSV/Excel

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `startUrls` | array | App Store or Play Store URLs to scrape | — |
| `maxReviews` | integer | Maximum reviews to collect per app | 500 |
| `country` | string | Two-letter store country code (`us`, `gb`, `jp`…) | `us` |
| `language` | string | Two-letter language code for Google Play (`en`, `de`, `fr`…) | `en` |

**Example input:**
```json
{
  "startUrls": [
    { "url": "https://apps.apple.com/us/app/notion/id1232780281" },
    { "url": "https://play.google.com/store/apps/details?id=notion.id" }
  ],
  "maxReviews": 1000,
  "country": "us",
  "language": "en"
}
````

### Output

Each review is one row in the dataset.

```json
[
  {
    "store": "apple",
    "appId": "1232780281",
    "reviewId": "10887654321",
    "rating": 5,
    "title": "Game changer for note-taking",
    "text": "Been using this for two years. Nothing else comes close for organizing projects.",
    "userName": "productivitynerd42",
    "date": "2025-04-18T14:22:00-07:00",
    "version": "3.12",
    "developerResponse": null,
    "thumbsUpCount": null
  },
  {
    "store": "google",
    "appId": "notion.id",
    "reviewId": "gp:AOqpTOH...",
    "rating": 4,
    "title": null,
    "text": "Solid app but the mobile editor still lags on Android 14.",
    "userName": "Marcus W.",
    "date": "2025-04-20T09:11:00",
    "version": "3.12.1",
    "developerResponse": {
      "text": "Thanks for the feedback! We have a fix shipping in 3.13.",
      "date": "2025-04-21T11:00:00"
    },
    "thumbsUpCount": 37
  }
]
```

You can download the dataset in JSON, HTML, CSV, or Excel from the Output tab or via the Apify API.

### Data fields

| Field | Description |
|---|---|
| `store` | `apple` or `google` |
| `appId` | App Store numeric ID or Play Store package name |
| `reviewId` | Unique review identifier |
| `rating` | Star rating (1–5) |
| `title` | Review title (Apple only; `null` for Google Play) |
| `text` | Full review body |
| `userName` | Reviewer display name |
| `date` | ISO 8601 timestamp of the review |
| `version` | App version the reviewer was running |
| `developerResponse` | Object with `text` and `date` if the developer replied; otherwise `null` |
| `thumbsUpCount` | Helpful votes (Google Play only; `null` for Apple) |

### Pricing

Runs are charged per result. A typical run fetching 1,000 reviews across two apps completes in under 2 minutes. Google Play runs use minimal compute; Apple runs are pure HTTP with no browser overhead.

Apify's free tier includes $5/month of usage — enough to run several hundred scrapes.

### Tips

- **Scale with country codes.** Apple's public feed returns up to 500 reviews per country. To get broader coverage for a major app, run separate jobs for `us`, `gb`, `au`, `ca` and merge the datasets.
- **Use scheduling for monitoring.** Set a weekly trigger to track rating changes and new review volume over time — useful for shipping post-mortems or tracking a competitor's app store performance.
- **Filter by rating in your pipeline.** The dataset includes the numeric `rating` field; pipe it through Apify's data transformation or your own ETL to isolate 1-star reviews for triage.
- **Google Play gets more reviews.** There is no hard cap for Google Play — `maxReviews` controls how many to fetch. For high-volume apps (e.g. social media apps), set a realistic limit to avoid very long run times.

### FAQ

**Is scraping app reviews legal?**
App reviews are publicly visible content. Collecting them for research, competitive analysis, or monitoring is standard practice across the industry. Always comply with the terms of service of the platforms you access and applicable data protection laws in your jurisdiction.

**Why does Apple cap at 500 reviews?**
Apple's public review feed is limited to 10 pages of 50 reviews each. This is a platform-level limit. Use the country field to collect reviews from different store regions for broader coverage.

**Can I scrape reviews for any app?**
Any app with a public listing on the App Store or Google Play can be scraped. Private or unlisted apps are not accessible.

**Something broken or a feature request?**
Open an issue in the Issues tab. For custom data pipelines or enterprise volumes, reach out via Discord: `maged03211`.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more App Store or Google Play URLs. Accepts both apple.com/app/... and play.google.com/store/apps/... links.

## `maxReviews` (type: `integer`):

Maximum number of reviews to collect per app. Apple App Store is capped at 500 per country by the public feed.

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

Two-letter country code for the store region (e.g. us, gb, de, jp). Affects which reviews are returned.

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

Two-letter language code for Google Play reviews (e.g. en, de, fr). Apple reviews always return in the store's language.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apps.apple.com/us/app/instagram/id389801252"
    },
    {
      "url": "https://play.google.com/store/apps/details?id=com.instagram.android"
    }
  ],
  "maxReviews": 500,
  "country": "us",
  "language": "en"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://apps.apple.com/us/app/instagram/id389801252"
        },
        {
            "url": "https://play.google.com/store/apps/details?id=com.instagram.android"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/app-store-reviews-scraper").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 = { "startUrls": [
        { "url": "https://apps.apple.com/us/app/instagram/id389801252" },
        { "url": "https://play.google.com/store/apps/details?id=com.instagram.android" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maged120/app-store-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://apps.apple.com/us/app/instagram/id389801252"
    },
    {
      "url": "https://play.google.com/store/apps/details?id=com.instagram.android"
    }
  ]
}' |
apify call maged120/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maged120/app-store-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store & Google Play Reviews Scraper",
        "description": "Scrape reviews from Apple App Store and Google Play in one run. Supports bulk app lists, country/language filtering, and developer response data.",
        "version": "0.1",
        "x-build-id": "ELvcLocda6mfJvllW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maged120~app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maged120-app-store-reviews-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/maged120~app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maged120-app-store-reviews-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/maged120~app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maged120-app-store-reviews-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "App URLs",
                        "type": "array",
                        "description": "Paste one or more App Store or Google Play URLs. Accepts both apple.com/app/... and play.google.com/store/apps/... links.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per app. Apple App Store is capped at 500 per country by the public feed.",
                        "default": 500
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for the store region (e.g. us, gb, de, jp). Affects which reviews are returned.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter language code for Google Play reviews (e.g. en, de, fr). Apple reviews always return in the store's language.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            },
                            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
