# eBay Sold Listings Scraper (`sync-network/ebay-sold-listings-scraper`) Actor

Scrape eBay sold listings (actual sold prices, not asking prices). Get confirmed prices across 8 eBay marketplaces. Fast/detailed modes with anti-scraping. Perfect for resellers, market research, and competitive analysis.

- **URL**: https://apify.com/sync-network/ebay-sold-listings-scraper.md
- **Developed by:** [Alam](https://apify.com/sync-network) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## eBay Sold Listings Scraper

![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)
![Category](https://img.shields.io/badge/category-Ecommerce-green.svg)
![Pricing](https://img.shields.io/badge/pricing-Pay--per--event-orange.svg)

### 📝 Description

The eBay Sold Listings Scraper extracts **confirmed eBay sold prices** — not asking prices. Get real market data from completed listings across 8 eBay marketplaces. Perfect for resellers, collectors, estate sales, and market research.

### ✨ Key Features

- ✅ **Real Sold Prices** - Scrape actual transaction prices, not listing prices
- 🌍 **8 Marketplaces** - US, UK, Germany, France, Italy, Spain, Canada, Australia
- ⚡ **Two Modes** - Fast mode (10-30s) or detailed mode (2-5min)
- 📊 **Rich Data** - Prices, shipping, seller info, item details
- 🔍 **Advanced Filters** - Price range, days, condition, category, location
- 🛡️ **Anti-Scraping** - Rate limiting, proxy support, realistic headers

### 🚀 Use Cases

- **Market Research** - Analyze sold prices for products
- **Price Comparison** - Compare asking vs. sold prices
- **Reselling** - Find underpriced items to flip
- **Collections** - Track market value of collectibles
- **Estate Sales** - Get realistic pricing for inherited items
- **Competitive Intelligence** - Monitor competitor sold prices

### 📦 Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|----------|-------------|
| `keyword` | string | ✅ Yes | - | Search keyword (e.g., "iphone 13") |
| `count` | integer | No | 100 | Max results (1-300) |
| `daysToScrape` | integer | No | 30 | Days back to scrape (1-90) |
| `ebaySite` | string | No | "ebay.com" | eBay site to scrape |
| `categoryId` | string | No | "0" | eBay category ID (0 = All Categories) |
| `sortOrder` | string | No | "endedRecently" | How to sort results |
| `minPrice` | number | No | - | Minimum sold price filter |
| `maxPrice` | number | No | - | Maximum sold price filter |
| `itemLocation` | string | No | "default" | Filter by location (default/domestic/worldwide) |
| `itemCondition` | string | No | "any" | Filter by condition (any/new/used) |
| `detailedSearch` | boolean | No | false | Visit each item page (slower, more data) |
| `currencyMode` | string | No | "localized" | Currency handling (localized/USD) |

#### Supported eBay Sites

- `ebay.com` - United States
- `ebay.co.uk` - United Kingdom
- `ebay.de` - Germany
- `ebay.fr` - France
- `ebay.it` - Italy
- `ebay.es` - Spain
- `ebay.ca` - Canada
- `ebay.com.au` - Australia

#### Sort Options

- `endedRecently` - Ended recently (newest)
- `timeNewlyListed` - Time newly listed
- `pricePlusPostageLowest` - Price + postage: lowest first
- `pricePlusPostageHighest` - Price + postage: highest first
- `distanceNearest` - Distance: nearest first

### 📤 Output

#### Fast Mode Output

```json
{
  "itemId": "1234567890",
  "url": "https://www.ebay.com/itm/1234567890",
  "title": "Apple iPhone 13 128GB Midnight - Unlocked",
  "categoryId": "9355",
  "category": "Cell Phones, Smartphones & Accessories",
  "endedAt": "2026-04-10T14:30:00.000Z",
  "soldPrice": "450.00",
  "soldCurrency": "USD",
  "shippingPrice": "0.00",
  "shippingCurrency": "USD",
  "shippingType": "free",
  "totalPrice": "450.00",
  "sellerUsername": "seller123",
  "sellerPositivePercent": 99.5,
  "sellerFeedbackScore": 1500,
  "scrapedAt": "2026-04-14T12:00:00.000Z"
}
````

#### Detailed Mode Output (Additional Fields)

```json
{
  "categoryPath": "Electronics > Cell Phones > Smartphones > iPhones",
  "condition": "New",
  "itemSpecifics": {
    "Brand": "Apple",
    "Model": "iPhone 13",
    "Storage Capacity": "128GB",
    "Color": "Midnight",
    "Network": "Unlocked"
  },
  "productDetails": {
    "Screen Size": "6.1\"",
    "Processor": "A15 Bionic",
    "RAM": "4GB",
    "Operating System": "iOS 16"
  },
  "itemLocation": "New York, NY, United States",
  "quantitySold": 1,
  "bids": 12
}
```

### ⚡ Performance

| Mode | 100 Results | 300 Results |
|------|-------------|-------------|
| Fast Mode | ~10-30 seconds | ~1-2 minutes |
| Detailed Mode | ~2-5 minutes | ~10-15 minutes |

> **Note:** eBay shows ~60 items per page with a maximum of 5 pages per run, giving a hard cap of ~300 results. For larger datasets, run multiple times with different date ranges or keywords.

### 🎯 Category IDs Reference

Find eBay category IDs at: https://sold-comps.com/ebay-categories

Common categories:

- `0` - All Categories
- `9355` - Cell Phones, Smartphones & Accessories
- `13997` - Computers/Tablets & Networking
- `1249` - Sporting Goods
- `267` - Books

### 📖 Usage Examples

#### Example 1: Basic Search (Fast Mode)

```bash
curl -X POST https://api.apify.com/v2/acts/syncnet/ebay-sold-listings-scraper/runs \
  -H 'Content-Type: application/json' \
  -d '{
    "keyword": "iphone 13",
    "count": 50,
    "daysToScrape": 30
  }'
```

#### Example 2: With Filters

```bash
curl -X POST https://api.apify.com/v2/acts/syncnet/ebay-sold-listings-scraper/runs \
  -H 'Content-Type: application/json' \
  -d '{
    "keyword": "gaming pc",
    "minPrice": 500,
    "maxPrice": 1000,
    "itemCondition": "used",
    "itemLocation": "domestic",
    "count": 100
  }'
```

#### Example 3: UK Marketplace (Detailed Mode)

```bash
curl -X POST https://api.apify.com/v2/acts/syncnet/ebay-sold-listings-scraper/runs \
  -H 'Content-Type: application/json' \
  -d '{
    "keyword": "ps5",
    "ebaySite": "ebay.co.uk",
    "detailedSearch": true,
    "count": 25
  }'
```

#### Example 4: Node.js SDK

```javascript
const { Actor } = require('apify');

const run = await Actor.call('syncnet/ebay-sold-listings-scraper', {
  keyword: 'macbook pro',
  minPrice: 800,
  maxPrice: 1500,
  daysToScrape: 14,
  detailedSearch: true
});

const { items } = await run.client.dataset(run.defaultDatasetId).listItems();
console.log('Results:', items);
```

#### Example 5: Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('syncnet/ebay-sold-listings-scraper').call(
  keyword='nintendo switch',
  ebaySite='ebay.com',
  count=100,
  daysToScrape=7
)

items = client.dataset(run['defaultDatasetId']).list_items()
print(f"Scraped {items['total']} items")
```

### 🛠️ Development

#### Build

```bash
npm install
npm run build
```

#### Run Locally

```bash
npm start
```

#### Test

```bash
npm test
```

### 🔒 Anti-Scraping Measures

- Rate limiting (2 requests/second)
- Realistic User-Agent headers
- Random delays between requests
- Proxy rotation support (Apify Proxy)
- Proper error handling (429, 403)

### 📊 Pricing

Pay-per-event pricing. Cost depends on:

- Number of results scraped
- Mode used (fast vs. detailed)
- Marketplace
- Proxy usage

### 🤝 Support

- Issues: Report via Apify Console
- Questions: Contact via Apify Actor page
- Documentation: See Apify Actor page

### 📄 License

MIT

### ⚠️ Disclaimer

This scraper extracts publicly available data from eBay. Please ensure your use complies with eBay's Terms of Service and applicable laws.

***

**Made with ❤️ by syncnet**

# Actor input Schema

## `keyword` (type: `string`):

What to search for on eBay sold listings (e.g., "iPhone 15 Pro", "RTX 4070", "Nike Air Max")

## `ebaySite` (type: `string`):

Which eBay site to scrape

## `count` (type: `integer`):

Maximum number of sold listings to scrape (1-500)

## `daysToScrape` (type: `integer`):

How many days back to look for sold listings (1-90)

## `sortOrder` (type: `string`):

How to sort search results

## `categoryId` (type: `string`):

eBay category ID to filter results (e.g., "0" for all categories). Leave empty for auto-detect.

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

Filter by minimum sold price

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

Filter by maximum sold price

## `itemCondition` (type: `string`):

Filter by item condition

## `itemLocation` (type: `string`):

Filter by item location

## `detailedSearch` (type: `boolean`):

Enable detailed mode to scrape individual item pages (slower but gets item specifics, condition, full description). Fast mode scrapes search results only.

## `currencyMode` (type: `string`):

How to handle currency in output

## Actor input object example

```json
{
  "keyword": "",
  "ebaySite": "ebay.com",
  "count": 10,
  "daysToScrape": 30,
  "sortOrder": "endedRecently",
  "categoryId": "",
  "itemCondition": "any",
  "itemLocation": "default",
  "detailedSearch": false,
  "currencyMode": "localized"
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("sync-network/ebay-sold-listings-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("sync-network/ebay-sold-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call sync-network/ebay-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Sold Listings Scraper",
        "description": "Scrape eBay sold listings (actual sold prices, not asking prices). Get confirmed prices across 8 eBay marketplaces. Fast/detailed modes with anti-scraping. Perfect for resellers, market research, and competitive analysis.",
        "version": "0.0",
        "x-build-id": "vgISGGU2zZ9ImN0pf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sync-network~ebay-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sync-network-ebay-sold-listings-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/sync-network~ebay-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sync-network-ebay-sold-listings-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/sync-network~ebay-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sync-network-ebay-sold-listings-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "minLength": 1,
                        "type": "string",
                        "description": "What to search for on eBay sold listings (e.g., \"iPhone 15 Pro\", \"RTX 4070\", \"Nike Air Max\")",
                        "default": ""
                    },
                    "ebaySite": {
                        "title": "eBay Site",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.ca",
                            "ebay.com.au"
                        ],
                        "type": "string",
                        "description": "Which eBay site to scrape",
                        "default": "ebay.com"
                    },
                    "count": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of sold listings to scrape (1-500)",
                        "default": 10
                    },
                    "daysToScrape": {
                        "title": "Days Back",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "How many days back to look for sold listings (1-90)",
                        "default": 30
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "endedRecently",
                            "timeNewlyListed",
                            "pricePlusPostageLowest",
                            "pricePlusPostageHighest",
                            "distanceNearest"
                        ],
                        "type": "string",
                        "description": "How to sort search results",
                        "default": "endedRecently"
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "eBay category ID to filter results (e.g., \"0\" for all categories). Leave empty for auto-detect.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "type": "number",
                        "description": "Filter by minimum sold price"
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "type": "number",
                        "description": "Filter by maximum sold price"
                    },
                    "itemCondition": {
                        "title": "Item Condition",
                        "enum": [
                            "any",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by item condition",
                        "default": "any"
                    },
                    "itemLocation": {
                        "title": "Item Location",
                        "enum": [
                            "default",
                            "domestic",
                            "worldwide"
                        ],
                        "type": "string",
                        "description": "Filter by item location",
                        "default": "default"
                    },
                    "detailedSearch": {
                        "title": "Detailed Mode",
                        "type": "boolean",
                        "description": "Enable detailed mode to scrape individual item pages (slower but gets item specifics, condition, full description). Fast mode scrapes search results only.",
                        "default": false
                    },
                    "currencyMode": {
                        "title": "Currency Mode",
                        "enum": [
                            "localized",
                            "USD"
                        ],
                        "type": "string",
                        "description": "How to handle currency in output",
                        "default": "localized"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
