# App Review Monitor · App Store & Google Play (`thisizkp/app-review-monitor`) Actor

Scrape and monitor app reviews from the Apple App Store and Google Play in one run. Normalized output, rating summaries, and incremental monitoring that returns only new reviews on every scheduled run.

- **URL**: https://apify.com/thisizkp/app-review-monitor.md
- **Developed by:** [Prasanth Karri](https://apify.com/thisizkp) (community)
- **Categories:** Business, Marketing, E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does App Review Monitor do?

**App Review Monitor scrapes app reviews from both the Apple App Store and Google Play in a single run** — and, unlike one-shot scrapers, it can **monitor your apps on a schedule and return only the reviews it hasn't seen before**. Point it at any app (yours or a competitor's), run it daily or hourly, and pipe fresh reviews straight into Slack, email, Google Sheets, or your own dashboard using [Apify integrations](https://apify.com/integrations).

**Still works in 2026.** Apple shut down its public RSS customer-reviews feed, silently breaking most App Store review scrapers (many still charge while returning zero results). This Actor uses the same review API the App Store website itself uses, so you get current reviews — including **developer replies**, which the old feed never exposed. If you're looking for a working **App Store review scraper**, a **Google Play review exporter**, an **Appbot alternative**, or **negative-review alerts for Slack**, this is the one Actor that covers all of it.

It extracts **reviews, ratings, review titles and text, authors, dates, app versions, helpful-vote counts, and developer replies**, plus a per-app **rating summary** (average rating, total rating count, and the star histogram on Google Play) — all in one normalized format across both stores, downloadable as **JSON, CSV, Excel, or HTML** or via API.

### Why monitor App Store and Google Play reviews?

- **Catch problems early** — a spike in 1–2★ reviews after a release is the fastest signal that something broke. Filter to negative reviews only and alert your team within the hour.
- **Watch competitors** — track what users praise or hate about competing apps to find feature gaps and positioning angles.
- **One schema, both stores** — every other actor makes you stitch together separate iOS and Android scrapers with different output formats. Here, `platform` is just a field.
- **Built for repeated runs** — monitoring mode remembers which reviews it has already returned (per app and country), so scheduled runs output *only new reviews*. No client-side dedup needed.
- **Replace expensive SaaS** — review-monitoring services charge $49–449/month for fixed app quotas. With pay-per-event pricing you pay only for what you actually scrape.

#### How it compares

| | This Actor | Single-store scrapers | RSS-based Apple scrapers | Review-monitoring SaaS |
| --- | --- | --- | --- | --- |
| Apple App Store + Google Play in one run | ✅ | ❌ one store only | ❌ | ✅ |
| Apple reviews that actually return data (post-RSS shutdown) | ✅ | varies | ❌ broken | ✅ |
| Developer replies included | ✅ | varies | ❌ | ✅ |
| Only-new-reviews monitoring built in | ✅ | ❌ | ❌ | ✅ |
| Pricing | ~$0.50 per 1,000 reviews | $0.50–3.00 per 1,000 | — | $49–449/month |

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

1. Open the Actor and paste your apps into the **Apps** field — App Store URLs, Google Play URLs, Apple numeric IDs, or Android package names, freely mixed. The platform is detected automatically.
2. Pick **countries** (storefronts) and how many reviews you need.
3. Optionally filter: **only negative reviews (1–2★)**, only reviews after a date, sort by newest or most helpful.
4. Click **Start**. Results land in the dataset within seconds to minutes.
5. For monitoring: enable **Monitoring mode**, then add a [schedule](https://docs.apify.com/platform/schedules) (e.g. every morning) and an [integration](https://apify.com/integrations) (Slack, email, webhook, Google Sheets). Each run delivers only what's new.

### Input

```json
{
    "apps": [
        "https://apps.apple.com/us/app/slack/id618783545",
        "com.Slack"
    ],
    "countries": ["us", "de"],
    "maxReviewsPerApp": 200,
    "sort": "newest",
    "ratingFilter": "negative",
    "monitoringMode": true
}
````

See the **Input** tab for all options, including the review-language for Google Play, custom state-store names for independent monitors, and optional proxy configuration.

### Output

One normalized record per review:

```json
{
    "type": "review",
    "platform": "apple",
    "appId": "618783545",
    "appName": "Slack",
    "country": "us",
    "reviewId": "14159981205",
    "date": "2026-06-08T22:18:31Z",
    "rating": 5,
    "title": "All",
    "text": "It's all here. Everyone is on the same page.",
    "author": "WFS403",
    "appVersion": null,
    "helpfulCount": null,
    "developerReplyDate": null,
    "developerReplyText": null,
    "reviewUrl": null
}
```

Plus one summary record per app and country:

```json
{
    "type": "summary",
    "platform": "google-play",
    "appId": "com.Slack",
    "appName": "Slack",
    "country": "us",
    "averageRating": 4.61,
    "ratingCount": 197857,
    "histogram": { "1": 6932, "2": 3727, "3": 8742, "4": 32925, "5": 145531 },
    "newReviewsThisRun": 25
}
```

You can download the dataset in JSON, CSV, Excel, or HTML from the **Output** tab or fetch it via the [dataset API](https://docs.apify.com/api/v2/dataset-items-get).

#### Data fields

| Field | Description |
| --- | --- |
| `platform` | `apple` or `google-play` |
| `appId` | Apple numeric ID or Android package name |
| `appName`, `country` | App display name and storefront country |
| `date`, `rating`, `title`, `text`, `author` | The review itself |
| `appVersion` | App version reviewed (Google Play only) |
| `helpfulCount` | Helpful votes (Google Play only) |
| `developerReplyDate`, `developerReplyText` | The developer's public response, if any |
| `reviewUrl` | Direct link to the review (Google Play only) |

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

Pricing is **pay-per-event**: a small flat fee per app+country checked, plus a per-review fee. Scraping 1,000 reviews costs well under a dollar — orders of magnitude cheaper than review-monitoring SaaS subscriptions. Daily monitoring of a handful of apps typically costs a few dollars per month, since monitoring mode only ever returns new reviews. You can cap spending per run with the **Maximum cost per run** setting.

### Tips

- **Negative-review alerting**: set `ratingFilter` to `negative`, enable monitoring mode, schedule hourly, and connect the Slack integration — you'll get 1–2★ reviews pushed to your channel as they appear.
- Apple's storefront exposes roughly the most recent ~500 reviews per country; multiply coverage by adding more `countries`. Google Play supports going much deeper — raise `maxReviewsPerApp` as needed.
- Use a different `stateStoreName` for each schedule if you run several independent monitors of the same apps.
- If you monitor many Apple apps at high frequency, add a proxy in **Proxy configuration** to avoid per-IP rate limits.

### FAQ, disclaimers, and support

**Is it legal to scrape app reviews?** This Actor collects only publicly available data — reviews that anyone can read in the app stores. Review content remains subject to Apple's and Google's terms; you are responsible for how you use the data. The Actor does not log in, bypass access controls, or collect private data.

**Why do Apple reviews lack helpful-vote counts and app versions?** Apple's current public review API doesn't expose them. Google Play records include both.

**A run returned zero reviews in monitoring mode — is that a bug?** No — it means no new reviews appeared since the last run for that app and country. Disable monitoring mode to re-scrape everything.

Found a problem or missing a feature? Open an issue on the **Issues** tab — feedback is very welcome and usually addressed quickly.

# Actor input Schema

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

Apps to scrape, in any of these formats: App Store URL (https://apps.apple.com/us/app/slack/id618783545), Google Play URL (https://play.google.com/store/apps/details?id=com.Slack), numeric Apple app ID (618783545), or Android package name (com.Slack). Mix both platforms freely — the platform is detected automatically.

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

Two-letter country codes of the app stores to check (ISO 3166-1, e.g. us, gb, de, in). Each app is checked in every listed country.

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

Upper limit of reviews scraped for each app + country combination. Note: Apple's public feed exposes at most ~500 recent reviews per country; Google Play allows going much deeper.

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

Order in which reviews are fetched. 'Rating' is supported on Google Play only — Apple falls back to newest first.

## `ratingFilter` (type: `string`):

Only keep reviews in the selected rating band. Useful for monitoring negative feedback.

## `reviewsAfterDate` (type: `string`):

Skip reviews written before this date (UTC). Leave empty to keep everything up to the max limit.

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

Two-letter language code for Google Play reviews (the Apple feed is per-country and ignores this). Default: en.

## `monitoringMode` (type: `boolean`):

Remember which reviews were already scraped (in a named key-value store) and output only new ones on subsequent runs.

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

Name of the key-value store that holds the seen-review state for monitoring mode. Use different names to run independent monitors.

## `includeRatingSummary` (type: `boolean`):

Push one summary record per app + country with the average rating, total rating count, and (on Google Play) the star histogram.

## `failIfNoReviews` (type: `boolean`):

Make the run FAIL if any checked app + country returns zero reviews (before filters) or errors. Useful for scheduled health checks with failure notifications; leave off for normal scraping.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/slack/id618783545",
    "com.Slack"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 200,
  "sort": "newest",
  "ratingFilter": "all",
  "language": "en",
  "monitoringMode": false,
  "stateStoreName": "app-review-monitor-state",
  "includeRatingSummary": true,
  "failIfNoReviews": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "apps": [
        "https://apps.apple.com/us/app/slack/id618783545",
        "com.Slack"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thisizkp/app-review-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "apps": [
        "https://apps.apple.com/us/app/slack/id618783545",
        "com.Slack",
    ],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("thisizkp/app-review-monitor").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://apps.apple.com/us/app/slack/id618783545",
    "com.Slack"
  ],
  "countries": [
    "us"
  ]
}' |
apify call thisizkp/app-review-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Review Monitor · App Store & Google Play",
        "description": "Scrape and monitor app reviews from the Apple App Store and Google Play in one run. Normalized output, rating summaries, and incremental monitoring that returns only new reviews on every scheduled run.",
        "version": "0.1",
        "x-build-id": "Thycs3bDiBBsMhUWB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thisizkp~app-review-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thisizkp-app-review-monitor",
                "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/thisizkp~app-review-monitor/runs": {
            "post": {
                "operationId": "runs-sync-thisizkp-app-review-monitor",
                "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/thisizkp~app-review-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-thisizkp-app-review-monitor",
                "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": "Apps to scrape, in any of these formats: App Store URL (https://apps.apple.com/us/app/slack/id618783545), Google Play URL (https://play.google.com/store/apps/details?id=com.Slack), numeric Apple app ID (618783545), or Android package name (com.Slack). Mix both platforms freely — the platform is detected automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes of the app stores to check (ISO 3166-1, e.g. us, gb, de, in). Each app is checked in every listed country.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app per country",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Upper limit of reviews scraped for each app + country combination. Note: Apple's public feed exposes at most ~500 recent reviews per country; Google Play allows going much deeper.",
                        "default": 200
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "helpfulness",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are fetched. 'Rating' is supported on Google Play only — Apple falls back to newest first.",
                        "default": "newest"
                    },
                    "ratingFilter": {
                        "title": "Rating filter",
                        "enum": [
                            "all",
                            "negative",
                            "neutral",
                            "positive"
                        ],
                        "type": "string",
                        "description": "Only keep reviews in the selected rating band. Useful for monitoring negative feedback.",
                        "default": "all"
                    },
                    "reviewsAfterDate": {
                        "title": "Only reviews after",
                        "type": "string",
                        "description": "Skip reviews written before this date (UTC). Leave empty to keep everything up to the max limit."
                    },
                    "language": {
                        "title": "Language (Google Play)",
                        "type": "string",
                        "description": "Two-letter language code for Google Play reviews (the Apple feed is per-country and ignores this). Default: en.",
                        "default": "en"
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only new reviews)",
                        "type": "boolean",
                        "description": "Remember which reviews were already scraped (in a named key-value store) and output only new ones on subsequent runs.",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "Name of the key-value store that holds the seen-review state for monitoring mode. Use different names to run independent monitors.",
                        "default": "app-review-monitor-state"
                    },
                    "includeRatingSummary": {
                        "title": "Include rating summaries",
                        "type": "boolean",
                        "description": "Push one summary record per app + country with the average rating, total rating count, and (on Google Play) the star histogram.",
                        "default": true
                    },
                    "failIfNoReviews": {
                        "title": "Fail when a source returns nothing",
                        "type": "boolean",
                        "description": "Make the run FAIL if any checked app + country returns zero reviews (before filters) or errors. Useful for scheduled health checks with failure notifications; leave off for normal scraping.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
