# 🛒 Amazon Price Tracker (`scrapium/amazon-price-tracker`) Actor

- **URL**: https://apify.com/scrapium/amazon-price-tracker.md
- **Developed by:** [Scrapium](https://apify.com/scrapium) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

## 🛒 Amazon Price Tracker — Real-Time Product Data Scraper

Track prices, discounts, ratings, reviews, sellers, and stock from any Amazon search URL. Built to be **fast**, **anti-bot resilient**, and **proxy-aware** — results stream into your dataset in real time, so you can watch them appear table-by-table while the run is still going.

> ⚡ Powered by browser-grade TLS fingerprinting and an adaptive proxy ladder.
> 🛡️ Starts direct, falls back through datacenter → residential automatically.
> 📊 Live dataset views: Overview, Pricing, Ratings, Stock — separated for you.

---

### 🌟 Why Choose This Actor?

* 🚀 **Real-time streaming** — every product is pushed to the dataset the moment it's extracted. No "all-or-nothing" waits.
* 🛡️ **Smart proxy escalation** — direct → datacenter → residential, with up to 3 retries on residential before giving up on a request.
* 🧠 **Browser-grade impersonation** — TLS, HTTP/2, and header order matched to real Chrome to slip past Amazon's CAPTCHA defenses.
* 🎯 **Built-in filters** — price floor/ceiling, minimum rating, minimum review count, custom sort order.
* 📊 **4 dataset views** out of the box: Overview · Pricing · Ratings · Stock — sliced for instant analysis.
* 🔁 **Bulk URLs supported** — paste any number of Amazon search URLs and it paginates each one until your target count is reached.

---

### 🚀 How to Use (Apify Console)

1. Log in at https://console.apify.com → **Actors**.
2. Open **Amazon Price Tracker**.
3. Paste your **Amazon search URLs** (e.g. `https://www.amazon.com/s?k=laptop`) into the `start_urls` field — one or many.
4. (Optional) Set price/rating filters, sort order, max results.
5. Leave **Proxy** set to *no proxy* (default) — the actor will auto-escalate if Amazon pushes back.
6. Click **Start**.
7. Watch the **Log** tab — products stream in with emojis and prices.
8. Open the **Output** tab — switch between 📦 Overview, 💰 Pricing, ⭐ Ratings, 📦 Stock.
9. Export to JSON / CSV / XLSX.

---

### 📥 Input

```json
{
  "start_urls": [
    { "url": "https://www.amazon.com/s?k=laptop" }
  ],
  "maxResults": 30,
  "sort_by": "relevance",
  "minPrice": 0,
  "maxPrice": 100000,
  "minRating": 0,
  "minReviews": 0,
  "concurrency": 4,
  "requestDelay": 1.0,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

| Field | Type | Description |
|-------|------|-------------|
| `start_urls` | array | 🔗 Bulk Amazon search URLs to crawl. Required. |
| `maxResults` | integer | 🎯 Cap on products collected across all URLs. Default `30`. |
| `sort_by` | string | 🔀 `relevance`, `price low to high`, `price high to low`, `avg. customer review`, `newest arrival`, or `popularity`. |
| `minPrice` | number | 💵 Skip products below this price. |
| `maxPrice` | number | 💰 Skip products above this price. |
| `minRating` | number | ⭐ Skip products under this star rating (0–5). |
| `minReviews` | integer | 💬 Skip products with fewer reviews than this. |
| `concurrency` | integer | ⚡ Parallel product workers (1–16). Default `4`. |
| `requestDelay` | number | ⏱️ Average seconds between requests. Jitter added automatically. |
| `proxyConfiguration` | object | 🛡️ Optional. Leave default to auto-escalate; set explicitly to force a tier. |

***

### 📤 Output

Each item pushed to the dataset matches the original input code's shape exactly:

```json
{
  "url": "https://www.amazon.com/HP-Stream-BrightView-N4120-Graphics/dp/B0CZL2SLCJ",
  "asin": "B0CZL2SLCJ",
  "title": "HP Stream 14\" HD BrightView Laptop, Intel Celeron N150, 16GB RAM, …",
  "price": 359.0,
  "originalPrice": null,
  "discount": null,
  "rating": 4.3,
  "reviewCount": 1674,
  "category": "Electronics > Computers & Accessories > … > Laptops",
  "seller": "Snow Bell",
  "availability": "In Stock",
  "imageUrl": "https://m.media-amazon.com/images/I/71M0XnAX3qL._AC_SY300_SX300_QL70_FMwebp_.jpg",
  "scrapedAt": "2026-05-14T07:29:19.973268Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | 🔗 Canonical product URL. |
| `asin` | string | 🆔 Amazon ASIN. |
| `title` | string | 🛒 Full product title. |
| `price` | number | 💵 Current price (USD). |
| `originalPrice` | number | 🏷️ Original list price (before discount). |
| `discount` | integer | 🔻 % off, if displayed. |
| `rating` | number | ⭐ Star rating (0–5). |
| `reviewCount` | integer | 💬 Number of customer reviews. |
| `category` | string | 🗂️ Breadcrumb path. |
| `seller` | string | 🏪 Seller name or merchant ID. |
| `availability` | string | 📦 Stock status text from Amazon. |
| `imageUrl` | string | 🖼️ Primary product image. |
| `scrapedAt` | string | 🕒 ISO-8601 timestamp of extraction. |

***

### 🤖 Use via API

Start a synchronous run and stream the dataset back:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "start_urls": [{"url": "https://www.amazon.com/s?k=headphones"}],
        "maxResults": 50
      }'
```

Or asynchronously (returns a `run.id` you can poll):

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<ACTOR_ID>/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"start_urls":[{"url":"https://www.amazon.com/s?k=headphones"}]}'
```

***

### 🎯 Best Use Cases

- 💰 **Repricing / dynamic pricing** — monitor competitor SKUs on a cron.
- 📈 **Market research** — capture rating + review distributions across categories.
- 🔍 **Product discovery** — surface highly-rated low-review products.
- 🚨 **Stock alerts** — feed the dataset into a webhook to detect "Only X left".
- 📊 **Trend dashboards** — pipe to BigQuery / Snowflake for time series of prices.

***

### 💵 Pricing

This actor uses **Pay-Per-Event** monetization. You're billed only when meaningful work happens:

| Event | When it fires | Why it's billed |
|-------|---------------|-----------------|
| 🚀 `actor-start` | Each run starts | Covers warmup + connection setup |
| 📦 `result-item` | Each product successfully pushed to the dataset | This is the value you receive — clean structured product data |

Skipped (filter-rejected) and failed products are **not billed**.

If your account hits `ACTOR_MAX_TOTAL_CHARGE_USD` mid-run, the actor stops cleanly and leaves the partial dataset intact — no failed runs.

***

### ❓ Frequently Asked Questions

**Q: Do I need to set up a proxy?**
🛡️ No. The actor starts direct and only escalates if Amazon pushes back. If you want to force residential from the first request, set `proxyConfiguration.useApifyProxy=true` and add `RESIDENTIAL` to the groups.

**Q: Why am I getting fewer results than I asked for?**
🎯 Filters cut some out, and the search may simply not have enough products. The actor logs how many candidates each page contained — check the run log to see why.

**Q: Will it scrape product pages outside the US marketplace?**
🌍 The current build targets `amazon.com`. International marketplaces work but selectors are tuned for US, so non-`.com` results may have empty optional fields.

**Q: Does it support direct product URLs (not just search URLs)?**
🔗 Today the actor expects search URLs and paginates them. Product-URL-only input is on the roadmap.

**Q: What if Amazon shows a CAPTCHA?**
🤖 The actor detects the CAPTCHA marker and escalates the proxy tier automatically. If it can't get past after the full ladder, it logs the affected URL and continues with the rest — partial results are always preserved.

***

### ⚖️ Legal & Compliance

- Data is collected only from **publicly available** Amazon listings — no login, no private data, no bypassed paywalls.
- You are responsible for compliance with Amazon's Terms of Service, your local laws (GDPR, CCPA, etc.), and any rate limits Amazon may impose.
- Use responsibly — keep concurrency reasonable, set polite delays, and don't redistribute scraped data in violation of Amazon's policies.

***

### 💬 Support & Feedback

Found a bug, missing field, or want a feature? Reach out via the **Issues** tab on the actor's Apify page. PRs welcome on selectors and parsing edge cases. 🚀

# Actor input Schema

## `start_urls` (type: `array`):

🛒 Paste **one or more Amazon search URLs** (e.g. `https://www.amazon.com/s?k=laptop`). Each URL is paginated automatically. ✨ Bulk input fully supported.

## `maxResults` (type: `integer`):

📦 Hard cap on how many products to extract across all search URLs. Stops the run cleanly once reached.

## `sort_by` (type: `string`):

🧭 Choose how Amazon should order results before scraping.

## `minPrice` (type: `number`):

📉 Skip products priced below this value. Use `0` to disable.

## `maxPrice` (type: `number`):

📈 Skip products priced above this value.

## `minRating` (type: `number`):

🌟 Skip products rated below this (0–5 scale). Use `0` to disable.

## `minReviews` (type: `integer`):

🗣️ Skip products with fewer than this many reviews. Use `0` to disable.

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

🔐 The actor starts **direct (no proxy)**, escalates to **datacenter** if Amazon blocks, then falls back to **residential** with up to 3 retries. Tweak this only if you want to force a specific Apify proxy group from the start.

## Actor input object example

```json
{
  "start_urls": [
    "https://www.amazon.com/s?k=laptop"
  ],
  "maxResults": 10,
  "sort_by": "relevance",
  "minPrice": 0,
  "maxPrice": 0,
  "minRating": 0,
  "minReviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "start_urls": [
        "https://www.amazon.com/s?k=laptop"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapium/amazon-price-tracker").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 = {
    "start_urls": ["https://www.amazon.com/s?k=laptop"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapium/amazon-price-tracker").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 '{
  "start_urls": [
    "https://www.amazon.com/s?k=laptop"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapium/amazon-price-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛒 Amazon Price Tracker",
        "description": null,
        "version": "0.3",
        "x-build-id": "BvC8hek3D7MsVvwLq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~amazon-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-amazon-price-tracker",
                "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/scrapium~amazon-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-amazon-price-tracker",
                "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/scrapium~amazon-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-amazon-price-tracker",
                "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": [
                    "start_urls"
                ],
                "properties": {
                    "start_urls": {
                        "title": "🔗 Amazon Search URLs (bulk supported)",
                        "type": "array",
                        "description": "🛒 Paste **one or more Amazon search URLs** (e.g. `https://www.amazon.com/s?k=laptop`). Each URL is paginated automatically. ✨ Bulk input fully supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🎯 Maximum Products to Collect",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "📦 Hard cap on how many products to extract across all search URLs. Stops the run cleanly once reached.",
                        "default": 10
                    },
                    "sort_by": {
                        "title": "🔀 Sort Results By",
                        "enum": [
                            "relevance",
                            "price low to high",
                            "price high to low",
                            "avg. customer review",
                            "newest arrival",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "🧭 Choose how Amazon should order results before scraping.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "💵 Minimum Price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "📉 Skip products priced below this value. Use `0` to disable.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "💰 Maximum Price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "📈 Skip products priced above this value.",
                        "default": 0
                    },
                    "minRating": {
                        "title": "⭐ Minimum Star Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "🌟 Skip products rated below this (0–5 scale). Use `0` to disable.",
                        "default": 0
                    },
                    "minReviews": {
                        "title": "💬 Minimum Review Count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🗣️ Skip products with fewer than this many reviews. Use `0` to disable.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "🔐 The actor starts **direct (no proxy)**, escalates to **datacenter** if Amazon blocks, then falls back to **residential** with up to 3 retries. Tweak this only if you want to force a specific Apify proxy group from the start.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```