# App Review Intelligence Agent (`rodrgds/app-review-intelligence-agent`) Actor

Analyze public App Store and Google Play reviews into complaint clusters, feature requests, churn risks, ASO opportunities, and product actions.

- **URL**: https://apify.com/rodrgds/app-review-intelligence-agent.md
- **Developed by:** [Rodrigo Dias](https://apify.com/rodrgds) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Intelligence Agent do?

App Review Intelligence Agent turns public reviews from the [Apple App Store](https://www.apple.com/app-store/) and [Google Play](https://play.google.com/store) into **product intelligence**, not just a review export. It fetches recent reviews, normalizes them, scores sentiment and urgency, tags recurring complaint categories, and writes an executive report for product, founder, ASO, marketing, and agency workflows.

Use it as an app review analysis API when you need answers such as "what is making users churn?", "which missing features keep coming up?", or "what should we fix before the next launch?"

### Want the finished report instead of running the Actor?

I also offer a fixed-scope [App Review Intelligence Audit](https://rgo.pt/services/app-review-audit): one iOS App Store or Google Play app, up to 500 recent public reviews, complaint clusters, churn risks, feature requests, ASO opportunities, and prioritized product actions. It costs **€150 one-time** and is delivered within 48 hours.

Use the Actor below when you want automation and API access. Use the audit when you want a report ready to review or send to a client.

### Why use App Review Intelligence Agent?

Raw app review scrapers are useful, but they leave the hard part to you. This Actor adds a product-analysis layer on top of review collection:

- Normalized iOS and Google Play review rows in one dataset.
- Sentiment and urgency scoring before any LLM is called.
- Keyword-based categories such as bug, crash, pricing, subscription, onboarding, support, ads, performance, UX, feature requests, privacy, auth, map/navigation UX, content coverage, and competitor/value objections.
- Complaint clusters with counts, severity, and example quotes.
- Churn risks, ASO opportunities, support opportunities, and prioritized product actions.
- Optional OpenRouter synthesis using `deepseek/deepseek-v4-flash` by default when `OPENROUTER_API_KEY` is available.

Because it runs on Apify, you can schedule it, call it through the API, monitor runs, and export results to JSON, CSV, Excel, HTML, or integrations.

### Live sample

A live Pokémon GO Google Play run analyzed 12 recent reviews in 24 seconds and produced an LLM-enriched report with churn risks, performance complaints, account-linking friction, ASO opportunities, and prioritized product actions.

- Run ID: `qJWJUlOsbQbiM105t`
- Dataset ID: `lkQNT0XaP45hFgTfM`
- Done-for-you audit: https://rgo.pt/services/app-review-audit


### What data can App Review Intelligence Agent extract?

| Field | Type | Description |
| --- | --- | --- |
| `type` | string | `review` for normalized review rows or `intelligence_report` for report rows |
| `source` | string | `appStore` or `googlePlay` |
| `rating`, `title`, `text`, `author`, `version`, `date` | mixed | Public review details from the store |
| `sentiment`, `sentimentScore`, `urgencyScore` | mixed | Deterministic scoring fields |
| `categories`, `signals` | array | Complaint categories and short extracted phrase labels |
| `topComplaintClusters` | array | Report-level clusters with count, severity, and examples |
| `featureRequests`, `churnRisks`, `asoOpportunities` | array | Product and marketing intelligence outputs |
| `markdownReport` | string | Human-readable executive report |

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

1. Add one or more Apple App Store IDs or URLs, Google Play package names, or Google Play URLs.
2. Choose sources, countries, languages, review limit, and sort order.
3. Optionally add a focus such as "Find churn risks, missing features, pricing objections, and onboarding complaints."
4. Add `OPENROUTER_API_KEY` as an Apify secret if you want LLM-enriched report writing.
5. Run the Actor and open the dataset. Review rows and final report rows are written to the same default dataset.

### How much will it cost to analyze app reviews?

This Actor is designed for pay-per-event pricing. It charges for analysis start, each review processed, and each intelligence report generated. In practice, cost scales with `maxReviewsPerApp`, number of apps, countries, languages, and selected sources.

Current scheduled pricing, configured through Apify API and subject to Apify's 14-day notice rule for switching a free Actor to paid:

| Event | Price | Meaning |
| --- | ---: | --- |
| `analysis-start` | $0.00005 | One real public-store analysis run starts |
| `review-processed` | $0.002 | One public app review is fetched, normalized, scored, and analyzed |
| `intelligence-report` | $0.05 | One product intelligence report is generated |

Example: 100 reviews + one report costs about $0.25005 before platform-usage/free-plan nuance. Set a small review limit first when testing a new app, then increase it for ongoing monitoring or competitor research.

### Input

See the input tab for full configuration options.

Example input:

```json
{
  "sources": ["appStore", "googlePlay"],
  "appStoreAppIds": ["284882215"],
  "googlePlayAppIds": ["com.whatsapp"],
  "countries": ["us"],
  "languages": ["en"],
  "maxReviewsPerApp": 50,
  "sort": "newest",
  "includeLlmReport": true,
  "model": "deepseek/deepseek-v4-flash",
  "focus": "Find churn risks, missing features, pricing objections, and onboarding complaints.",
  "dryRun": false
}
````

`dryRun` uses built-in fixture reviews and does not fetch public stores. It is useful for checking output shape.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Simplified output sample:

```json
[
  {
    "type": "review",
    "source": "googlePlay",
    "appId": "com.example.app",
    "appName": "Example App",
    "rating": 2,
    "text": "The app crashes after login and support has not replied.",
    "sentiment": "negative",
    "sentimentScore": -0.75,
    "urgencyScore": 0.79,
    "categories": ["crash", "support"],
    "signals": ["crash: crash", "support: support"]
  },
  {
    "type": "intelligence_report",
    "appId": "com.example.app",
    "appName": "Example App",
    "reviewCount": 50,
    "averageRating": 3.4,
    "negativeRate": 0.32,
    "topComplaintClusters": [
      {
        "topic": "crash",
        "count": 8,
        "severity": 0.74,
        "exampleQuotes": ["The app crashes after login and support has not replied."]
      }
    ],
    "executiveSummary": "Moderate negative review pressure for Example App...",
    "markdownReport": "## Example App review intelligence\n..."
  }
]
```

### Data source note

Review fetching uses public Apple App Store and Google Play review endpoints through the `app-store-scraper` and `google-play-scraper` npm packages. No store credentials are required. Store availability, localization, ranking, and returned review counts can vary by country, language, and source behavior.

### OpenRouter and LLM note

The Actor always runs deterministic analysis first. If `OPENROUTER_API_KEY` is available and `includeLlmReport` is true, it asks OpenRouter to improve the report using the selected model, defaulting to `deepseek/deepseek-v4-flash`. If the key is missing or the LLM call fails, the Actor still outputs normalized reviews, deterministic scoring, and a markdown report.

The API key is read from the environment and is never printed or written to the dataset.

### FAQ, disclaimers, and support

#### Is this just a review scraper?

No. It does fetch public reviews, but the output is designed around decisions: clusters, risks, product actions, support opportunities, and ASO messaging. The normalized review rows are included so teams can audit the report.

#### Can I use it for competitor research?

Yes. Add competitor App Store IDs or Google Play package names and compare complaint clusters, feature requests, review sentiment, and ASO opportunities.

#### Is personal data included?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Use the Issues tab for feedback and the API tab for programmatic access.

# Actor input Schema

## `sources` (type: `array`):

Choose which public app stores to analyze. Allowed values: appStore, googlePlay.

## `appStoreAppIds` (type: `array`):

Numeric Apple App Store IDs or App Store URLs.

## `googlePlayAppIds` (type: `array`):

Google Play package names or Google Play URLs.

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

Two-letter country codes to query.

## `languages` (type: `array`):

Language codes used where the source supports them.

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

Maximum recent reviews to fetch per app, country, language, and source.

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

Review sort order where supported by the source package.

## `includeLlmReport` (type: `boolean`):

Use OpenRouter to enrich the deterministic report when OPENROUTER\_API\_KEY is available.

## `model` (type: `string`):

OpenRouter model ID used for report synthesis.

## `focus` (type: `string`):

Optional focus for the product intelligence report.

## `dryRun` (type: `boolean`):

Use fixture reviews and skip PPE charges.

## Actor input object example

```json
{
  "sources": [
    "appStore",
    "googlePlay"
  ],
  "appStoreAppIds": [
    "284882215"
  ],
  "googlePlayAppIds": [
    "com.whatsapp"
  ],
  "countries": [
    "us"
  ],
  "languages": [
    "en"
  ],
  "maxReviewsPerApp": 100,
  "sort": "newest",
  "includeLlmReport": true,
  "model": "deepseek/deepseek-v4-flash",
  "focus": "",
  "dryRun": false
}
```

# 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 = {
    "sources": [
        "appStore",
        "googlePlay"
    ],
    "appStoreAppIds": [
        "284882215"
    ],
    "googlePlayAppIds": [
        "com.whatsapp"
    ],
    "countries": [
        "us"
    ],
    "languages": [
        "en"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rodrgds/app-review-intelligence-agent").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 = {
    "sources": [
        "appStore",
        "googlePlay",
    ],
    "appStoreAppIds": ["284882215"],
    "googlePlayAppIds": ["com.whatsapp"],
    "countries": ["us"],
    "languages": ["en"],
}

# Run the Actor and wait for it to finish
run = client.actor("rodrgds/app-review-intelligence-agent").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 '{
  "sources": [
    "appStore",
    "googlePlay"
  ],
  "appStoreAppIds": [
    "284882215"
  ],
  "googlePlayAppIds": [
    "com.whatsapp"
  ],
  "countries": [
    "us"
  ],
  "languages": [
    "en"
  ]
}' |
apify call rodrgds/app-review-intelligence-agent --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Review Intelligence Agent",
        "description": "Analyze public App Store and Google Play reviews into complaint clusters, feature requests, churn risks, ASO opportunities, and product actions.",
        "version": "1.0",
        "x-build-id": "QCkSXZDiNK7Q0Dh4s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rodrgds~app-review-intelligence-agent/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rodrgds-app-review-intelligence-agent",
                "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/rodrgds~app-review-intelligence-agent/runs": {
            "post": {
                "operationId": "runs-sync-rodrgds-app-review-intelligence-agent",
                "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/rodrgds~app-review-intelligence-agent/run-sync": {
            "post": {
                "operationId": "run-sync-rodrgds-app-review-intelligence-agent",
                "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": {
                    "sources": {
                        "title": "Review sources",
                        "type": "array",
                        "description": "Choose which public app stores to analyze. Allowed values: appStore, googlePlay.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "appStore",
                            "googlePlay"
                        ]
                    },
                    "appStoreAppIds": {
                        "title": "App Store app IDs or URLs",
                        "type": "array",
                        "description": "Numeric Apple App Store IDs or App Store URLs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "googlePlayAppIds": {
                        "title": "Google Play package names or URLs",
                        "type": "array",
                        "description": "Google Play package names or Google Play URLs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes to query.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "us"
                        ]
                    },
                    "languages": {
                        "title": "Languages",
                        "type": "array",
                        "description": "Language codes used where the source supports them.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "en"
                        ]
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum recent reviews to fetch per app, country, language, and source.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "rating",
                            "helpfulness"
                        ],
                        "type": "string",
                        "description": "Review sort order where supported by the source package.",
                        "default": "newest"
                    },
                    "includeLlmReport": {
                        "title": "Include LLM report",
                        "type": "boolean",
                        "description": "Use OpenRouter to enrich the deterministic report when OPENROUTER_API_KEY is available.",
                        "default": true
                    },
                    "model": {
                        "title": "OpenRouter model",
                        "type": "string",
                        "description": "OpenRouter model ID used for report synthesis.",
                        "default": "deepseek/deepseek-v4-flash"
                    },
                    "focus": {
                        "title": "Analysis focus",
                        "type": "string",
                        "description": "Optional focus for the product intelligence report.",
                        "default": ""
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Use fixture reviews and skip PPE charges.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
