# Mobile Apps Reviews, Downloads and Data (`trovevault/mobile-apps-reviews-downloads-data-scraper`) Actor

Extracts mobile app reviews, ratings, installs, metadata, versions, sentiment, themes, and competitor signals. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/mobile-apps-reviews-downloads-data-scraper.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 app or 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

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

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

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


# README

## Mobile Apps Reviews, Downloads and Data: Google Play and App Store Intelligence

Mobile Apps Reviews, Downloads and Data collects public mobile app intelligence from Google Play and the App Store. It returns app metadata, ratings, review samples, approximate Google Play installs, version data, developer names, categories, review sentiment, complaint themes, praise signals, and a simple market opportunity score. Use it for competitor analysis, product research, app store monitoring, customer feedback triage, and market research across many apps in one run.

### Why use Mobile Apps Reviews, Downloads and Data?

- Compare competitor apps across Google Play and the App Store using one dataset.
- Monitor ratings, review volume, version updates, complaint themes, and public install ranges.
- Find product opportunities from repeated review complaints such as crashes, login issues, payments, ads, performance, support, privacy, and usability.
- Run scheduled checks and append results to a shared dataset for trend tracking.
- Export results to JSON, CSV, Excel, Google Sheets, BI tools, or your own data warehouse.

### What data does it extract?

| Field | Description |
|---|---|
| `store` | `google_play` or `app_store`, detected from each URL or ID. |
| `appName`, `developerName`, `category` | Public app identity and category metadata. |
| `rating`, `ratingCount`, `reviewCount` | Public rating and review metrics when available. |
| `installsText`, `minInstalls`, `maxInstalls` | Google Play public install range such as `100M+`. |
| `downloadsAvailable`, `downloadsNote` | Whether public download data exists and why fields may be null. |
| `version`, `updatedAtStore` | Latest public version and store update date. |
| `reviewRating`, `reviewTitle`, `reviewText` | Public written review fields. |
| `sentiment`, `themes` | Lightweight interpretation of sampled reviews. |
| `complaintSignals`, `positiveSignals` | Detected complaints and praise categories. |
| `marketOpportunityScore` | 0 to 100 score based on rating gaps, negative reviews, and complaints. |
| `analysisWarnings` | Notes about partial data, missing reviews, or App Store download limits. |

### How can I use it for competitor analysis?

Use Mobile Apps Reviews, Downloads and Data with a list of competitor app URLs or IDs. The actor creates app-level rows for each app and country, then review-level rows when review collection is enabled. You can sort by `marketOpportunityScore`, filter by `complaintSignals`, and compare `rating`, `ratingCount`, `reviewCount`, and `installsText` across apps.

### Why use this actor instead of alternatives?

| Feature | Alternatives | This Actor |
|---|---|---|
| Store support | Often one store only | Google Play and App Store in one input list |
| Input handling | Separate package ID and app ID fields | Detects store from URLs, package IDs, and Apple app IDs |
| Downloads | Often implied as exact | Labels Google Play installs as approximate and App Store downloads as unavailable |
| Reviews | Raw text only | Adds sentiment, themes, complaint signals, and praise signals |
| Large lists | Browser-heavy scraping can be costly | HTTP-first design with concurrency controls |

### How do I use Mobile Apps Reviews, Downloads and Data?

1. Add Google Play URLs, App Store URLs, Google Play package IDs, or Apple numeric app IDs to `apps`.
2. Set `countries` to the markets you want to check, such as `us`, `gb`, or `de`.
3. Choose `maxReviewsPerApp`. Use `5` to `20` for fast monitoring and `50` to `200` for product research.
4. Keep `analysisMode` as `themes` when you want complaint and praise categories.
5. Run the actor and export the dataset from Apify.
6. Schedule the actor daily or weekly to monitor rating changes, review themes, and competitor updates.

### Input example

```json
{
  "apps": [
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    "com.spotify.music",
    "324684580"
  ],
  "countries": ["us", "gb"],
  "maxReviewsPerApp": 25,
  "analysisMode": "themes",
  "includeReviews": true,
  "includeAppMetadata": true,
  "maxConcurrency": 6
}
````

### Input reference

| Field | Type | Default | Description |
|---|---|---:|---|
| `apps` | array | required | App Store URLs, Play Store URLs, Google package IDs, or Apple numeric app IDs. |
| `countries` | array | `["us"]` | Country codes used for store-specific metadata and reviews. |
| `maxReviewsPerApp` | integer | `100` | Review cap for each app and country. Use lower values for large runs. |
| `includeReviews` | boolean | `true` | Collect public written reviews and review-level rows. |
| `includeAppMetadata` | boolean | `true` | Emit app-level rows with ratings, installs, version, and analysis. |
| `analysisMode` | string | `themes` | `basic`, `sentiment`, or `themes`. |
| `maxConcurrency` | integer | `6` | Number of app-country jobs processed in parallel. |
| `requestDelayMillis` | integer | `100` | Delay used to reduce bursts against public store endpoints. |
| `datasetId` | string | empty | Optional dataset to append results to. |
| `runId` | string | empty | Optional pipeline run ID copied into each row. |

### Output example

```json
{
  "entityType": "app",
  "store": "google_play",
  "country": "us",
  "appId": "com.duolingo",
  "appName": "Duolingo: Language Lessons",
  "developerName": "Duolingo",
  "rating": 4.7,
  "ratingCount": 32000000,
  "installsText": "100M+",
  "downloadsAvailable": true,
  "downloadsNote": "Google Play exposes approximate public install ranges, not exact downloads.",
  "sampledReviewCount": 25,
  "negativeReviewShare": 0.16,
  "complaintSignals": ["ads", "performance"],
  "positiveSignals": ["usability", "design"],
  "marketOpportunityScore": 28.2,
  "scrapedAt": "2026-04-27T09:00:00.000Z",
  "error": false
}
```

### How do I use it via API?

You can run Mobile Apps Reviews, Downloads and Data through the Apify API with a bearer token:

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~mobile-apps-reviews-downloads-data-scraper/runs?waitForFinish=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "apps": ["com.duolingo", "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"],
    "countries": ["us"],
    "maxReviewsPerApp": 10,
    "analysisMode": "themes"
  }'
```

### Limitations

- App Store public pages and public lookup APIs do not expose download counts. App Store download fields are intentionally null unless a future authenticated owner mode is added.
- Google Play installs are public ranges such as `1M+`, not exact download counts.
- Review availability varies by country, store policy, app age, and public review volume.

### FAQ

#### Does it work on all Google Play and App Store apps?

It works with public apps that are available in the selected country. Removed, private, region-blocked, or age-restricted apps may return structured error rows.

#### Can I scrape multiple apps at once?

Yes. Add many app URLs or IDs to `apps`. For 500 apps, use one or two countries first, keep `maxReviewsPerApp` low, and use `maxConcurrency` around `3` to `8`.

#### Can I get exact App Store downloads?

No. Exact App Store downloads are not public competitor data. The actor labels this limitation in `downloadsNote` and keeps App Store download fields null.

#### Can I get Google Play downloads?

You can get public approximate install ranges from Google Play, such as `100K+`, `1M+`, or `100M+`. These are useful for market sizing but should not be treated as exact downloads.

#### How do I monitor changes over time?

Schedule the actor daily or weekly and set `datasetId` to append each run into a shared dataset. Compare `rating`, `ratingCount`, `reviewCount`, `installsText`, `version`, `updatedAtStore`, and `complaintSignals` over time.

#### Can I use this via the Apify API?

Yes. Use the `curl` example above or call the actor from any API client with `Authorization: Bearer $APIFY_TOKEN`.

#### Can I use this through an MCP Server?

Yes. If your MCP setup can run Apify actors or call HTTP APIs, pass the same JSON input to the actor and read the default dataset items.

#### Is scraping app store data legal?

Public store data can often be collected for research, monitoring, and interoperability, but you are responsible for using it lawfully and respecting applicable terms, privacy rules, and local regulations.

### Related actors

Related TroveVault actors may include product review scrapers, SEO metadata scrapers, and competitor monitoring actors. Use this actor when the target is mobile app store intelligence.

### Changelog

- `0.1` Initial public competitor intelligence version for Google Play and App Store.

### Feedback

Open an Apify issue with the app URL, selected country, and run ID if a store layout change or parsing issue affects your results.

# Actor input Schema

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

One or more mobile apps to analyze. The actor detects the store from each value and accepts Google Play URLs such as `https://play.google.com/store/apps/details?id=com.duolingo`, App Store URLs such as `https://apps.apple.com/us/app/duolingo-language-lessons/id570060128`, Google Play package IDs such as `com.duolingo`, or Apple numeric app IDs such as `570060128`. Use exact app URLs when possible because they remove ambiguity and keep large runs more reliable. For 500 apps, keep `maxReviewsPerApp` modest unless you need deep review sampling.

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

Country codes to query for store-specific ratings, rankings, metadata, and reviews. The actor uses ISO 3166-1 alpha-2 codes such as `us`, `gb`, `de`, or `br` and creates app-country rows so you can compare market differences. Start with one country for smoke tests, then add priority markets for competitor analysis. More countries multiply the number of requests and increase runtime.

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

Maximum number of public review rows to collect for each app and country. The actor uses this cap separately for each detected store-country pair and also uses the sampled reviews for sentiment, complaint themes, and opportunity signals. Use 5 to 20 for fast monitoring, 50 to 200 for practical competitor research, and higher values only when you need broader review evidence. Higher values improve theme coverage but take longer and make 500-app runs more expensive.

## `includeReviews` (type: `boolean`):

When enabled, the actor collects public written reviews for each app and country. Reviews are useful for sentiment, theme clustering, complaint monitoring, and support triage. Disable this when you only need app metadata, ratings, and install ranges for a very large app list.

## `includeAppMetadata` (type: `boolean`):

When enabled, the actor emits one app-level row per app and country with rating, rating count, approximate Play Store installs, category, developer, price, version, and update metadata. Keep this enabled for competitor benchmarking and scheduled monitoring. Disable it only when you want review rows without app-level summaries.

## `analysisMode` (type: `string`):

Controls how much interpretation is added to the raw store data. `basic` returns store fields and simple review sentiment. `sentiment` adds app-level rating health and review sentiment summaries. `themes` adds lightweight complaint and praise themes from review text. Use `themes` for product research and `basic` for the cheapest large runs.

## `maxConcurrency` (type: `integer`):

Maximum number of app-country jobs processed in parallel. The actor uses this to keep 500-app runs fast without opening browsers. Use 3 to 8 for stable public scraping and lower it if stores throttle requests. Higher values can finish faster but may increase rate-limit errors.

## `requestDelayMillis` (type: `integer`):

Small delay before each app-country job starts. The actor uses this to reduce request bursts against public store endpoints. Use `0` for small tests, 100 to 500 for larger competitor lists, and higher values if you see temporary throttling. Larger delays improve politeness but increase total runtime.

## `proxyConfiguration` (type: `object`):

Proxy settings for public store requests. The actor passes this setting to supported HTTP clients when available and still soft-fails individual blocked app-country jobs. Enable Apify Proxy only if Google Play or App Store requests return HTTP 403, 429, CAPTCHA, or region-specific blocks. Leave it disabled for normal runs to keep costs lower.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for scheduled mobile app monitoring pipelines that combine several runs into one long-term dataset. Leave blank to write only to the default run dataset.

## `runId` (type: `string`):

ID of an existing Apify actor run to associate results with. The actor copies this value into each dataset row so external workflows can connect app intelligence to an upstream job, client account, or monitoring batch. Leave blank for standalone runs.

## Actor input object example

```json
{
  "apps": [
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 5,
  "includeReviews": true,
  "includeAppMetadata": true,
  "analysisMode": "themes",
  "maxConcurrency": 6,
  "requestDelayMillis": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "apps": [
        "https://play.google.com/store/apps/details?id=com.duolingo",
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
    ],
    "countries": [
        "us"
    ],
    "maxReviewsPerApp": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/mobile-apps-reviews-downloads-data-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://play.google.com/store/apps/details?id=com.duolingo",
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
    ],
    "countries": ["us"],
    "maxReviewsPerApp": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/mobile-apps-reviews-downloads-data-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 '{
  "apps": [
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 5
}' |
apify call trovevault/mobile-apps-reviews-downloads-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mobile Apps Reviews, Downloads and Data",
        "description": "Extracts mobile app reviews, ratings, installs, metadata, versions, sentiment, themes, and competitor signals. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "5YTrGsREICux699QW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~mobile-apps-reviews-downloads-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-mobile-apps-reviews-downloads-data-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/trovevault~mobile-apps-reviews-downloads-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-mobile-apps-reviews-downloads-data-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/trovevault~mobile-apps-reviews-downloads-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-mobile-apps-reviews-downloads-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "apps"
                ],
                "properties": {
                    "apps": {
                        "title": "Apps",
                        "type": "array",
                        "description": "One or more mobile apps to analyze. The actor detects the store from each value and accepts Google Play URLs such as `https://play.google.com/store/apps/details?id=com.duolingo`, App Store URLs such as `https://apps.apple.com/us/app/duolingo-language-lessons/id570060128`, Google Play package IDs such as `com.duolingo`, or Apple numeric app IDs such as `570060128`. Use exact app URLs when possible because they remove ambiguity and keep large runs more reliable. For 500 apps, keep `maxReviewsPerApp` modest unless you need deep review sampling.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Country codes to query for store-specific ratings, rankings, metadata, and reviews. The actor uses ISO 3166-1 alpha-2 codes such as `us`, `gb`, `de`, or `br` and creates app-country rows so you can compare market differences. Start with one country for smoke tests, then add priority markets for competitor analysis. More countries multiply the number of requests and increase runtime.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max Reviews Per App",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of public review rows to collect for each app and country. The actor uses this cap separately for each detected store-country pair and also uses the sampled reviews for sentiment, complaint themes, and opportunity signals. Use 5 to 20 for fast monitoring, 50 to 200 for practical competitor research, and higher values only when you need broader review evidence. Higher values improve theme coverage but take longer and make 500-app runs more expensive.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "When enabled, the actor collects public written reviews for each app and country. Reviews are useful for sentiment, theme clustering, complaint monitoring, and support triage. Disable this when you only need app metadata, ratings, and install ranges for a very large app list.",
                        "default": true
                    },
                    "includeAppMetadata": {
                        "title": "Include App Metadata",
                        "type": "boolean",
                        "description": "When enabled, the actor emits one app-level row per app and country with rating, rating count, approximate Play Store installs, category, developer, price, version, and update metadata. Keep this enabled for competitor benchmarking and scheduled monitoring. Disable it only when you want review rows without app-level summaries.",
                        "default": true
                    },
                    "analysisMode": {
                        "title": "Analysis Mode",
                        "enum": [
                            "basic",
                            "sentiment",
                            "themes"
                        ],
                        "type": "string",
                        "description": "Controls how much interpretation is added to the raw store data. `basic` returns store fields and simple review sentiment. `sentiment` adds app-level rating health and review sentiment summaries. `themes` adds lightweight complaint and praise themes from review text. Use `themes` for product research and `basic` for the cheapest large runs.",
                        "default": "themes"
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of app-country jobs processed in parallel. The actor uses this to keep 500-app runs fast without opening browsers. Use 3 to 8 for stable public scraping and lower it if stores throttle requests. Higher values can finish faster but may increase rate-limit errors.",
                        "default": 6
                    },
                    "requestDelayMillis": {
                        "title": "Request Delay Milliseconds",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Small delay before each app-country job starts. The actor uses this to reduce request bursts against public store endpoints. Use `0` for small tests, 100 to 500 for larger competitor lists, and higher values if you see temporary throttling. Larger delays improve politeness but increase total runtime.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for public store requests. The actor passes this setting to supported HTTP clients when available and still soft-fails individual blocked app-country jobs. Enable Apify Proxy only if Google Play or App Store requests return HTTP 403, 429, CAPTCHA, or region-specific blocks. Leave it disabled for normal runs to keep costs lower.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for scheduled mobile app monitoring pipelines that combine several runs into one long-term dataset. Leave blank to write only to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify actor run to associate results with. The actor copies this value into each dataset row so external workflows can connect app intelligence to an upstream job, client account, or monitoring batch. Leave blank for standalone runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
