# AI - App Store & Google Play reviews scraper (1$/1.000 reviews) (`lofomachines/app-review-intelligence`) Actor

Scrape Apple App Store and Google Play reviews in one run and get AI-classified sentiment, themes, bugs, feature requests, churn signals, and executive insight reports.

- **URL**: https://apify.com/lofomachines/app-review-intelligence.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** AI, MCP servers, Social media
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Reviews Scraper + AI Insights — App Store & Google Play in One Run 📱🤖

**Scrape Apple App Store reviews and Google Play reviews together, and get every review automatically classified by AI** — sentiment, theme, severity, churn risk — plus an executive insight report with top complaints, top feature requests, emerging issues, and concrete recommendations for every app you analyze.

Stop exporting raw CSVs and reading thousands of reviews by hand. Paste an app link (or just the app name), click **Start**, and get an analysis that would normally take a product team days — in minutes.

### What does App Review Intelligence do?

- ⭐ **Scrapes app reviews from both stores** — Apple App Store (iOS) and Google Play (Android) — in a single run, normalized into one consistent format
- 🌍 **Multi-country support** — collect reviews from the US, UK, Germany, Italy, France, Spain, Brazil, India, Japan, and dozens of other storefronts
- 🤖 **AI review classification** — every review is enriched with `sentiment` (positive / neutral / negative / mixed), `category` (bug, feature request, UX, performance, pricing, ads, account access, support, content, praise), up to 3 concrete `topics`, a problem `severity`, and a `churnSignal` flag for users threatening to leave
- 📊 **Per-app insight report** — average rating, rating distribution, sentiment breakdown, top topics, 12-month rating trend, developer response rate, churn signals, and a 0–100 **App Health Score**
- 🧠 **AI executive summary** — strengths, top complaints, top feature requests, emerging issues, and prioritized recommendations, written like a senior product analyst would
- ⚔️ **Competitor comparison** — add two or more apps and get an automatic side-by-side ranking with key differentiators and opportunities
- 🔎 **Zero setup** — no API keys, no login, no cookies. Works with URLs, app IDs, package names, or just app names ("Duolingo")

### Who is this for?

- **Product managers** mining feature requests, bug reports, and churn reasons from real user feedback
- **App developers & indie hackers** monitoring releases — see instantly if a new version triggers a wave of complaints
- **ASO specialists & mobile marketing agencies** running review audits and reputation reports for clients
- **Founders & investors** validating a market — analyze competitor apps' weaknesses before building
- **UX researchers & data scientists** who need clean, labeled voice-of-customer datasets
- **Customer support teams** spotting emerging issues before they hit ticket queues
- **AI agents & LLM pipelines** that need structured, pre-classified review data (works great via API, MCP, Make, Zapier, n8n)

### Use cases

#### 1. Competitor app analysis
Add your app and 2–3 competitors. Get a side-by-side comparison of health scores, sentiment, top complaints, and the exact features users beg competitors for — your roadmap shortcut.

#### 2. Find bugs & technical issues fast
Set **Analysis focus** to *Find bugs & technical issues*. Crashes, login failures, payment errors, and performance problems are extracted, tagged, and ranked by severity.

#### 3. Discover feature requests & product ideas
Set the focus to *Feature requests*. The report distills hundreds of "I wish this app could…" reviews into a clean, prioritized list of product opportunities.

#### 4. Understand churn & cancellations
The *churn* focus highlights why users uninstall, cancel subscriptions, or switch to alternatives — with churn-risk flags on individual reviews so you can quantify it.

#### 5. Release monitoring & reputation management
Run it on a schedule after each release (newest reviews first) and watch the monthly trend, sentiment breakdown, and emerging issues. Pipe results to Slack, Sheets, or your BI tool.

#### 6. Market research & app due diligence
Evaluating a niche or an acquisition target? Analyze the leading apps in the category and instantly see what users love, hate, and still miss.

### Input

Designed for non-technical users — just three things really matter:

| Field | Description |
|---|---|
| **Apps to analyze** | App Store / Google Play URLs, Apple app IDs, Android package names, or plain app names (matched on both stores automatically) |
| **Max reviews per app** | 10–5,000 reviews per app (default 250) |
| **Countries** | Storefront country codes, e.g. `us`, `gb`, `de`, `it` (default `us`) |
| Language | Preferred review language (default `en`) |
| Sort reviews by | Newest first or most helpful first |
| AI insights | Toggle AI classification and reports on/off |
| Analysis focus | Balanced, bugs, feature requests, churn, or competitor research |

Example input:

```json
{
    "apps": ["Duolingo", "https://play.google.com/store/apps/details?id=com.babbel.mobile.android.en"],
    "maxReviewsPerApp": 500,
    "countries": ["us", "gb"],
    "analysisGoal": "competitor"
}
````

### Output

You get three kinds of records in the dataset (filter by the `type` field), exportable as **JSON, CSV, Excel, or via API**.

#### Enriched review (`type: "review"`)

```json
{
    "type": "review",
    "appName": "Duolingo - Language Lessons",
    "platform": "ios",
    "country": "us",
    "rating": 2,
    "title": "New update ruined it",
    "text": "Ever since the last update the app crashes every time I open a lesson...",
    "date": "2026-06-02T09:14:33.000Z",
    "appVersion": "7.92.1",
    "helpfulCount": 41,
    "developerReply": null,
    "sentiment": "negative",
    "category": "bug",
    "topics": ["crashes on startup", "lesson loading"],
    "severity": "high",
    "churnSignal": true
}
```

#### App insight report (`type: "app_insights"`)

Average rating, rating distribution, sentiment & category breakdowns, top topics with counts, 12-month trend, developer response rate, churn signals, **App Health Score (0–100)**, store metadata (developer, category, installs, store rating), and the AI report:

```json
{
    "aiReport": {
        "summary": "Users love the gamified learning experience, but the latest release introduced...",
        "strengths": ["Engaging streak and gamification system", "..."],
        "topComplaints": ["Crashes when opening lessons after the latest update", "..."],
        "topFeatureRequests": ["Offline mode for lessons", "..."],
        "emergingIssues": ["Spike in login failures starting May 2026", "..."],
        "recommendations": ["Hotfix the lesson-opening crash affecting iOS users", "..."]
    }
}
```

#### Cross-app comparison (`type: "comparison"`)

A ranked comparison of all analyzed apps with reasons, key differentiators, and opportunities. A consolidated JSON report (`INSIGHTS`) is also saved to the run's key-value store — perfect for feeding dashboards or LLM workflows with a single request.

### Why teams choose this Actor

- **Two stores, one dataset** — no more stitching together separate iOS and Android scrapers
- **Insights, not just rows** — AI does the reading, tagging, and summarizing for you
- **Fast and affordable** — built for scale, priced for everyday use
- **No authentication required** — no store accounts, tokens, or developer access needed
- **Automation-ready** — REST API, webhooks, scheduled runs, and native integrations with Make, Zapier, n8n, Google Sheets, Slack, and the Apify MCP server for AI agents

### FAQ

**Do I need an Apple or Google account?**
No. The Actor needs zero credentials from you.

**Can I analyze any app?**
Yes — any publicly listed app on the Apple App Store or Google Play, in any supported country storefront.

**How many reviews can I get?**
Up to 5,000 per app per run. Apple storefronts expose the most recent reviews per country, so adding more countries increases iOS coverage.

**What languages are supported?**
Reviews are collected in any language; AI topic tags are normalized to English so cross-country data stays consistent and filterable.

**Can I use it without AI?**
Yes — switch off **AI insights** to get clean, normalized raw reviews from both stores.

**Is this legal?**
The Actor only collects publicly available review data that anyone can see in the app stores. No personal accounts are accessed.

**Can I run it on a schedule?**
Yes — use Apify Schedules to monitor your app (or competitors) daily or weekly, and connect webhooks to get alerts.

***

*app store reviews scraper · google play reviews scraper · app review analysis · review sentiment analysis · ASO tools · app store optimization · competitor app analysis · voice of customer · mobile app market research · app reviews API · ios reviews export · android reviews export*

# Actor input Schema

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

One or more apps. You can paste an <b>App Store URL</b>, a <b>Google Play URL</b>, an Apple app ID (e.g. <code>310633997</code>), an Android package name (e.g. <code>com.whatsapp</code>), or simply type an <b>app name</b> (e.g. <code>Duolingo</code>) and the best match will be found on both stores automatically. Add your competitors here too to get a side-by-side comparison.

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

Maximum number of reviews to collect for each app. More reviews = deeper insights.

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

Two-letter country codes of the app stores to collect reviews from (e.g. <code>us</code>, <code>gb</code>, <code>de</code>, <code>it</code>, <code>fr</code>, <code>es</code>, <code>br</code>, <code>in</code>, <code>jp</code>). Reviews are collected country by country until the maximum is reached.

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

Preferred language code for review collection (mainly affects Google Play), e.g. <code>en</code>, <code>de</code>, <code>it</code>, <code>es</code>, <code>pt</code>.

## `sortBy` (type: `string`):

Collect the newest reviews first (best for monitoring) or the most helpful ones first (best for research).

## `aiInsights` (type: `boolean`):

When enabled, every review is enriched with sentiment, theme, topic tags, severity, and churn-risk signals, and each app gets an executive insight report (top complaints, top feature requests, emerging issues, recommendations). Disable to get clean raw reviews only.

## `analysisGoal` (type: `string`):

Tell the AI what matters most to you. This shapes the insight reports and recommendations.

## Actor input object example

```json
{
  "apps": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
    "com.whatsapp"
  ],
  "maxReviewsPerApp": 100,
  "countries": [
    "us"
  ],
  "language": "en",
  "sortBy": "newest",
  "aiInsights": true,
  "analysisGoal": "balanced"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "apps": [
        "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
        "com.whatsapp"
    ],
    "countries": [
        "us"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "apps": [
        "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
        "com.whatsapp",
    ],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/app-review-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "apps": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997",
    "com.whatsapp"
  ],
  "countries": [
    "us"
  ]
}' |
apify call lofomachines/app-review-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI - App Store & Google Play reviews scraper (1$/1.000 reviews)",
        "description": "Scrape Apple App Store and Google Play reviews in one run and get AI-classified sentiment, themes, bugs, feature requests, churn signals, and executive insight reports.",
        "version": "1.0",
        "x-build-id": "kg9ViaGdactzbviHL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~app-review-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-app-review-intelligence",
                "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/lofomachines~app-review-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-app-review-intelligence",
                "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/lofomachines~app-review-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-app-review-intelligence",
                "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 analyze",
                        "type": "array",
                        "description": "One or more apps. You can paste an <b>App Store URL</b>, a <b>Google Play URL</b>, an Apple app ID (e.g. <code>310633997</code>), an Android package name (e.g. <code>com.whatsapp</code>), or simply type an <b>app name</b> (e.g. <code>Duolingo</code>) and the best match will be found on both stores automatically. Add your competitors here too to get a side-by-side comparison.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each app. More reviews = deeper insights.",
                        "default": 100
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes of the app stores to collect reviews from (e.g. <code>us</code>, <code>gb</code>, <code>de</code>, <code>it</code>, <code>fr</code>, <code>es</code>, <code>br</code>, <code>in</code>, <code>jp</code>). Reviews are collected country by country until the maximum is reached.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Preferred language code for review collection (mainly affects Google Play), e.g. <code>en</code>, <code>de</code>, <code>it</code>, <code>es</code>, <code>pt</code>.",
                        "default": "en"
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Collect the newest reviews first (best for monitoring) or the most helpful ones first (best for research).",
                        "default": "newest"
                    },
                    "aiInsights": {
                        "title": "AI insights & review classification",
                        "type": "boolean",
                        "description": "When enabled, every review is enriched with sentiment, theme, topic tags, severity, and churn-risk signals, and each app gets an executive insight report (top complaints, top feature requests, emerging issues, recommendations). Disable to get clean raw reviews only.",
                        "default": true
                    },
                    "analysisGoal": {
                        "title": "Analysis focus",
                        "enum": [
                            "balanced",
                            "bugs",
                            "feature_requests",
                            "churn",
                            "competitor"
                        ],
                        "type": "string",
                        "description": "Tell the AI what matters most to you. This shapes the insight reports and recommendations.",
                        "default": "balanced"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```