# Google Play Reviews Scraper (`dami_studio/google-play-reviews-scraper`) Actor

Scrape Google Play reviews by app ID or URL. Paginate, deduplicate, filter by stars or date, choose sort order and locale, and add app metadata. Direct requests by default with optional proxy fallback.

- **URL**: https://apify.com/dami\_studio/google-play-reviews-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.12 / 1,000 google play reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Google Play Reviews Scraper

Fetch public Google Play reviews by Android package ID or Google Play app URL. The actor
paginates through review pages, removes duplicate review IDs, applies optional star and
date filters, and saves one structured dataset row per successful review.

No API key, login, cookies, or proxy are required for normal runs.

### Features

- Accepts Android package IDs, Google Play app URLs, or both.
- Supports country and language localization.
- Sorts by newest, rating, or helpfulness.
- Returns up to 5,000 matching reviews per app.
- Filters by one star rating and an inclusive UTC date cutoff.
- Deduplicates review IDs across every pagination page.
- Adds useful app metadata to each review with one extra lookup per app.
- Uses conservative shared throttling and retries.
- Uses direct requests by default to avoid unnecessary proxy costs.
- Supports optional Apify or custom proxy fallback.
- Returns clear, uncharged diagnostics instead of failing the run.
- Returns one labeled, uncharged sample row when the input is empty.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `appIds` | string array | none | Package IDs such as `com.spotify.music`. URLs also work here. |
| `appUrls` | string array | none | Google Play details URLs. |
| `country` | string | `us` | Two-letter Google Play storefront country. |
| `language` | string | `en` | Two-letter review and store language. |
| `sort` | enum | `newest` | `newest`, `rating`, or `helpfulness`. |
| `maxReviewsPerApp` | integer | `100` | Maximum saved rows per app after filtering, up to 5,000. |
| `starRating` | enum | `all` | `all`, or one value from `1` to `5`. Numeric values are also accepted through the API. |
| `dateCutoff` | string | none | Include reviews on or after this `YYYY-MM-DD` UTC date. |
| `includeAppMetadata` | boolean | `true` | Add app summary fields to every review. |
| `requestsPerSecond` | integer | `3` | Shared request limit from 1 to 10 requests per second. |
| `proxyConfiguration` | object | disabled | Optional Apify or custom proxy fallback. |

At least one real app ID or URL is needed for live data. The schema intentionally has no
required fields so an empty automated test run succeeds with one `_sample: true` row.

#### Example input

```json
{
  "appIds": [
    "com.spotify.music",
    "https://play.google.com/store/apps/details?id=com.whatsapp"
  ],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 500,
  "starRating": 1,
  "dateCutoff": "2026-01-01",
  "includeAppMetadata": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output

Each real dataset row represents one unique review:

```json
{
  "ok": true,
  "_sample": false,
  "appId": "com.spotify.music",
  "appUrl": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "appTitle": "Spotify: Music and Podcasts",
  "appSummary": "Listen to songs, discover music and enjoy podcasts",
  "appDeveloper": "Spotify AB",
  "appScore": 4.3,
  "appRatings": 33000000,
  "appReviewCount": 8000000,
  "appInstalls": "1,000,000,000+",
  "appMinInstalls": 1000000000,
  "appGenre": "Music & Audio",
  "appVersion": "Varies with device",
  "appUpdated": "2026-07-20T00:00:00.000Z",
  "appIcon": "https://play-lh.googleusercontent.com/...",
  "appPriceText": "Free",
  "appContentRating": "Teen",
  "reviewId": "gp:...",
  "reviewUrl": "https://play.google.com/store/apps/details?id=com.spotify.music&reviewId=...",
  "userName": "Reviewer",
  "userImage": "https://play-lh.googleusercontent.com/...",
  "date": "2026-07-24T16:10:00.000Z",
  "score": 5,
  "scoreText": "5",
  "title": null,
  "text": "The review text.",
  "thumbsUp": 12,
  "version": "9.0.0",
  "replyDate": null,
  "replyText": null,
  "criterias": [],
  "country": "us",
  "language": "en",
  "sort": "newest"
}
```

Google Play may omit individual fields. Missing values are returned as `null`, an empty
array, or an empty string where appropriate.

### Filtering and pagination

`maxReviewsPerApp` is the number of rows saved after filters and deduplication. The actor
continues through pagination pages until it reaches that limit, Google Play has no more
pages, or a safety limit of 100 pages is reached.

With `sort: "newest"` and a `dateCutoff`, the actor stops once a page crosses the cutoff
because all later pages are older. With rating or helpfulness sorting, it keeps paginating
because later pages can still contain dates that match.

### Pricing and billing

The intended Store price is **$0.00012 per successful review**, below the current comparison
price of $0.00015 per review.

The actor writes accepted reviews in page-sized batches. Only after a batch is successfully
saved does it charge the `review` event for those rows. These rows are never charged:

- Empty-input sample rows.
- Invalid-input diagnostics.
- Not-found, blocked, rate-limited, network, parsing, and no-results diagnostics.
- Duplicate reviews.
- Reviews rejected by the star or date filter.

The direct-request default avoids residential proxy charges. At the intended price, enabling
residential proxies can make small or heavily filtered runs unprofitable, so proxy use should
remain an explicit fallback for blocked high-volume runs.

### Proxy guidance

Google Play normally works without a proxy. Start with the default direct connection and the
default request rate. If a high-volume run receives `RATE_LIMITED` or `BLOCKED` diagnostics:

1. Lower `requestsPerSecond`.
2. Retry after the temporary block clears.
3. Enable an Apify proxy only when direct requests remain blocked.

Country-specific data is primarily selected by the `country` input. A proxy can also affect
regional availability, so use a matching proxy country when strict geolocation is required.

### Diagnostics

Errors and empty results exit successfully with an uncharged dataset row where `ok` is
`false`. Check `errorCode`, `error`, and `details`.

| Code | Meaning |
| --- | --- |
| `BAD_INPUT` | An app ID, URL, locale, filter, limit, or proxy setting is invalid. |
| `NOT_FOUND` | The app is unavailable in the selected country. |
| `RATE_LIMITED` | Google Play returned a rate limit after retries. |
| `BLOCKED` | Google Play returned a captcha, consent wall, or access block. |
| `PARSE_ERROR` | The Google Play response format changed unexpectedly. |
| `NETWORK` | The request could not complete. |
| `NO_RESULTS` | No reviews matched the app, locale, and filters. |

One app failure does not stop the remaining app IDs. If a later pagination page fails, the
actor keeps earlier successful rows and adds an uncharged diagnostic with `partial: true`.

### Development

```bash
npm ci
npm test
npm run smoke -- com.spotify.music 5
npm start
```

The smoke command uses a real public Google Play app and does not use Apify billing or deploy
anything. Running `npm start` with empty local input writes one labeled sample row.

### Data source

This actor uses the actively maintained `@mradex77/google-play-scraper` package, which
provides typed errors, retries, throttling, pagination, and daily live contract tests against
Google Play. Google Play has no official public API for review data, so public page and internal
endpoint formats can still change.

This actor is not affiliated with Google. Use public data responsibly and comply with applicable
terms and laws.

# Actor input Schema

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

Android package IDs, one per line. Google Play URLs are also accepted here.

## `appUrls` (type: `array`):

Full play.google.com/store/apps/details URLs. IDs and URLs are merged and deduplicated.

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

Two-letter Google Play country code, such as us, ca, gb, de, or jp.

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

Two-letter review and store language code, such as en, fr, de, es, or ja.

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

Review order returned by Google Play.

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

Maximum successful review rows saved for each app after filters are applied.

## `starRating` (type: `string`):

Return all ratings or only reviews with the selected star rating.

## `dateCutoff` (type: `string`):

Optional inclusive UTC date cutoff in YYYY-MM-DD format. Leave empty for no date filter.

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

Fetch one app details page per app and attach title, summary, developer, rating, installs, genre, version, icon, and price fields to every review.

## `requestsPerSecond` (type: `integer`):

Shared Google Play request rate. The conservative default reduces blocking without proxy costs.

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

Optional. No proxy is used by default. Enable an Apify or custom proxy only if Google Play rate-limits or blocks your runs.

## Actor input object example

```json
{
  "appIds": [
    "com.spotify.music"
  ],
  "country": "us",
  "language": "en",
  "sort": "newest",
  "maxReviewsPerApp": 100,
  "starRating": "all",
  "includeAppMetadata": true,
  "requestsPerSecond": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Successful review rows are stored in the default dataset. Empty, invalid, or failed inputs produce uncharged diagnostic rows.

# 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.spotify.music"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/google-play-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.spotify.music"] }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/google-play-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.spotify.music"
  ]
}' |
apify call dami_studio/google-play-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Play Reviews Scraper",
        "description": "Scrape Google Play reviews by app ID or URL. Paginate, deduplicate, filter by stars or date, choose sort order and locale, and add app metadata. Direct requests by default with optional proxy fallback.",
        "version": "0.1",
        "x-build-id": "0VhPgJjj8uoi31e2K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dami_studio~google-play-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dami_studio-google-play-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/dami_studio~google-play-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dami_studio-google-play-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/dami_studio~google-play-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dami_studio-google-play-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": "Android package IDs, one per line. Google Play URLs are also accepted here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appUrls": {
                        "title": "Google Play app URLs",
                        "type": "array",
                        "description": "Full play.google.com/store/apps/details URLs. IDs and URLs are merged and deduplicated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter Google Play country code, such as us, ca, gb, de, or jp.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter review and store language code, such as en, fr, de, es, or ja.",
                        "default": "en"
                    },
                    "sort": {
                        "title": "Sort reviews",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "Review order returned by Google Play.",
                        "default": "newest"
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum successful review rows saved for each app after filters are applied.",
                        "default": 100
                    },
                    "starRating": {
                        "title": "Star filter",
                        "enum": [
                            "all",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Return all ratings or only reviews with the selected star rating.",
                        "default": "all"
                    },
                    "dateCutoff": {
                        "title": "Reviews on or after",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive UTC date cutoff in YYYY-MM-DD format. Leave empty for no date filter."
                    },
                    "includeAppMetadata": {
                        "title": "Include app metadata",
                        "type": "boolean",
                        "description": "Fetch one app details page per app and attach title, summary, developer, rating, installs, genre, version, icon, and price fields to every review.",
                        "default": true
                    },
                    "requestsPerSecond": {
                        "title": "Requests per second",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Shared Google Play request rate. The conservative default reduces blocking without proxy costs.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy fallback",
                        "type": "object",
                        "description": "Optional. No proxy is used by default. Enable an Apify or custom proxy only if Google Play rate-limits or blocks your runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
