# Boots Reviews Scraper (`stealth_mode/boots-reviews-scraper`) Actor

Collect detailed product reviews from Boots.com with ratings, customer feedback, photos, videos, and 47+ fields per review. Perfect for sentiment analysis, reputation monitoring, and e-commerce intelligence.

- **URL**: https://apify.com/stealth\_mode/boots-reviews-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Boots Reviews Scraper: Extract Product Reviews & Ratings at Scale

---

### What Is Boots.com?

Boots.com is the official UK e-commerce platform for Boots the Chemist, a major health and beauty retailer. The site hosts thousands of beauty, skincare, and wellness products, each with customer reviews and ratings. These reviews are valuable for market research, competitor analysis, and understanding consumer sentiment — but extracting this data manually is tedious and error-prone. The **Boots Reviews Scraper** automates the collection process, delivering structured review data in seconds.

---

### Overview

The **Boots Reviews Scraper** extracts product reviews and customer feedback from Boots.com product pages, converting unstructured review data into clean, queryable records. It is designed for:

- **E-commerce analysts** studying consumer preferences and product performance
- **Reputation managers** monitoring brand sentiment and review trends
- **Market researchers** analyzing competitor product feedback
- **Content creators** building review aggregators or comparison tools
- **Sentiment analysis teams** processing large-scale customer feedback

Key strengths include flexible sorting (by rating, helpfulness, or submission date), configurable pagination via offset, and reliable error handling with `ignore_url_failures`.

---

### Input Format

The scraper accepts a JSON configuration object to define which reviews to collect and how to order them:

```json
{
  "urls": [
    "https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"
  ],
  "offset": 20,
  "sort_by": "rating:desc",
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Direct links to Boots product pages (with review sections). Each URL should point to a product detail page with reviews enabled. |
| `offset` | Integer | Skip the first N reviews before collection starts. Useful for pagination (e.g., `offset: 20` skips the first 20 reviews). Default: `0`. |
| `sort_by` | String | Sorting method: `"rating:desc"` (highest first), `"rating:asc"` (lowest first), `"helpfulness:desc,totalpositivefeedbackcount:desc"` (most helpful), `"submissiontime:desc"` (newest), or `""` (any order). |
| `ignore_url_failures` | Boolean | If `true`, scraper continues if a URL fails; if `false`, the entire run stops on error. Recommended: `true` for bulk operations. |
| `max_items_per_url` | Integer | Maximum reviews collected per product URL (e.g., `200` pulls up to 200 reviews per page). |

> **Tip:** Use `sort_by: "rating:desc"` to prioritize highly-rated reviews, or `"helpfulness:desc"` to focus on reviews marked as useful by other customers.

***

### Output Format

**Sample output**

```json
{
  "id": "398279849",
  "cid": null,
  "source_client": "elfcosmetics",
  "last_moderated_time": "2025-09-12T19:49:37.000+00:00",
  "last_modification_time": "2025-09-12T19:49:37.000+00:00",
  "product_id": "2188603",
  "original_product_name": "Lip Plumping Gloss",
  "author_id": "hnlwwujiz2ynl6pflxccwek06",
  "content_locale": "en_US",
  "is_featured": false,
  "inappropriate_feedback_list": [],
  "total_inappropriate_feedback_count": 0,
  "is_syndicated": true,
  "syndication_source": {
    "client_id": null,
    "logo_image_url": "https://photos-eu.bazaarvoice.com/photo/2/cGhvdG86YXR0cmlidXRpb25sb2dvMg/e2a500b6-62d1-4260-bb04-39cf2ae38c1d",
    "content_link": null,
    "name": "eyeslipsface.com"
  },
  "total_client_response_count": 0,
  "total_comment_count": 0,
  "rating": 5,
  "is_ratings_only": false,
  "is_recommended": false,
  "moderation_status": "APPROVED",
  "submission_time": "2025-09-12T17:58:55.000+00:00",
  "review_text": "I love this gloss, the minty tingling feels nice and cool. I use this for my natural ‘no makeup’ looks",
  "title": "Sparkling Rosé",
  "user_nickname": "CinnamonMarie2",
  "rating_range": 5,
  "helpfulness": null,
  "additional_fields": {},
  "campaign_id": null,
  "total_feedback_count": 0,
  "tag_dimensions": {},
  "cons": null,
  "additional_fields_order": [],
  "tag_dimensions_order": [],
  "context_data_values_order": [],
  "badges_order": [],
  "secondary_ratings": {},
  "submission_id": null,
  "comment_ids": [],
  "total_positive_feedback_count": 0,
  "videos": [],
  "pros": null,
  "secondary_ratings_order": [],
  "client_responses": [],
  "total_negative_feedback_count": 0,
  "photos": [],
  "context_data_values": {},
  "user_location": null,
  "badges": {},
  "product_recommendation_ids": [],
  "from_url": "https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"
}
```

Each scraped review returns a comprehensive record with 47+ fields covering review content, author details, moderation, feedback, and media:

#### Review Identification & Metadata

| Field | Meaning |
|---|---|
| `ID` | Unique identifier for the review |
| `Submission ID` | Secondary ID tracking the submission event |
| `CID` | Content ID used by the review platform |
| `Product ID` | Identifier of the reviewed product |
| `Campaign ID` | Marketing campaign associated with the review (if any) |
| `Source Client` | Platform or source that collected the review |

#### Content & Text

| Field | Meaning |
|---|---|
| `Review Text` | Full review body written by the customer |
| `Title` | Short headline/summary of the review |
| `Pros` | Strengths of the product highlighted by the reviewer |
| `Cons` | Weaknesses or drawbacks mentioned |
| `Submission Time` | When the review was posted |

#### Author & User Information

| Field | Meaning |
|---|---|
| `Author ID` | Unique ID of the reviewer |
| `User Nickname` | Display name of the reviewer |
| `User Location` | Geographic location of the reviewer |
| `Content Locale` | Language/locale of the review text |

#### Ratings & Recommendations

| Field | Meaning |
|---|---|
| `Rating` | Numeric rating (e.g., 1–5 stars) |
| `Rating Range` | Scale of the rating system |
| `Is Recommended` | Boolean indicating if the reviewer recommends the product |
| `Is Ratings Only` | True if review contains only a rating, no text |
| `Secondary Ratings` | Additional rating dimensions (e.g., "value for money," "fragrance strength") |

#### Feedback & Helpfulness

| Field | Meaning |
|---|---|
| `Helpfulness` | Number of users who found the review helpful |
| `Total Feedback Count` | Total feedback received (helpful + unhelpful) |
| `Total Positive Feedback Count` | Users who marked review as helpful |
| `Total Negative Feedback Count` | Users who marked review as unhelpful |
| `Inappropriate Feedback List` | Flagged issues or complaints about the review |
| `Total Inappropriate Feedback Count` | Count of inappropriate reports |

#### Moderation & Status

| Field | Meaning |
|---|---|
| `Moderation Status` | Review approval status (approved, pending, rejected) |
| `Last Moderated Time` | When moderation last updated the review |
| `Last Modification Time` | Last edit or update timestamp |
| `Is Featured` | Whether the review is highlighted/featured on the product page |

#### Media & Additional Content

| Field | Meaning |
|---|---|
| `Photos` | Customer-uploaded product photos |
| `Videos` | Customer-uploaded product videos |
| `Comment IDs` | IDs of comments/replies to this review |
| `Total Comment Count` | Count of replies or follow-up comments |

#### Company Responses

| Field | Meaning |
|---|---|
| `Client Responses` | Official Boots responses to the review |
| `Total Client Response Count` | Number of company replies |

#### Badges & Tags

| Field | Meaning |
|---|---|
| `Badges` | Visual badges (e.g., "Verified Purchase," "Top Reviewer") |
| `Tag Dimensions` | Categorization tags applied to the review |

#### Syndication & System Fields

| Field | Meaning |
|---|---|
| `Is Syndicated` | Whether review is shared across other platforms |
| `Syndication Source` | If syndicated, the original source |
| `Original Product Name` | Product name at time of review submission |
| `Additional Fields` | Extra custom fields specific to the campaign |
| `Product Recommendation IDs` | Related product suggestions from the review |
| `Context Data Values` | Contextual metadata about the reviewer or purchase |

***

### How to Use

1. **Find product URLs** — Navigate to Boots.com, select a product page, and scroll to the reviews section. Copy the full URL (including `#BVRRContainer` anchor for review section).
2. **Configure parameters:**
   - Paste product URL(s) into `urls`
   - Set `max_items_per_url` (e.g., `100` for first 100 reviews per product)
   - Choose `sort_by` method (e.g., `"rating:desc"` for top-rated reviews first)
   - Set `offset` if you want to skip earlier reviews and paginate
3. **Run the scraper** — Start the actor and monitor progress in the run log
4. **Export data** — Download results as JSON, CSV, or Excel for analysis

**Best practices:**

- Use `sort_by: "helpfulness:desc"` when analyzing opinion quality, not just popularity
- Set `offset: 0` initially, then increment to paginate through large review sets
- Enable `ignore_url_failures: true` when scraping multiple products to avoid partial run failures
- Filter results by `Moderation Status: "approved"` to focus on verified reviews

***

### Use Cases & Business Value

- **Sentiment analysis:** Aggregate reviews to understand customer satisfaction trends by product category
- **Competitor intelligence:** Monitor how competitor products are rated vs. your own offerings
- **Feature analysis:** Extract pros/cons to identify most-discussed product features
- **Quality assurance:** Identify recurring complaints to guide product development
- **Influencer insights:** Find high-engagement reviews and influential reviewers for partnership outreach
- **Content marketing:** Source authentic customer quotes and testimonials for campaigns

The Boots Reviews Scraper transforms review data into actionable insights, eliminating hours of manual collection and enabling data-driven decisions in product development, marketing, and customer service.

***

### Conclusion

The **Boots Reviews Scraper** is an essential tool for anyone leveraging customer feedback for competitive advantage. With 47+ fields capturing everything from ratings and text to photos, videos, and company responses, it provides a complete picture of customer sentiment at scale. Start collecting Boots product reviews today and unlock insights that drive smarter business decisions.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product reviews urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `sort_by` (type: `string`):

Sort Items by

## `offset` (type: `integer`):

Offset

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"
    ],
    "offset": 0,
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/boots-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 = {
    "urls": ["https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"],
    "offset": 0,
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/boots-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 '{
  "urls": [
    "https://www.boots.com/elf-lip-plumping-gloss-10256999#BVRRContainer"
  ],
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/boots-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boots Reviews Scraper",
        "description": "Collect detailed product reviews from Boots.com with ratings, customer feedback, photos, videos, and 47+ fields per review. Perfect for sentiment analysis, reputation monitoring, and e-commerce intelligence.",
        "version": "0.0",
        "x-build-id": "2VVCeyhvqIb3JSpeV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~boots-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-boots-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/stealth_mode~boots-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-boots-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/stealth_mode~boots-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-boots-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": {
                    "urls": {
                        "title": "URLs of the product reviews urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product reviews urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort_by": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "helpfulness:desc,totalpositivefeedbackcount:desc",
                            "rating:desc",
                            "rating:asc",
                            "submissiontime:desc"
                        ],
                        "type": "string",
                        "description": "Sort Items by"
                    },
                    "offset": {
                        "title": "Offset",
                        "type": "integer",
                        "description": "Offset"
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
