# App Store & Google Play Reviews Scraper: Full History (`n1raxi/app-reviews-scraper`) Actor

Scrape App Store and Google Play reviews of any iOS or Android app: the whole history of each country and language, with ratings, app versions, and developer replies. Filter by stars, dates, and keywords, export to Excel, CSV, or JSON, and monitor new reviews with Slack or Telegram alerts.

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

## Pricing

from $0.08 / 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 Scraper: Full History** gets every review of any iOS or Android app from the Apple
App Store and the Google Play Store, with no 500-review limit. It reads the whole history of each App Store country and
each Google Play language and puts both stores in one table, ready for Excel, CSV, or JSON. You don't need an Apple or
Google account.

| App Store countries | Google Play languages | Review history | Price |
|---|---|---|---|
| 175 | 75 | Complete, back to the first review | $0.10 per 1,000 reviews |

**Quick start:** Click **Try for free**, then **Start**. The prefilled input returns the newest 100 reviews of Spotify
from each store in a few seconds.

### How much of an app's history do you get?

The most used App Store review tools return the newest 500 reviews per country. For a popular app, that is a small
share of what users have written:

| App | Written reviews in the US App Store | Share in the newest 500 |
|---|---|---|
| Calm | 43,315 | 1.2% |
| Uber | 253,157 | 0.20% |
| Duolingo | 397,050 | 0.13% |
| Spotify | 910,994 | 0.055% |

*Review counts as the App Store showed them on October 17, 2026.*

This Actor reads the whole history, and you can check that nothing is missing:

- **App Store:** The Apps table shows how many written reviews each country has. For Headspace in the US, it counted
  26,427, and the run returned all 26,427 in 4.5 minutes, back to February 2012, each with its app version.
- **Google Play:** The store doesn't publish how many written reviews an app has, so the dates show the depth. One run
  read all 67,883 reviews in Headspace's English group, back to January 2012, in about 3 minutes.

### How does it compare with other app review scrapers?

| | Typical app review scraper | This Actor |
|---|---|---|
| App Store reviews per country | Usually the newest 500 | The whole history |
| Stores | Usually one store per Actor | App Store and Google Play in one table |
| App version of App Store reviews | Only for the newest 500 | For every review |
| Review dates | Some are an hour off for App Store reviews posted from November to March, a time zone error | Exact, in UTC |
| Review language | Google's phone-language group at best | The language the review is written in, in both stores |
| Developer replies and helpful votes | Often missing or empty | Every reply and vote the store shows |
| Ratings by country | Sometimes the US rating for every country | Each country's own rating and star counts |
| Apps by topic | A list of apps, with reviews in a second run | The top apps with their reviews and ratings in one run |
| Only new reviews on a schedule | You set a date or remove repeats yourself | Remembered between runs, with none missed or repeated |
| Free plan | Some return 10 reviews a run or 500 in total | The first 100 reviews of each app in every run, with every filter |

*Based on the Store pages of the most used app review scrapers on Apify and on test runs of six of them in October
2026: the same apps (Telegram, Duolingo, Mercado Libre, and two small apps), with each result checked against what the
store itself shows.*

### What else can this app review scraper do?

| Feature | What you get |
|---|---|
| Both stores in one table | The same columns for App Store and Google Play reviews, ready to sort and compare |
| Flexible input | Links, App Store IDs, Google Play package names, or app names; or the top apps for a search such as `meditation app` |
| Filters | Stars, dates, keywords, review language, app version, developer reply, helpful votes, length, and device |
| Ratings by country | Each app's rating and star counts in every country you choose |
| Developer reply stats | How many reviews the developer answered and the median time to reply |
| Monitoring | Only the reviews posted since the last run, with alerts in Slack or Telegram and delivery to Notion or Todoist |
| Clear results | An app given by name is taken only when the store's result fits the name, and any app or market not read as asked gets a row that says why |

### What can you use it for?

| Use case | What to enter | Result | Cost |
|---|---|---|---|
| Try it on any app | **Apps**: a link or a name | The newest 100 reviews from each store | About $0.02 |
| Read every review of an app in one country | **Apps**: Headspace's App Store link; **Max reviews**: `0` | All 26,427 US App Store reviews in 4.5 minutes | About $2.64 |
| Read every review of an app in every market | **Apps**: `Bitwarden`; **Countries** and **Languages**: `all`; **Max reviews**: `0` | 38,240 reviews from 97 App Store countries and 54 Google Play languages, and 324 Apps rows, in 9 minutes | About $4.31 |
| Find what users dislike about a niche's leaders | **Search terms**: `fitness tracker`; **Stars**: 1 and 2; **Date from**: `90 days` | 10,622 reviews of the top 10 apps in each store | About $1.09 |
| Compare an app's ratings around the world | **Apps**: `Spotify`; **Countries**: `all`; **Max reviews**: `50` | 339 Apps rows with the rating in each country of each store, and 7,429 reviews | About $1.25 |
| Read reviews in other languages | **Apps**: `com.duolingo`; **Languages**: `de`, `fr`, `es`; **Max reviews**: `500` | 1,500 reviews | About $0.15 |
| Watch new 1- and 2-star reviews of your app and two rivals | **Apps**: `Duolingo`, `Babbel`, `Busuu`; **Stars**: 1 and 2; **Only new reviews**; **App details and ratings** off; a daily schedule | About 3,900 new reviews a month | About $0.40 a month |

Prices are for the Starter plan. App teams use the Actor to follow feedback after each release, ASO specialists and
marketers to compare competitors market by market, and data teams to build review datasets for sentiment analysis.

> **Good to know:** The App Store keeps separate reviews and ratings for each country, and Google Play groups reviews
> by the language of the reviewer's phone. If you leave **Countries** and **Languages** empty, you get one App Store
> country, with reviews in every language, and one Google Play language: the US and English, unless an app's link names
> others. The run tells you which. Set both to `all` to cover every market.

### How much does it cost to scrape app reviews?

You pay only for results: $0.10 per 1,000 reviews, and less on the Scale and Business plans. With **App details and
ratings** on, each app also gets a row in the Apps table for every country you choose, with its rating and details.
Reviews that your filters remove and Apps rows that only explain why an app was not read are free, and alerts and
deliveries to Notion or Todoist cost nothing extra.

| Price | Free | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 reviews | $0.10 | $0.10 | $0.09 | $0.08 |
| 1,000 Apps rows, one per app and country | $1.50 | $1.50 | $1.35 | $1.20 |
| Run start | $0.0003 | $0.0003 | $0.0003 | $0.0003 |

#### Is there a free plan?

Yes. Apify gives every account $5 of usage each month, enough for up to 50,000 reviews, with no credit card required.
On the Free plan, each run reads the newest 100 reviews of each app, or the 100 most helpful, and you get every field,
every filter, and the Apps table for them, so you can check the data before you pay. The whole history and monitoring
need a paid Apify plan.

#### How do I keep a large run within budget?

Check the size first: run with **Max reviews** `1`, and the Apps table shows how many reviews each App Store country
has. Google Play doesn't publish this number. At $0.10 per 1,000 reviews, Spotify's whole US history costs about $91.
To cap what a run can cost, set a maximum cost in its run options: the run stops there and keeps what it has read.

#### How long does a run take?

A run lasts up to 1 hour unless you raise **Timeout** in the run options. Most histories take minutes: all 26,427 US
reviews of Headspace took 4.5 minutes. The largest apps have hundreds of thousands of reviews in one country, such as
Spotify with 910,994 in the US, so raise **Timeout** before you read their whole history. If time runs out, you keep
every review read up to then, and the Apps table says so.

### How to scrape App Store and Google Play reviews

1. Click **Try for free** and sign in to Apify.
2. In **Apps**, add apps from either store, one per line: a link, an App Store ID (`324684580`), a Google Play package
   name (`com.spotify.music`), or a name (`Spotify`). To find apps by topic, use **Search terms**.
3. Set **Countries**, **Languages**, and **Max reviews** if you need more than the newest 100 reviews of one market.
4. Open **Filters** to keep only the reviews you need.
5. Click **Start**, then download the reviews from the **Output** tab.

### Input examples

#### Scrape all App Store reviews of an app

`"maxReviews": 0` returns the whole history, and the Apps table shows how many reviews the App Store counts.

```json
{ "apps": ["https://apps.apple.com/us/app/headspace-sleep-meditation/id493145008"], "maxReviews": 0 }
```

#### Scrape all reviews of an app in every country and language

`all` in **Countries** and **Languages** reads every App Store country and every Google Play language group. For
Bitwarden, that was 38,240 reviews in 9 minutes, back to 2016. Popular apps have many more, so check the size first, as
described in *How do I keep a large run within budget?* above.

```json
{ "apps": ["Bitwarden"], "countries": ["all"], "languages": ["all"], "maxReviews": 0 }
```

#### Get reviews of the top apps for a topic

The search runs in the first country in **Countries**, so choose one country to see the leaders of that market. Google
Play results come in the store's own order. App Store results are the apps the App Store website shows, though their
order can differ slightly.

```json
{ "searchTerms": ["fitness tracker"], "stars": ["1", "2"], "from": "90 days" }
```

#### Get App Store reviews from all countries

Each review has its `country`. **App details and ratings** adds an Apps row for each country, at $1.50 per 1,000 rows,
and takes about 8 minutes for all countries, so turn it off if you only need the reviews.

```json
{ "apps": ["Spotify"], "countries": ["all"], "maxReviews": 200 }
```

#### Download Google Play reviews in other languages

Each review also gets the language its text is written in.

```json
{ "apps": ["com.duolingo"], "languages": ["de", "fr", "es"], "maxReviews": 500 }
```

#### Find bug reports in negative reviews

Keywords ignore case and accents: `nao funciona` also matches *não funciona*, and `crash*` matches *crashes*.

```json
{ "apps": ["com.whatsapp"], "stars": ["1", "2"], "keywords": ["crash*", "freez*"], "from": "30 days", "developerReply": "notReplied" }
```

#### See how users rated an app version

`9.1` also matches 9.1.2, and `>= 9.0` or `< 10` set a range. The Apps table shows the rating of these reviews next to
the app's overall rating.

```json
{ "apps": ["com.spotify.music"], "versions": ["9.1"], "maxReviews": 1000 }
```

### Monitor app reviews with Slack and Telegram alerts

Save your input as a task, turn on **Only new reviews**, and add a schedule. Each run returns only the reviews posted
since the previous run, with none missed or repeated. The stores publish reviews about a day after they are written, so
a daily schedule is enough.

After each run with new reviews, you get one message: the number of new reviews for each app and star rating, the five
with the fewest stars, and a link to the rest. A run with nothing new sends nothing.

- **Telegram:** Create a bot with [@BotFather](https://t.me/BotFather), paste its token into **Telegram bot token**,
  then open your bot and press **Start**. For a group or a channel, add the bot there and enter its chat ID or @name.
- **Slack:** Add [Incoming Webhooks](https://api.slack.com/messaging/webhooks) to a channel and paste the webhook URL
  into **Slack webhook URL**.

Apify stores the token and the webhook URL encrypted. When you start runs through the API, add them to the input as
`telegramBotToken` or `slackWebhookUrl`. This input watches Duolingo's new 1- and 2-star reviews in both stores:

```json
{ "apps": ["570060128", "com.duolingo"], "stars": ["1", "2"], "onlyNew": true }
```

### What app review data can you extract?

| Reviews table | Apps table |
|---|---|
| Star rating (1 to 5), title, and text | Average rating and the number of ratings for each star |
| Date posted, in UTC | Number of written reviews in the country (App Store) |
| App version the review is about | Rating of the reviews returned and how many have 1 or 2 stars or a reply |
| Language the review is written in | Median time the developer takes to reply |
| Reviewer's name and helpful votes | Version, release notes, description, and update and release dates |
| Developer reply and its date | Developer, website, email, category, price, and installs |
| Country (App Store) or phone language (Google Play) | Place in the search results and the status of each app |

A review in the **Reviews** table, with some columns left out:

```json
{ "store": "appStore", "appId": "571800810", "appTitle": "Calm", "country": "us", "language": "en", "rating": 1,
  "title": "I do not recommend", "text": "They steal your money and refuse to give it back. Get headspace.",
  "date": "2026-10-08T04:26:46.000Z", "appVersion": "7.2", "userName": "kezia b", "helpfulVotes": 0,
  "developerReply": "We're sorry to hear this. If your subscription was purchased through the App Store, Apple handles refunds directly...",
  "developerReplyDate": "2026-10-09T13:28:18.000Z" }
```

- `language` is the language the review is written in, and `reviewerLanguage` is the phone language that Google Play
  groups it by. `language` is empty when a text is too short to tell, such as "ok" or a single emoji.
- `appVersion` is in every App Store review. Google Play shows it for most reviews but not all.
- `status` in the Apps table is `ok`, `partial`, `failed`, `notFound`, or `invalid`, and `statusMessage` explains
  anything that was not done as asked.

### Export app reviews to Excel, CSV, JSON, or Google Sheets

- **Download:** On the **Output** tab, choose Excel, CSV, JSON, XML, or HTML. Apify's Excel export drops most emoji, so
  choose CSV or JSON to keep them.
- **Google Sheets:** Add the [Google Sheets Import & Export](https://apify.com/lukaskrivka/google-sheets) Actor on the
  **Integrations** tab of your task.
- **Zapier, Make, n8n, and webhooks:** Send each run's reviews to other apps when the run ends.

#### Use it as an App Store and Google Play reviews API

Start a run from your own code and get the reviews back as JSON. The input is the JSON shown above, and the **API** tab
of this page has ready-made requests for every language and the command line.

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("n1raxi/app-reviews-scraper").call(run_input={"apps": ["com.spotify.music"], "stars": ["1", "2"]})
reviews = client.dataset(run["defaultDatasetId"]).list_items().items
apps = client.dataset(run["storageIds"]["datasets"]["apps"]).list_items().items
```

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('n1raxi/app-reviews-scraper').call({ apps: ['com.spotify.music'], stars: ['1', '2'] });
const { items: reviews } = await client.dataset(run.defaultDatasetId).listItems();
const { items: apps } = await client.dataset(run.storageIds.datasets.apps).listItems();
```

#### Use it from AI agents (MCP)

AI assistants and agents that support MCP, such as Claude, Cursor, and VS Code, can run this Actor through Apify's MCP
server. Add `https://mcp.apify.com?tools=n1raxi/app-reviews-scraper` as a server, sign in to Apify, and ask in plain
words:

- *What do users dislike about the latest version of Calm?*
- *Compare the 1-star reviews of Duolingo and Babbel from the last month.*
- *In which countries is Spotify rated lowest?*

The agent fills in the input and reads the results. Runs cost the same as from the Console.

### Send app reviews to Notion or Todoist

The Actor adds each review it returns to Notion or Todoist through an Apify MCP connector. You sign in once, in Apify,
and the Actor never sees your password. It can only add a database, pages, and tasks, and it never changes or deletes
what you already have.

1. In **Notion or Todoist connector**, add a connector: choose Notion or Todoist, sign in, and allow access.
2. In **Notion page or Todoist project**, enter where the reviews go:
   - **Notion:** A page link. The first run creates an "App reviews" database on that page, and later runs add to it.
   - **Todoist:** A project name or link, or leave it empty for the Inbox. Each review becomes a task, and 1-star
     reviews get the highest priority. A project holds up to 300 open tasks, so send only the reviews that need an
     answer.

If delivery fails, the run still succeeds, and its status explains what went wrong.

### FAQ

#### Do I need an Apple or Google account?

No. The Actor reads the reviews that the stores show to any visitor, so it works for any app, not only your own.

#### Why not use App Store Connect or Google Play Console?

They show only your own apps. App Store Connect lists the reviews of your team's apps, and the Google Play Developer API
returns only the reviews written or edited in the last week; older reviews are a CSV download in Play Console. This
Actor reads the public reviews of any app, including your competitors', with both stores in one table.

#### Can I get more than 500 App Store reviews?

Yes. There is no 500-review limit: on any paid Apify plan, set **Max reviews** to `0` to get the whole history of each
country.

#### How do I get Google Play reviews from a specific country?

Google Play groups reviews by the language of the reviewer's phone, so choose the language of that market, such as
German for Germany, Austria, and Switzerland. Ratings and prices differ by country, and the Apps table has a row for each
country you choose.

#### How do I get every Google Play review written in one language?

Google Play files a review under the language of the reviewer's phone, not the language of its text, so some English
reviews sit in other groups, such as Dutch. **Languages** `en` reads only the English group. To find every English
review, also set **Google Play language groups** in the **Advanced** section to `all`.

#### Can I use the reviews for sentiment analysis?

Yes. Each review comes with its stars, text, language, app version, and date, so you can group the reviews before you
analyze them. The Actor doesn't score sentiment itself.

#### Why are there fewer reviews than ratings?

Most people only tap the stars, and the stores don't publish ratings without text. The Apps table shows both numbers.

#### Why are the newest reviews about a day old?

Both stores publish reviews some time after they are written. Google Play holds new reviews for about a day, as its
help pages say, and the App Store usually adds them once a day. The Actor returns each review as soon as the store
shows it, with the date it was written.

#### Is it legal to scrape app reviews?

The Actor reads public reviews that anyone can see in the stores and returns only the reviewer's public nickname. You
are responsible for using the data in line with the laws that apply to you, such as the GDPR. This Actor is not
affiliated with or endorsed by Apple or Google.

#### Something doesn't work?

Open an issue on the **Issues** tab with a link to your run, and we will answer quickly. For a custom solution, write
to us there too.

### More from this developer

- [Telegram Scraper: Exact Views, Deleted Posts & Ads](https://apify.com/n1raxi/telegram-channel-scraper): exact
  views, keyword search, deleted and edited posts, and ad checks for public Telegram channels and groups, with no login.

# Actor input Schema

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

One app per line, from either store: an App Store link or ID (<code>324684580</code>), a Google Play link or package name (<code>com.spotify.music</code>), or just a name (<code>Spotify</code>). Links, IDs, and package names always point to their own store. A name is searched for in the stores chosen in Stores, and the Actor takes the store's first result only if its name matches. If it doesn't, the Apps table shows what the store found.

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

Find apps by what they do, one search per line, such as <code>fitness tracker</code> or <code>photo editor</code>. The Actor takes the top apps from each store's search and reads their reviews like the apps in Apps, and the Apps table shows each app's place in the search. The search runs in the first country in Countries (the US if it is empty or <code>all</code>) and, on Google Play, in the first language you choose (English if Languages is empty). To see the leaders of one market, list only that country.

## `appsPerSearch` (type: `integer`):

How many top apps to take from each search: up to 200 on the App Store and up to 30 on Google Play, which shows no more. For example, 10 apps with Max reviews 100 give up to 1,000 reviews from each store in each country and language.

## `stores` (type: `array`):

Where to look for apps given by name and for Search terms: both stores or only one. Links, IDs, and package names always point to their own store.

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

Each App Store country has its own reviews and ratings: an app's reviews in the US are not the same as in Germany. Use codes (<code>us</code>, <code>de</code>), names (<code>Germany</code>), or <code>all</code> for every country. <b>Empty:</b> the US, or the country of each App Store link. Google Play groups reviews by language instead (see Languages), so for Google Play, countries change only the rating and price in the Apps table. Names and Search terms are searched for in the first country listed.

## `languages` (type: `array`):

Keep only reviews written in these languages: codes (<code>en</code>, <code>de</code>) or names (<code>German</code>, <code>Deutsch</code>). On Google Play, this also chooses which reviews are read, as Google Play groups reviews by the language of the reviewer's phone. <b>Empty:</b> all languages on the App Store and English on Google Play. <b><code>all</code>:</b> every language in both stores. The Actor detects each review's language from its text; a very short review, such as <i>ok</i>, takes the language of the reviews around it.

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

How many reviews to return for each App Store country and each Google Play language. Only reviews that pass the filters count. <code>0</code>: the whole history. <b>Empty:</b> 100, or all reviews since Date from, or all new reviews when monitoring. On the Apify Free plan, the Actor reads only the first 100 reviews of each app; any paid plan reads the whole history. A whole history can be large: Spotify has 910,994 reviews in the US App Store alone, about $91. To check the size first, run with Max reviews 1 and see each country's review count in the Apps table. A run lasts up to 1 hour; to read more, raise Timeout in the run options, where you can also set a maximum cost.

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

Newest first is the fastest with Date from: reading stops at that date, even for apps with long histories.

## `onlyNew` (type: `boolean`):

For monitoring: save the input as a task and add a schedule. Each run then returns only the reviews posted since the task's previous run, with none missed or repeated. The first run returns the newest 100 reviews, or as many as Max reviews or Date from allow. To get the new reviews in Telegram or Slack, fill in New review alerts below; to send them to Notion or Todoist, fill in the section after it. Requires a paid Apify plan.

## `stars` (type: `array`):

Return only reviews with these ratings, for example 1 and 2 stars for negative reviews or 5 stars for praise. <b>Empty:</b> all ratings.

## `from` (type: `string`):

Return reviews posted at or after this time (UTC). Use a date (<code>2026-10-01</code>), a date and time (<code>2026-10-01T08:00:00Z</code>), <code>today</code>, <code>yesterday</code>, or a period back from now (<code>24 hours</code>, <code>7 days</code>, <code>1 month</code>).

## `to` (type: `string`):

Return reviews posted before this time (UTC), in the same formats as Date from. A date alone means the end of that day.

## `keywords` (type: `array`):

Return only reviews whose title or text contains at least one of these words or phrases. Matching ignores letter case and accents and finds whole words only: <code>nao funciona</code> also finds <i>não funciona</i>. Add <code>*</code> to match word endings: <code>crash*</code> also finds <i>crashes</i>. Use <code>+</code> to require all words: <code>login + error</code>.

## `excludeKeywords` (type: `array`):

Skip reviews whose title or text contains any of these words or phrases. Same rules as Keywords, for example <code>refund</code> or <code>promo\*</code>.

## `developerReply` (type: `string`):

Filter reviews by whether the developer replied to them.

## `versions` (type: `array`):

Return only reviews of these app versions, in both stores and through the whole history. <code>8.1</code> also matches 8.1.2; use <code>>= 8.0</code> or <code>< 9</code> to set a range.

## `minHelpfulVotes` (type: `integer`):

Return only reviews that at least this many people found helpful.

## `minLength` (type: `integer`):

Return only reviews whose text has at least this many letters and digits, to skip one-word reviews such as <i>Good</i>. Spaces, punctuation, and emoji are not counted.

## `device` (type: `string`):

Return only Google Play reviews written on this kind of device. The App Store does not record devices.

## `appDetails` (type: `boolean`):

Adds a row for each app in each country to the Apps table: its rating and star counts, the number of reviews, a summary of the reviews returned (their average rating, how many are negative or answered, how fast the developer replies, and their languages), and the app's price, version, description, developer contacts, and installs. Turn it off if you need only the reviews. With all countries, App Store details take about 8 minutes. Any app that could not be read as asked always gets a row that explains why.

## `telegramBotToken` (type: `string`):

Create a bot with <a href='https://t.me/BotFather' target='_blank'>@BotFather</a> (send it /newbot), paste its token here, then open your bot and press Start. The token is stored encrypted.

## `telegramChat` (type: `string`):

Where to send the alerts. <b>Empty:</b> the chat that last messaged the bot (you, after pressing Start). You can also enter a chat ID, or the @name of a group or channel where the bot is a member or admin.

## `slackWebhookUrl` (type: `string`):

In Slack, add <a href='https://api.slack.com/messaging/webhooks' target='_blank'>Incoming Webhooks</a> to a channel and paste its webhook URL here (https://hooks.slack.com/services/...). The URL is stored encrypted.

## `connector` (type: `string`):

Pick your Notion or Todoist connector, or add one here: choose Notion or Todoist, sign in and allow access. You can also manage connectors in Settings > API & Integrations > MCP connectors. The Actor never sees your Notion or Todoist password or token.

## `connectorTarget` (type: `string`):

<b>Notion:</b> the link of a page. The first run creates a database named App reviews on that page, and later runs add to it. <b>Todoist:</b> the name or link of a project, or leave it empty for the Inbox. Each review becomes a task, and 1-star reviews get the highest priority. A Todoist project holds up to 300 open tasks, so send only the reviews that need an answer, such as new 1- and 2-star reviews.

## `googlePlayLanguages` (type: `array`):

Google Play files each review under the language of the reviewer's phone, which is not always the language the review is written in. <b>Empty:</b> the groups of the languages in Languages; if that is empty too, the language of each Google Play link, or else English. <b><code>all</code>:</b> all 75 groups. For example, <code>all</code> here and <code>en</code> in Languages finds every English review, whatever group it is in.

## `stateName` (type: `string`):

Only for monitoring, and usually left empty: each saved task remembers which reviews it has already returned. Set a name only to share that memory between tasks or to run two separate monitors from one task. Use lowercase letters, digits, and hyphens.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "searchTerms": [],
  "appsPerSearch": 10,
  "stores": [
    "appStore",
    "googlePlay"
  ],
  "countries": [],
  "languages": [],
  "maxReviews": 100,
  "sort": "newest",
  "onlyNew": false,
  "stars": [],
  "keywords": [],
  "excludeKeywords": [],
  "developerReply": "any",
  "versions": [],
  "device": "any",
  "appDetails": true,
  "googlePlayLanguages": []
}
```

# Actor output Schema

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

One row per review.

## `apps` (type: `string`):

One row per app in each country: ratings, details, and how many reviews were returned. Apps that could not be read as asked say why.

# 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/spotify-music-and-podcasts/id324684580",
        "https://play.google.com/store/apps/details?id=com.spotify.music"
    ],
    "maxReviews": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("n1raxi/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/spotify-music-and-podcasts/id324684580",
        "https://play.google.com/store/apps/details?id=com.spotify.music",
    ],
    "maxReviews": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("n1raxi/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/spotify-music-and-podcasts/id324684580",
    "https://play.google.com/store/apps/details?id=com.spotify.music"
  ],
  "maxReviews": 100
}' |
apify call n1raxi/app-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,n1raxi/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/3cuBvaEJY4BlB5Ydy/builds/nVjtlT61HxIxAi524/openapi.json
