# App Store Reviews Scraper (`glassventures/app-store-reviews-scraper`) Actor

Scrape App Store reviews and app details from Apple iTunes. Extract ratings, review text, authors, versions. Export to JSON, CSV, Excel.

- **URL**: https://apify.com/glassventures/app-store-reviews-scraper.md
- **Developed by:** [Glass Ventures](https://apify.com/glassventures) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## App Store Reviews Scraper

Scrape customer reviews and app details from the Apple App Store using public iTunes RSS feeds and API.

### What does App Store Reviews Scraper do?

App Store Reviews Scraper extracts customer reviews and app metadata from Apple's App Store. It uses Apple's public RSS feeds and iTunes API to reliably gather review text, ratings, author information, app versions, and more — without needing login credentials.

The actor supports three input methods: direct App Store URLs, numeric App IDs, and search terms to discover apps. It handles pagination automatically, fetching up to 500 reviews per app (Apple's RSS feed limit of 10 pages with 50 reviews each).

Whether you are monitoring customer feedback for your own app, analyzing competitor reviews, or building a dataset for sentiment analysis, this actor delivers structured data ready for export.

### Use Cases

- **App developers** — Monitor customer feedback, track ratings across versions, and identify common issues in reviews
- **Market researchers** — Analyze competitor apps, compare ratings, and study user sentiment across app categories
- **Data analysts** — Build review datasets for NLP, sentiment analysis, or trend detection
- **Product managers** — Track feature requests and bug reports from user reviews at scale

### Features

- Scrape reviews by App Store URL, App ID, or search term
- Extract full review data: title, text, rating, author, version, date, vote count
- Extract app metadata: name, developer, price, rating, genre, release date
- Support for 7 country stores (US, UK, CA, AU, DE, FR, JP)
- Automatic pagination through all available review pages
- Deduplication of reviews across pages
- Proxy support with automatic rotation
- Handles large datasets with configurable limits
- Exports to JSON, CSV, Excel, or connect via API

### How much will it cost?

Apple's iTunes API and RSS feeds are lightweight and fast. This actor uses minimal compute resources.

| Results | Estimated Cost |
|---------|---------------|
| 100     | ~$0.01        |
| 1,000   | ~$0.05        |
| 10,000  | ~$0.40        |

| Cost Component | Per 1,000 Results |
|----------------|-------------------|
| Platform compute | ~$0.03 |
| Proxy (datacenter) | ~$0.02 |
| **Total** | **~$0.05** |

### How to use

1. Go to the App Store Reviews Scraper page on Apify Store
2. Click "Start" or "Try for free"
3. Enter App Store URLs, App IDs, or search terms
4. Select your country store and set the maximum number of reviews
5. Click "Start" and wait for the results

### Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| startUrls | array | App Store URLs to scrape | - |
| appIds | array | Apple numeric App IDs | - |
| searchTerms | array | Search queries to find apps | - |
| country | string | Country store code (us, gb, ca, au, de, fr, jp) | us |
| maxItems | number | Max reviews to scrape | 100 |
| proxyConfig | object | Proxy settings | Apify Proxy |

### Output

The actor produces two types of records in the dataset:

#### Review record

```json
{
    "reviewId": "10987654321",
    "title": "Great game!",
    "text": "This game is really fun and addictive. Love the new levels!",
    "rating": 5,
    "author": "GameFan123",
    "version": "1.265.0",
    "date": "2024-12-15T10:30:00-07:00",
    "voteCount": 3,
    "appId": "553834731",
    "appName": "Candy Crush Saga",
    "url": "https://apps.apple.com/app/id553834731",
    "dataType": "review",
    "scrapedAt": "2024-12-20T14:22:00.000Z"
}
````

#### App record

```json
{
    "appName": "Candy Crush Saga",
    "appId": "553834731",
    "developer": "King",
    "price": "Free",
    "rating": 4.7,
    "ratingCount": 3245678,
    "description": "Start playing Candy Crush Saga today...",
    "genres": ["Games", "Puzzle", "Entertainment"],
    "releaseDate": "2012-11-14T08:00:00Z",
    "currentVersion": "1.265.0",
    "url": "https://apps.apple.com/us/app/candy-crush-saga/id553834731",
    "dataType": "app",
    "scrapedAt": "2024-12-20T14:22:00.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| reviewId | string | Unique Apple review identifier |
| title | string | Review title or app name |
| text | string | Full review content |
| rating | number | Star rating (1-5) or average app rating |
| author | string | Review author name |
| version | string | App version reviewed |
| date | string | Review date (ISO 8601) |
| voteCount | number | Helpful votes on the review |
| appId | string | Apple App Store numeric ID |
| appName | string | Name of the app |
| developer | string | App developer name |
| price | string | App price |
| ratingCount | number | Total number of ratings |
| description | string | App description |
| genres | array | App genre categories |
| releaseDate | string | Original release date |
| currentVersion | string | Latest app version |
| dataType | string | Record type: "review" or "app" |
| scrapedAt | string | ISO 8601 scrape timestamp |

### Integrations

Connect App Store Reviews Scraper with other tools:

- **Apify API** — REST API for programmatic access
- **Webhooks** — get notified when a run finishes
- **Zapier / Make** — connect to 5,000+ apps
- **Google Sheets** — export directly to spreadsheets

#### API Example (Node.js)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('YOUR_USERNAME/app-store-reviews-scraper').call({
    appIds: ['553834731'],
    country: 'us',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### API Example (Python)

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('YOUR_USERNAME/app-store-reviews-scraper').call(run_input={
    'appIds': ['553834731'],
    'country': 'us',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### API Example (cURL)

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~app-store-reviews-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"appIds": ["553834731"], "country": "us", "maxItems": 100}'
```

### Tips and tricks

- Start with a small `maxItems` (10-20) to test before running large scrapes
- Apple's RSS feed provides a maximum of ~500 reviews per app (10 pages x 50 reviews)
- Use the `country` parameter to get reviews from specific regional stores
- Combine `appIds` and `searchTerms` in a single run to scrape multiple apps
- App details are automatically fetched alongside reviews

### FAQ

**Q: Does this actor require login credentials?**
A: No. It uses Apple's public RSS feeds and iTunes API, which are freely accessible.

**Q: How fast is the scraping?**
A: Approximately 200-500 reviews per minute, depending on proxy and concurrency settings.

**Q: What is the maximum number of reviews I can get per app?**
A: Apple's RSS feed provides up to ~500 reviews per app (10 pages). This is an Apple-side limitation.

**Q: What should I do if I get blocked?**
A: Apple's public APIs rarely block requests. If you encounter issues, try enabling Apify Proxy or reducing concurrency.

**Q: Can I get reviews in different languages?**
A: Yes, use the `country` parameter to target a specific store. Reviews will be in the local language of that store.

### Is it legal to scrape the App Store?

Web scraping of publicly available data is generally legal based on precedents like the LinkedIn v. HiQ Labs case. This actor only accesses Apple's public RSS feeds and iTunes API, which are designed for public consumption. Always review and respect Apple's Terms of Service. For more information, see [Apify's blog on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### Limitations

- Maximum ~500 reviews per app due to Apple's RSS feed pagination limit
- Reviews are sorted by most recent only (Apple RSS feed limitation)
- Some older reviews may not be available through the RSS feed
- Search API returns a maximum of 200 apps per query

### Changelog

- **v0.1** (2026-04-23) — Initial release

# Actor input Schema

## `startUrls` (type: `array`):

App Store URLs to scrape reviews from. Supports URLs like https://apps.apple.com/us/app/candy-crush-saga/id553834731

## `appIds` (type: `array`):

Apple App Store numeric IDs. Find the ID in the App Store URL after '/id'.

## `searchTerms` (type: `array`):

Search queries to find apps on the App Store. The actor will search for each term and scrape reviews from matching apps.

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

App Store country code. Determines which regional store to scrape reviews from.

## `maxItems` (type: `integer`):

Maximum number of reviews to scrape per app. Use 0 or leave empty for unlimited.

## `maxConcurrency` (type: `integer`):

Maximum number of requests processed in parallel.

## `debugMode` (type: `boolean`):

Enables verbose logging for troubleshooting.

## `extendOutputFunction` (type: `string`):

A JavaScript function to customize each output item. Receives { data, request }.

## `proxyConfig` (type: `object`):

Select proxies to use. Apple's public feeds usually work without proxies.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apps.apple.com/us/app/candy-crush-saga/id553834731"
    }
  ],
  "appIds": [
    "553834731"
  ],
  "country": "us",
  "maxItems": 100,
  "maxConcurrency": 10,
  "debugMode": false,
  "extendOutputFunction": "async ({ data }) => {\n    return data;\n}",
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://apps.apple.com/us/app/candy-crush-saga/id553834731"
        }
    ],
    "appIds": [
        "553834731"
    ],
    "extendOutputFunction": async ({ data }) => {
        return data;
    },
    "proxyConfig": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glassventures/app-store-reviews-scraper").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 = {
    "startUrls": [{ "url": "https://apps.apple.com/us/app/candy-crush-saga/id553834731" }],
    "appIds": ["553834731"],
    "extendOutputFunction": """async ({ data }) => {
    return data;
}""",
    "proxyConfig": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("glassventures/app-store-reviews-scraper").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 '{
  "startUrls": [
    {
      "url": "https://apps.apple.com/us/app/candy-crush-saga/id553834731"
    }
  ],
  "appIds": [
    "553834731"
  ],
  "extendOutputFunction": "async ({ data }) => {\\n    return data;\\n}",
  "proxyConfig": {
    "useApifyProxy": true
  }
}' |
apify call glassventures/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Reviews Scraper",
        "description": "Scrape App Store reviews and app details from Apple iTunes. Extract ratings, review text, authors, versions. Export to JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "YU8VWtbSOn1G3CQAF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/glassventures~app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-glassventures-app-store-reviews-scraper",
                "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/glassventures~app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-glassventures-app-store-reviews-scraper",
                "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/glassventures~app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-glassventures-app-store-reviews-scraper",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "App Store URLs to scrape reviews from. Supports URLs like https://apps.apple.com/us/app/candy-crush-saga/id553834731",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Apple App Store numeric IDs. Find the ID in the App Store URL after '/id'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Search queries to find apps on the App Store. The actor will search for each term and scrape reviews from matching apps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "jp"
                        ],
                        "type": "string",
                        "description": "App Store country code. Determines which regional store to scrape reviews from.",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per app. Use 0 or leave empty for unlimited.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of requests processed in parallel.",
                        "default": 10
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Enables verbose logging for troubleshooting.",
                        "default": false
                    },
                    "extendOutputFunction": {
                        "title": "Extend Output Function",
                        "type": "string",
                        "description": "A JavaScript function to customize each output item. Receives { data, request }."
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to use. Apple's public feeds usually work without proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
