# AliExpress Reviews Scraper (`fetch_cat/aliexpress-reviews-scraper`) Actor

Extract public AliExpress product reviews with ratings, text, buyer countries, variants, media URLs, helpful votes, and seller replies.

- **URL**: https://apify.com/fetch\_cat/aliexpress-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 review extracteds

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

## AliExpress Reviews Scraper

Extract public AliExpress product reviews from product URLs or product IDs. Get one clean dataset row per review with ratings, text, buyer country, masked buyer name, variant details, images, helpful votes, seller replies when available, and product-level review stats.

Use this Actor for product research, dropshipping due diligence, competitor monitoring, quality tracking, sentiment analysis, and recurring review exports.

### Who is it for?

- **Ecommerce sellers** checking buyer complaints, variant quality, and product-market fit.
- **Dropshippers and product researchers** comparing competitor products before sourcing.
- **Review intelligence teams** building recurring dashboards from public AliExpress feedback.
- **Analysts and developers** exporting structured review data to CSV, JSON, APIs, BI tools, or AI workflows.

### Input recipes

- **Small smoke test**: keep the default product URL and `maxReviewsPerProduct: 20`.
- **Bulk product monitoring**: add many `productUrls` and schedule the Actor weekly.
- **Photo review audit**: enable `includeMedia` to export only reviews with customer images.
- **Newest feedback first**: set `sort` to `recent` to inspect the latest buyer issues.

### Example input

```json
{
  "productUrls": [
    "https://www.aliexpress.com/item/1005001388303149.html"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "default",
  "countries": ["US"],
  "includeMedia": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

You can also use product IDs directly:

```json
{
  "productIds": ["1005001388303149"],
  "maxReviewsPerProduct": 50,
  "sort": "recent"
}
```

### Example output

```json
{
  "productId": "1005001388303149",
  "productUrl": "https://www.aliexpress.com/item/1005001388303149.html",
  "reviewId": "50208122799602247",
  "rating": 5,
  "buyerEval": 100,
  "reviewText": "The child really liked it! It arrived faster than expected, everything works, and it's not very noisy. I recommend it 👍",
  "originalReviewText": "очень понравился ребенку! пришел быстрее, чем ожидали, все работает, не очень шумный. рекомендую👍",
  "translatedReviewText": "The child really liked it! It arrived faster than expected, everything works, and it's not very noisy. I recommend it 👍",
  "reviewDate": "27 Feb 2026",
  "buyerCountry": "RU",
  "buyerNameMasked": "Б***а",
  "anonymous": false,
  "variant": "Color:With 2pcs Battery",
  "mediaUrls": ["https://ae-pic-a1.aliexpress-media.com/kf/example.jpg"],
  "thumbnailUrls": ["https://ae-pic-a1.aliexpress-media.com/kf/example.jpg_220x220.jpg"],
  "helpfulCount": 0,
  "notHelpfulCount": 0,
  "sellerReply": null,
  "additionalFeedback": null,
  "reviewType": "REVIEW",
  "selectedReview": true,
  "samePurchaseSuggestion": "Buy the same",
  "sourceLanguage": "en",
  "translated": true,
  "totalReviews": 33,
  "averageRating": 4.6,
  "positiveRate": 81.8,
  "scrapedAt": "2026-07-09T18:07:01.014Z"
}
```

### What data can you extract?

| Field | Description |
| --- | --- |
| `productId` | AliExpress product ID. |
| `productUrl` | Canonical product page URL. |
| `reviewId` | Unique review identifier. |
| `rating` | Normalized star rating from 1 to 5. |
| `buyerEval` | Raw AliExpress rating score, usually 0 to 100. |
| `reviewText` | Best available review text for analysis. |
| `originalReviewText` | Original buyer feedback when available. |
| `translatedReviewText` | Translated feedback when AliExpress exposes it. |
| `reviewDate` | Review date text returned by AliExpress. |
| `buyerCountry` | Buyer country code. |
| `buyerNameMasked` | Public masked buyer display name. |
| `anonymous` | Whether AliExpress marks the review as anonymous. |
| `variant` | Purchased variant/SKU text. |
| `mediaUrls` | Customer image URLs. |
| `thumbnailUrls` | Customer image thumbnail URLs. |
| `helpfulCount` / `notHelpfulCount` | Vote counts exposed for the review. |
| `sellerReply` | Seller reply text when publicly available. |
| `additionalFeedback` | Additional buyer feedback when available. |
| `reviewType` | AliExpress review type label. |
| `selectedReview` | Whether the review is highlighted by AliExpress. |
| `samePurchaseSuggestion` | Repurchase signal text when available. |
| `sourceLanguage` | Source language code when available. |
| `translated` | Whether the saved text appears to use a translated version. |
| `totalReviews`, `averageRating`, `positiveRate` | Product review summary stats when available. |
| `scrapedAt` | Timestamp when the row was saved. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Product URLs | `productUrls` | AliExpress product pages to process. | `["https://www.aliexpress.com/item/1005001388303149.html"]` |
| Product IDs | `productIds` | Numeric IDs if you already have them. | `["1005001388303149"]` |
| Max reviews per product | `maxReviewsPerProduct` | Limit output volume and spend per product. | `20` |
| Sort order | `sort` | Default relevance or newest-first review order. | `"recent"` |
| Country/language endpoints | `countries` | Country parameters to request from AliExpress. | `["US"]` |
| Only reviews with media | `includeMedia` | Keep only reviews with customer images. | `true` |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings. | `{ "useApifyProxy": false }` |

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Review extracted | `$0.0001` per saved review on Bronze, with automatic volume discounts on higher tiers | Each review saved to the dataset. |

Review extraction tier labels and prices: Free `$0.000115`, Bronze `$0.0001`, Silver `$0.000078`, Gold `$0.00006`, Platinum `$0.00004`, Diamond `$0.000028`.

### Tips for best results

- Start with `maxReviewsPerProduct: 20` until you confirm the product has the reviews you need.
- Use `productIds` for automated workflows when your system already stores AliExpress IDs.
- Use `includeMedia: true` for photo review analysis, but expect fewer results.
- Split very large product lists into scheduled batches so each run is easy to retry and inspect.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/aliexpress-reviews-scraper").call({
  productUrls: ["https://www.aliexpress.com/item/1005001388303149.html"],
  maxReviewsPerProduct: 20
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/aliexpress-reviews-scraper").call(run_input={
    "productIds": ["1005001388303149"],
    "maxReviewsPerProduct": 20,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~aliexpress-reviews-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productIds":["1005001388303149"],"maxReviewsPerProduct":20}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/aliexpress-reviews-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/aliexpress-reviews-scraper"
    }
  }
}
```

Example prompt: "Run AliExpress Reviews Scraper for these product URLs and summarize the most common complaints by variant."

### Limits and caveats

- The Actor extracts public review data only. It does not log in, use buyer accounts, or access private buyer information.
- AliExpress may return translated text, original text, or both depending on the product and review.
- Some products return few or no reviews, or expose fewer optional fields.
- Very large recurring jobs may need proxy configuration if AliExpress throttles requests.

### Legality and responsible use

This Actor is designed for public AliExpress review pages and ordinary ecommerce research workflows. Use it only for lawful purposes, respect AliExpress terms and applicable privacy rules, and avoid collecting or combining data in ways that identify private individuals.

### Related actors

- [AliExpress Products Scraper](https://apify.com/fetch_cat/aliexpress-products-scraper)
- [Google Maps Reviews Scraper](https://apify.com/fetch_cat/google-maps-reviews-scraper)

### FAQ

#### Can I export reviews to CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, HTML table, and API access.

#### Does this scrape private buyer information?

No. It saves only public review fields that AliExpress exposes to ordinary visitors, such as masked buyer names and country codes.

#### Why are some reviews missing images or seller replies?

Those fields are optional on AliExpress. The Actor leaves unavailable fields empty instead of guessing.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL.

### Changelog

#### 0.1

- Initial version for extracting public AliExpress product reviews from product URLs and product IDs.

# Actor input Schema

## `productUrls` (type: `array`):

AliExpress product page URLs to extract reviews from.

## `productIds` (type: `array`):

Numeric AliExpress product IDs. Use this if you already have product IDs instead of URLs.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to save for each product.

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

Review ordering returned by AliExpress.

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

Optional AliExpress country parameters to try, such as US, GB, FR, DE. Leave empty to use US.

## `includeMedia` (type: `boolean`):

If enabled, save only reviews that include customer images.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy configuration. Datacenter proxies are usually enough; use residential only if your run is blocked.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.aliexpress.com/item/1005001388303149.html"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "default",
  "countries": [
    "US"
  ],
  "includeMedia": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "productUrls": [
        "https://www.aliexpress.com/item/1005001388303149.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/aliexpress-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 = { "productUrls": ["https://www.aliexpress.com/item/1005001388303149.html"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/aliexpress-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 '{
  "productUrls": [
    "https://www.aliexpress.com/item/1005001388303149.html"
  ]
}' |
apify call fetch_cat/aliexpress-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress Reviews Scraper",
        "description": "Extract public AliExpress product reviews with ratings, text, buyer countries, variants, media URLs, helpful votes, and seller replies.",
        "version": "0.1",
        "x-build-id": "ifQSiHeqOeIi31Ssm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~aliexpress-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-aliexpress-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/fetch_cat~aliexpress-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-aliexpress-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/fetch_cat~aliexpress-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-aliexpress-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "AliExpress product page URLs to extract reviews from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productIds": {
                        "title": "Product IDs",
                        "type": "array",
                        "description": "Numeric AliExpress product IDs. Use this if you already have product IDs instead of URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each product.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "default",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Review ordering returned by AliExpress.",
                        "default": "default"
                    },
                    "countries": {
                        "title": "Country/language endpoints",
                        "type": "array",
                        "description": "Optional AliExpress country parameters to try, such as US, GB, FR, DE. Leave empty to use US.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "US"
                        ]
                    },
                    "includeMedia": {
                        "title": "Only reviews with media",
                        "type": "boolean",
                        "description": "If enabled, save only reviews that include customer images.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. Datacenter proxies are usually enough; use residential only if your run is blocked.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
