# Amazon Search Scraper ✨ (`premiumscraper/amazon-search-scraper`) Actor

Amazon Search Scraper extracts product listings including ASIN, title, URL, image, price, discount percent, rating, reviews count, stock info, delivery details, coupon, badge, sponsored status, and prime eligibility ✨ Amazon Search Scraper 🔍

- **URL**: https://apify.com/premiumscraper/amazon-search-scraper.md
- **Developed by:** [Premium Scraper](https://apify.com/premiumscraper) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## 🔍 Amazon Search Scraper

Welcome to the official documentation for the **Amazon Search Scraper**! The **Amazon Search Scraper** is a high-performance, low-latency, and high-resiliency cloud-based data extraction tool designed to gather structured e-commerce datasets from Amazon.

Whether you need to monitor competitors, analyze e-commerce pricing trends, track product reviews, or build an independent e-commerce catalog, the **Amazon Search Scraper** provides a production-grade interface that delivers highly accurate listings directly to your dataset.

---

### 🚀 Why the Amazon Search Scraper is the Best

Many scraper actors get blocked within a few requests or deliver low-quality, duplicated data. The **Amazon Search Scraper** is engineered from the ground up to solve these issues:

1. **Misspelling & Autocorrection Intelligence 🔎**
   If you supply a misspelled keyword, the **Amazon Search Scraper** query system automatically scans Amazon's autocomplete suggestions, identifies the correct term, and routes directly to the corrected query—ensuring the **Amazon Search Scraper** never delivers empty datasets due to typos.
2. **Sponsored Products Filtering Button 🏷️**
   You get complete control! With the **Amazon Search Scraper**, you can choose to skip or include sponsored ad results with a simple toggle, saving you money on unwanted entries in your **Amazon Search Scraper** dataset.
3. **Pay-Per-Event (PPE) Billing Ready 💸**
   The **Amazon Search Scraper** utilizes Apify's modern Pay-Per-Event billing, allowing you to only pay for successfully extracted unique products, protected by a maximum cost safety limit.

---

### ⚠️ Important: The 300–350 Products Limit Explained for Amazon Search Scraper

When running the **Amazon Search Scraper**, you might configure the max products per keyword to `500` or more. However, it is **perfectly normal** to see only **300 to 350 unique products** returned. 

Here is why:
* **Duplicate Removal:** Amazon search listings naturally repeat products across pages. The **Amazon Search Scraper** keeps a strict memory cache of all seen ASINs. This means the **Amazon Search Scraper** filters out duplicates so you only get **unique products** in your dataset.
* **Amazon's Natural Listing Limit:** Amazon rarely lists more than 300-350 unique items for a keyword search on their live pages.
* **Auto-Stopping:** If the **Amazon Search Scraper** encounters 5 consecutive pages with 0 new unique products, the **Amazon Search Scraper** engine automatically stops pagination to save you proxy bandwidth and Pay-Per-Event billing costs.

---

### 📦 Detailed Data Fields Extracted by Amazon Search Scraper

For every product found, the **Amazon Search Scraper** extracts a comprehensive set of **26 attributes**, parsing raw HTML cards into clean JSON records. Here is a detailed breakdown of the exact fields the **Amazon Search Scraper** outputs:

#### 🆔 Identification & URL Fields
* **`asin` (string):** The unique 10-character Amazon Standard Identification Number.
* **`title` (string):** The full name/title of the product.
* **`product_url` (string):** Clean URL pointing to the product detail page, with all tracking parameters removed.
* **`image_url` (string):** High-quality product main image link.
* **`search_keyword` (string):** The exact keyword query used by the **Amazon Search Scraper** to locate this product.
* **`serial_number` (integer):** The incremental index indicating the collection sequence order in the **Amazon Search Scraper** run.

#### 💵 Pricing & Discount Fields
* **`price` (string):** The current listing price formatted as a string containing the currency symbol (e.g. `$599.00`).
* **`price_num` (float):** The parsed numeric float value of the current price (e.g., `599.00`). Handy for sorting and price analysis.
* **`list_price` (string):** The original retail price / strike-through list price of the product if on discount.
* **`list_price_num` (float):** The parsed numeric float value of the list price.
* **`discount` (string):** Raw display text of the savings percentage (e.g., `15% off`).
* **`discount_percent` (integer):** The clean numeric percentage value of the discount. Calculated automatically by the **Amazon Search Scraper** if original price is present.
* **`discount_amount` (float):** The exact dollar amount saved (original price minus current price).
* **`coupon` (string):** Extracted discount coupon text when available (e.g., `Save 5%`).
* **`deal_type` (string):** Special promotional tags (e.g. `Limited time deal`, `Deal of the day`).

#### ⭐ Ratings & Customer Review Fields
* **`rating` (string):** Full text representing user feedback (e.g., `4.8 out of 5 stars`).
* **`rating_num` (float):** Clean decimal representation of the user rating.
* **`reviews_count` (string):** Total display count of customer ratings.
* **`reviews_count_num` (integer):** Clean parsed integer representation of the reviews count.

#### 🚚 Delivery & Badge Fields
* **`delivery` (string):** Full delivery info containing dates, shipping rates, and stock status.
* **`free_delivery_eligible` (boolean):** Set to `true` by the **Amazon Search Scraper** if the product is eligible for free shipping/delivery.
* **`fastest_delivery_date` (string):** Extracted date text indicating the fastest possible delivery date.
* **`is_prime` (boolean):** `true` if the item is eligible for Prime shipping.
* **`badge` (string):** Highlight badges (e.g. `Best Seller`, `Amazon's Choice`).
* **`is_best_seller` (boolean):** `true` if the product is a designated Best Seller.
* **`is_amazons_choice` (boolean):** `true` if the product is designated as Amazon's Choice.

#### 🛑 Stock & Availability Fields
* **`stock_info` (string):** Stock availability details (e.g. `Only 2 left in stock`).
* **`currently_unavailable` (boolean):** `true` if the product is out of stock / currently unavailable.
* **`has_buying_choices` (boolean):** `true` if the product has multiple seller offers / buying choices.
* **`is_sponsored` (boolean):** Indicates if the product listing is a sponsored ad. By default, the **Amazon Search Scraper** skips sponsored items unless configured otherwise.

---

### 📈 Business Use Cases for Amazon Search Scraper

Here is how you can leverage data gathered by the **Amazon Search Scraper** for commercial success:

* **Competitor Product Monitoring:** Run the **Amazon Search Scraper** regularly to track when your competitors launch new products, change product descriptions, or update titles.
* **Pricing & Discount Optimizations:** Utilize the price attributes inside **Amazon Search Scraper** output to adjust your retail strategy, identifying discount patterns and coupon distribution.
* **Market Intelligence & Trend Analysis:** Feed **Amazon Search Scraper** data into your analytics dashboards to find out which categories have the highest ratings and most reviews.
* **Brand Image & Review Checks:** Use **Amazon Search Scraper** to monitor ratings of your products, catching bad reviews or stock shortages instantly.

---

### 📋 JSON Output Sample from Amazon Search Scraper

Here is a sample JSON product object exported by the **Amazon Search Scraper**:

```json
{
    "asin": "B0FRGTYSL5",
    "title": "PlayStation®5 console – 1TB",
    "product_url": "https://www.amazon.com/PlayStation%C2%AE5-console-1TB-PlayStation-5/dp/B0FRGTYSL5",
    "image_url": "https://m.media-amazon.com/images/I/51tSjJJl82L._AC_UY218_.jpg",
    "rating": "4.7 out of 5 stars",
    "reviews_count": "1325",
    "bought_past_month": "6K+ bought in past month",
    "delivery": "FREE delivery Thu, Jul 16 Or fastest delivery Tomorrow, Jul 12",
    "is_sponsored": false,
    "is_prime": true,
    "currently_unavailable": false,
    "has_buying_choices": false,
    "price": "$499.00",
    "price_num": 499.00,
    "rating_num": 4.7,
    "reviews_count_num": 1325,
    "free_delivery_eligible": true,
    "fastest_delivery_date": "Tomorrow, Jul 12",
    "search_keyword": "ps5",
    "serial_number": 1
}
````

***

### 🛠️ How to Run the Amazon Search Scraper

Using the **Amazon Search Scraper** on the Apify Platform is simple:

1. Open the **Amazon Search Scraper** input console page.
2. Provide a list of search keywords to the **Amazon Search Scraper** configuration (e.g. `["ps5", "wireless controller"]`).
3. Set your target max products per keyword inside the **Amazon Search Scraper** configuration settings.
4. Choose whether to turn on the **Include Sponsored Products** checkbox on the **Amazon Search Scraper** dashboard.
5. Select your residential proxy country exit node for **Amazon Search Scraper** requests.
6. Click **Start** to run the **Amazon Search Scraper** execution.

#### Example Input Configuration:

```json
{
    "keywords": ["ps5", "xbox series x"],
    "max_products_per_keyword": 100,
    "includeSponsored": false,
    "proxyCountry": "US"
}
```

***

### 💸 Pay-Per-Event Billing & Budget Limits

With the **Amazon Search Scraper**, you are in control of your budget. The **Amazon Search Scraper** will automatically halt execution once your maximum cost per run is reached. Your dataset remains preserved up to the exact point of the stop. The **Amazon Search Scraper** only logs successful PPE confirmation hits, ensuring transparency.

***

### ⚙️ Advanced Tips for Amazon Search Scraper

Here are a few advanced tips to optimize your **Amazon Search Scraper** usage:

- **Regional Targeting:** Set the `proxyCountry` dropdown inside **Amazon Search Scraper** settings to match the regional search listings of your target demographic (e.g. `GB` for the United Kingdom).
- **Automated Scheduling:** Schedule the **Amazon Search Scraper** to run daily or weekly on the Apify console to construct historical pricing charts.
- **Integrate with Webhooks:** Connect **Amazon Search Scraper** dataset events to trigger Slack notifications or database inserts as soon as a run completes.

Use the **Amazon Search Scraper** today to get the most reliable, clean, and unique Amazon data!

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search on Amazon (e.g. \['ps5', 'xbox series x']).

## `max_products_per_keyword` (type: `integer`):

The maximum number of products to collect for each search keyword.

## `includeSponsored` (type: `boolean`):

If checked, sponsored (ad) products will be included in the output. By default, sponsored products are skipped.

## `proxyCountry` (type: `string`):

Choose the residential proxy exit country for Amazon requests. US is recommended.

## Actor input object example

```json
{
  "keywords": [
    "ps5"
  ],
  "max_products_per_keyword": 50,
  "includeSponsored": false,
  "proxyCountry": "US"
}
```

# 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 = {
    "keywords": [
        "ps5"
    ],
    "proxyCountry": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("premiumscraper/amazon-search-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 = {
    "keywords": ["ps5"],
    "proxyCountry": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("premiumscraper/amazon-search-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 '{
  "keywords": [
    "ps5"
  ],
  "proxyCountry": "US"
}' |
apify call premiumscraper/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Scraper ✨",
        "description": "Amazon Search Scraper extracts product listings including ASIN, title, URL, image, price, discount percent, rating, reviews count, stock info, delivery details, coupon, badge, sponsored status, and prime eligibility ✨ Amazon Search Scraper 🔍",
        "version": "1.0",
        "x-build-id": "sIOEIKdeykLrzRekr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/premiumscraper~amazon-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-premiumscraper-amazon-search-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/premiumscraper~amazon-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-premiumscraper-amazon-search-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/premiumscraper~amazon-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-premiumscraper-amazon-search-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔑 Search Keywords",
                        "type": "array",
                        "description": "List of keywords to search on Amazon (e.g. ['ps5', 'xbox series x']).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_products_per_keyword": {
                        "title": "📦 Max Products per Keyword",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of products to collect for each search keyword.",
                        "default": 50
                    },
                    "includeSponsored": {
                        "title": "🏷️ Include Sponsored Products",
                        "type": "boolean",
                        "description": "If checked, sponsored (ad) products will be included in the output. By default, sponsored products are skipped.",
                        "default": false
                    },
                    "proxyCountry": {
                        "title": "🌐 Proxy Country",
                        "enum": [
                            "US",
                            "GB",
                            "AU",
                            "CA",
                            "DE",
                            "FR",
                            "NL",
                            "IT",
                            "ES",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "BE",
                            "AT",
                            "CH",
                            "IE",
                            "PL",
                            "PT",
                            "CZ",
                            "HU",
                            "RO",
                            "GR",
                            "JP",
                            "KR",
                            "SG",
                            "IN",
                            "BR",
                            "MX",
                            "AR",
                            "TR"
                        ],
                        "type": "string",
                        "description": "Choose the residential proxy exit country for Amazon requests. US is recommended.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
