# Walmart Reviews Scraper (`jdtpnjtp/walmart-reviews-scraper`) Actor

Scrape Walmart product reviews by product ID or URL. Extract reviewer name, star rating, review title, text, date, helpful votes, and verified purchase status. Sort, filter by stars, and paginate at scale. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/walmart-reviews-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 reviews

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

## Walmart Reviews Scraper

**Scrape Walmart product reviews from $0.60 / 1,000 results, and pull thousands of reviews per product in one run.** Get reviewer name, star rating, review title, text, date, helpful votes and verified-purchase status as clean rows ready for CSV, Excel, JSON or the API. No HTML parsing, no maintenance - you pay only per review returned.

---

### Why this Actor?

| Capability | Data Forge Walmart Reviews Scraper | Other review scrapers |
|---|---|---|
| Star-rating filter (1-5) | **Yes - isolate any single 1 to 5 star tier** | No filter, mixed dump |
| Verified-purchase-only filter | **Yes - keep confirmed buyers only** | Not available |
| Sort control | **5 modes: newest first, oldest first, highest rating, lowest rating, most relevant** | Unsorted dump |
| Fields per review row | **9 fields: text, date, verified flag, rating, title, author, helpful votes, negative votes, review ID** | Rating and text only |
| Depth per product | **Up to 1,000 reviews, paginated 20 per page** | No depth control |
| Pricing model | **Pay per review returned, $0.60 / 1,000** | Per-run or subscription pricing |

### What does the Walmart Reviews Scraper do?

The Walmart Reviews Scraper turns any product on Walmart.com into a structured review dataset. Feed it one or more Walmart product IDs (catalog id or numeric item id) or product URLs, and it returns each review as a flat row: who wrote it, the star rating, the review headline and body, the date, how many shoppers found it helpful, and whether it was a Verified Purchase. Sort by newest, oldest, rating or relevance, narrow to a single star rating, keep only verified buyers, and paginate to thousands of reviews per product. The first paragraph says it best - this is the fast, low-cost way to pull Walmart reviews at scale without touching a browser.

### What data can you get from a Walmart review?

Each review row carries the fields buyers ask for:

- 👤 **Author** - the reviewer's display name
- ⭐ **Rating** - star rating from 1 to 5
- 📛 **Title** - the review headline
- 📝 **Text** - the written review body
- 📅 **Date** - when the review was submitted
- ✅ **Verified purchase** - true when the reviewer is a confirmed buyer
- 👍 **Helpful count** - how many shoppers marked it helpful
- 👎 **Negative feedback** - how many marked it unhelpful
- 🆔 **Review ID** - a stable identifier for deduping

The complete raw review object is also attached under `data`, so no field is ever lost.

### Input modes

Five ready-to-run recipes. Each maps 1:1 to a published example task - swap in your own Walmart product IDs and press Start. Every mode below stays at 100 reviews, so a full test run costs about $0.06.

#### 1. Build a sentiment dataset

Data teams: pull a broad review sample for one product to train or score a sentiment model.

```json
{
  "productIds": ["18533160127"],
  "maxReviewsPerProduct": 100
}
````

#### 2. Mine 1-star complaints

Product and CX teams: isolate the angriest reviews to surface defects, sizing issues and return drivers.

```json
{
  "productIds": ["18533160127"],
  "rating": "1",
  "maxReviewsPerProduct": 100
}
```

#### 3. Keep verified buyers only

Researchers: drop unverified noise and keep only reviews carrying the Verified Purchase badge.

```json
{
  "productIds": ["18533160127"],
  "verifiedOnly": true,
  "maxReviewsPerProduct": 100
}
```

#### 4. Monitor newest reviews first

Brand monitoring: pull the freshest reviews first to catch new complaints the day they land.

```json
{
  "productIds": ["18533160127"],
  "sort": "submission-desc",
  "maxReviewsPerProduct": 100
}
```

#### 5. Collect 5-star social proof

Marketing: gather top-rated reviews for landing pages, ads and social-proof widgets.

```json
{
  "productIds": ["18533160127"],
  "rating": "5",
  "maxReviewsPerProduct": 100
}
```

### How to scrape Walmart reviews

1. Open the Walmart Reviews Scraper and click **Try for free**. The input form is prefilled with a working example product, so a first run returns real reviews with zero setup.
2. In **Products**, paste one or more product IDs (`19075520026`) or product/reviews URLs. Mix both freely.
3. Pick a **Sort order** - newest, oldest, highest rating, lowest rating or most relevant - and optionally set a **Star rating filter** to keep only 1 to 5 star reviews.
4. Set **Max reviews per product** to control depth and cost, and toggle **Verified purchases only** when you want confirmed buyers.
5. Click **Start**, then export the results to CSV, Excel, JSON or the API.

#### Input example

```json
{
  "productIds": ["19075520026", "https://www.walmart.com/ip/967557625"],
  "sort": "submission-desc",
  "maxReviewsPerProduct": 500,
  "rating": "5",
  "verifiedOnly": true
}
```

#### Output example

```json
{
  "query": "19075520026",
  "row_type": "review",
  "review_id": "a1b2c3d4e5f6",
  "author": "Jamie R.",
  "rating": 5,
  "title": "Works great, crisps fast",
  "text": "Crispy results, heats fast, and cleanup takes a minute. Best kitchen buy this year.",
  "date": "2026-05-22",
  "verified_purchase": true,
  "helpful_count": 47,
  "negative_feedback": 2,
  "data": { "...": "complete review object" }
}
```

Each run also writes a summary record to the `OUTPUT` key with the review count, error count and estimated cost. Error rows carry an `error_code` and are free - you pay only for real reviews.

### How much does it cost to scrape Walmart reviews?

Reviews are billed at **$0.60 per 1,000 results** ($0.0006 each). The math is simple:

- **$5** in free Apify trial credits = roughly **8,300 reviews** ($5 / $0.0006)
- **1,000 reviews** = **$0.60**
- **8,300 reviews** = **$5.00**
- **10,000 reviews** = **$6.00**

You are charged only for review rows actually returned. Errors and empty results cost nothing, so a misconfigured run never burns your budget. Live per-event pricing is shown on this actor's Apify Store page.

### What can you use Walmart reviews for?

- **Sentiment analysis** - track how shoppers feel about a product over time.
- **Product feedback mining** - surface defects, sizing issues and feature requests at scale.
- **Competitor CX intelligence** - read how rival products handle complaints and returns.
- **Quality monitoring** - watch ratings and themes shift right after a restock or relaunch.
- **Review summarization** - feed reviews into an LLM to auto-tag issues and route them to teams.
- **Assortment and merchandising** - compare review volume and scores across a category.
- **Brand monitoring** - get a heads-up when negative reviews spike on your listing.
- **Churn and returns research** - read 1 and 2 star reviews to learn why buyers send items back.
- **Pre-purchase research** - benchmark a product against substitutes before you stock it.

### Is it legal to scrape Walmart?

Scraping publicly available data, including public product reviews on Walmart.com, is broadly legal in the US and EU and has been upheld in cases such as hiQ v. LinkedIn. This actor collects only public review data that any visitor can see, never private accounts or hidden content. You are responsible for using the output in line with Walmart's terms, GDPR/CCPA and your local laws - for compliance-sensitive projects, consult your legal team.

### Related actors

Part of the **Data Forge** fleet:

- **[Walmart Product Scraper](https://apify.com/jdtpnjtp/walmart-product-scraper)** - pull rich product data: title, brand, price, rollback flag, rating, specs, images and seller.
- **[Walmart Intelligence Scraper](https://apify.com/jdtpnjtp/walmart-intelligence-scraper)** - the umbrella actor for product search, category, bestsellers, deals, product detail and reviews in one place.
- **[Amazon Reviews Scraper](https://apify.com/jdtpnjtp/amazon-reviews)** - the same review workflow for Amazon: rating, title, text, date and verified-purchase per row.

Need TripAdvisor, Booking, Google Maps or Google Play data too? The broader Data Forge fleet covers those.

### FAQ

**How many reviews can I pull per product?**
Up to 1,000 per product via pagination - set **Max reviews per product** to control depth, and run many products in a single job.

**Which products are supported?**
Any product on Walmart.com that has public reviews. Pass a catalog id, a numeric item id, or a product/reviews URL - the input is normalized for you.

**Is it legal to scrape Walmart reviews?**
Public product reviews are public data, and scraping public data is broadly legal in the US and EU, as upheld in hiQ v. LinkedIn. This actor reads only reviews any visitor can see, never private accounts. See the legality section above for the full note, and confirm your specific use with your legal team.

**How fresh are the reviews?**
Every run pulls reviews live from Walmart.com with no cached middle layer, so a scheduled daily run always reflects the current review set. Use the Newest first sort (`submission-desc`) to surface reviews posted since your last run.

**What if a product has only a few reviews?**
You get exactly what the product has - if there are 12 public reviews, you receive 12 rows and pay for 12. **Max reviews per product** is a ceiling, not a target. If a product or filter set returns no reviews at all, the run pushes a free `NO_REVIEWS` row and you are charged nothing.

**Can I schedule this to monitor reviews over time?**
Yes. Every Data Forge actor ships an Apify scheduler and webhooks. Run it daily or hourly with sort `submission-desc`, then pipe new rows into your warehouse, a Google Sheet or a Slack alert to catch negative reviews as they land.

**Can I call this from the API or an integration?**
Yes. Each Apify actor ships a REST API, scheduler, webhooks and an MCP server, so you can run the Walmart Reviews Scraper from your own code, Make, Zapier or an AI agent.

**Can I filter by star rating or verified buyers?**
Yes. Set the **Star rating filter** to keep only 1 to 5 star reviews, toggle **Verified purchases only**, and **Sort** by newest, oldest, rating or relevance.

**Do I pay for failed runs?**
No. Error and empty rows are free - you are billed only for real review results.

### Support

I personally support customers directly - reach out on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Walmart products to pull reviews for. Each item can be a product ID (catalog id or numeric item id) or a product/reviews URL.

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

Upper bound on reviews pulled per product (paginated, 20 per page). Each review is one paid result.

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

Order reviews are pulled in.

## `rating` (type: `string`):

Keep only reviews with this star rating (1-5).

## `verifiedOnly` (type: `boolean`):

Keep only reviews carrying the Verified Purchase badge.

## Actor input object example

```json
{
  "productIds": [
    "19075520026"
  ],
  "maxReviewsPerProduct": 40,
  "sort": "relevancy",
  "rating": "",
  "verifiedOnly": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; one flat row per review, full payload under data.

## `summary` (type: `string`):

OUTPUT key: reviews, products, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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 = {
    "productIds": [
        "19075520026"
    ],
    "maxReviewsPerProduct": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/walmart-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 = {
    "productIds": ["19075520026"],
    "maxReviewsPerProduct": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/walmart-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 '{
  "productIds": [
    "19075520026"
  ],
  "maxReviewsPerProduct": 40
}' |
apify call jdtpnjtp/walmart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Reviews Scraper",
        "description": "Scrape Walmart product reviews by product ID or URL. Extract reviewer name, star rating, review title, text, date, helpful votes, and verified purchase status. Sort, filter by stars, and paginate at scale. Pay per result.",
        "version": "1.0",
        "x-build-id": "daHB6PMozU0b4lZU6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~walmart-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-walmart-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/jdtpnjtp~walmart-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-walmart-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/jdtpnjtp~walmart-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-walmart-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": {
                    "productIds": {
                        "title": "Products",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Walmart products to pull reviews for. Each item can be a product ID (catalog id or numeric item id) or a product/reviews URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on reviews pulled per product (paginated, 20 per page). Each review is one paid result.",
                        "default": 40
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevancy",
                            "submission-desc",
                            "submission-asc",
                            "rating-desc",
                            "rating-asc"
                        ],
                        "type": "string",
                        "description": "Order reviews are pulled in.",
                        "default": "relevancy"
                    },
                    "rating": {
                        "title": "Star rating filter",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Keep only reviews with this star rating (1-5).",
                        "default": ""
                    },
                    "verifiedOnly": {
                        "title": "Verified purchases only",
                        "type": "boolean",
                        "description": "Keep only reviews carrying the Verified Purchase badge.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
