# Newegg Products Scraper (`fetch_cat/newegg-products-scraper`) Actor

Scrape Newegg search and category listings for product prices, ratings, reviews, sellers, stock text, promos, images, and URLs.

- **URL**: https://apify.com/fetch\_cat/newegg-products-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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

## Newegg Products Scraper

Extract structured product data from public Newegg search and category listing pages. Use it to monitor PC hardware prices, compare sellers, track stock signals, collect ratings, or build ecommerce intelligence feeds.

### Who is it for

- Ecommerce teams comparing Newegg pricing against other marketplaces
- Resellers and PC builders tracking component prices and availability
- Marketplace analysts watching ratings, review volume, and seller offers
- Data teams that need repeatable JSON, CSV, or Excel exports from Newegg listings

### What you can scrape

- Product titles and Newegg product URLs
- Item numbers / model hints
- Current and original price text
- Numeric price when visible
- Ratings and review counts
- Seller, shipper, availability, and promotion text
- Product images
- Category/breadcrumb context when available
- Optional product-page specification rows

### Input recipes

#### Search Newegg by keyword

```json
{
  "searchQueries": ["rtx 4070", "gaming laptop"],
  "maxItems": 50,
  "pageLimit": 2,
  "sort": "featured"
}
````

#### Scrape a specific Newegg listing URL

```json
{
  "startUrls": [
    { "url": "https://www.newegg.com/p/pl?d=mechanical+keyboard" }
  ],
  "maxItems": 25,
  "pageLimit": 1
}
```

#### Include extra specification rows

```json
{
  "searchQueries": ["ssd 2tb"],
  "maxItems": 10,
  "includeProductDetails": true
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `searchQueries` | array of strings | Newegg keywords to search. |
| `startUrls` | array of URLs | Public Newegg listing/search/category URLs to scrape. |
| `maxItems` | integer | Maximum product rows to save across all sources. |
| `pageLimit` | integer | Maximum listing pages to scan for each source. |
| `sort` | string | Sort for generated search URLs: `featured`, `lowest_price`, `highest_price`, `best_selling`, `best_rating`, `most_reviews`. |
| `includeProductDetails` | boolean | Visit product pages to collect extra `specs` when available. |
| `proxyConfiguration` | object | Apify proxy configuration. A US residential route is enabled by default because Newegg blocks or geo-limits many other requests. |

Provide at least one `searchQueries` value or one `startUrls` entry.

### Output example

```json
{
  "query": "rtx 4070",
  "startUrl": "https://www.newegg.com/p/pl?d=rtx+4070",
  "pageUrl": "https://www.newegg.com/p/pl?d=rtx+4070",
  "position": 1,
  "title": "GIGABYTE GeForce RTX 4070 Graphics Card...",
  "productUrl": "https://www.newegg.com/p/N82E16814932611?Item=N82E16814932611",
  "itemNumber": "N82E16814932611",
  "model": "GV-N4070...",
  "price": 549.99,
  "currentPriceText": "$549.99",
  "originalPriceText": null,
  "rating": 5,
  "reviewCount": 128,
  "availability": "In stock",
  "seller": "Newegg",
  "shipper": null,
  "promoText": null,
  "imageUrl": "https://c1.neweggimages.com/...jpg",
  "brand": "GIGABYTE",
  "category": "GPUs / Video Graphics Cards",
  "breadcrumbs": ["Components", "GPUs / Video Graphics Cards"],
  "specs": null,
  "scrapedAt": "2026-07-08T08:30:00.000Z"
}
```

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |
| `result` | Charged per Newegg product saved to the dataset. | $0.00003 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Tips for reliable runs

- Keep `includeProductDetails` off unless you need specifications; listing-only runs are faster.
- Use `maxItems` and `pageLimit` together to control cost and run duration.
- Keep the default US residential proxy route enabled for reliable Newegg access. Disable it only when your network can reach Newegg directly.
- For price monitoring, run the same query URL on a schedule and compare exported datasets.

### Limits and caveats

- Newegg page layout and availability wording can vary by region and seller.
- Some products may not show prices, ratings, reviews, or stock text.
- Sponsored and organic products may both appear when Newegg renders them as product cards.
- The actor only extracts public data visible without logging in.

### API usage

Start a run with cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~newegg-products-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["rtx 4070"],"maxItems":25,"pageLimit":1}'
```

Run it from Node.js:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/newegg-products-scraper').call({
  searchQueries: ['rtx 4070'],
  maxItems: 25,
  pageLimit: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items);
```

Run it from Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/newegg-products-scraper').call(run_input={
    'searchQueries': ['rtx 4070'],
    'maxItems': 25,
    'pageLimit': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items(clean=True).items
print(items)
```

Download dataset items:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=$APIFY_TOKEN"
```

### MCP and agent usage

Use this actor from AI agents through Apify MCP:

```text
https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper
```

Claude CLI setup:

```bash
claude mcp add apify-newegg "https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper"
```

JSON MCP server config:

```json
{
  "mcpServers": {
    "apify-newegg": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/newegg-products-scraper"
    }
  }
}
```

Example prompts:

- "Find current Newegg prices and review counts for RTX 4070 graphics cards and return the lowest-priced in-stock items."
- "Track Newegg gaming laptop listings under 1000 USD and summarize sellers, ratings, and promo text."

### Legality and responsible use

This actor extracts publicly visible Newegg listing data. Use the results responsibly, respect applicable laws and Newegg terms, and avoid collecting or storing personal data you do not need.

### FAQ

#### Do I need a Newegg account?

No. The actor is designed for public Newegg listing pages visible without login.

#### Can it scrape product details?

Yes, set `includeProductDetails` to `true` for small runs when you need extra `specs`. This visits product pages and is slower than listing-only extraction.

#### What if I get no products?

Check that the query or listing URL returns products in your browser, reduce filters, and confirm Apify Proxy is enabled if the site blocks your network.

#### Is this legal?

This actor extracts publicly visible information. You are responsible for using the data in line with applicable laws, Newegg terms, and privacy requirements.

### Related actors

- https://apify.com/fetch\_cat/lazada-products-scraper
- https://apify.com/fetch\_cat/aliexpress-products-scraper
- https://apify.com/fetch\_cat/google-shopping-results-scraper

### Support

Open an issue from the actor page and include your run ID, run URL, input JSON, expected output, and actual output so we can reproduce the problem.

### Changelog

- 2026-07-11: Enabled a US residential proxy route by default and made blocked or empty scrapes fail explicitly instead of reporting false success.
- 2026-07-08: Initial build for Newegg search and category product listings.

# Actor input Schema

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

Newegg keywords to search, such as GPU models, laptop types, components, or brands.

## `startUrls` (type: `array`):

Optional Newegg search or category URLs. Use this when you already have a Newegg listing page to monitor.

## `maxItems` (type: `integer`):

Maximum number of product rows to save across all searches and URLs.

## `pageLimit` (type: `integer`):

Maximum listing pages to scan for each search query or start URL.

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

Sort option for generated search query URLs. Start URLs keep their own sort parameters.

## `includeProductDetails` (type: `boolean`):

Also visit product pages to collect extra specification rows when available. This is slower and uses more requests.

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

A US residential Apify Proxy route is enabled by default because Newegg blocks or geo-limits many other requests. Disable it only when your network can reach Newegg directly.

## Actor input object example

```json
{
  "searchQueries": [
    "rtx 4070"
  ],
  "startUrls": [
    {
      "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
    }
  ],
  "maxItems": 20,
  "pageLimit": 3,
  "sort": "featured",
  "includeProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "rtx 4070"
    ],
    "startUrls": [
        {
            "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/newegg-products-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 = {
    "searchQueries": ["rtx 4070"],
    "startUrls": [{ "url": "https://www.newegg.com/p/pl?d=gaming+laptop" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/newegg-products-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 '{
  "searchQueries": [
    "rtx 4070"
  ],
  "startUrls": [
    {
      "url": "https://www.newegg.com/p/pl?d=gaming+laptop"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call fetch_cat/newegg-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newegg Products Scraper",
        "description": "Scrape Newegg search and category listings for product prices, ratings, reviews, sellers, stock text, promos, images, and URLs.",
        "version": "0.1",
        "x-build-id": "wb65vmTZfWjRsRSmb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~newegg-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-newegg-products-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/fetch_cat~newegg-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-newegg-products-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/fetch_cat~newegg-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-newegg-products-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Newegg keywords to search, such as GPU models, laptop types, components, or brands.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Newegg listing URLs",
                        "type": "array",
                        "description": "Optional Newegg search or category URLs. Use this when you already have a Newegg listing page to monitor.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product rows to save across all searches and URLs.",
                        "default": 20
                    },
                    "pageLimit": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum listing pages to scan for each search query or start URL.",
                        "default": 3
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "featured",
                            "lowest_price",
                            "highest_price",
                            "best_selling",
                            "best_rating",
                            "most_reviews"
                        ],
                        "type": "string",
                        "description": "Sort option for generated search query URLs. Start URLs keep their own sort parameters.",
                        "default": "featured"
                    },
                    "includeProductDetails": {
                        "title": "Fetch product detail pages",
                        "type": "boolean",
                        "description": "Also visit product pages to collect extra specification rows when available. This is slower and uses more requests.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "A US residential Apify Proxy route is enabled by default because Newegg blocks or geo-limits many other requests. Disable it only when your network can reach Newegg directly."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```