# Walmart Scraper — Product Prices, Reviews & Inventory (`junipr/walmart-scraper`) Actor

Scrape Walmart product listings by search query or URL. Extract prices, reviews, ratings, availability, seller info, and product specs. Support for search results and individual product pages.

- **URL**: https://apify.com/junipr/walmart-scraper.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.30 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Product Scraper

The most reliable Walmart.com scraping tool on Apify. Achieve 95%+ success rate where competitors struggle with maintenance issues and poor anti-bot handling. Extract comprehensive product data including prices, reviews, seller info, variants, specifications, and store pickup availability — all with a simple search query or product URL.

### What can it do?

- **Search scraping** — Enter any search term and get full product listings from Walmart search results
- **Direct URL scraping** — Provide product page URLs for detailed extraction
- **Category browsing** — Scrape all products from Walmart category and browse pages
- **Review extraction** — Get customer reviews with ratings, dates, and helpfulness scores
- **Variant details** — Extract all product variants (size, color, configuration) with individual prices
- **Seller information** — Identify marketplace sellers vs Walmart direct, including fulfillment type
- **Store pickup availability** — Check in-store pickup and delivery options by ZIP code or store ID
- **Price monitoring** — Track prices, savings, Rollback deals, and Walmart+ pricing

### What data can you extract from Walmart?

| Field | Description |
|-------|-------------|
| `title` | Product name |
| `productId` | Walmart product/item ID |
| `upc` | Universal Product Code |
| `brand` | Brand name |
| `price` | Current selling price |
| `originalPrice` | Pre-sale price (if discounted) |
| `savings` / `savingsPercent` | Dollar and percentage savings |
| `rating` | Average customer rating (0-5) |
| `reviewCount` | Total number of reviews |
| `category` | Full category path |
| `images` | All product image URLs |
| `variants` | Size, color, and configuration options |
| `seller` | Seller name, type (Walmart/Marketplace), fulfillment |
| `fulfillment` | Shipping speed, pickup availability, delivery dates |
| `reviews` | Individual reviews with author, rating, text, helpfulness |
| `specifications` | Technical specs (processor, RAM, dimensions, etc.) |
| `walmartPlus` | Walmart+ eligibility and benefits |
| `badges` | Best Seller, Rollback, Clearance badges |

### How to scrape Walmart products

1. Go to the [Walmart Product Scraper](https://apify.com/junipr/walmart-scraper) on Apify
2. Enter your search terms (e.g., "air fryer"), product URLs, or category URLs
3. Set your desired maximum number of products
4. Toggle optional features: reviews, variants, seller info, pickup availability
5. Click "Start" and wait for results
6. Download your data as JSON, CSV, or Excel

**Zero-config example** — just enter a search term and run:

```json
{
  "searchTerms": ["laptop"]
}
````

### Cost of scraping Walmart

This actor uses Pay-Per-Event pricing at **$1.30 per 1,000 products** ($0.0013 per product). You only pay for successfully extracted products — failed requests, 404s, and blocked pages are never charged.

Pricing includes all platform compute costs — no hidden fees.

| Products | Cost |
|----------|------|
| 100 | $0.13 |
| 1,000 | $1.30 |
| 10,000 | $13.00 |

Compared to alternatives: Bright Data Walmart collector costs $500+/month, ScrapeHero starts at $99/month. With this actor, scrape 10,000 products for just $25 with no monthly commitment.

### Proxy Requirements

This actor requires residential proxies because Walmart uses PerimeterX (HUMAN Security) bot detection that aggressively blocks datacenter IP addresses.

- **Paid Apify plan users**: Works automatically with the default residential proxy configuration.
- **Free plan users**: Provide your own residential proxy URL in the Proxy Configuration input field.
- Without a residential proxy, the actor will exit with a clear error message.

### Input and Output examples

**Input:**

```json
{
  "searchTerms": ["air fryer"],
  "maxProducts": 50,
  "includeReviews": true,
  "maxReviews": 5,
  "includeVariants": true,
  "includeSeller": true,
  "sortBy": "best_seller"
}
```

**Output (per product):**

```json
{
  "url": "https://www.walmart.com/ip/Ninja-Air-Fryer/123456789",
  "productId": "123456789",
  "title": "Ninja 4-Quart Air Fryer",
  "brand": "Ninja",
  "price": 69.99,
  "originalPrice": 89.99,
  "savings": "$20.00",
  "savingsPercent": 22,
  "inStock": true,
  "rating": 4.7,
  "reviewCount": 15234,
  "category": "Home/Kitchen/Air Fryers",
  "seller": {
    "name": "Walmart.com",
    "type": "INTERNAL",
    "isWalmartFulfilled": true
  },
  "badges": ["Best Seller", "Rollback"],
  "scrapedAt": "2026-03-11T12:00:00.000Z"
}
```

### Related scrapers by Junipr

- [Etsy Product Scraper](https://apify.com/junipr/etsy-product-scraper) — Scrape Etsy listings with prices, ratings, and shop info
- [eBay Sold Listings Scraper](https://apify.com/junipr/ebay-sold-listings) — Extract completed/sold eBay listings for market research
- [Fiverr Scraper](https://apify.com/junipr/fiverr-scraper) — Scrape Fiverr gig listings and seller data
- [Trustpilot Reviews Scraper](https://apify.com/junipr/trustpilot-reviews-scraper) — Extract customer reviews from Trustpilot

### FAQ

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

$1.30 per 1,000 products with Pay-Per-Event pricing. You only pay for successfully scraped products — no monthly fees, no minimum commitment. Failed requests and blocked pages are never charged.

#### Can I get Walmart store inventory data?

Yes. Enable the "Include Pickup Availability" option and provide either a Walmart Store ID or a ZIP code. The scraper will return pickup availability, store name, and estimated pickup dates for each product.

#### Does it work with Walmart marketplace sellers?

Yes. The scraper extracts full seller details including seller name, seller type (Walmart direct vs third-party marketplace), and whether the item is fulfilled by Walmart. Use the "Fulfillment Type" filter to narrow results to Walmart-fulfilled or marketplace-only items.

#### How do I monitor Walmart prices over time?

Schedule the actor to run daily or weekly on Apify with the same search terms. Each run saves results to a new dataset. Compare datasets over time to track price changes, identify Rollback deals, and monitor stock availability. Apify's built-in scheduling makes this easy to set up.

#### Is scraping Walmart legal?

This actor extracts publicly available product information from Walmart.com. No login or authentication is required. The data extracted does not include personally identifiable information. Users are responsible for complying with applicable laws and Walmart's terms of service in their jurisdiction.

#### Why is this better than other Walmart scrapers?

Existing Walmart scrapers on Apify have poor ratings (2-3 stars) and frequent maintenance issues. This actor uses residential proxy rotation, PerimeterX bypass strategies, and multiple data extraction methods (JSON-LD, Next.js data, DOM parsing) for 95%+ reliability. It also extracts more data points than competitors — including variants, seller info, specifications, and pickup availability.

# Actor input Schema

## `searchTerms` (type: `array`):

Search keywords to find products on Walmart (e.g. "laptop", "air fryer"). At least one of searchTerms, productUrls, or categoryUrls is required.

## `productUrls` (type: `array`):

Direct Walmart product page URLs to scrape (e.g. "https://www.walmart.com/ip/Product-Name/123456789").

## `categoryUrls` (type: `array`):

Walmart category or browse page URLs to scrape products from.

## `maxProducts` (type: `integer`):

Maximum number of products to extract per search term or category.

## `includeReviews` (type: `boolean`):

Extract customer reviews for each product.

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

Maximum number of reviews to extract per product.

## `includeVariants` (type: `boolean`):

Extract all product variant options (sizes, colors, etc.).

## `includeSeller` (type: `boolean`):

Extract marketplace seller details.

## `includePickup` (type: `boolean`):

Check in-store pickup availability. Requires storeId or zipCode.

## `storeId` (type: `string`):

Walmart store ID for pickup and local inventory checks.

## `zipCode` (type: `string`):

5-digit US ZIP code for delivery and pickup estimates.

## `sortBy` (type: `string`):

Sort order for search results.

## `minPrice` (type: `integer`):

Filter results by minimum price in USD. Leave 0 for no minimum.

## `maxPrice` (type: `integer`):

Filter results by maximum price in USD. Leave 0 for no maximum.

## `fulfillment` (type: `string`):

Filter by fulfillment method.

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

Residential proxy is recommended — Walmart uses PerimeterX which blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "searchTerms": [
    "laptop"
  ],
  "productUrls": [],
  "categoryUrls": [],
  "maxProducts": 100,
  "includeReviews": true,
  "maxReviews": 10,
  "includeVariants": true,
  "includeSeller": true,
  "includePickup": false,
  "storeId": "",
  "zipCode": "",
  "sortBy": "best_match",
  "minPrice": 0,
  "maxPrice": 0,
  "fulfillment": "all",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Walmart products with full details — prices, reviews, variants, seller info, and fulfillment.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/walmart-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("junipr/walmart-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 '{}' |
apify call junipr/walmart-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Scraper — Product Prices, Reviews & Inventory",
        "description": "Scrape Walmart product listings by search query or URL. Extract prices, reviews, ratings, availability, seller info, and product specs. Support for search results and individual product pages.",
        "version": "1.0",
        "x-build-id": "aCXoJFqFhcgOtwk2z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~walmart-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-walmart-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/junipr~walmart-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-walmart-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/junipr~walmart-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-walmart-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Search keywords to find products on Walmart (e.g. \"laptop\", \"air fryer\"). At least one of searchTerms, productUrls, or categoryUrls is required.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "laptop"
                        ]
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Walmart product page URLs to scrape (e.g. \"https://www.walmart.com/ip/Product-Name/123456789\").",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "Walmart category or browse page URLs to scrape products from.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per search term or category.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract customer reviews for each product.",
                        "default": true
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Product",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per product.",
                        "default": 10
                    },
                    "includeVariants": {
                        "title": "Include Variants",
                        "type": "boolean",
                        "description": "Extract all product variant options (sizes, colors, etc.).",
                        "default": true
                    },
                    "includeSeller": {
                        "title": "Include Seller Info",
                        "type": "boolean",
                        "description": "Extract marketplace seller details.",
                        "default": true
                    },
                    "includePickup": {
                        "title": "Include Pickup Availability",
                        "type": "boolean",
                        "description": "Check in-store pickup availability. Requires storeId or zipCode.",
                        "default": false
                    },
                    "storeId": {
                        "title": "Store ID",
                        "type": "string",
                        "description": "Walmart store ID for pickup and local inventory checks.",
                        "default": ""
                    },
                    "zipCode": {
                        "title": "ZIP Code",
                        "type": "string",
                        "description": "5-digit US ZIP code for delivery and pickup estimates.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "best_match",
                            "price_low",
                            "price_high",
                            "best_seller",
                            "rating_high",
                            "new"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "best_match"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Filter results by minimum price in USD. Leave 0 for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Filter results by maximum price in USD. Leave 0 for no maximum.",
                        "default": 0
                    },
                    "fulfillment": {
                        "title": "Fulfillment Type",
                        "enum": [
                            "all",
                            "walmart_fulfilled",
                            "marketplace",
                            "pickup",
                            "delivery"
                        ],
                        "type": "string",
                        "description": "Filter by fulfillment method.",
                        "default": "all"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended — Walmart uses PerimeterX which blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
