# App Store & Google Play Reviews Scraper: Only New Reviews (`chimey_forearm/app-reviews-scraper`) Actor

App Store reviews and Google Play reviews scraper in one run, no login: ratings, text, dates, developer replies, countries. Only-new monitoring, star and date filters, app search. $0.10 per 1,000 reviews. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/chimey_forearm/app-reviews-scraper.md
- **Developed by:** [Mohamed Bahaa](https://apify.com/chimey_forearm) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 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.

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

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

> **App Store reviews scraper, Google Play reviews scraper and app reviews API in one run.** One schema for both stores, only new reviews on scheduled runs, and App Store history past Apple's 500-review cap.

![App Reviews Scraper output table: App Store and Google Play reviews with stars, title, text, date, version and developer reply](https://api.apify.com/v2/key-value-stores/ZA74NSNlX7nM76ZW5/records/reviews-output.png)

| What you can extract | Features & integrations |
|---|---|
| ⭐ **Star rating**: 1 to 5 stars per review | **Both stores, one run**: App Store and Google Play together |
| 📝 **Review title & text**: the full review | **Search by app name**: or paste app URLs and IDs |
| 📅 **Date & country**: when and where it was posted | **Filters**: countries, language, star range, date from |
| 💬 **Developer reply**: the reply text when there is one | **Only new reviews**: per app, store and country |
| 👤 **Reviewer name**: as shown in the store | **Scheduling**: run it hourly, daily or weekly with Apify schedules |
| 📱 **App version & thumbs-up**: Google Play reviews | **Export anywhere**: JSON, CSV, Excel, XML or HTML from the dataset |
| 🏪 **Store & app name**: App Store or Google Play in one schema | **API & SDKs**: Apify REST API plus JavaScript and Python clients |
| 🔗 **Review URL**: link back to the review | **AI agents (MCP)**: call it from Claude or other agents via Apify's MCP server |

**Try it free in 1 click:** open this [ready-made example](https://apify.com/chimey_forearm/app-reviews-scraper/examples/find-negative-spotify-reviews-on-app-store-and-google-play) and press Start. Apify's free plan includes $5 of usage every month, no credit card needed. The Input example below returned 40 records and costs about $0.004 at list price.

**Google Play reviews scraper** and **App Store reviews scraper** in **one run** and **one normalized schema**. Paste app URLs or IDs from either store (or search by app name), pick countries, and get star rating, title, review text, date, country and the developer's reply as clean JSON, CSV or Excel. No login, no browser, no API key. Only public reviews. Pay per review.

- **App Store reviews scraper + Google Play reviews scraper in one run.** Both stores land in the same dataset with the same fields; `store` tells them apart. Compare your iOS and Android reviews (or a competitor's) side by side.
- **Only new reviews since the last run (app review monitoring).** Turn on `onlyNewReviews` and the Actor remembers what it already returned, per app, store and country, in a named key-value store in your account. Test: run 1 saved 100 Duolingo reviews (50 per store); a run a minute later returned only the 2 reviews that had appeared since and skipped the 100 it had already returned.
- **App Store reviews past the 500-review cap.** It pages Apple's web reviews feed instead of the RSS feed that stops at 500; one test run pulled 3,140 App Store reviews for a single app and country.
- **An App Store and Google Play reviews API alternative.** Apple's App Store Connect API and the Google Play Developer API return reviews only for your own apps and need a developer account. This Actor reads the public reviews of any app, yours or a competitor's, with no developer account and no login.
- **Search apps by name.** Type `"spotify"` or `"habit tracker"`; the top match on each store is scraped. No URL hunting.
- **Filter reviews by stars and date.** Star rating range (e.g. only 1–2★ complaints), "reviews since" date (`2026-01-01` or `7 days`), newest-first or most-relevant sort.
- **Multi-country App Store reviews.** App Store reviews are per storefront: scrape `us`, `gb`, `de`, `jp`… in one run, each row tagged with its country.
- **Developer replies** included with their date, on both stores. Google Play reviews also include the app version (when the store shows one) and the thumbs-up count.
- **No duplicate rows.** The same app pasted twice (URL and ID) is scraped once, and Google Play, which shows the same reviews in every country, isn't repeated per country.
- **Respects your spending limit** and stops cleanly when it is reached. If Apple rate-limits a long run, it slows down and waits instead of giving up.
- **Lightweight:** plain HTTP, 256 MB memory, fast and cheap to run.

### What data can App Store & Google Play Reviews Scraper extract?

| | Field | What it is |
|---|---|---|
| 🏪 | `store` | `appStore` or `googlePlay` |
| 🆔 | `appId` | App Store numeric ID or Google Play package name |
| 📱 | `appName` | App name |
| 🔑 | `reviewId` | The store's review ID |
| 👤 | `userName` | Reviewer name as shown in the store |
| 🖼️ | `userImage` | Reviewer avatar URL (Google Play) |
| ⭐ | `rating` | Star rating, 1 to 5 |
| 🏷️ | `title` | Review title (App Store) |
| 📝 | `text` | Review text |
| 📅 | `date` | Review date (ISO 8601) |
| ✏️ | `isEdited` | Whether the review was edited (App Store) |
| 🔢 | `appVersion` | App version the review was written on (Google Play, when shown) |
| 👍 | `thumbsUp` | Helpful votes (Google Play) |
| 💬 | `developerReply` | The developer's reply, if any |
| 🗓️ | `developerReplyDate` | When the developer replied |
| 🌍 | `country` | Storefront country |
| 🗣️ | `language` | Review language (Google Play) |
| 🔗 | `reviewUrl` | Link to the review (Google Play) or the app's reviews page (App Store) |
| 🌐 | `appUrl` | App page URL |
| 🔍 | `searchTerm` | The search term that found the app (when you used search) |
| ⏱️ | `scrapedAt` | When the row was scraped |

#### Store differences (good to know)

| Field | App Store | Google Play |
|---|---|---|
| `title` | ✅ | — (Google Play reviews have no title) |
| `appVersion` | — (not exposed publicly by Apple) | ✅ |
| `thumbsUp` | — | ✅ |
| `userImage` | — | ✅ |
| `isEdited` | ✅ | — |
| `developerReply` + date | ✅ | ✅ |
| Per-country reviews | ✅ separate per storefront | mostly global; filtered by `language` |

`reviewUrl` on Google Play links to the single review; on the App Store it links to the app's reviews page (Apple has no public per-review link).

### How to use App Store & Google Play Reviews Scraper in 5 steps

1. Create a free [Apify account](https://console.apify.com/sign-up).
2. Open [App Store & Google Play Reviews Scraper](https://apify.com/chimey_forearm/app-reviews-scraper).
3. Add your input: App Store or Google Play app URLs or IDs (you can mix both stores), or app names under **Search apps by name**; then pick countries, a star-rating range and how many reviews per app you want.
4. Click **Start**.
5. Download the reviews as JSON, CSV or Excel, or get them through the API. To watch an app, turn on **Only new reviews since the last run** and schedule it daily.

### Input

| Field | What it does |
|---|---|
| `apps` | App Store URLs (`https://apps.apple.com/us/app/whatsapp-messenger/id310633997`) or IDs (`id310633997`, `310633997`); Google Play URLs (`https://play.google.com/store/apps/details?id=com.whatsapp`) or package names (`com.whatsapp`). Mix both. |
| `searchTerms` | App names or keywords, e.g. `["spotify"]`. Searched in the first country (App Store via Apple's iTunes Search API, Google Play via its search page). |
| `searchResultsPerTerm` | Top results to scrape per term, per store (1–10). Default 1. |
| `searchStore` | `both` (default), `appStore` or `googlePlay`. |
| `countries` | Two-letter codes, e.g. `["us","gb"]`. Empty = the country in the App Store URL, else `us`. |
| `language` | Google Play review language (`en`, `de`, `es`…). Default `en`. |
| `sort` | `newest` (default) or `mostRelevant`. |
| `maxReviewsPerApp` | Per app, per country. Default 100. `0` = no limit (your spending limit still applies). |
| `minRating` / `maxRating` | Star range, 1–5. Set both to `1` for 1-star reviews only. |
| `dateFrom` | Only reviews on/after a date: `2026-01-01`, or relative `7 days`, `2 weeks`, `3 months`. |
| `onlyNewReviews` | `true` = return only reviews not returned by an earlier run (per app and country). Forces newest-first sort. |
| `stateStoreName` | Name of the key-value store that remembers seen reviews. Default `app-reviews-state`; use one name per monitoring task. |
| `dedupeReviews` | Default `true`: scrape Google Play once instead of once per country (same reviews everywhere for a language). |

#### Example input

This exact input was run on Oct 19 2026 (Spotify on both stores, 20 reviews per store). Paste it into the **Input** tab (switch to JSON view) and click **Start**:

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "countries": ["us"],
  "maxReviewsPerApp": 20
}
```

#### More tested inputs

Every example below was test-run and works as is.

##### 1. Find 1-2 star complaints about an app on both stores

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "maxRating": 2,
  "maxReviewsPerApp": 100
}
```

##### 2. Compare iOS vs Android reviews, by app name (no URLs needed)

```json
{
  "searchTerms": [
    "whatsapp"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100
}
```

The top App Store and Google Play match for each term is scraped; every row carries `searchTerm` and `appName` so you can check what was matched.

##### 3. Monitor new reviews daily across several countries (only new ones)

```json
{
  "apps": [
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "com.duolingo"
  ],
  "countries": [
    "us",
    "gb",
    "de"
  ],
  "onlyNewReviews": true,
  "stateStoreName": "duolingo-monitor",
  "maxReviewsPerApp": 500
}
```

Schedule this daily. The first run saves up to 500 newest reviews per app and country; every later run returns only reviews it hasn't returned before and stops paging as soon as it reaches them. App Store reviews are collected per country; Google Play is collected once (it shows the same reviews in every country for a language).

### Output

One row per review, with the same fields for both stores. Real records from the example input above (one per store, Oct 19 2026):

```json
[
  {
    "store": "appStore",
    "appId": "324684580",
    "appName": "Spotify: Music and Podcasts",
    "reviewId": "14682519213",
    "userName": "Evan_qp",
    "userImage": null,
    "rating": 5,
    "title": "good",
    "text": "great but too much ads / too frequently",
    "date": "2026-10-18T17:53:02Z",
    "isEdited": false,
    "appVersion": null,
    "thumbsUp": null,
    "developerReply": null,
    "developerReplyDate": null,
    "country": "us",
    "language": null,
    "reviewUrl": "https://apps.apple.com/us/app/id324684580?see-all=reviews",
    "appUrl": "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "searchTerm": null,
    "scrapedAt": "2026-10-20T01:40:37.547Z"
  },
  {
    "store": "googlePlay",
    "appId": "com.spotify.music",
    "appName": "Spotify: Music and Podcasts",
    "reviewId": "5e9a9c64-5e03-4be7-a08d-cd2d84b1f1e8",
    "userName": "Aryan Verma",
    "userImage": "https://play-lh.googleusercontent.com/a/ACg8ocKURBeWBwwLv6LS4iYm8amJ_xVACx-14wC7EcaBwvcgLN9fcg=mo",
    "rating": 1,
    "title": null,
    "text": "to much add",
    "date": "2026-10-19T01:36:46.832Z",
    "isEdited": null,
    "appVersion": null,
    "thumbsUp": 0,
    "developerReply": "Hey. We hear you and we'll pass your feedback along to the Ads team. For an ad-free experience, we'd recommend checking out our Premium plans at spotify.com/premium. If you've never had Premium before, you should be eligible for our trial.",
    "developerReplyDate": "2026-10-19T16:09:03.268Z",
    "country": "us",
    "language": "en",
    "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=5e9a9c64-5e03-4be7-a08d-cd2d84b1f1e8&hl=en&gl=us",
    "appUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&hl=en&gl=us",
    "searchTerm": null,
    "scrapedAt": "2026-10-20T01:40:38.019Z"
  }
]
```

You can download the dataset as JSON, CSV, Excel, XML or HTML. A `RUN_SUMMARY` record in the run's key-value store gives counts per app, which apps each search term matched, and how many duplicate / already-seen reviews were skipped.

### How can I use the data?

- **App review monitoring and alerts:** schedule it daily with `onlyNewReviews: true` and send new reviews to Slack or email.
- **Competitor analysis** and **feature-request mining** across iOS and Android.
- **Sentiment analysis**, topic modeling, and LLM / AI agent pipelines.
- **ASO (App Store Optimization) research** and release QA ("what broke in version X?").
- **Customer support:** find unanswered 1★ reviews (`developerReply` is `null`).

Ready-made example tasks: [Find negative Spotify reviews on App Store and Google Play](https://apify.com/chimey_forearm/app-reviews-scraper/examples/find-negative-spotify-reviews-on-app-store-and-google-play) and [Monitor new app reviews since the last run](https://apify.com/chimey_forearm/app-reviews-scraper/examples/monitor-new-app-reviews-since-the-last-run).

### More Actors from the same developer

| Actor | What it does |
|---|---|
| [Telegram Channel Scraper](https://apify.com/chimey_forearm/telegram-channel-scraper) | Public Telegram channel posts with a keyword monitor and only-new mode |
| [Substack Scraper](https://apify.com/chimey_forearm/substack-to-markdown) | Substack newsletters to clean Markdown, plus podcast transcripts |
| [Greenhouse & Workday Jobs Scraper](https://apify.com/chimey_forearm/ats-jobs-scraper) | Jobs from 8 career-site platforms with visa sponsorship and clearance flags |
| [Website to Markdown Crawler](https://apify.com/chimey_forearm/sitemap-to-markdown) | Any website to Markdown for RAG, with incremental sync and llms.txt |
| [Government Bids & RFP Scraper](https://apify.com/chimey_forearm/opengov-bids-scraper) | Open bids and RFPs from 500+ US city and county portals on OpenGov |
| [State Bids Scraper](https://apify.com/chimey_forearm/state-bids-scraper) | Open bids from COMMBUYS, BidBuy, NJSTART, OregonBuys and NevadaEPro |
| [PERM Green Card Sponsors](https://apify.com/chimey_forearm/perm-green-card-sponsors) | Companies that sponsor green cards, from official DOL PERM data |

### Error items

An input that can't be scraped becomes one error row in the dataset instead of a silent gap:

```json
{"type": "error", "input": "com.notreal.app", "error": "APP_NOT_FOUND", "errorMessage": "...", "store": "googlePlay", "appId": "com.notreal.app", "country": "us", "scrapedAt": "..."}
```

| `error` | When |
|---|---|
| `UNSUPPORTED_URL` | The input is not an App Store or Google Play app URL or ID |
| `APP_NOT_FOUND` | The app doesn't exist, or isn't available in the requested App Store storefront(s) |
| `NO_SEARCH_RESULTS` | A search term matched no apps (`input` is `search: <term>`) |
| `FETCH_FAILED` | The store kept refusing after retries, or an unexpected error; the message says how many reviews were saved before the failure |

`store`, `appId` and `country` are included when the app is known (not on `UNSUPPORTED_URL` or `NO_SEARCH_RESULTS` rows). Error rows count as one item each. Not reported as rows: invalid country codes (anything that isn't two letters is dropped), an invalid `dateFrom` (ignored, with a warning in the log), and duplicate inputs for the same app (scraped once, noted in the log). When your spending limit is reached the run stops cleanly and says so in the log.

### FAQ

**How much does it cost?** Pay per event: about **$0.10 per 1,000 reviews** ($0.0001 per review saved; error rows count as one item) plus a tiny start fee ($0.00005 per run at the default 256 MB memory). No platform usage is passed on to you on top. Set a maximum cost per run in Apify and the Actor stops exactly there. See the [Pricing tab](https://apify.com/chimey_forearm/app-reviews-scraper/pricing).

**How many reviews can I get?** Thousands per app and country. In our tests one run returned 5,500 Google Play reviews and about 3,000–3,900 App Store reviews for Spotify (US). Set `maxReviewsPerApp` to `0` for everything (watch your spending limit). Apple rate-limits very long App Store runs: the scraper then slows down and waits up to a few minutes; if Apple keeps refusing, it keeps every review already saved and adds a `FETCH_FAILED` row saying how many it got. For ongoing tracking, `onlyNewReviews` avoids re-downloading history.

**Why do I get Google Play reviews for only one country?** Google Play shows the identical review list in every country for a given language (we checked us/gb/in/ng and sa/eg: 150 of 150 the same). So by default each Google Play app is scraped once, in your first country. Use `language` to get reviews in another language, or set `dedupeReviews` to `false` to repeat them per country.

**How does "only new reviews" work?** After each app and country, the scraper stores the newest review date plus the IDs of the last 48 hours of reviews in a named key-value store (`stateStoreName`) in your Apify account. The next run reads newest-first, skips IDs it has already returned, and stops once it is 24 hours older than the previous newest review (the overlap catches late-published reviews). Delete that store, or use a new name, to start over. If a run hits your spending limit, its memory for that app isn't updated, so the next run picks up the rest.

**What if search finds the wrong app?** Search takes the store's own top result. Check `appName` and `searchTerm` in the output, raise `searchResultsPerTerm`, or paste the exact URL instead.

**Can I connect it to Make, Zapier, Google Sheets or Slack?** Yes. Use Apify's integrations for Make, Zapier, n8n, Google Sheets and Slack, or a webhook that fires when a run finishes. Combine it with an Apify Schedule for daily review alerts.

**Can I use it through the API?** Yes. Use the Apify REST API or the official clients. Node.js (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('chimey_forearm/app-reviews-scraper').call({
    apps: ['com.spotify.music'],
    maxReviewsPerApp: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("chimey_forearm/app-reviews-scraper").call(run_input={
    "apps": ["com.spotify.music"],
    "maxReviewsPerApp": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**Can AI agents use it (MCP)?** Yes. Connect Claude, Cursor or another MCP client to the Apify MCP server (https://mcp.apify.com) and add `chimey_forearm/app-reviews-scraper` as a tool. Input and output are simple JSON.

**Is it legal to scrape App Store and Google Play reviews?** It collects only publicly visible reviews, without logging in. Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. However, your results could contain personal data, which is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. Reviewer names (`userName`) and avatars (`userImage`) are personal data under the GDPR, so drop them if you don't need them.

**Found a bug or need a field?** Open an issue in the **Issues** tab and I'll usually reply within a day.

If it saved you time, a quick review on the Store helps a solo developer keep improving it. Bugs or ideas? Open an Issue.

# Actor input Schema

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

One per line, mix both stores freely. App Store: https://apps.apple.com/us/app/whatsapp-messenger/id310633997, or just the id ("id310633997" / "310633997"). Google Play: https://play.google.com/store/apps/details?id=com.whatsapp, or just the package name ("com.whatsapp"). Don't know the URL? Use "Search apps by name" below instead.

## `searchTerms` (type: `array`):

App names or keywords, e.g. "spotify" or "habit tracker". The scraper searches the App Store (official iTunes Search API) and Google Play (public search page) in the first country below and scrapes the top result(s), so you don't need URLs or IDs. Each review row carries the searchTerm it came from. Results are whatever the store ranks first, so check appName in the output.

## `searchResultsPerTerm` (type: `integer`):

How many top search results to scrape for each search term, in each store. 1 = just the best match.

## `searchStore` (type: `string`):

Which store(s) to search for the terms above.

## `countries` (type: `array`):

Two-letter country codes, e.g. "us", "gb", "de". App Store reviews are separate per country storefront, so each country is scraped separately. Google Play uses it as the gl= region. Empty = the country in the App Store URL, otherwise "us".

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

Two-letter language code for Google Play reviews (hl=), e.g. "en", "de", "es". Google Play returns reviews written in this language. App Store reviews are whatever was written in each country storefront.

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

Newest first (best for monitoring and for the date filter) or the stores' Most relevant / helpful order.

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

Stop after this many matching reviews for each app in each country. 0 = no limit (capped only by the run's spending limit).

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

Keep reviews with at least this many stars (1–5). Set min and max to 1 to collect only 1-star complaints.

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

Keep reviews with at most this many stars (1–5).

## `dateFrom` (type: `string`):

Only reviews posted on or after this date. Use YYYY-MM-DD or a relative value like "7 days", "2 weeks", "3 months". With Newest first sort the scraper stops paging as soon as it reaches older reviews.

## `onlyNewReviews` (type: `boolean`):

Turn on for scheduled runs: each run saves only reviews it has not returned before, per app and country, so you pay for new reviews only. The first run behaves like a normal run (limited by Max reviews per app / Reviews since) and remembers what it saw; later runs stop paging as soon as they reach already-seen reviews. Forces Newest-first sort. Make Max reviews per app large enough to cover the reviews an app gets between runs.

## `stateStoreName` (type: `string`):

Name of the named key-value store (in your Apify account) where seen reviews are remembered. Use a different name per monitoring task to keep them separate, or a new name to start fresh. Lowercase letters, digits and hyphens.

## `dedupeReviews` (type: `boolean`):

Google Play shows the identical review list in every country for a language, so with several countries each Google Play app is scraped once (in the first country) instead of returning the same reviews again for every country. The same app given twice (URL and ID, or also found by search) is scraped once either way. App Store countries always have different reviews and are all scraped.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "searchResultsPerTerm": 1,
  "searchStore": "both",
  "countries": [
    "us"
  ],
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 100,
  "minRating": 1,
  "maxRating": 5,
  "onlyNewReviews": false,
  "stateStoreName": "app-reviews-state",
  "dedupeReviews": true
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `summary` (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 = {
    "apps": [
        "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
        "https://play.google.com/store/apps/details?id=com.whatsapp"
    ],
    "countries": [
        "us"
    ],
    "maxReviewsPerApp": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("chimey_forearm/app-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 = {
    "apps": [
        "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
        "https://play.google.com/store/apps/details?id=com.whatsapp",
    ],
    "countries": ["us"],
    "maxReviewsPerApp": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("chimey_forearm/app-reviews-scraper").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": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 100
}' |
apify call chimey_forearm/app-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

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/wjYOdF16OOtUwZDdO/builds/yecPl2cJrPLF9opEf/openapi.json