# Walmart Price History Tracker — Price Trends & Alerts (`junipr/walmart-price-history`) Actor

Track Walmart product price history over time. Extract current and historical prices, price drops, and deal alerts. Monitor multiple products simultaneously.

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

## Pricing

from $58.70 / 1,000 product trackeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Price History Tracker

Track Walmart product prices and price history signals with structured JSON output. This actor monitors rollbacks, clearance pricing, "was/now" indicators, discount percentages, seller breakdowns, and fulfillment options for any Walmart.com product. Track hundreds of products at once by URL, UPC barcode, item ID, or search query.

### Why Use This Actor

Existing Walmart scrapers return general product data but skip the price history signals that matter most for deal-finding, competitor research, and price monitoring. This actor specifically extracts rollback and clearance indicators, "was" prices, discount calculations, and price type labels (rollback vs clearance vs reduced vs regular). This is the pricing intelligence that tells you whether a price is genuinely discounted or just the standard price. No other Walmart actor on Apify Store provides this level of pricing detail.

### How to Use

Provide a list of product URLs, item IDs, UPC barcodes, or search queries. The actor fetches each product page using residential proxy (required for Walmart) and returns structured pricing data with history signals. Run on a schedule to track price changes over time and build your own price history database.

**Zero-config start:** The actor works immediately with default inputs (a sample product URL). Just click "Start" to see the output format.

### Input Configuration

- **Product URLs** — Direct Walmart.com product page URLs for specific products
- **Item IDs** — Numeric Walmart item IDs (found in the product URL path)
- **UPC Barcodes** — UPC codes to look up matching Walmart products
- **Search Queries** — Product search terms returning top N results per query
- **Price History** — Toggle rollback/clearance/was-price signal extraction
- **Seller Breakdown** — Include third-party marketplace seller prices alongside Walmart's price
- **Variants** — Optionally include all size/color variants with individual pricing
- **In-Stock Check** — Report availability status and fulfillment options (shipping, pickup, delivery)

### Output Format

Each product result includes a `pricing` object with current and original prices plus discount calculations, a `priceHistory` object with boolean flags for rollback, clearance, reduced, and special buy status, an `availability` object with stock status and fulfillment methods, and a `sellers` array listing all sellers sorted by price. The `priceType` field labels each price as `regular`, `rollback`, `clearance`, `reduced`, or `special_buy` so you can programmatically filter for deals.

```json
{
  "itemId": "1752657021",
  "title": "Apple AirPods Pro (2nd Generation)",
  "pricing": {
    "currentPrice": 189.99,
    "originalPrice": 249.00,
    "discountPercent": 24,
    "priceType": "rollback"
  },
  "priceHistory": {
    "wasPrice": 249.00,
    "isRollback": true,
    "isClearance": false
  },
  "availability": {
    "inStock": true,
    "stockStatus": "in_stock",
    "fulfillmentOptions": {
      "shipping": true,
      "freeShipping": true,
      "pickup": true
    }
  }
}
````

### Tips and Advanced Usage

Use `includeVariants: true` to track how sizes and colors affect pricing — useful for apparel and electronics. Run the actor on a daily schedule and compare datasets to detect price drops, rollback starts, and clearance events. Set `checkInStock: true` to identify high-demand out-of-stock items. Use `searchQueries` to find all products in a category and compare competitor prices. Combine with the [Walmart Product Scraper](https://apify.com/junipr/walmart-scraper) for full product details alongside pricing intelligence.

### Proxy Requirements

Walmart uses PerimeterX bot detection and blocks datacenter IP addresses. This actor requires residential proxies, which are included with paid Apify subscription plans. Free-plan users must provide their own residential proxy URL in the Proxy Configuration input field. Without residential proxy, the actor will exit with an actionable error message explaining the requirement.

### Pricing

This actor uses Pay-Per-Event (PPE) pricing: **$58.70 per 1,000 products tracked** ($0.0587 per event).

Pricing includes all platform compute costs — no hidden fees.

### Related Actors

- [Walmart Product Scraper](https://apify.com/junipr/walmart-scraper) — Full product data extraction including reviews, specs, and images
- [eBay Sold Listings Scraper](https://apify.com/junipr/ebay-sold-listings) — Track completed sale prices on eBay
- [Amazon Reviews Scraper](https://apify.com/junipr/amazon-reviews-scraper) — Extract Amazon product reviews for competitive analysis

#### Why does it need residential proxies?

Walmart uses PerimeterX, an aggressive bot detection system that fingerprints requests and blocks datacenter IP ranges. Residential proxies rotate through real consumer IP addresses that PerimeterX allows through. Without residential proxy, every request gets a CAPTCHA challenge page instead of product data.

#### How do I detect when a product's price dropped?

Run the actor on a daily schedule with the same product URLs. Compare the `pricing.currentPrice` field across runs. When the price decreases, the `priceHistory.wasPrice` field often shows the previous price, and `pricing.discountPercent` shows the savings percentage.

#### What's the difference between rollback and clearance?

Rollback is a temporary promotional price reduction — Walmart intends to return the item to regular price later. Clearance is permanent inventory reduction pricing — the item is being discontinued or phased out. The `pricing.priceType` field distinguishes these: `rollback` vs `clearance`.

#### Can I track prices for all variants (sizes/colors)?

Yes. Set `includeVariants: true` in the input. The `variants` array in each result will list every size, color, or configuration option with its individual price and stock status.

#### Does it work for third-party sellers on Walmart Marketplace?

Yes. When `includeSellerBreakdown` is enabled, the `sellers` array includes all marketplace sellers with their prices, sorted from lowest to highest. The `isWalmart` field indicates whether Walmart itself is selling or a third-party seller.

#### How do I set up daily price monitoring?

In the Apify Console, click "Schedule" on the actor page. Set the frequency to daily and configure your input with the product URLs you want to track. Each run creates a new dataset that you can export or connect to via the Apify API.

#### Does it track prices in different geographic regions?

This actor targets Walmart.com (US) only. Walmart.ca (Canada) URLs are rejected with an `UNSUPPORTED_REGION` error. Pricing may vary by zip code within the US, and the actor uses a default location for consistency.

#### What's the "priceType" field?

The `priceType` field categorizes the current price status: `regular` (standard price, no promotion), `rollback` (temporary promotional reduction), `clearance` (permanent markdown for inventory reduction), `reduced` (generic price markdown), or `special_buy` (limited-time special purchase promotion).

# Actor input Schema

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

Walmart.com product page URLs (e.g. "https://www.walmart.com/ip/Product-Name/123456789"). Full URLs including domain.

## `itemIds` (type: `array`):

Walmart item IDs (numeric, from product URL path). Example: "1752657021".

## `upcs` (type: `array`):

UPC barcodes to look up on Walmart. The actor will search Walmart for matching products.

## `searchQueries` (type: `array`):

Product search terms. Returns top N results per query with pricing data.

## `maxResultsPerSearch` (type: `integer`):

Maximum number of products to return per search query.

## `searchSortBy` (type: `string`):

How to sort search results.

## `searchCategory` (type: `string`):

Walmart category ID to scope search. Leave empty for all categories.

## `extractPriceHistory` (type: `boolean`):

Extract historical price signals from product page (was/now, rollback, clearance indicators).

## `includeSellerBreakdown` (type: `boolean`):

Include third-party seller prices in addition to Walmart's own price.

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

Include all product variants (sizes, colors) with their individual prices. Multiplies result count.

## `checkInStock` (type: `boolean`):

Check and report in-stock status and fulfillment options (pickup, delivery, shipping).

## `includeDescription` (type: `boolean`):

Include full product description text. Adds bulk to output.

## `includeImages` (type: `boolean`):

Include product image URLs in output.

## `includeReviewSummary` (type: `boolean`):

Include rating, review count, and top review summary.

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

Residential proxy required — Walmart 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
{
  "productUrls": [
    "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/1752657021"
  ],
  "itemIds": [],
  "upcs": [],
  "searchQueries": [],
  "maxResultsPerSearch": 1,
  "searchSortBy": "best_match",
  "searchCategory": "",
  "extractPriceHistory": false,
  "includeSellerBreakdown": false,
  "includeVariants": false,
  "checkInStock": false,
  "includeDescription": false,
  "includeImages": false,
  "includeReviewSummary": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Walmart products with full pricing intelligence — current/original prices, rollback/clearance flags, seller breakdown, and availability.

# 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-price-history").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-price-history").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-price-history --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Price History Tracker — Price Trends & Alerts",
        "description": "Track Walmart product price history over time. Extract current and historical prices, price drops, and deal alerts. Monitor multiple products simultaneously.",
        "version": "1.0",
        "x-build-id": "xqnDZ5ANJcAYTBxpy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~walmart-price-history/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-walmart-price-history",
                "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-price-history/runs": {
            "post": {
                "operationId": "runs-sync-junipr-walmart-price-history",
                "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-price-history/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-walmart-price-history",
                "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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Walmart.com product page URLs (e.g. \"https://www.walmart.com/ip/Product-Name/123456789\"). Full URLs including domain.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/1752657021"
                        ]
                    },
                    "itemIds": {
                        "title": "Item IDs",
                        "type": "array",
                        "description": "Walmart item IDs (numeric, from product URL path). Example: \"1752657021\".",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "upcs": {
                        "title": "UPC Barcodes",
                        "type": "array",
                        "description": "UPC barcodes to look up on Walmart. The actor will search Walmart for matching products.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Product search terms. Returns top N results per query with pricing data.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResultsPerSearch": {
                        "title": "Max Results Per Search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of products to return per search query.",
                        "default": 1
                    },
                    "searchSortBy": {
                        "title": "Search Sort Order",
                        "enum": [
                            "best_match",
                            "price_asc",
                            "price_desc",
                            "rating"
                        ],
                        "type": "string",
                        "description": "How to sort search results.",
                        "default": "best_match"
                    },
                    "searchCategory": {
                        "title": "Search Category",
                        "type": "string",
                        "description": "Walmart category ID to scope search. Leave empty for all categories.",
                        "default": ""
                    },
                    "extractPriceHistory": {
                        "title": "Extract Price History",
                        "type": "boolean",
                        "description": "Extract historical price signals from product page (was/now, rollback, clearance indicators).",
                        "default": false
                    },
                    "includeSellerBreakdown": {
                        "title": "Include Seller Breakdown",
                        "type": "boolean",
                        "description": "Include third-party seller prices in addition to Walmart's own price.",
                        "default": false
                    },
                    "includeVariants": {
                        "title": "Include Variants",
                        "type": "boolean",
                        "description": "Include all product variants (sizes, colors) with their individual prices. Multiplies result count.",
                        "default": false
                    },
                    "checkInStock": {
                        "title": "Check In-Stock Status",
                        "type": "boolean",
                        "description": "Check and report in-stock status and fulfillment options (pickup, delivery, shipping).",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include Description",
                        "type": "boolean",
                        "description": "Include full product description text. Adds bulk to output.",
                        "default": false
                    },
                    "includeImages": {
                        "title": "Include Images",
                        "type": "boolean",
                        "description": "Include product image URLs in output.",
                        "default": false
                    },
                    "includeReviewSummary": {
                        "title": "Include Review Summary",
                        "type": "boolean",
                        "description": "Include rating, review count, and top review summary.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy required — Walmart 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```