# Heavy Equipment Scraper (`crawlerbros/heavyequipment-scraper`) Actor

Scrape heavyequipment.com listings - search by keyword, browse by category or equipment type, or filter by US state / Canadian province. Get price, manufacturer, model, hours, condition, and images for construction and industrial equipment for sale.

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

## Pricing

from $3.00 / 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.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Heavy Equipment Scraper

Scrape **heavyequipment.com** — a marketplace for construction, forestry, and industrial equipment for sale. Search by keyword, browse by category or specific equipment type (excavators, dozers, cranes, wheel loaders, and more), or filter by US state / Canadian province. Get price, manufacturer, model, hours, condition, description, and photos for every listing. No login, no cookies required.

### What this actor does

- **Four modes:** `search` (keyword), `byCategory` (top-level category), `bySubCategory` (specific equipment type), `byLocation` (US state / Canadian province)
- **Two-tier filtering:** category, keyword, and location are applied on the source site itself; manufacturer, price, model year, and condition are applied after retrieval so you can narrow results by criteria the site itself doesn't support natively
- **Real prices only** — if a listing has no genuine price posted anywhere, the `price` field is simply left out rather than showing a fake `$0`
- **Empty fields are omitted** — a listing only includes the fields that were actually found on its page

### Output per listing

- `title` — listing headline
- `listingUrl` — direct link to the listing
- `price`, `currency` — numeric price and its currency (USD or CAD), when a real price is posted
- `category` — top-level category (e.g. `Heavy Equipment`), when known from the search
- `subCategory` — the specific equipment type as listed on the page (e.g. `Excavators`, `Dozers`, `Graders`)
- `manufacturer`, `model`, `serialNumber`, `series`
- `hours` — recorded operating hours, when listed
- `year` — model year, extracted from the title when present
- `condition` — one of `new`, `like_new`, `lightly_used`, `heavy_usage`, `salvage`, `repair`
- `description` — full listing description
- `images[]` — photo URLs
- `sku` — internal listing SKU
- `recordType: "listing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `search` / `byCategory` / `bySubCategory` / `byLocation` |
| `q` | string | – | Keyword search (mode=search) |
| `category` | string | `1` | Top-level category (mode=byCategory) |
| `subCategory` | string | `excavators` | Specific equipment type (mode=bySubCategory) |
| `country` | string | `233` (United States) | Country (mode=byLocation) |
| `state` | string | – | US state / Canadian province (mode=byLocation) |
| `manufacturer` | string | – | Keep only this manufacturer (partial match, e.g. `cat`, `john deere`) |
| `minPrice` / `maxPrice` | int | – | Price range in USD/CAD |
| `minYear` / `maxYear` | int | – | Model year range |
| `condition` | string | – | `new` / `like_new` / `lightly_used` / `heavy_usage` / `salvage` / `repair` |
| `maxItems` | int | `20` | Hard cap on emitted records (1–500) |
| `proxyConfiguration` | object | Apify Proxy (auto) | Optional — only used automatically as a fallback if the site starts blocking requests |

#### Example: search by keyword, filter by manufacturer

```json
{
  "mode": "search",
  "q": "excavator",
  "manufacturer": "komatsu",
  "maxItems": 25
}
````

#### Example: browse a specific equipment type with price and year filters

```json
{
  "mode": "bySubCategory",
  "subCategory": "dozers",
  "minPrice": 20000,
  "maxPrice": 100000,
  "minYear": 2010,
  "maxItems": 50
}
```

#### Example: browse all heavy equipment listed in a US state

```json
{
  "mode": "byLocation",
  "country": "233",
  "state": "1416",
  "condition": "lightly_used",
  "maxItems": 50
}
```

#### Example: browse a top-level category

```json
{
  "mode": "byCategory",
  "category": "1",
  "maxItems": 20
}
```

### Use cases

- **Equipment dealers** — monitor new listings and pricing for competitive benchmarking
- **Buyers** — filter a small marketplace quickly by manufacturer, price, and condition without manual browsing
- **Market research** — track how equipment types (excavators, cranes, dozers) are priced across regions
- **Procurement teams** — build a shortlist of available equipment matching budget and year requirements
- **Data aggregators** — feed heavy-equipment listings into a broader marketplace search tool

### FAQ

**What's heavyequipment.com?** An online marketplace for buying and selling construction, forestry, and industrial equipment, parts, attachments, and reference manuals.

**Why do `category` and `subCategory` sometimes differ from what I expected?** `category` reflects the top-level section the listing was found under (e.g. "Heavy Equipment"), while `subCategory` reflects the specific equipment type recorded on the listing itself (e.g. "Excavators", "Graders") — sellers occasionally label a listing under a type that doesn't map 1:1 to the browse menu.

**Why is `price` missing on some listings?** A small number of listings on the source site have no price entered anywhere (neither the listing page nor its structured data) — these are typically "call for price" style listings. Rather than showing a fabricated `$0`, the actor leaves the field out entirely.

**Why aren't `manufacturer`, `minPrice`/`maxPrice`, `minYear`/`maxYear`, and `condition` available as search parameters on the site itself?** They aren't — the source site's own search only supports keyword, category, and location. This actor applies those four filters itself after retrieving the listings, so results can be further narrowed by manufacturer, price, and year after retrieval, even though the site can't do that natively.

**Does `manufacturer` require an exact match?** No — it matches at the start of a word, case-insensitively, so `cat` matches `CAT` and `Caterpillar` but correctly skips unrelated brands like `Bobcat`.

**Are `location` (city/dealer) or `seller phone` available?** No — the source site doesn't display seller location, dealer name, or contact phone on listing pages; that information requires contacting the seller through the site directly.

**Is this actor affiliated with heavyequipment.com?** No — this is an independent, third-party actor that reads publicly available listing pages.

**How fresh is the data?** As fresh as the last time you ran the actor — each run reads the live site directly, there's no caching.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `q` (type: `string`):

Free-text keyword search, e.g. `caterpillar` (mode=search).

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

Top-level category to browse (mode=byCategory).

## `subCategory` (type: `string`):

Specific equipment type to browse (mode=bySubCategory).

## `country` (type: `string`):

Country to browse (mode=byLocation). Combined server-side with the Heavy Equipment category.

## `state` (type: `string`):

US state or Canadian province to filter by (mode=byLocation). Leave as "(no state filter)" to browse the whole selected country.

## `manufacturer` (type: `string`):

Keep only listings whose manufacturer matches (case-insensitive, partial match allowed). Not a controlled list on the source site, so any text works — common values include CAT / Caterpillar, John Deere, Komatsu, Case, Volvo, Kubota, Bobcat, JCB, Hitachi, Sany, Doosan, Liebherr, Hyundai, Ponsse.

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

Drop listings priced below this amount. Applied after retrieval, on whichever currency the listing was posted in.

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

Drop listings priced above this amount. Applied after retrieval, on whichever currency the listing was posted in.

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

Drop listings whose title year is earlier than this. Listings with no extractable year are kept unless this filter is set.

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

Drop listings whose title year is later than this. Listings with no extractable year are kept unless this filter is set.

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

Keep only listings with this condition.

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

Hard cap on emitted records.

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

Optional. The source site has no anti-bot protection, so a proxy isn't required — this is only used as an automatic fallback if the site starts blocking requests.

## Actor input object example

```json
{
  "mode": "byCategory",
  "q": "caterpillar",
  "category": "1",
  "subCategory": "excavators",
  "country": "233",
  "state": "",
  "condition": "",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped heavyequipment.com listings.

# 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 = {
    "mode": "byCategory",
    "q": "caterpillar",
    "category": "1",
    "subCategory": "excavators",
    "country": "233",
    "state": "",
    "condition": "",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/heavyequipment-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 = {
    "mode": "byCategory",
    "q": "caterpillar",
    "category": "1",
    "subCategory": "excavators",
    "country": "233",
    "state": "",
    "condition": "",
    "maxItems": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/heavyequipment-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 '{
  "mode": "byCategory",
  "q": "caterpillar",
  "category": "1",
  "subCategory": "excavators",
  "country": "233",
  "state": "",
  "condition": "",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/heavyequipment-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Heavy Equipment Scraper",
        "description": "Scrape heavyequipment.com listings - search by keyword, browse by category or equipment type, or filter by US state / Canadian province. Get price, manufacturer, model, hours, condition, and images for construction and industrial equipment for sale.",
        "version": "1.0",
        "x-build-id": "4YqRb2BaKt5NcjPd3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~heavyequipment-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-heavyequipment-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/crawlerbros~heavyequipment-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-heavyequipment-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/crawlerbros~heavyequipment-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-heavyequipment-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "bySubCategory",
                            "byLocation"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byCategory"
                    },
                    "q": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `caterpillar` (mode=search)."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "1",
                            "9",
                            "14",
                            "30",
                            "37",
                            "46"
                        ],
                        "type": "string",
                        "description": "Top-level category to browse (mode=byCategory).",
                        "default": "1"
                    },
                    "subCategory": {
                        "title": "Equipment type",
                        "enum": [
                            "",
                            "atvs-and-utvs",
                            "auto-trailers-hec",
                            "backhoe-loaders",
                            "combines",
                            "compactors",
                            "crane",
                            "dozers",
                            "end-dump",
                            "excavators",
                            "forklift",
                            "generators",
                            "graders",
                            "integrated-tool-carriers",
                            "mowers",
                            "pavers",
                            "pipelayers",
                            "scrapers",
                            "shovels-and-draglines",
                            "skidsteer",
                            "wheel-loaders"
                        ],
                        "type": "string",
                        "description": "Specific equipment type to browse (mode=bySubCategory).",
                        "default": "excavators"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "233",
                            "39"
                        ],
                        "type": "string",
                        "description": "Country to browse (mode=byLocation). Combined server-side with the Heavy Equipment category.",
                        "default": "233"
                    },
                    "state": {
                        "title": "State / province",
                        "enum": [
                            "",
                            "1456",
                            "1400",
                            "1424",
                            "1434",
                            "1444",
                            "1402",
                            "1416",
                            "1450",
                            "1435",
                            "1399",
                            "1437",
                            "1436",
                            "1455",
                            "1412",
                            "1411",
                            "1398",
                            "1460",
                            "1425",
                            "1440",
                            "1459",
                            "1410",
                            "1428",
                            "1406",
                            "1419",
                            "1403",
                            "1457",
                            "1453",
                            "1401",
                            "1433",
                            "1426",
                            "1438",
                            "1420",
                            "1430",
                            "1451",
                            "1446",
                            "1439",
                            "1408",
                            "1458",
                            "1404",
                            "1417",
                            "1423",
                            "1452",
                            "1447",
                            "1418",
                            "1431",
                            "4851",
                            "1421",
                            "1415",
                            "1448",
                            "1422",
                            "1449",
                            "1461",
                            "1443",
                            "1445",
                            "1454",
                            "1407",
                            "1432",
                            "1413",
                            "1414",
                            "1409",
                            "1427",
                            "1405",
                            "1462",
                            "1429",
                            "1441",
                            "1442",
                            "872",
                            "875",
                            "867",
                            "868",
                            "877",
                            "878",
                            "874",
                            "876",
                            "866",
                            "871",
                            "873",
                            "870",
                            "869"
                        ],
                        "type": "string",
                        "description": "US state or Canadian province to filter by (mode=byLocation). Leave as \"(no state filter)\" to browse the whole selected country.",
                        "default": ""
                    },
                    "manufacturer": {
                        "title": "Manufacturer",
                        "type": "string",
                        "description": "Keep only listings whose manufacturer matches (case-insensitive, partial match allowed). Not a controlled list on the source site, so any text works — common values include CAT / Caterpillar, John Deere, Komatsu, Case, Volvo, Kubota, Bobcat, JCB, Hitachi, Sany, Doosan, Liebherr, Hyundai, Ponsse."
                    },
                    "minPrice": {
                        "title": "Min price (USD/CAD)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop listings priced below this amount. Applied after retrieval, on whichever currency the listing was posted in."
                    },
                    "maxPrice": {
                        "title": "Max price (USD/CAD)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop listings priced above this amount. Applied after retrieval, on whichever currency the listing was posted in."
                    },
                    "minYear": {
                        "title": "Min model year",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Drop listings whose title year is earlier than this. Listings with no extractable year are kept unless this filter is set."
                    },
                    "maxYear": {
                        "title": "Max model year",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Drop listings whose title year is later than this. Listings with no extractable year are kept unless this filter is set."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "new",
                            "like_new",
                            "lightly_used",
                            "heavy_usage",
                            "salvage",
                            "repair"
                        ],
                        "type": "string",
                        "description": "Keep only listings with this condition.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The source site has no anti-bot protection, so a proxy isn't required — this is only used as an automatic fallback if the site starts blocking requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
