# Commercial Truck Trader Scraper (`parseforge/commercialtrucktrader-scraper`) Actor

Scrape commercial truck listings from CommercialTruckTrader.com. Get prices, make, model, year, mileage, condition, category, dealer info, and images. Filter by category (dump, flatbed, box trucks), condition, make, price, and year. Covers 230,000+ trucks from dealers nationwide.

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

## Pricing

from $8.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚛 Commercial Truck Trader Listings Scraper

Whether you're a fleet manager sourcing vehicles, a truck dealer tracking competitor pricing, or a market researcher analyzing the commercial truck market, this tool makes it easy to collect structured listing data from CommercialTruckTrader.com - one of the largest online marketplaces for commercial trucks in the United States.

> **The Commercial Truck Trader Scraper collects truck listings with titles, prices, years, makes, models, conditions, mileage, dealer info, and images. Filter by category, condition, make, price range, and year.**

### ✨ What Does It Do

- 🚛 **Truck listings** - collect titles, years, makes, models, and prices from thousands of commercial truck listings
- 💰 **Pricing data** - extract listing prices and conditions (new/used) for market comparisons
- 📊 **Specifications** - get mileage, category, and detailed truck specs for every listing
- 🏢 **Dealer information** - dealer names and locations for each listing
- 📸 **Image galleries** - collect listing photos and primary images
- 🔍 **20+ categories** - search dump trucks, box trucks, flatbeds, tow trucks, semi trucks, and many more

### 🔧 Input

- **Start URL** - paste any CommercialTruckTrader.com search URL directly (overrides all filter options below)
- **Max Items** - how many truck listings to collect (free users get 10 items, paid users up to 1,000,000)
- **Category** - type of truck (dump trucks, box trucks, flatbeds, tow trucks, semi trucks, and more)
- **Condition** - filter by New or Used
- **Make** - manufacturer (e.g., Freightliner, Peterbilt, Kenworth, International, Mack, Volvo)
- **Min Price / Max Price** - price range in USD
- **Min Year / Max Year** - model year range

```json
{
    "maxItems": 10,
    "category": "Dump-Trucks",
    "condition": "U",
    "make": "Freightliner"
}
````

### 📊 Output

Each truck listing includes up to 15+ data fields. Download as JSON, CSV, or Excel.

| 📌 Field | 📄 Description |
|----------|---------------|
| 🖼️ imageUrl | Primary listing photo |
| 📋 title | Full truck title (year, make, model) |
| 🔗 url | Direct link to listing on CommercialTruckTrader |
| 💰 price | Listing price |
| 📅 year | Model year |
| 🏭 make | Truck manufacturer |
| 🚛 model | Truck model name |
| ✅ condition | New or Used |
| 🏷️ category | Truck category (dump, flatbed, etc.) |
| 📏 mileage | Odometer reading |
| 📍 location | Dealer city and state |
| 🏢 dealerName | Dealer or seller name |
| 📸 images | Full image gallery |

```json
{
    "imageUrl": "https://www.commercialtrucktrader.com/img/truck123.jpg",
    "title": "2021 Freightliner M2 106 Dump Truck",
    "url": "https://www.commercialtrucktrader.com/listing/2021-Freightliner-M2-106-123456",
    "listingId": "123456",
    "price": "$89,500",
    "year": 2021,
    "make": "Freightliner",
    "model": "M2 106 Dump Truck",
    "condition": "Used",
    "category": "Dump Trucks",
    "mileage": "45,000 mi",
    "location": "Dallas, TX",
    "dealerName": "Lone Star Truck Sales",
    "specifications": {},
    "images": [],
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

### 💎 Why Choose the Commercial Truck Trader Scraper?

| Feature | Our Tool | Manual CTT Search |
|---------|----------|-------------------|
| Batch collection | ✅ Up to 1M listings | ❌ Browse one at a time |
| Multiple filters | ✅ Category, make, condition, price, year | ⚠️ Limited search |
| 20+ categories | ✅ Dump, flatbed, tow, semi, and more | ⚠️ Search one at a time |
| Structured output | ✅ JSON, CSV, Excel | ❌ HTML pages only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |
| Dealer details | ✅ Name + location per listing | ⚠️ Click each listing |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your category, condition, make, price range, and year filters (or paste a CTT URL)
3. **Run It** - click "Start" and get structured truck data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🚛 **Fleet managers** - source vehicles across multiple categories and price ranges from dealers nationwide
- 🏢 **Truck dealers** - monitor competitor pricing and inventory to identify underpriced listings for resale
- 📊 **Market researchers** - build comprehensive commercial truck market databases and analyze pricing trends
- 🚚 **Logistics companies** - find available trucks for fleet expansion and compare new vs used pricing
- 📈 **Data analysts** - track depreciation patterns by make and year, and create pricing dashboards
- 🏗️ **Construction companies** - find dump trucks, flatbeds, and specialty vehicles at competitive prices

### ❓ FAQ

🚛 **What is Commercial Truck Trader?**
CommercialTruckTrader.com is one of the largest online marketplaces for commercial trucks in the United States. It features listings from dealers and private sellers for dump trucks, box trucks, flatbeds, semi trucks, and over 20 other categories.

🔍 **What truck categories are supported?**
All major categories including dump trucks, box trucks, flatbed trucks, tow trucks, semi trucks, cab and chassis, cargo vans, crane trucks, fuel trucks, garbage trucks, refrigerated trucks, utility trucks, and many more.

📋 **Can I filter by location?**
Yes. Use the Start URL option and paste a search URL with location filters already applied from CommercialTruckTrader.com.

⏱️ **How long does a run take?**
Most runs complete in under a minute. The scraper collects hundreds of listings quickly from search results.

📅 **Can I schedule regular runs?**
Yes. Set up a scheduled run to track new listings, price changes, and inventory levels daily, weekly, or at any interval.

### 🔗 Integrate Commercial Truck Trader Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate truck market monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new trucks match your criteria
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export truck data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more vehicle and equipment data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Copart Public Search Scraper | Collect vehicle auction data from Copart.com | [Link](https://apify.com/parseforge/copart-public-search-scraper) |
| Machinery Trader Scraper | Collect heavy equipment listings from MachineryTrader.com | [Link](https://apify.com/parseforge/machinerytrader-scraper) |
| Iron Planet Scraper | Extract heavy equipment auction data from IronPlanet | [Link](https://apify.com/parseforge/iron-planet-scraper) |
| Bring A Trailer Auctions Scraper | Extract vehicle auction data from Bring a Trailer | [Link](https://apify.com/parseforge/bringatrailer-auctions-scraper) |
| AutoNation Scraper | Collect vehicle listings from AutoNation dealerships | [Link](https://apify.com/parseforge/autonation-scraper) |

**Pro Tip:** 💡 Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to Commercial Truck Trader, Trader Interactive, or any of their subsidiaries. It accesses only publicly available data from CommercialTruckTrader.com.

# Actor input Schema

## `startUrl` (type: `string`):

Direct CommercialTruckTrader.com search URL. Use this OR the filters below, not both. Example: https://www.commercialtrucktrader.com/Dump-Trucks/trucks-for-sale

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `category` (type: `string`):

Type of commercial truck to search for

## `condition` (type: `string`):

Filter by truck condition

## `make` (type: `string`):

Filter by manufacturer (e.g., Freightliner, Peterbilt, Kenworth, International, Mack, Volvo)

## `minPrice` (type: `integer`):

Minimum price in USD

## `maxPrice` (type: `integer`):

Maximum price in USD

## `minYear` (type: `integer`):

Minimum model year

## `maxYear` (type: `integer`):

Maximum model year

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

Residential proxies are required to bypass DataDome protection

## Actor input object example

```json
{
  "maxItems": 10,
  "condition": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `trucks` (type: `string`):

Complete dataset with all scraped truck listings

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

Overview of truck listings with key fields

# 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 = {
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/commercialtrucktrader-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 = {
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/commercialtrucktrader-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 '{
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parseforge/commercialtrucktrader-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Commercial Truck Trader Scraper",
        "description": "Scrape commercial truck listings from CommercialTruckTrader.com. Get prices, make, model, year, mileage, condition, category, dealer info, and images. Filter by category (dump, flatbed, box trucks), condition, make, price, and year. Covers 230,000+ trucks from dealers nationwide.",
        "version": "0.0",
        "x-build-id": "QmM52ROeXadEIaAGe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~commercialtrucktrader-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-commercialtrucktrader-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/parseforge~commercialtrucktrader-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-commercialtrucktrader-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/parseforge~commercialtrucktrader-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-commercialtrucktrader-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct CommercialTruckTrader.com search URL. Use this OR the filters below, not both. Example: https://www.commercialtrucktrader.com/Dump-Trucks/trucks-for-sale"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Dump-Trucks",
                            "Box-Trucks",
                            "Flatbed-Trucks",
                            "Tow-Trucks",
                            "Cab-Chassis",
                            "Cargo-Vans",
                            "Conventional-Day-Cab",
                            "Conventional-Sleeper-Truck",
                            "Crane-Trucks",
                            "Dump-Trailers",
                            "Flatbed-Trailers",
                            "Fuel-Trucks",
                            "Garbage-Trucks",
                            "Logging-Trucks",
                            "Pickup-Trucks",
                            "Refrigerated-Trucks",
                            "Semi-Trucks",
                            "Stake-Trucks",
                            "Tank-Trucks",
                            "Utility-Trucks",
                            "Vocational-Trucks"
                        ],
                        "type": "string",
                        "description": "Type of commercial truck to search for"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "U",
                            "N"
                        ],
                        "type": "string",
                        "description": "Filter by truck condition",
                        "default": ""
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Filter by manufacturer (e.g., Freightliner, Peterbilt, Kenworth, International, Mack, Volvo)"
                    },
                    "minPrice": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in USD"
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in USD"
                    },
                    "minYear": {
                        "title": "Min Year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Minimum model year"
                    },
                    "maxYear": {
                        "title": "Max Year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Maximum model year"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies are required to bypass DataDome protection"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
