# Walgreens Reviews Scraper (`stealth_mode/walgreens-reviews-scraper`) Actor

Scrape product search results from Walgreens with 51+ data fields including pricing, inventory, images, ratings, and fulfillment details. Perfect for price monitoring, retail analytics, and product intelligence across thousands of SKUs.

- **URL**: https://apify.com/stealth\_mode/walgreens-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

## Walgreens Reviews Scraper: Collect Product Feedback at Scale

---

### Why Scrape Walgreens Reviews?

Walgreens is one of America's largest pharmacy and retail chains, hosting millions of customer reviews across its product catalog. Customer feedback on Walgreens.com shapes purchasing decisions and brand reputation. Manually collecting and analyzing reviews is inefficient at scale — the **Walgreens Reviews Scraper** automates the extraction, delivering structured review data with ratings, metadata, and user insights in minutes.

---

### Overview

The **Walgreens Reviews Scraper** extracts comprehensive customer reviews from Walgreens product detail pages, capturing everything from star ratings to user photos, videos, and feedback statistics. It supports:

- **Sentiment analysis:** Analyze positive/negative feedback trends
- **Brand monitoring:** Track what customers say about your products vs. competitors
- **Market research:** Extract consumer opinions for product development
- **Reputation management:** Monitor review volume, ratings, and customer responses
- **Competitive intelligence:** Understand product positioning in the Walgreens marketplace

Key features include flexible sorting (by relevance, high/low ratings), pagination via offset, retry logic for reliability, and granular control over volume.

---

### Input Format

The scraper accepts a JSON configuration object with the following parameters:

```json
{
  "urls": [
    "https://www.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"
  ],
  "sort_by": "helpfulness:desc,totalpositivefeedbackcount:desc",
  "offset": 20,
  "ignore_url_failures": true,
  "max_retries_per_url": 2,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | Product detail page URLs from Walgreens.com | `["https://www.walgreens.com/store/c/..."]` |
| `sort_by` | String | Sort reviews by: `relevancy:a1`, `rating:desc`, or `rating:asc` | `"rating:desc"` (high to low) |
| `offset` | Integer | Number of reviews to skip before scraping (pagination) | `20` |
| `ignore_url_failures` | Boolean | Continue if a URL fails to scrape | `true` |
| `max_retries_per_url` | Integer | Retry failed URLs up to N times | `2` |
| `max_items_per_url` | Integer | Maximum reviews to collect per product | `200` |

> **Tip:** Use `offset` to paginate through large review sets. E.g., offset `0` for reviews 1–200, then `200` for reviews 201–400.

***

### Output Format

**Sample output**

```json
{
  "id": "276714335",
  "cid": null,
  "source_client": "dove",
  "badges": {},
  "badges_order": [],
  "last_moderated_time": "2026-05-27T13:45:46.000+00:00",
  "last_modification_time": "2026-05-27T13:45:46.000+00:00",
  "product_id": "300469784",
  "original_product_name": "All Star Comfort Body + Face Wash",
  "campaign_id": null,
  "context_data_values_order": [],
  "author_id": "topbox_af555bca13bc67c815f4bfca03563691295cdf6c0b22c4b84e55c628cf5d612b",
  "content_locale": "en_US",
  "is_featured": false,
  "total_inappropriate_feedback_count": 0,
  "total_client_response_count": 0,
  "total_comment_count": 0,
  "rating": 5,
  "secondary_ratings_order": [],
  "is_ratings_only": false,
  "is_recommended": true,
  "total_feedback_count": 0,
  "total_negative_feedback_count": 0,
  "total_positive_feedback_count": 0,
  "moderation_status": "APPROVED",
  "submission_id": null,
  "submission_time": "2026-05-26T00:39:32.000+00:00",
  "review_text": "[This review was collected as part of a promotion.] My husband has been using this body wash for about a month now and he loves it! It smells amazing\r\n\r\nI received this product for free from top box marketing for testing and review purposes.",
  "title": "Smells Amazing!",
  "user_nickname": "Yasmin",
  "context_data_values": {},
  "secondary_ratings": {},
  "additional_fields_order": [],
  "tag_dimensions_order": [],
  "cons": null,
  "tag_dimensions": {},
  "additional_fields": {},
  "comment_ids": [],
  "inappropriate_feedback_list": [],
  "client_responses": [],
  "pros": null,
  "videos": [],
  "is_syndicated": true,
  "rating_range": 5,
  "helpfulness": null,
  "product_recommendation_ids": [],
  "user_location": null,
  "photos": [],
  "from_url": "https://www.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"
}
```

Each scraped review returns a rich record with 45+ fields covering reviews, metadata, and user data:

#### Review Core Fields

| Field | Meaning |
|---|---|
| `ID` | Unique review identifier in Walgreens system |
| `CID` | Review content ID |
| `Title` | Review headline (short summary) |
| `Review Text` | Full review body text |
| `Submission Time` | When the review was posted |
| `Submission ID` | Submission tracking ID |
| `Source Client` | Platform origin (e.g., web, mobile, syndicated) |

#### Rating & Sentiment

| Field | Meaning |
|---|---|
| `Rating` | Star rating (1–5) given by reviewer |
| `Rating Range` | Scale used for ratings |
| `Is Recommended` | Boolean: does reviewer recommend the product |
| `Is Ratings Only` | Boolean: review contains only a rating, no text |
| `Secondary Ratings` | Additional attribute ratings (e.g., value, quality) |
| `Secondary Ratings Order` | Sort order for secondary ratings |

#### Feedback Metrics

| Field | Meaning |
|---|---|
| `Total Positive Feedback Count` | Number of "helpful" votes received |
| `Total Negative Feedback Count` | Number of "not helpful" votes |
| `Total Feedback Count` | Total feedback votes (positive + negative) |
| `Total Inappropriate Feedback Count` | Flags for offensive/spam content |
| `Inappropriate Feedback List` | Details of inappropriate flags |
| `Helpfulness` | Calculated helpfulness score |

#### User & Moderation

| Field | Meaning |
|---|---|
| `Author ID` | Unique identifier for the reviewer |
| `User Nickname` | Display name of the reviewer |
| `User Location` | Geographic location of the reviewer |
| `Content Locale` | Language/region of the review |
| `Moderation Status` | Review approval status (approved, pending, rejected) |
| `Last Moderated Time` | Last moderation action timestamp |
| `Last Modification Time` | Last edit or update timestamp |

#### Engagement & Interaction

| Field | Meaning |
|---|---|
| `Total Comment Count` | User comments on this review |
| `Comment IDs` | IDs of related comments |
| `Total Client Response Count` | Responses from Walgreens or vendor |
| `Client Responses` | Full text of official responses |
| `Is Featured` | Boolean: review is highlighted/featured |
| `Is Syndicated` | Review sourced from partner platform |

#### Product & Campaign Data

| Field | Meaning |
|---|---|
| `Product ID` | The product being reviewed |
| `Original Product Name` | Full product name at review time |
| `Campaign ID` | Associated marketing campaign |
| `Product Recommendation IDs` | Related product recommendations |
| `Badges` | Trust badges (e.g., "Verified Purchase") |
| `Badges Order` | Sort order of badges |

#### Rich Media & Context

| Field | Meaning |
|---|---|
| `Photos` | URLs of user-submitted product photos |
| `Videos` | URLs of user-submitted product videos |
| `Pros` | Bulleted advantages mentioned in review |
| `Cons` | Bulleted disadvantages mentioned in review |
| `Tag Dimensions` | Custom attributes/tags (e.g., "drying", "fragrance") |
| `Tag Dimensions Order` | Sort order for tags |
| `Context Data Values` | Additional structured data |
| `Context Data Values Order` | Context data sort order |
| `Additional Fields` | Extra metadata fields |
| `Additional Fields Order` | Sort order for additional fields |

***

### How to Use

1. **Find product URLs** — Navigate to Walgreens.com, locate a product detail page, and copy the full URL.
2. **Configure sorting** — Choose how to order reviews:
   - `relevancy:a1` → Relevance (Walgreens algorithm)
   - `rating:desc` → Highest ratings first
   - `rating:asc` → Lowest ratings first
3. **Set pagination** — Use `offset` to skip reviews (e.g., `offset: 0` for first batch, `offset: 200` for second batch).
4. **Adjust volume** — Set `max_items_per_url` to the number of reviews you need per product (up to 200).
5. **Run the scraper** — Execute and monitor the run. Failed URLs are skipped if `ignore_url_failures: true`.
6. **Export data** — Download results as JSON, CSV, or Excel for analysis.

**Best practices:**

- Start with `sort_by: "helpfulness:desc"` to prioritize useful reviews.
- Use `max_retries_per_url: 2` for reliability on large runs.
- For high-volume scraping, split URLs across multiple runs to avoid timeouts.

***

### Business Applications

- **Brand health tracking:** Monitor sentiment and rating trends over time
- **Competitor analysis:** Compare customer satisfaction across product categories
- **Product development:** Extract feature feedback (Pros/Cons) to inform improvements
- **Review moderation:** Identify inappropriate or spam reviews at scale
- **Marketing intelligence:** Understand what drives positive/negative perception
- **Vendor management:** Track how competitors' products are reviewed on Walgreens

By automating review collection, you transform hours of manual work into actionable data that feeds machine learning models, dashboards, and strategic decision-making.

***

### Conclusion

The **Walgreens Reviews Scraper** delivers customer feedback at enterprise scale. With 45+ fields covering ratings, engagement, media, and user data, it enables comprehensive sentiment analysis and competitive intelligence in the retail pharmacy market. Start scraping today to unlock insights hidden in millions of customer voices.

# Actor input Schema

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

Add the URLs of the product details 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`):

Select your option to sort reviews

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

The number of items to skip before starting to scrape.

## `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.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"
  ],
  "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.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"
    ],
    "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/walgreens-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.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"],
    "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/walgreens-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.walgreens.com/store/c/dove-men-care-limited-edition-fifa-body---face-wash-all-star-comfort/ID=300469784-product"
  ],
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/walgreens-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walgreens Reviews Scraper",
        "description": "Scrape product search results from Walgreens with 51+ data fields including pricing, inventory, images, ratings, and fulfillment details. Perfect for price monitoring, retail analytics, and product intelligence across thousands of SKUs.",
        "version": "0.0",
        "x-build-id": "RaYN4EoRtP7GAmjbO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~walgreens-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-walgreens-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~walgreens-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-walgreens-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~walgreens-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-walgreens-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 details urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product details 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": [
                            "relevancy:a1",
                            "rating:desc",
                            "rating:asc"
                        ],
                        "type": "string",
                        "description": "Select your option to sort reviews"
                    },
                    "offset": {
                        "title": "Offset",
                        "type": "integer",
                        "description": "The number of items to skip before starting to scrape."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
