# Trustpilot Scraper (`magicfingers/trustpilot-scraper`) Actor

Scrape Trustpilot company profiles, reviews, ratings, and category pages. Filter by star rating, date range, language, and verification status. Supports pagination for companies with thousands of reviews.

- **URL**: https://apify.com/magicfingers/trustpilot-scraper.md
- **Developed by:** [abdulrahman alrashid](https://apify.com/magicfingers) (community)
- **Categories:** Other
- **Stats:** 18 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 1.00 out of 5 stars

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

## Trustpilot Scraper

Scrape company profiles, reviews, ratings, and category pages from [Trustpilot](https://www.trustpilot.com). Extract structured data for sentiment analysis, market research, competitor monitoring, and reputation tracking.

### Features

- **Search companies** by keyword or name
- **Scrape company profiles**: name, TrustScore, total reviews, category, location, website, response rate, claimed status, description
- **Scrape all reviews**: reviewer name, location, rating (1-5 stars), title, review text, date of experience, date posted, company reply, verified status, useful votes, language
- **Filter reviews** by star rating, date range, language, and verification status
- **Scrape category pages** (e.g., "Electronics & Technology")
- **Full pagination support** for companies with thousands of reviews
- **Three-layer extraction**: `__NEXT_DATA__` (primary) > JSON-LD structured data > HTML fallback
- **Anti-bot handling**: session rotation, rate limit detection, realistic browser headers

### Input Configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `action` | string | `scrapeReviews` | One of: `scrapeReviews`, `scrapeCompanyProfile`, `searchCompanies`, `scrapeCategory` |
| `companyUrls` | string[] | `[]` | Company URLs or slugs (e.g., `https://www.trustpilot.com/review/example.com` or `example.com`) |
| `searchQuery` | string | | Keyword to search for companies |
| `categoryUrl` | string | | Full category page URL |
| `maxReviews` | integer | `100` | Max reviews per company (0 = unlimited) |
| `maxSearchResults` | integer | `50` | Max companies from search/category |
| `filterByStars` | integer[] | `[]` | Only these star ratings (e.g., `[1, 2]`) |
| `filterDateFrom` | string | | Only reviews after this date (`YYYY-MM-DD`) |
| `filterDateTo` | string | | Only reviews before this date (`YYYY-MM-DD`) |
| `filterLanguage` | string | | Language code (e.g., `en`, `de`, `fr`) |
| `filterVerifiedOnly` | boolean | `false` | Only verified reviews |
| `includeCompanyProfile` | boolean | `true` | Output company profile with reviews |
| `proxyConfiguration` | object | Apify residential | Proxy settings |
| `maxConcurrency` | integer | `5` | Concurrent requests (1-20) |

### Usage Examples

#### Scrape reviews for a company

```json
{
    "action": "scrapeReviews",
    "companyUrls": ["https://www.trustpilot.com/review/amazon.com"],
    "maxReviews": 500,
    "filterByStars": [1, 2],
    "filterVerifiedOnly": true
}
````

#### Search for companies

```json
{
    "action": "searchCompanies",
    "searchQuery": "web hosting",
    "maxSearchResults": 100
}
```

#### Scrape company profile only

```json
{
    "action": "scrapeCompanyProfile",
    "companyUrls": ["amazon.com", "ebay.com", "walmart.com"]
}
```

#### Scrape a category page

```json
{
    "action": "scrapeCategory",
    "categoryUrl": "https://www.trustpilot.com/categories/electronics_technology",
    "maxSearchResults": 200
}
```

### Output Schema

Each result includes a `type` field: `company_profile`, `review`, `search_result`, or `category_result`.

#### Company Profile

```json
{
    "type": "company_profile",
    "companyName": "Amazon",
    "trustScore": 1.7,
    "totalReviews": 125432,
    "category": "Electronics & Technology",
    "location": "Seattle, WA, US",
    "website": "https://www.amazon.com",
    "responseRate": 12,
    "claimed": true,
    "description": "...",
    "scrapedAt": "2025-01-15T10:30:00.000Z"
}
```

#### Review

```json
{
    "type": "review",
    "companySlug": "amazon.com",
    "companyName": "Amazon",
    "reviewId": "65abc123def456",
    "reviewerName": "John D.",
    "reviewerLocation": "US",
    "reviewerReviewCount": 5,
    "rating": 4,
    "title": "Great product, slow shipping",
    "reviewText": "The product quality was excellent but delivery took 2 weeks...",
    "dateOfExperience": "2025-01-10T00:00:00.000Z",
    "datePosted": "2025-01-12T14:22:00.000Z",
    "verified": true,
    "companyReply": "Thank you for your feedback...",
    "companyReplyDate": "2025-01-13T09:00:00.000Z",
    "usefulVotes": 3,
    "language": "en",
    "reviewUrl": "https://www.trustpilot.com/reviews/65abc123def456",
    "scrapedAt": "2025-01-15T10:30:00.000Z"
}
```

#### Search/Category Result

```json
{
    "type": "search_result",
    "companyName": "Bluehost",
    "slug": "bluehost.com",
    "trustScore": 3.8,
    "totalReviews": 4521,
    "category": "Web Hosting",
    "profileUrl": "https://www.trustpilot.com/review/bluehost.com",
    "scrapedAt": "2025-01-15T10:30:00.000Z"
}
```

### Pricing

**Pay-Per-Event**: $0.35 per 1,000 results ($0.00035 per result)

| Results | Cost |
|---------|------|
| 100 | $0.035 |
| 1,000 | $0.35 |
| 10,000 | $3.50 |
| 100,000 | $35.00 |

### Technical Details

- Uses **CheerioCrawler** from Crawlee for fast, lightweight HTML parsing
- Extracts data from **`__NEXT_DATA__`** (Next.js server-side props) as the primary data source
- Falls back to **JSON-LD structured data**, then **HTML DOM parsing** if needed
- Session pool with cookie persistence for anti-bot resilience
- Randomized User-Agent headers across Chrome versions and platforms
- Automatic retry with session rotation on 403/429 responses
- Detects and handles Cloudflare challenge pages

### Legal Notice

This Actor is intended for legitimate data collection purposes such as market research, sentiment analysis, and reputation monitoring. Always respect Trustpilot's Terms of Service. The responsibility for how the data is used lies with the end user.

# Actor input Schema

## `action` (type: `string`):

What to scrape from Trustpilot.

## `companyUrls` (type: `array`):

List of Trustpilot company URLs (e.g., https://www.trustpilot.com/review/example.com) or slugs (e.g., example.com). Used for scrapeReviews and scrapeCompanyProfile actions.

## `searchQuery` (type: `string`):

Keyword or company name to search for. Used with searchCompanies action.

## `categoryUrl` (type: `string`):

Trustpilot category page URL (e.g., https://www.trustpilot.com/categories/electronics\_technology). Used with scrapeCategory action.

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

Maximum number of reviews to scrape per company. Set to 0 for all reviews.

## `maxSearchResults` (type: `integer`):

Maximum number of companies to return from search or category pages.

## `filterByStars` (type: `array`):

Only scrape reviews with these star ratings. Leave empty for all ratings.

## `filterDateFrom` (type: `string`):

Only scrape reviews posted on or after this date (YYYY-MM-DD).

## `filterDateTo` (type: `string`):

Only scrape reviews posted on or before this date (YYYY-MM-DD).

## `filterLanguage` (type: `string`):

Only scrape reviews in this language (e.g., 'en', 'de', 'fr'). Leave empty for all languages.

## `filterVerifiedOnly` (type: `boolean`):

If enabled, only scrape reviews marked as verified.

## `includeCompanyProfile` (type: `boolean`):

When scraping reviews, also output a company profile record.

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

Select proxies to use for scraping.

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

Maximum number of concurrent page requests.

## Actor input object example

```json
{
  "action": "scrapeReviews",
  "companyUrls": [
    "https://www.trustpilot.com/review/amazon.com"
  ],
  "maxReviews": 5,
  "maxSearchResults": 50,
  "filterByStars": [],
  "filterVerifiedOnly": false,
  "includeCompanyProfile": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5
}
```

# 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 = {
    "action": "scrapeReviews",
    "companyUrls": [
        "https://www.trustpilot.com/review/amazon.com"
    ],
    "maxReviews": 5,
    "maxSearchResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("magicfingers/trustpilot-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 = {
    "action": "scrapeReviews",
    "companyUrls": ["https://www.trustpilot.com/review/amazon.com"],
    "maxReviews": 5,
    "maxSearchResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("magicfingers/trustpilot-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 '{
  "action": "scrapeReviews",
  "companyUrls": [
    "https://www.trustpilot.com/review/amazon.com"
  ],
  "maxReviews": 5,
  "maxSearchResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5
}' |
apify call magicfingers/trustpilot-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper",
        "description": "Scrape Trustpilot company profiles, reviews, ratings, and category pages. Filter by star rating, date range, language, and verification status. Supports pagination for companies with thousands of reviews.",
        "version": "1.0",
        "x-build-id": "BQsuQ285vJtM6aH8t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/magicfingers~trustpilot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-magicfingers-trustpilot-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/magicfingers~trustpilot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-magicfingers-trustpilot-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/magicfingers~trustpilot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-magicfingers-trustpilot-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",
                "required": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "scrapeReviews",
                            "scrapeCompanyProfile",
                            "searchCompanies",
                            "scrapeCategory"
                        ],
                        "type": "string",
                        "description": "What to scrape from Trustpilot.",
                        "default": "scrapeReviews"
                    },
                    "companyUrls": {
                        "title": "Company URLs or Slugs",
                        "type": "array",
                        "description": "List of Trustpilot company URLs (e.g., https://www.trustpilot.com/review/example.com) or slugs (e.g., example.com). Used for scrapeReviews and scrapeCompanyProfile actions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword or company name to search for. Used with searchCompanies action."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "Trustpilot category page URL (e.g., https://www.trustpilot.com/categories/electronics_technology). Used with scrapeCategory action."
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Company",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company. Set to 0 for all reviews.",
                        "default": 5
                    },
                    "maxSearchResults": {
                        "title": "Max Search/Category Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of companies to return from search or category pages.",
                        "default": 50
                    },
                    "filterByStars": {
                        "title": "Filter by Star Rating",
                        "type": "array",
                        "description": "Only scrape reviews with these star ratings. Leave empty for all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        },
                        "default": []
                    },
                    "filterDateFrom": {
                        "title": "Filter Date From",
                        "type": "string",
                        "description": "Only scrape reviews posted on or after this date (YYYY-MM-DD)."
                    },
                    "filterDateTo": {
                        "title": "Filter Date To",
                        "type": "string",
                        "description": "Only scrape reviews posted on or before this date (YYYY-MM-DD)."
                    },
                    "filterLanguage": {
                        "title": "Filter by Language",
                        "type": "string",
                        "description": "Only scrape reviews in this language (e.g., 'en', 'de', 'fr'). Leave empty for all languages."
                    },
                    "filterVerifiedOnly": {
                        "title": "Verified Reviews Only",
                        "type": "boolean",
                        "description": "If enabled, only scrape reviews marked as verified.",
                        "default": false
                    },
                    "includeCompanyProfile": {
                        "title": "Include Company Profile with Reviews",
                        "type": "boolean",
                        "description": "When scraping reviews, also output a company profile record.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to use for scraping.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent page requests.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
