# Multi-Platform Review Scraper MCP (`red.cars/multi-review-scraper-mcp`) Actor

Scrape Google, Trustpilot, Yelp, TripAdvisor reviews: ratings, review text, sentiment, aggregate summary. AI agent MCP tool. No API keys needed.

- **URL**: https://apify.com/red.cars/multi-review-scraper-mcp.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.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

## Multi-Platform Review Scraper MCP

Scrape customer reviews, ratings, and sentiment analysis from **Google**, **Trustpilot**, **Yelp**, **TripAdvisor**, and **Amazon** in a single AI agent tool call. Returns individual review records with reviewer metadata, aggregate cross-platform ratings, sentiment classification, and fake review detection.

### Overview

This MCP server gives AI agents live access to customer review data across five major platforms. For any business URL, it returns:

- **Individual review records** — star rating, title, text, author name, date, verified badge, helpful votes
- **Cross-platform summary** — aggregate average rating, total review counts per platform, sentiment breakdown
- **Fake review detection** — probability scoring and flagging of suspicious reviews
- **Export functionality** — JSON, CSV, or Markdown export of review data

Review data is extracted from public HTML using structured data selectors and JSON-LD schemas. No API keys required for any platform.

### Tools

#### `scrapeReviews`

Scrape individual customer reviews and aggregate summary from one or all platforms.

**Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `businessUrl` | string | Yes | Business URL on a review platform |
| `businessName` | string | No | Business name to disambiguate searches |
| `location` | string | No | City/address to disambiguate multi-location businesses |
| `platform` | string | No | Target platform: `google`, `trustpilot`, `yelp`, `tripadvisor`, `amazon`, or `all` (default: `all`) |
| `maxReviews` | integer | No | Maximum reviews per platform, 1–100 (default: 25) |

**Returns:** Individual review array plus cross-platform summary with sentiment breakdown.

#### `aggregateRatings`

Get aggregate ratings summary across all detected platforms — average rating, total review count, and per-platform breakdown.

**Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `businessUrl` | string | Yes | Business URL on a review platform |
| `businessName` | string | No | Business name to search for |
| `location` | string | No | City/address to disambiguate |

**Returns:** Average rating, total reviews across platforms, platform count, sentiment.

#### `exportReviews`

Export scraped reviews in specified format with all review data and metadata.

**Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `reviews` | array | Yes | Array of review objects to export |
| `format` | string | No | Export format: `json`, `csv`, or `markdown` (default: `json`) |
| `filename` | string | No | Output filename without extension (default: `reviews`) |

**Returns:** Export confirmation with format, filename, and review count.

#### `detectFakeReviews`

Analyze reviews for potential fake indicators using multiple signal detection methods.

**Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `reviews` | array | Yes | Array of review objects to analyze |
| `threshold` | number | No | Minimum fake probability (0–1) to flag as suspicious (default: 0.7) |

**Detection Signals:**
- Missing rating or very short review body
- No review date
- Generic or suspicious reviewer name patterns
- Rating anomalies (5 stars with 10 character review)
- ALL CAPS title
- Excessive punctuation
- URLs in review text
- Repeated character patterns (e.g., "goooood")

**Returns:** Analysis with probability scores, flags, and list of suspicious reviews.

### Input Schema

```json
{
  "operation": "scrapeReviews",
  "businessUrl": "https://www.trustpilot.com/review/airbnb.com",
  "businessName": "Airbnb",
  "location": "Global",
  "platform": "all",
  "maxReviews": 25,
  "exportFormat": "json",
  "fakeReviewThreshold": 0.7
}
````

#### Operations

| Operation | Description |
|-----------|-------------|
| `scrapeReviews` | Scrape reviews from specified platform(s) |
| `aggregateRatings` | Get aggregate ratings summary |
| `exportReviews` | Export reviews to JSON/CSV/Markdown |
| `detectFakeReviews` | Analyze reviews for fake indicators |

### Output Schema

#### scrapeReviews Response

```json
{
  "operation": "scrapeReviews",
  "input": {
    "businessUrl": "https://www.trustpilot.com/review/airbnb.com",
    "platform": "all",
    "maxReviews": 25
  },
  "summary": {
    "averageRating": 4.3,
    "totalReviewsAcrossPlatforms": 847,
    "platformCount": 3,
    "platforms": [
      {
        "platform": "google",
        "averageRating": 4.5,
        "totalReviews": 420,
        "reviewsScraped": 25
      },
      {
        "platform": "trustpilot",
        "averageRating": 4.1,
        "totalReviews": 327,
        "reviewsScraped": 25
      },
      {
        "platform": "yelp",
        "averageRating": 3.8,
        "totalReviews": 100,
        "reviewsScraped": 10
      }
    ],
    "sentiment": "positive",
    "sentimentBreakdown": {
      "positive": 38,
      "neutral": 8,
      "negative": 4
    },
    "reviewsAnalyzed": 46,
    "timestamp": "2026-05-19T21:30:00.000Z"
  },
  "reviews": [
    {
      "platform": "google",
      "rating": 5,
      "reviewTitle": "Excellent service",
      "reviewBody": "Had a great experience with this business. Fast delivery and friendly staff.",
      "reviewerName": "Alex M.",
      "reviewDate": "2026-02-15",
      "verified": false,
      "helpfulVotes": 3,
      "url": "https://www.google.com/maps/..."
    }
  ],
  "reviewCount": 46,
  "timestamp": "2026-05-19T21:30:00.000Z"
}
```

#### detectFakeReviews Response

```json
{
  "operation": "detectFakeReviews",
  "totalReviews": 46,
  "suspiciousCount": 3,
  "cleanCount": 43,
  "threshold": 0.7,
  "fakeProbability": 0.065,
  "suspiciousReviews": [
    {
      "platform": "yelp",
      "rating": 5,
      "reviewerName": "J.",
      "reviewDate": "2026-01-01",
      "fakeProbability": 0.82,
      "flags": ["veryShort", "noDate", "genericReviewer"]
    }
  ],
  "timestamp": "2026-05-19T21:30:00.000Z"
}
```

### Supported Platforms

| Platform | URL Pattern | Features |
|----------|-------------|----------|
| **Google** | `google.com/maps/search/...` or place URL | Reviews, ratings, user metadata |
| **Trustpilot** | `trustpilot.com/review/...` | Verified reviews, aggregate rating, helpful votes |
| **Yelp** | `yelp.com/biz/...` | Reviews, ratings, user info |
| **TripAdvisor** | `tripadvisor.com/...` | Reviews, ratings, travel-specific data |
| **Amazon** | `amazon.com/.../product/...` or `amzn.com/...` | Product reviews, verified purchase badge |

### Pricing (Pay-Per-Event)

| Event | Cost |
|-------|------|
| `scrape_reviews` | $0.05 |
| `aggregate_ratings` | $0.03 |
| `export_reviews` | $0.02 |
| `detect_fake_reviews` | $0.06 |
| `platform_scrape` | $0.04 per platform |

**Example:** Scraping reviews across all 5 platforms with 25 reviews each = 5 platform scrapes = $0.20 total.

### Error Handling & Retry Logic

This actor implements exponential backoff retry for transient failures:

- **Max retries:** 3 attempts
- **Base delay:** 1000ms, doubling each retry (1000ms → 2000ms → 4000ms)
- **Max delay:** 30 seconds
- **Retryable errors:** Network timeouts, 502/503/429 responses, connection resets

Failed scrapes return partial results with error annotations per platform rather than failing the entire operation.

### Use Cases

- **Reputation monitoring** — Track ratings and sentiment across platforms over time
- **Competitive analysis** — Compare review patterns between your business and competitors
- **Lead qualification** — Gauge customer satisfaction before sales outreach
- **Market research** — Extract customer pain points and product feedback at scale
- **Fake review detection** — Identify suspicious reviews for further investigation
- **Support ticket triage** — Identify negative reviewers for proactive outreach

### Quick Start

```bash
## Install dependencies
npm install

## Run locally with test input
echo '{"operation":"scrapeReviews","businessUrl":"https://www.trustpilot.com/review/airbnb.com","platform":"all","maxReviews":10}' | INPUT_STORE=1 apify run

## Run with a file
apify run --input-file ./test-input.json
```

#### Test Input (test-input.json)

```json
{
  "operation": "scrapeReviews",
  "businessUrl": "https://www.trustpilot.com/review/airbnb.com",
  "platform": "all",
  "maxReviews": 10
}
```

### Architecture

- **Standby mode** — Spins up on-demand when MCP request arrives, spins down when idle
- **MCP protocol** — Native MCP server implementation for AI agent integrations
- **Readiness probe** — Health check at `GET /` with `x-apify-container-server-readiness-probe` header
- **90s tool timeout** — Prevents long-running operations from hanging
- **No external APIs** — Uses public HTML scraping, no API keys or credentials required

#### File Structure

```
multi-review-scraper-mcp/
├── .actor/
│   └── actor.json          ## Actor definition with PPE pricing
├── src/
│   └── main.js             ## MCP server implementation
├── Dockerfile              ## Container build definition
├── package.json            ## Node.js dependencies
└── README.md               ## This file
```

### Troubleshooting

| Issue | Solution |
|-------|----------|
| Empty reviews returned | Business may not have reviews on that platform; try a different URL |
| Platform not detected | Use direct review page URL (e.g., `trustpilot.com/review/example.com`) |
| Rating mismatch | Platform counts may differ due to filtering or rounding |
| Timeout errors | Reduce `maxReviews` to 10–25 for large businesses |
| Fake detection seems off | Adjust `threshold` parameter (lower = more sensitive) |

### Build & Deploy

```bash
## Syntax check
node --check src/main.js

## Build Docker image
apify build

## Push to Apify platform
apify push

## View on Apify
apify open
```

### License

MIT License — Wilson Davalos

# Actor input Schema

## `operation` (type: `string`):

The operation to perform: scrapeReviews, aggregateRatings, exportReviews, detectFakeReviews

## `businessUrl` (type: `string`):

Business URL on a review platform (Google Maps, Trustpilot, Yelp, TripAdvisor, or Amazon product page)

## `businessName` (type: `string`):

Business name to search for (use with location)

## `location` (type: `string`):

Business location (city, state/country) to disambiguate searches

## `platform` (type: `string`):

Platform to scrape: google, trustpilot, yelp, tripadvisor, amazon, or all (default: all)

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

Maximum reviews to scrape per platform (1-100)

## `exportFormat` (type: `string`):

Export format: json, csv, or markdown

## `fakeReviewThreshold` (type: `number`):

Minimum fake probability (0-1) to flag a review as suspicious

## Actor input object example

```json
{
  "operation": "scrapeReviews",
  "businessUrl": "",
  "businessName": "",
  "location": "",
  "platform": "all",
  "maxReviews": 25,
  "exportFormat": "json",
  "fakeReviewThreshold": 0.7
}
```

# 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 = {
    "businessUrl": "",
    "platform": "all",
    "maxReviews": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("red.cars/multi-review-scraper-mcp").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 = {
    "businessUrl": "",
    "platform": "all",
    "maxReviews": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("red.cars/multi-review-scraper-mcp").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 '{
  "businessUrl": "",
  "platform": "all",
  "maxReviews": 25
}' |
apify call red.cars/multi-review-scraper-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-Platform Review Scraper MCP",
        "description": "Scrape Google, Trustpilot, Yelp, TripAdvisor reviews: ratings, review text, sentiment, aggregate summary. AI agent MCP tool. No API keys needed.",
        "version": "1.0",
        "x-build-id": "EcxMkjXun3pX40fyt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/red.cars~multi-review-scraper-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-red.cars-multi-review-scraper-mcp",
                "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/red.cars~multi-review-scraper-mcp/runs": {
            "post": {
                "operationId": "runs-sync-red.cars-multi-review-scraper-mcp",
                "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/red.cars~multi-review-scraper-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-red.cars-multi-review-scraper-mcp",
                "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": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "type": "string",
                        "description": "The operation to perform: scrapeReviews, aggregateRatings, exportReviews, detectFakeReviews",
                        "default": "scrapeReviews"
                    },
                    "businessUrl": {
                        "title": "Business URL",
                        "type": "string",
                        "description": "Business URL on a review platform (Google Maps, Trustpilot, Yelp, TripAdvisor, or Amazon product page)",
                        "default": ""
                    },
                    "businessName": {
                        "title": "Business Name",
                        "type": "string",
                        "description": "Business name to search for (use with location)",
                        "default": ""
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Business location (city, state/country) to disambiguate searches",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "type": "string",
                        "description": "Platform to scrape: google, trustpilot, yelp, tripadvisor, amazon, or all (default: all)",
                        "default": "all"
                    },
                    "maxReviews": {
                        "title": "Max Reviews per Platform",
                        "type": "integer",
                        "description": "Maximum reviews to scrape per platform (1-100)",
                        "default": 25
                    },
                    "exportFormat": {
                        "title": "Export Format",
                        "type": "string",
                        "description": "Export format: json, csv, or markdown",
                        "default": "json"
                    },
                    "fakeReviewThreshold": {
                        "title": "Fake Review Threshold",
                        "type": "number",
                        "description": "Minimum fake probability (0-1) to flag a review as suspicious",
                        "default": 0.7
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```