# App Reviews Scraper: Google Play & App Store Review Extractor (`code-node-tools/app-reviews-scraper`) Actor

Scrape and filter reviews from Google Play and the App Store by rating, keyword, date, and developer reply status. Find competitor complaints, feature requests, and sentiment trends in minutes. Supports keyword-based app discovery and multi-country data collection.

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

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## App Reviews Scraper - Extract Google Play & App Store Reviews

Extract app reviews from **Google Play Store** and **Apple App Store** with advanced filtering, multi-country support, and automatic deduplication. Get ratings, review text, author info, developer replies, and comprehensive app metadata in seconds.

### What is App Reviews Scraper?

**App Reviews Scraper** is a powerful web scraping tool that extracts user reviews and ratings from both **Google Play Store** and **Apple App Store**. Perfect for competitor analysis, sentiment monitoring, and market research.

Simply provide **app IDs or search keywords**, select your target countries, and get structured review data ready for analysis. No coding required - just point, click, and scrape!

**Key features:**

- ✅ **Dual Store Support** - Scrape both Google Play and App Store simultaneously
- ✅ **Multi-Country Scraping** - Extract reviews from up to 155 countries in one run
- ✅ **Smart Filtering** - Filter by rating, date, keywords, developer replies, and more
- ✅ **Automatic Deduplication** - No duplicate reviews, clean data guaranteed
- ✅ **Pay Per Review** - Only $0.50 per 1,000 reviews scraped

### 💰 Pricing - How much does it cost to scrape app reviews?

**Simple, transparent pricing - pay only for what you scrape!**

| Plan        | Price per 1,000 Reviews | Discount |
| ----------- | ----------------------- | -------- |
| FREE/BRONZE | $0.50                   | -        |
| SILVER      | $0.45                   | 10% off  |
| GOLD        | $0.40                   | 20% off  |

Plus a one-time **$0.00005 per Actor start** (first 5 seconds free).

**No hidden fees!** Platform costs (compute, proxies, storage) are included. You only pay for unique reviews that get added to your dataset.

#### Pricing Examples

**100 reviews:** $0.05
**1,000 reviews:** $0.50
**10,000 reviews:** $5.00
**100,000 reviews:** $50.00

Want to test it? **Start with the free tier** and get hundreds of reviews at no cost!

### What data can you extract from app stores?

The App Reviews Scraper extracts comprehensive review data and organizes it into **5 named datasets** for easy analysis:

#### 📊 Named Datasets

Your scraped data is automatically organized into the following datasets:

| Dataset Name               | Content                                | Use Case                                   |
| -------------------------- | -------------------------------------- | ------------------------------------------ |
| **`app-overview`**         | App metadata only (no reviews)         | Quick app information and ratings overview |
| **`all-reviews`**          | All scraped reviews with complete data | Full dataset for comprehensive analysis    |
| **`positive-reviews`**     | Reviews with 4-5 star ratings          | Identify strengths and happy customers     |
| **`negative-reviews`**     | Reviews with 1-2 star ratings          | Find issues and complaints                 |
| **`reviews-with-replies`** | Reviews with developer responses       | Track developer engagement                 |

#### 📋 Review Data Fields

| Field               | Description         | Example                       |
| ------------------- | ------------------- | ----------------------------- |
| **Review ID**       | Unique identifier   | `googleplay_scraper-d9fd...`  |
| **Store**           | Platform source     | `googleplay` or `appstore`    |
| **App Name**        | Application name    | `WhatsApp Messenger`          |
| **Developer**       | Publisher name      | `WhatsApp LLC`                |
| **App Rating**      | Overall app rating  | `4.64` (1-5 stars)            |
| **Rating Count**    | Total ratings       | `239,556,988`                 |
| **Country**         | Review origin       | `us`, `gb`, `de`              |
| **Rating**          | Review rating       | `5` (1-5 stars)               |
| **Title**           | Review title        | `"Great app!"`                |
| **Review Text**     | Full review content | `"Nothing beats this app..."` |
| **Author**          | Reviewer name       | `John Doe`                    |
| **App Version**     | Version reviewed    | `2.26.16.72`                  |
| **Date Posted**     | Publication date    | `2024-07-23T14:12:52+00:00`   |
| **Date Updated**    | Last edit date      | `2024-07-24T10:30:00+00:00`   |
| **Is Edited**       | Edit status         | `true` or `false`             |
| **Thumbs Up**       | Helpful votes       | `15`                          |
| **Developer Reply** | Response text       | `"Thank you for..."`          |
| **Reply Date**      | Response date       | `2024-07-25T09:00:00+00:00`   |
| **Language**        | Review language     | `en`, `es`, `fr`              |

### 🚀 How to scrape app reviews in 4 easy steps

#### Method 1: Using App IDs (Direct Mode)

1. **Find your app IDs:**
   - **Google Play:** Package name (e.g., `com.whatsapp`)
   - **App Store:** Numeric ID from URL (e.g., `310633997`)

2. **Configure the scraper:**
   - Add app IDs to the input
   - Select countries (up to 155 available)
   - Set max reviews per app
   - Apply filters (optional)

3. **Run the scraper:**
   - Click "Start" and wait for completion
   - Processing time: 1-5 minutes depending on volume

4. **Download your data:**
   - Data is automatically organized into 5 named datasets
   - Export as JSON, CSV, Excel, or HTML
   - Access via API or integrations

#### 📂 Accessing Named Datasets

After your scraper run completes, you'll find 5 organized datasets:

**Via Apify Console:**

1. Go to your Actor run detail page
2. Click "Storage" → "Datasets"
3. Select the dataset you need:
   - `app-overview` - App info only
   - `all-reviews` - Complete dataset
   - `positive-reviews` - 4-5 star reviews
   - `negative-reviews` - 1-2 star reviews
   - `reviews-with-replies` - Developer engagement

**Via API (JavaScript):**

```javascript
const apifyClient = new ApifyClient({ token: "YOUR_API_TOKEN" });

// Get all reviews
const allReviews = await apifyClient.dataset("all-reviews").listItems();

// Get only negative reviews for issue analysis
const negativeReviews = await apifyClient
  .dataset("negative-reviews")
  .listItems();
````

**Via API (Python):**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

## Get all reviews
all_reviews = client.dataset('all-reviews').list_items().items

## Get app overview
apps = client.dataset('app-overview').list_items().items
```

#### Method 2: Using Keywords (Search Mode)

**Single Keyword:**

1. **Enter your search keyword:**
   - Example: `"messaging"`, `"photo editor"`, `"fitness"`

2. **Configure scraping:**
   - Select max apps to find (1-50)
   - Select countries
   - Set reviews per app
   - Apply filters

**Multiple Keywords (NEW!):**

1. **Enter multiple search keywords:**
   - Example: `["fitness tracker", "workout app", "health monitor"]`
   - Each keyword searches separately and results are combined

2. **Configure scraping:**
   - Select max apps per keyword (1-50)
   - Select countries
   - Set reviews per app
   - Automatic deduplication of apps and reviews

3. **Run and download:**
   - Scraper finds apps and extracts reviews automatically
   - Results ready in minutes

#### Video Tutorial

https://www.youtube.com/watch?v=YOUR\_VIDEO\_ID\_HERE

*(Replace with your actual video tutorial when available)*

### Why scrape app reviews?

#### Business Use Cases

**📊 Competitor Analysis**

- Monitor competitor sentiment across markets
- Identify feature gaps and opportunities
- Track rating trends over time

**🎯 Market Research**

- Understand user pain points
- Discover popular features
- Analyze sentiment by country

**💡 Product Development**

- Prioritize features based on user feedback
- Find and fix critical bugs
- Track user satisfaction post-update

**🌍 Multi-Market Strategy**

- Compare sentiment across countries
- Identify regional preferences
- Optimize localization efforts

**📈 SEO & App Store Optimization**

- Track keyword mentions in reviews
- Monitor rating distribution
- Analyze review velocity

### Advanced Features

#### 🎯 Smart Filter Multiplier

When you apply filters, the scraper automatically fetches **10x more reviews** to ensure you get your target amount after filtering.

**Example:**

```json
{
  "maxReviewsPerApp": 1000,
  "minScore": 4
}
```

- Fetches: 10,000 reviews
- Filters to: ~1,000 4-5 star reviews
- You pay for: 1,000 reviews only

#### 🌍 Multi-Country Support

Scrape from **1-155 countries** in a single run:

```json
{
  "countries": ["us", "gb", "de", "fr", "jp", "br", "in"]
}
```

**Benefits:**

- Compare sentiment across regions
- Identify global trends
- Single run efficiency
- Same pricing regardless of country count

#### 🔄 Automatic Retries

Built-in resilience with exponential backoff:

- Retries: Up to 3 attempts
- Success rate: +35-55% improvement
- No extra cost for retries

#### 🎯 Smart Deduplication

Automatically removes duplicate reviews by ID:

- Clean data guaranteed
- Pay only for unique reviews
- Typical savings: 10-40% with multi-country

### Input Parameters

#### App Selection

- **App IDs** (array): Google Play package names or App Store numeric IDs
- **Search Keyword** (string): Find apps by keyword
- **Max Apps per Search** (number): Limit apps to process (1-50, default: 10)

#### Review Configuration

- **Max Reviews per App** (number): Total across all countries (1-100,000, default: 100)
- **Sort By** (select): Newest or Oldest first
- **Language** (string): Language code (e.g., `en`, `es`)
- **Countries** (multi-select): Select 1-155 countries (default: US)

#### Filters

- **Min/Max Score** (1-5): Filter by rating
- **Date Range**: From/To dates
- **Keywords** (array): Must contain these words
- **Min Thumbs Up** (number): Minimum helpful votes
- **Developer Reply Filter**: All / With Reply / Without Reply
- **Min Review Length** (number): Minimum character count

### Output Examples

#### Example Input

```json
{
  "appIds": ["com.whatsapp"],
  "countries": ["us", "gb", "ca"],
  "maxReviewsPerApp": 100,
  "minScore": 4,
  "sortBy": "newest"
}
```

#### Example Output

```json
{
  "id": "googleplay_scraper-d9fd7825-d788-4bb5-9f58-cb90c74a6466",
  "store": "googleplay",
  "app_id": "com.whatsapp",
  "app_name": "WhatsApp Messenger",
  "app_developer": "WhatsApp LLC",
  "app_rating": 4.64,
  "app_rating_count": 239556988,
  "country": "us",
  "rating": 5,
  "title": "",
  "body": "Best messaging app ever! Love the new features.",
  "author_name": "John Doe",
  "app_version": "2.26.16.72",
  "created_at": "2024-07-23T14:12:52+00:00",
  "updated_at": null,
  "is_edited": false,
  "thumbs_up": 15,
  "developer_reply": "Thank you for your feedback!",
  "developer_reply_date": "2024-07-24T10:00:00+00:00",
  "language": "en"
}
```

#### Dataset Views

The output includes 5 pre-configured views:

1. **Overview with App Info** - App metadata + review summary
2. **All Reviews** - Complete review details
3. **Positive Reviews** - 4-5 star reviews only
4. **Negative Reviews** - 1-2 star reviews only
5. **Reviews with Developer Replies** - Reviews with responses

### Export Formats

Download your scraped data in multiple formats:

- **JSON** - For developers and APIs
- **CSV** - For Excel and data analysis
- **HTML** - For web viewing
- **Excel** - Direct spreadsheet import

### Integration & API

#### Apify API

Access your data programmatically:

```javascript
// Node.js example
const { ApifyClient } = require("apify-client");

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });
const input = {
  appIds: ["com.whatsapp"],
  maxReviewsPerApp: 100,
};

const run = await client.actor("YOUR_ACTOR_ID").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Integrations

Connect with popular tools:

- **Make (Integromat)** - Automation workflows
- **Zapier** - App connections
- **Google Sheets** - Direct export
- **Slack** - Notifications
- **Webhooks** - Custom integrations

#### Scheduling

Run automatically on a schedule:

- Daily, weekly, or monthly runs
- Monitor new reviews continuously
- Track sentiment trends over time

### Tips for Best Results

#### 1. Start Small, Scale Up

Test with 100 reviews before running large batches:

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

#### 2. Use Filters Effectively

Target specific reviews to save costs:

```json
{
  "minScore": 1,
  "maxScore": 2,
  "dateFrom": "2024-01-01"
}
```

Only pay for negative reviews from 2024!

#### 3. Multi-Country Strategy

For App Store apps, use **Search Mode** for best metadata:

```json
{
  "searchKeyword": "whatsapp",
  "countries": ["us", "gb", "de"]
}
```

#### 4. Monitor Competitors

Schedule daily runs to track competitor sentiment:

```json
{
  "appIds": ["competitor1", "competitor2", "competitor3"],
  "maxReviewsPerApp": 50,
  "sortBy": "newest"
}
```

#### 5. Analyze Trends

Export data and analyze in your favorite tools:

- Excel/Google Sheets for charts
- Python/R for sentiment analysis
- Tableau/Power BI for dashboards

### Frequently Asked Questions

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

Yes! Our scraper only extracts **publicly available data** that users have chosen to share publicly on app stores. We do not extract any private user data.

However, you should:

- ✅ Use scraped data for legitimate purposes
- ✅ Comply with GDPR and data protection laws
- ✅ Not use data for spam or harassment
- ✅ Respect app store terms of service

For more information, read our blog post: [Is Web Scraping Legal?](https://blog.apify.com/is-web-scraping-legal/)

#### How does the scraper handle App Store IDs?

**Google Play:** Use package names (e.g., `com.whatsapp`)
**App Store:** Use numeric IDs (e.g., `310633997`)

**Finding App Store IDs:**

1. Go to app page in browser
2. Look at URL: `https://apps.apple.com/.../id310633997`
3. The number after `id` is your App ID

**Pro Tip:** Use Search Mode for App Store apps to get full metadata automatically!

#### Can I scrape reviews from multiple countries?

Yes! Select up to **155 countries** in a single run. The scraper fetches reviews from all selected countries efficiently in one API call.

**Important:** `maxReviewsPerApp` is the total limit across ALL countries, not per country.

#### Do I pay for duplicate reviews?

No! The scraper automatically deduplicates reviews by ID. You only pay for unique reviews added to your dataset.

#### What's the maximum number of reviews I can scrape?

Technically unlimited! Set `maxReviewsPerApp` up to 100,000. For larger volumes, run the scraper multiple times or contact us for custom solutions.

#### How long does scraping take?

**Typical times:**

- 100 reviews: ~1-2 minutes
- 1,000 reviews: ~3-5 minutes
- 10,000 reviews: ~15-30 minutes

Time varies based on:

- Number of apps
- Number of countries
- Applied filters
- Network conditions

#### Can I schedule automatic runs?

Yes! Use Apify's **Scheduler** feature:

1. Go to Schedules tab
2. Set frequency (hourly, daily, weekly, monthly)
3. Configure input
4. Save and activate

Perfect for monitoring reviews continuously!

#### What if my app has no reviews in a country?

No problem! The scraper continues with other countries. You're only charged for reviews actually scraped.

#### Can I get data in Python?

Yes! Use the Apify Python Client:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run_input = {
    "appIds": ["com.whatsapp"],
    "maxReviewsPerApp": 100
}

run = client.actor('YOUR_ACTOR_ID').call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### How do I filter reviews after scraping?

Use the **Dataset Views**:

1. Click on your dataset
2. Select a view (Positive, Negative, etc.)
3. Export filtered results

Or use the **Dataset API** to filter programmatically.

#### Is there a free trial?

Yes! **Free Apify accounts** include:

- $5 free platform credits monthly
- \~10,000 reviews free per month
- All features included

Perfect for testing and small projects!

#### What about support and custom solutions?

**Support:**

- 📖 Read our documentation
- 💬 Open an issue on GitHub
- 📧 Contact us via Apify Console

**Custom Solutions:**
Need bulk discounts, custom features, or dedicated support? [Contact us](https://apify.com/contact) for enterprise solutions!

### Troubleshooting

#### "No reviews found"

**Possible causes:**

- App ID is incorrect
- App has no reviews in selected country
- Filters are too strict

**Solutions:**

- Verify app ID format
- Try different countries
- Remove or loosen filters

#### "Actor run failed"

**Possible causes:**

- Network timeout
- Invalid input
- Rate limiting

**Solutions:**

- Check input format
- Try again (automatic retries included)
- Contact support if persists

#### "Fewer reviews than expected"

**Possible causes:**

- Filters removed many reviews
- App has fewer reviews available
- Duplicates were removed

**Solutions:**

- Check duplicate removal log
- Adjust filters
- Increase maxReviewsPerApp

### Related Actors

Explore our other data extraction tools:

- **[Instagram Scraper](https://apify.com/apify/instagram-scraper)** - Extract Instagram posts, profiles, and hashtags
- **[Google Maps Scraper](https://apify.com/nwua/google-maps-scraper)** - Scrape business data from Google Maps
- **[Amazon Product Scraper](https://apify.com/junglee/amazon-crawler)** - Extract Amazon product data and reviews
- **[Twitter Scraper](https://apify.com/apidojo/twitter-user-scraper)** - Scrape tweets and user profiles

### Why Choose Apify?

#### 🚀 Powerful Platform Features

- **Serverless Computing** - No infrastructure management
- **Automatic Scaling** - Handle any data volume
- **Proxy Rotation** - Built-in residential proxies
- **Cloud Storage** - Unlimited dataset storage
- **API Access** - RESTful API for all data
- **Monitoring** - Track runs and performance
- **Scheduling** - Automate recurring scrapes
- **Integrations** - Connect with 1000+ apps

#### 💎 Enterprise Ready

- **99.9% Uptime SLA**
- **GDPR Compliant**
- **SOC 2 Certified**
- **Dedicated Support**
- **Custom Solutions**
- **Volume Discounts**

### Need Help?

- 📖 **Documentation:** [Apify Docs](https://docs.apify.com)
- 💬 **Issues:** [Report a bug](https://github.com/apify/app-reviews-scraper/issues)
- 📧 **Contact:** <support@apify.com>
- 🎓 **Academy:** [Learn web scraping](https://docs.apify.com/academy)

***

**Made with ❤️ by Apify**

Start scraping app reviews today and unlock powerful insights from user feedback!

[🚀 Try App Reviews Scraper Now](https://console.apify.com)

# Actor input Schema

## `appIds` (type: `array`):

List of App IDs. For Google Play: use package names (e.g., com.whatsapp). For App Store: use numeric IDs (e.g., 310633997). App names will be fetched automatically for Google Play. For App Store, the numeric ID will be used as the name unless found via search.

## `searchKeyword` (type: `string`):

Search for apps by a single keyword. Use 'Search Keywords' for multiple keywords.

## `searchKeywords` (type: `array`):

Search for apps using multiple keywords. Each keyword will be searched separately and results combined. Example: \['fitness tracker', 'workout app', 'health monitor']

## `maxAppsPerSearch` (type: `integer`):

Maximum number of apps to fetch per search query (only used when Search Keyword is provided)

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

Maximum number of reviews to fetch per app

## `sortBy` (type: `string`):

Sort fetched reviews by date (Note: App search results are sorted by relevance and cannot be changed)

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

Language code for reviews (e.g., en, es, fr)

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

Select one or more countries for app reviews. Reviews will be fetched from all selected countries.

## `minScore` (type: `integer`):

Filter reviews by minimum rating (1-5 stars)

## `maxScore` (type: `integer`):

Filter reviews by maximum rating (1-5 stars)

## `minThumbsUp` (type: `integer`):

Filter reviews by minimum number of helpful votes

## `developerReplyFilter` (type: `string`):

Filter reviews by developer reply status

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

Filter out reviews that don't contain specific keywords

## `minReviewLength` (type: `integer`):

Filter reviews by minimum character count

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

Filter reviews from this date (YYYY-MM-DD format)

## `dateTo` (type: `string`):

Filter reviews up to this date (YYYY-MM-DD format)

## Actor input object example

```json
{
  "appIds": [
    "com.whatsapp"
  ],
  "maxAppsPerSearch": 10,
  "maxReviewsPerApp": 100,
  "sortBy": "newest",
  "language": "en",
  "countries": [
    "us"
  ],
  "developerReplyFilter": "all"
}
```

# Actor output Schema

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

All scraped app reviews with ratings, text, author info, developer replies, and app metadata

# 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 = {
    "appIds": [
        "com.whatsapp"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("code-node-tools/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 = {
    "appIds": ["com.whatsapp"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("code-node-tools/app-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 '{
  "appIds": [
    "com.whatsapp"
  ],
  "countries": [
    "us"
  ]
}' |
apify call code-node-tools/app-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Reviews Scraper: Google Play & App Store Review Extractor",
        "description": "Scrape and filter reviews from Google Play and the App Store by rating, keyword, date, and developer reply status. Find competitor complaints, feature requests, and sentiment trends in minutes. Supports keyword-based app discovery and multi-country data collection.",
        "version": "1.0",
        "x-build-id": "BfWZCcgdIe08WrSHX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/code-node-tools~app-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-code-node-tools-app-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/code-node-tools~app-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-code-node-tools-app-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/code-node-tools~app-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-code-node-tools-app-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",
                "properties": {
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "List of App IDs. For Google Play: use package names (e.g., com.whatsapp). For App Store: use numeric IDs (e.g., 310633997). App names will be fetched automatically for Google Play. For App Store, the numeric ID will be used as the name unless found via search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeyword": {
                        "title": "Search Keyword (Single)",
                        "type": "string",
                        "description": "Search for apps by a single keyword. Use 'Search Keywords' for multiple keywords."
                    },
                    "searchKeywords": {
                        "title": "Search Keywords (Multiple)",
                        "type": "array",
                        "description": "Search for apps using multiple keywords. Each keyword will be searched separately and results combined. Example: ['fitness tracker', 'workout app', 'health monitor']",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAppsPerSearch": {
                        "title": "Maximum Apps per Search",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of apps to fetch per search query (only used when Search Keyword is provided)",
                        "default": 10
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum Reviews per App",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per app",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Sort fetched reviews by date (Note: App search results are sorted by relevance and cannot be changed)",
                        "default": "newest"
                    },
                    "language": {
                        "title": "Language",
                        "pattern": "^[a-z]{2}$",
                        "type": "string",
                        "description": "Language code for reviews (e.g., en, es, fr)",
                        "default": "en"
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more countries for app reviews. Reviews will be fetched from all selected countries.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ae",
                                "ag",
                                "ai",
                                "al",
                                "am",
                                "ao",
                                "ar",
                                "at",
                                "au",
                                "az",
                                "bb",
                                "be",
                                "bf",
                                "bg",
                                "bh",
                                "bj",
                                "bm",
                                "bn",
                                "bo",
                                "br",
                                "bs",
                                "bt",
                                "bw",
                                "by",
                                "bz",
                                "ca",
                                "cg",
                                "ch",
                                "cl",
                                "cn",
                                "co",
                                "cr",
                                "cv",
                                "cy",
                                "cz",
                                "de",
                                "dk",
                                "dm",
                                "do",
                                "dz",
                                "ec",
                                "ee",
                                "eg",
                                "es",
                                "fi",
                                "fj",
                                "fm",
                                "fr",
                                "gb",
                                "gd",
                                "gh",
                                "gm",
                                "gr",
                                "gt",
                                "gw",
                                "gy",
                                "hk",
                                "hn",
                                "hr",
                                "hu",
                                "id",
                                "ie",
                                "il",
                                "in",
                                "is",
                                "it",
                                "jm",
                                "jo",
                                "jp",
                                "ke",
                                "kg",
                                "kh",
                                "kn",
                                "kr",
                                "kw",
                                "ky",
                                "kz",
                                "la",
                                "lb",
                                "lc",
                                "lk",
                                "lr",
                                "lt",
                                "lu",
                                "lv",
                                "md",
                                "mg",
                                "mk",
                                "ml",
                                "mn",
                                "mo",
                                "mr",
                                "ms",
                                "mt",
                                "mu",
                                "mw",
                                "mx",
                                "my",
                                "mz",
                                "na",
                                "ne",
                                "ng",
                                "ni",
                                "nl",
                                "no",
                                "np",
                                "nz",
                                "om",
                                "pa",
                                "pe",
                                "pg",
                                "ph",
                                "pk",
                                "pl",
                                "pt",
                                "pw",
                                "py",
                                "qa",
                                "ro",
                                "ru",
                                "sa",
                                "sb",
                                "sc",
                                "se",
                                "sg",
                                "si",
                                "sk",
                                "sl",
                                "sn",
                                "sr",
                                "st",
                                "sv",
                                "sz",
                                "tc",
                                "td",
                                "th",
                                "tj",
                                "tm",
                                "tn",
                                "tr",
                                "tt",
                                "tw",
                                "tz",
                                "ua",
                                "ug",
                                "us",
                                "uy",
                                "uz",
                                "vc",
                                "ve",
                                "vg",
                                "vn",
                                "ye",
                                "za",
                                "zw"
                            ],
                            "enumTitles": [
                                "United Arab Emirates",
                                "Antigua and Barbuda",
                                "Anguilla",
                                "Albania",
                                "Armenia",
                                "Angola",
                                "Argentina",
                                "Austria",
                                "Australia",
                                "Azerbaijan",
                                "Barbados",
                                "Belgium",
                                "Burkina-Faso",
                                "Bulgaria",
                                "Bahrain",
                                "Benin",
                                "Bermuda",
                                "Brunei Darussalam",
                                "Bolivia",
                                "Brazil",
                                "Bahamas",
                                "Bhutan",
                                "Botswana",
                                "Belarus",
                                "Belize",
                                "Canada",
                                "Democratic Republic of the Congo",
                                "Switzerland",
                                "Chile",
                                "China",
                                "Colombia",
                                "Costa Rica",
                                "Cape Verde",
                                "Cyprus",
                                "Czech Republic",
                                "Germany",
                                "Denmark",
                                "Dominica",
                                "Dominican Republic",
                                "Algeria",
                                "Ecuador",
                                "Estonia",
                                "Egypt",
                                "Spain",
                                "Finland",
                                "Fiji",
                                "Federated States of Micronesia",
                                "France",
                                "Great Britain",
                                "Grenada",
                                "Ghana",
                                "Gambia",
                                "Greece",
                                "Guatemala",
                                "Guinea Bissau",
                                "Guyana",
                                "Hong Kong",
                                "Honduras",
                                "Croatia",
                                "Hungary",
                                "Indonesia",
                                "Ireland",
                                "Israel",
                                "India",
                                "Iceland",
                                "Italy",
                                "Jamaica",
                                "Jordan",
                                "Japan",
                                "Kenya",
                                "Kyrgyzstan",
                                "Cambodia",
                                "Saint Kitts and Nevis",
                                "South Korea",
                                "Kuwait",
                                "Cayman Islands",
                                "Kazakhstan",
                                "Laos",
                                "Lebanon",
                                "Saint Lucia",
                                "Sri Lanka",
                                "Liberia",
                                "Lithuania",
                                "Luxembourg",
                                "Latvia",
                                "Moldova",
                                "Madagascar",
                                "Macedonia",
                                "Mali",
                                "Mongolia",
                                "Macau",
                                "Mauritania",
                                "Montserrat",
                                "Malta",
                                "Mauritius",
                                "Malawi",
                                "Mexico",
                                "Malaysia",
                                "Mozambique",
                                "Namibia",
                                "Niger",
                                "Nigeria",
                                "Nicaragua",
                                "Netherlands",
                                "Norway",
                                "Nepal",
                                "New Zealand",
                                "Oman",
                                "Panama",
                                "Peru",
                                "Papua New Guinea",
                                "Philippines",
                                "Pakistan",
                                "Poland",
                                "Portugal",
                                "Palau",
                                "Paraguay",
                                "Qatar",
                                "Romania",
                                "Russia",
                                "Saudi Arabia",
                                "Solomon Islands",
                                "Seychelles",
                                "Sweden",
                                "Singapore",
                                "Slovenia",
                                "Slovakia",
                                "Sierra Leone",
                                "Senegal",
                                "Suriname",
                                "Sao Tome e Principe",
                                "El Salvador",
                                "Swaziland",
                                "Turks and Caicos Islands",
                                "Chad",
                                "Thailand",
                                "Tajikistan",
                                "Turkmenistan",
                                "Tunisia",
                                "Turkey",
                                "Trinidad and Tobago",
                                "Taiwan",
                                "Tanzania",
                                "Ukraine",
                                "Uganda",
                                "United States of America",
                                "Uruguay",
                                "Uzbekistan",
                                "Saint Vincent and the Grenadines",
                                "Venezuela",
                                "British Virgin Islands",
                                "Vietnam",
                                "Yemen",
                                "South Africa",
                                "Zimbabwe"
                            ]
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "minScore": {
                        "title": "Minimum Score",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Filter reviews by minimum rating (1-5 stars)"
                    },
                    "maxScore": {
                        "title": "Maximum Score",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Filter reviews by maximum rating (1-5 stars)"
                    },
                    "minThumbsUp": {
                        "title": "Minimum Thumbs Up",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter reviews by minimum number of helpful votes"
                    },
                    "developerReplyFilter": {
                        "title": "Developer Reply Filter",
                        "enum": [
                            "all",
                            "with_reply",
                            "without_reply"
                        ],
                        "type": "string",
                        "description": "Filter reviews by developer reply status",
                        "default": "all"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Filter out reviews that don't contain specific keywords",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minReviewLength": {
                        "title": "Minimum Review Length",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter reviews by minimum character count"
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter reviews from this date (YYYY-MM-DD format)"
                    },
                    "dateTo": {
                        "title": "Date To",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter reviews up to this date (YYYY-MM-DD format)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
