# App Store & Google Play Reviews Scraper + AI Sentiment (`plum_spear/aztec-apify-reviews`) Actor

Extract iOS App Store and Google Play reviews at scale, with optional AI sentiment, topic and bug-vs-feature analysis per review.

- **URL**: https://apify.com/plum\_spear/aztec-apify-reviews.md
- **Developed by:** [Roberto Kerber](https://apify.com/plum_spear) (community)
- **Categories:** AI, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 1,000 results

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 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

## App Store & Google Play Reviews Scraper with AI Sentiment Analysis

Scrape user reviews from the **Apple App Store (iOS)** and **Google Play (Android)** at scale - and get **AI-powered sentiment, topics, summaries, and bug-vs-feature classification on every single review**, not just raw text.

Most app review scrapers dump raw data on you and leave the hard part - making sense of it - entirely up to you. This Actor is different. Every review comes back **already enriched**: sentiment scored, key topics extracted, a one-line summary written, and the review tagged as a bug, feature request, praise, or complaint. You go straight from "thousands of reviews" to "here's exactly what users are telling us" - no extra pipeline, no manual tagging, no separate AI step.

Whether you're doing **app feedback analysis**, **competitor app review monitoring**, **ASO research**, or feeding a **RAG / LLM pipeline**, this is the fastest path from store reviews to structured, actionable insight.

### What does this Actor do?

This **app store reviews scraper** collects public user reviews from iOS and Android stores and runs **app review sentiment analysis** on each one. In a single run you get:

- 🍎 **Apple App Store reviews** pulled via Apple's official RSS feed - reliable, and **no proxy needed**
- 🤖 **Google Play reviews** for Android, with deep pagination to reach far more reviews
- 🧠 **AI analysis on every review**: sentiment (positive / neutral / negative), topic list, a short summary, and a type label (bug / feature request / praise / complaint)
- 🌍 **Country and language targeting** - scrape any store locale to compare markets
- 🔌 **Bring your own LLM** (OpenAI, Groq, Together, Ollama, or any OpenAI-compatible endpoint) for richer analysis - or use the built-in keyword analysis with **zero setup**
- 📦 **Clean structured JSON output** ready for dashboards, BI tools, spreadsheets, or LLM apps

No other reviews scraper on the market ships enrichment in the box. Competitors give you text; this Actor gives you understanding.

### Why use this instead of a plain review scraper?

Raw reviews are a wall of text. The value is locked inside, and extracting it normally means building your own NLP step, paying for a separate AI service, and gluing it all together.

This Actor collapses that whole workflow into one run. The **iOS app reviews API** and **Google Play reviews scraper** feed directly into per-review AI enrichment, so the output is already segmented by sentiment and category. You can filter to "all negative bug reports from the last version" or "every feature request mentioning notifications" the moment the run finishes.

### Use cases

- **Product managers** - Track what users complain about release over release, and quantify whether a new version moved sentiment up or down.
- **App developers** - Surface real bugs and feature requests buried inside thousands of reviews, automatically separated from praise and noise.
- **ASO and growth teams** - Mine review language for keyword opportunities and understand what drives ratings, powering smarter **app store optimization (ASO)**.
- **Competitive intelligence** - Run **competitor app reviews** monitoring to see exactly what rival apps are praised and hated for, by country.
- **Market researchers** - Quantify user sentiment across countries, languages, and app versions for **app feedback analysis** at scale.
- **Support and CX teams** - Catch recurring complaints early with continuous **review monitoring** before they snowball.
- **AI / RAG builders** - Feed clean, pre-classified review data straight into LLM apps without a separate preprocessing stage.

### How to scrape app reviews with this Actor

1. Pick a store: `appstore` or `googleplay`.
2. Provide the app's `appId` (App Store numeric ID or Google Play package name) or paste the full store `url`.
3. Set `country`, optionally `language`, and how many reviews you want with `maxReviews`.
4. Leave `enrich` on (default) to get AI analysis automatically. Optionally plug in your own LLM for deeper analysis.
5. Run the Actor and export results as JSON, CSV, Excel, or push them to any pipeline via the Apify API.

### Input

| Field | Description | Example |
|-------|-------------|---------|
| `store` | `appstore` or `googleplay` | `appstore` |
| `appId` | App Store numeric ID or Google Play package name | `389801252` / `com.whatsapp` |
| `url` | Full store URL (alternative to `appId`) | `https://apps.apple.com/us/app/id389801252` |
| `country` | Two-letter store country code | `us`, `gb`, `br`, `de` |
| `language` | Language code (Google Play) | `en`, `pt`, `de` |
| `maxReviews` | Maximum number of reviews to fetch | `100` |
| `enrich` | Enable AI analysis on each review | `true` |
| `llmBaseUrl` | *(optional)* OpenAI-compatible endpoint for richer analysis | `https://api.openai.com/v1` |
| `llmModel` | *(optional)* Model name | `gpt-4o-mini` |
| `llmApiKey` | *(optional, secret)* API key for your LLM | |

> Leave the LLM fields empty and the Actor falls back to fast built-in keyword analysis - the AI fields are **always** populated, with zero configuration required.

### Example input

```json
{
  "store": "appstore",
  "appId": "389801252",
  "country": "us",
  "maxReviews": 100,
  "enrich": true
}
````

### Example output

Each review is returned as a structured record with an `ai` block attached:

```json
{
  "store": "appstore",
  "appId": "389801252",
  "country": "us",
  "title": "Please bring back the old feed",
  "text": "I think Instagram is generally great but the new feed is...",
  "rating": 2,
  "version": "350.1",
  "author": "user_handle",
  "ai": {
    "sentiment": "negative",
    "topics": ["feed algorithm", "user experience"],
    "summary": "User dislikes the new feed and wants the old one back.",
    "type": "feature_request",
    "method": "llm"
  }
}
```

### Output fields

**Review fields:** `store`, `appId`, `country`, `reviewId`, `title`, `text`, `rating`, `version`, `author`, `date` (Google Play), `thumbsUp` (Google Play)

**AI analysis (`ai` block):**

- `sentiment` - `positive`, `neutral`, or `negative`
- `topics` - array of key topics mentioned in the review
- `summary` - one-line summary of what the review says
- `type` - `bug`, `feature_request`, `praise`, `complaint`, `question`, or `other`
- `method` - `llm` (when you supply an LLM) or `keyword` (built-in analysis)

### Frequently asked questions

#### How do I scrape app reviews from the App Store and Google Play?

Set `store` to `appstore` or `googleplay`, give the Actor an `appId` or store `url`, choose a `country`, and run it. Reviews come back as structured JSON, each one already enriched with sentiment and a category. No code required.

#### Is there a free tier?

Apify gives all users free monthly platform usage. You can run this Actor within that free allowance to test it on a small `maxReviews` value before scaling up - no credit card needed to start.

#### How much does it cost?

Pricing is pay-per-result at **$0.15 per 1,000 reviews scraped**, with an optional small fee per review enriched by AI. There's no subscription and no minimum. You only pay for what you actually scrape.

#### What's the rate limit / how many reviews can I get?

Apple's public review feed is capped at roughly **500 most-recent reviews per country per app**. To gather more from iOS, run the Actor across multiple countries. **Google Play supports deeper pagination**, so you can collect significantly more Android reviews in one run. The Actor paces requests politely to stay within store limits.

#### Do I need a proxy to scrape reviews?

No. The App Store path uses Apple's official RSS feed and **needs no proxy at all**. This keeps runs fast, cheap, and reliable.

#### Can I use my own AI model for the sentiment analysis?

Yes. Provide `llmBaseUrl`, `llmModel`, and `llmApiKey` to route enrichment through any OpenAI-compatible endpoint - OpenAI, Groq, Together, a local Ollama server, and more - for richer, more nuanced analysis. Skip them entirely and the built-in keyword analyzer runs automatically.

#### What can I do with the scraped review data?

Power product roadmaps, monitor competitor apps, drive ASO keyword research, build sentiment dashboards, feed RAG and LLM pipelines, or run ongoing review monitoring to catch issues early. The output is clean structured JSON, ready for any downstream tool.

#### How do I export the results?

Results are stored in an Apify dataset and can be exported to JSON, CSV, Excel, or HTML, or pulled programmatically through the Apify API and integrations.

#### Is scraping app store reviews legal?

This Actor collects only publicly available review data that any visitor can see on the App Store and Google Play. As with any scraping, you're responsible for how you use the data and for complying with applicable terms and local regulations.

### Notes & limits

- Apple's public review feed is capped at **~500 most-recent reviews per country per app**. To cover more, run across multiple countries.
- Google Play supports deeper pagination for larger Android review pulls.
- The Actor paces requests politely to stay within store rate limits.

### Pricing

Pay-per-result: **$0.15 per 1,000 reviews scraped**, plus an optional small fee per review enriched with AI analysis. No subscription, no minimums, no proxy costs. You only pay for the reviews you actually collect.

***

**Keywords:** app store reviews scraper, iOS app reviews API, Google Play reviews scraper, app review sentiment analysis, ASO, app feedback analysis, competitor app reviews, review monitoring.

# Actor input Schema

## `store` (type: `string`):

Which store to scrape reviews from.

## `appId` (type: `string`):

App Store numeric ID (e.g. 310633997) or Google Play package (e.g. com.whatsapp). You can also use the URL field instead.

## `url` (type: `string`):

Full store URL. Used if App ID is empty.

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

Two-letter country code of the store locale (e.g. us, gb, br, de).

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

Two-letter language code for Google Play reviews.

## `maxReviews` (type: `integer`):

Maximum number of reviews to fetch. Note: Apple caps the public review feed at ~500 per country per app.

## `enrich` (type: `boolean`):

Adds an 'ai' object to each review with sentiment, topics, a short summary and a bug/feature-request classification. Works out of the box with built-in analysis; provide an LLM endpoint below for deeper topic/summary extraction.

## `llmBaseUrl` (type: `string`):

Optional. OpenAI-compatible /v1 endpoint (OpenAI, Groq, Together, Ollama, etc.) for richer AI analysis. Leave empty to use the built-in fast keyword analysis.

## `llmModel` (type: `string`):

Model name for the LLM endpoint above (e.g. gpt-4o-mini, llama-3.3-70b-versatile).

## `llmApiKey` (type: `string`):

Bearer token for the LLM endpoint, if required.

## Actor input object example

```json
{
  "store": "appstore",
  "country": "us",
  "language": "en",
  "maxReviews": 100,
  "enrich": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("plum_spear/aztec-apify-reviews").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("plum_spear/aztec-apify-reviews").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 '{}' |
apify call plum_spear/aztec-apify-reviews --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store & Google Play Reviews Scraper + AI Sentiment",
        "description": "Extract iOS App Store and Google Play reviews at scale, with optional AI sentiment, topic and bug-vs-feature analysis per review.",
        "version": "0.1",
        "x-build-id": "B4Ql5afSNcBK9SCxY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/plum_spear~aztec-apify-reviews/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-plum_spear-aztec-apify-reviews",
                "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/plum_spear~aztec-apify-reviews/runs": {
            "post": {
                "operationId": "runs-sync-plum_spear-aztec-apify-reviews",
                "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/plum_spear~aztec-apify-reviews/run-sync": {
            "post": {
                "operationId": "run-sync-plum_spear-aztec-apify-reviews",
                "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": {
                    "store": {
                        "title": "Store",
                        "enum": [
                            "appstore",
                            "googleplay"
                        ],
                        "type": "string",
                        "description": "Which store to scrape reviews from.",
                        "default": "appstore"
                    },
                    "appId": {
                        "title": "App ID or package name",
                        "type": "string",
                        "description": "App Store numeric ID (e.g. 310633997) or Google Play package (e.g. com.whatsapp). You can also use the URL field instead."
                    },
                    "url": {
                        "title": "App URL (alternative to App ID)",
                        "type": "string",
                        "description": "Full store URL. Used if App ID is empty."
                    },
                    "country": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code of the store locale (e.g. us, gb, br, de).",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language (Google Play only)",
                        "type": "string",
                        "description": "Two-letter language code for Google Play reviews.",
                        "default": "en"
                    },
                    "maxReviews": {
                        "title": "Max reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch. Note: Apple caps the public review feed at ~500 per country per app.",
                        "default": 100
                    },
                    "enrich": {
                        "title": "Enable AI analysis (sentiment, topics, summary)",
                        "type": "boolean",
                        "description": "Adds an 'ai' object to each review with sentiment, topics, a short summary and a bug/feature-request classification. Works out of the box with built-in analysis; provide an LLM endpoint below for deeper topic/summary extraction.",
                        "default": true
                    },
                    "llmBaseUrl": {
                        "title": "LLM base URL (OpenAI-compatible, optional)",
                        "type": "string",
                        "description": "Optional. OpenAI-compatible /v1 endpoint (OpenAI, Groq, Together, Ollama, etc.) for richer AI analysis. Leave empty to use the built-in fast keyword analysis."
                    },
                    "llmModel": {
                        "title": "LLM model (optional)",
                        "type": "string",
                        "description": "Model name for the LLM endpoint above (e.g. gpt-4o-mini, llama-3.3-70b-versatile)."
                    },
                    "llmApiKey": {
                        "title": "LLM API key",
                        "type": "string",
                        "description": "Bearer token for the LLM endpoint, if required."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```