# App Review Monitor — App Store & Google Play Review Tracker (`mfapitools/app-review-monitor`) Actor

Monitor Apple App Store and Google Play Store reviews for changes. Detects new, edited, and deleted reviews. Pay per check + per detected change. Perfect for app reputation monitoring, competitor analysis, and 1-star alerting.

- **URL**: https://apify.com/mfapitools/app-review-monitor.md
- **Developed by:** [Mariano Ferreras](https://apify.com/mfapitools) (community)
- **Categories:** Developer tools, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review checks

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

## App Review Monitor — App Store & Google Play Review Tracker

> **Pay-per-event — zero monthly fee, zero subscription.** Monitor Apple App Store and Google Play Store reviews for changes. Detects new, edited, and deleted reviews with smart state tracking via Apify KeyValueStore. Pay per check + per detected change. No rental. No idle fees.

---

### What it does

This is an **app review monitoring** tool that periodically fetches the latest reviews from both the Apple App Store (via RSS JSON feed) and Google Play Store (via SSR HTML parsing), detects changes since the last check, and emits only the changed reviews to the dataset.

**Change types detected:**
- **New** — a review ID not seen before
- **Edited** — same review ID but the content, title, rating, or version changed
- **Deleted** — a review ID is no longer present in the latest fetch

Run it once to establish a baseline for each app, then schedule it (e.g. every hour, daily, weekly) to monitor continuously. State persists across runs via Apify's built-in KeyValueStore — no external storage needed.

---

### Use cases

- **App reputation monitoring** — track your app's reviews across both stores in one tool
- **1-star alerting** — get notified the moment a new 1-star review drops (use `minRating: 1`)
- **Competitive intelligence** — watch competitor apps for new praise, complaints, or feature requests
- **Review response tracking** — detect when a developer edits a review in response to a bug fix
- **Regulatory / compliance monitoring** — track apps in regulated industries for emerging sentiment changes
- **Agent-powered workflows** — wire this into an AI agent: have it summarize what changed across all your monitored apps

---

### Input example

Monitor Facebook on both platforms, plus Instagram on Play Store:

```json
{
  "apps": [
    {
      "appId": "284882215",
      "platform": "appstore",
      "country": "us",
      "language": "en",
      "label": "Facebook (iOS)"
    },
    {
      "appId": "com.facebook.katana",
      "platform": "playstore",
      "language": "en",
      "label": "Facebook (Android)"
    },
    {
      "appId": "com.instagram.android",
      "platform": "playstore",
      "language": "en",
      "label": "Instagram (Android)"
    }
  ],
  "maxReviewsPerApp": 100,
  "minRating": 2,
  "webhookUrl": "https://hooks.example.com/review-alerts"
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `apps` | array | required | One or more apps to monitor. Each entry: `appId` (string), `platform` ("appstore" | "playstore"), `country` (App Store only, default "us"), `language` (default "en"), `label` (optional, appears in output) |
| `maxReviewsPerApp` | integer | 200 | Max reviews to fetch per app per run |
| `minRating` | integer | none | Only alert on reviews at or below this rating (1–5). E.g. `2` = alert on 1★ and 2★ only |
| `webhookUrl` | string | none | POST changed reviews (new/edited) to this URL |
| `webhookSecret` | string | none | Bearer token for webhook auth |
| `useResidentialProxy` | boolean | false | Upgrade to residential proxies if needed |

#### Finding app IDs

- **App Store (iOS):** Find your app's ID in its App Store URL. E.g. `apps.apple.com/us/app/facebook/id284882215` → ID is `284882215`.
- **Play Store (Android):** The package name is in the URL. E.g. `play.google.com/store/apps/details?id=com.facebook.katana` → ID is `com.facebook.katana`.

***

### Output example

```json
[
  {
    "changeType": "new",
    "reviewId": "14338093308",
    "rating": 5,
    "title": "Happy Thursday",
    "text": "GM",
    "author": "spicy and dicey",
    "date": "2026-07-23T04:40:43-07:00",
    "version": "570.0.0",
    "helpfulVotes": 0,
    "platform": "appstore",
    "appId": "284882215",
    "label": "Facebook (iOS)",
    "checkedAt": "2026-07-24T10:00:00.000Z",
    "previousRating": null,
    "previousHash": null
  }
]
```

| Field | Type | Notes |
|---|---|---|
| `changeType` | string | "new", "edited", or "deleted" |
| `reviewId` | string | Unique review identifier |
| `rating` | integer | 1–5 star rating |
| `title` | string | Review title |
| `text` | string | Full review body text |
| `author` | string | Reviewer display name |
| `date` | string | ISO 8601 date of the review |
| `version` | string|null | App version at time of review |
| `helpfulVotes` | integer | Number of helpful votes |
| `platform` | string | "appstore" or "playstore" |
| `appId` | string | The app ID or package name |
| `label` | string|null | Human-readable label from input |
| `checkedAt` | string | ISO timestamp of when we checked |
| `previousRating` | integer|null | Previous rating (only on "edited") |
| `previousHash` | string|null | Previous content hash (only on "edited") |

***

### Pricing

This actor uses **pay-per-event** pricing. You are never charged for failed requests or quarantined results.

| Event | Price | Description |
|---|---|---|
| `review-checked` | — | Charged once per app per run, covers fetch cost |
| `review-changed` | — | Charged once per detected new or edited review |
| `apify-actor-start` | platform-managed | Standard platform startup event |

The `review-changed` event is only triggered when a review actually differs from the previous check. Deleted reviews are detected but not charged.

***

### Scheduling

App Review Monitor is designed to be run on a schedule. Create a schedule in Apify Console (e.g. hourly, daily) and the actor will automatically compare against the previous run's stored state.

To monitor many apps, batch them into a single run using the `apps` input array. This is more efficient than one schedule per app.

***

### How it works

**Apple App Store:** Fetches the RSS JSON feed at `https://itunes.apple.com/{country}/rss/customerreviews/id={appId}/sortBy=mostRecent/json`. No proxy or browser needed. Paginates up to your `maxReviewsPerApp` limit. Apple returns at most ~50 reviews per request, so the practical limit per fetch is ~500 reviews.

**Google Play Store:** Fetches the SSR HTML page and extracts the embedded review data from the `AF_initDataCallback` payload. No proxy or browser needed for moderate volume. The initial page load typically returns the most recent ~20 reviews.

**State management:** Each app's previous review set is stored in a named KVS keyed by SHA-256(appId+platform). Only the minimum data needed for diffing is stored (review ID → hash + rating).

***

### Use with AI agents (MCP)

This actor is available as a tool for AI assistants via the Apify MCP server. Agents can monitor app reviews directly — no Apify console needed.

#### MCP setup

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

#### Example agent prompts

- "Monitor Facebook reviews on both App Store and Google Play. Alert me on any 1-star reviews"
- "Check Instagram Play Store reviews for anything new since yesterday"
- "What's the sentiment trend for our app this week?"

***

### Limitations

- **Apple RSS caps at ~50 reviews per request** — the feed is limited by Apple. If your app gets many reviews, you may miss some between runs. Recommended schedule: every few hours for active apps.
- **Google Play only returns ~20 reviews on initial page** — the SSR HTML only embeds a limited number of reviews. Full pagination is not available via plain HTTP (the Play Store API requires Play Integrity attestation).
- **First run is always a baseline** — the first check of any app shows all fetched reviews as "new". Schedule the second run to see only changes.
- **No login-gated data** — this actor only fetches public review data. No App Store Connect or Google Play Console access.
- **Google Play parsing is fragile** — relies on the internal `AF_initDataCallback` JSON structure, which Google may change without notice. The fixture test catches breakage.
- **Public data only** — only reviews visible to the public on each store's public pages.

***

### Changelog

See [CHANGELOG.md](./CHANGELOG.md).

# Actor input Schema

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

One or more apps to monitor for review changes. Each entry specifies the platform (App Store or Google Play), the app ID, optional country/language, and a human-readable label.

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

Maximum number of reviews to fetch PER APP per run (default 50 — matches this actor's example of ~1 app; if you list N apps in the `apps` field, total cost scales as N x this value, e.g. 10 apps at the default = up to 500 reviews charged). Raise it deliberately for deep history; keep it low for frequent monitoring runs.

## `minRating` (type: `integer`):

Only alert on reviews at or below this rating. E.g. 2 = alert on 1★ and 2★ only. Leave empty to alert on all rating changes.

## `webhookUrl` (type: `string`):

URL to POST changed reviews to (new/edited only). Optional. Webhook failures never affect the run.

## `webhookSecret` (type: `string`):

Bearer token / secret for webhook auth. Sent as Authorization: Bearer <secret>.

## `useResidentialProxy` (type: `boolean`):

Switch to residential proxies if datacenter IPs are blocked. Generally not needed for App Store RSS or Google Play.

## Actor input object example

```json
{
  "apps": [
    {
      "appId": "284882215",
      "platform": "appstore",
      "country": "us",
      "language": "en",
      "label": "Facebook (App Store)"
    }
  ],
  "maxReviewsPerApp": 50,
  "useResidentialProxy": 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": [
        {
            "appId": "284882215",
            "platform": "appstore",
            "country": "us",
            "language": "en",
            "label": "Facebook (App Store)"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mfapitools/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": [{
            "appId": "284882215",
            "platform": "appstore",
            "country": "us",
            "language": "en",
            "label": "Facebook (App Store)",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("mfapitools/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": [
    {
      "appId": "284882215",
      "platform": "appstore",
      "country": "us",
      "language": "en",
      "label": "Facebook (App Store)"
    }
  ]
}' |
apify call mfapitools/app-review-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mfapitools/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 Review Tracker",
        "description": "Monitor Apple App Store and Google Play Store reviews for changes. Detects new, edited, and deleted reviews. Pay per check + per detected change. Perfect for app reputation monitoring, competitor analysis, and 1-star alerting.",
        "version": "0.1",
        "x-build-id": "HOOZGMpzIQpKfkMas"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mfapitools~app-review-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mfapitools-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/mfapitools~app-review-monitor/runs": {
            "post": {
                "operationId": "runs-sync-mfapitools-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/mfapitools~app-review-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-mfapitools-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 to monitor",
                        "type": "array",
                        "description": "One or more apps to monitor for review changes. Each entry specifies the platform (App Store or Google Play), the app ID, optional country/language, and a human-readable label.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "appId": {
                                    "title": "App ID",
                                    "type": "string",
                                    "description": "App Store: numeric ID (e.g. 284882215 for Facebook). Google Play: package name (e.g. com.facebook.katana)."
                                },
                                "platform": {
                                    "title": "Platform",
                                    "type": "string",
                                    "enum": [
                                        "appstore",
                                        "playstore"
                                    ],
                                    "description": "Which app store to monitor."
                                },
                                "country": {
                                    "title": "Country (App Store only)",
                                    "type": "string",
                                    "description": "Two-letter country code for the App Store feed (e.g. 'us', 'gb', 'fr'). Ignored for Google Play.",
                                    "default": "us"
                                },
                                "language": {
                                    "title": "Language",
                                    "type": "string",
                                    "description": "Language code for review display (e.g. 'en', 'es', 'fr').",
                                    "default": "en"
                                },
                                "label": {
                                    "title": "Label",
                                    "type": "string",
                                    "description": "Optional human-readable label for this app (appears in output)."
                                }
                            },
                            "required": [
                                "appId",
                                "platform"
                            ]
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch PER APP per run (default 50 — matches this actor's example of ~1 app; if you list N apps in the `apps` field, total cost scales as N x this value, e.g. 10 apps at the default = up to 500 reviews charged). Raise it deliberately for deep history; keep it low for frequent monitoring runs.",
                        "default": 50
                    },
                    "minRating": {
                        "title": "Minimum rating threshold",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only alert on reviews at or below this rating. E.g. 2 = alert on 1★ and 2★ only. Leave empty to alert on all rating changes."
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "URL to POST changed reviews to (new/edited only). Optional. Webhook failures never affect the run."
                    },
                    "webhookSecret": {
                        "title": "Webhook secret",
                        "type": "string",
                        "description": "Bearer token / secret for webhook auth. Sent as Authorization: Bearer <secret>."
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxies",
                        "type": "boolean",
                        "description": "Switch to residential proxies if datacenter IPs are blocked. Generally not needed for App Store RSS or Google Play.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
