# Mecum Auctions Scraper - Collector Car Lots & Results (`growth-installations/mecum-auctions-scraper`) Actor

Scrape Mecum Auctions for collector-car lots across live and past events: year, make, model, body style, engine, transmission, VIN partial, estimate range, hammer price, sold flag, condition, and photos. Covers Kissimmee (world's largest collector-car auction) and 12+ annual events.

- **URL**: https://apify.com/growth-installations/mecum-auctions-scraper.md
- **Developed by:** [Growth Installations](https://apify.com/growth-installations) (community)
- **Categories:** Agents, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 lot scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Mecum Auctions Scraper - Collector Car Lots & Results

Scrape Mecum Auctions for collector-car lots across live and past events: year, make, model, body style, engine, transmission, VIN partial, estimate range, hammer price, sold flag, condition, and photos. Covers Kissimmee (world's largest collector-car auction) and 12+ annual events.

Built for collector-car investors, classic-car insurance appraisers, dealer wholesale intelligence, muscle-car market analysts, concours d'elegance organizers, auction house competitive research.

### What this mecum.com scraper extracts

Every run produces one row per record, with change annotations against your last snapshot, with the following fields:

- **lot_id** (string), Numeric Mecum lot id
- **lot_number** (string), Event-scoped lot number (e.g. S190)
- **lot_series** (string), Descriptive tag ('1 of 5 Produced with Automatic', 'Barn Find', etc.)
- **auction_event** (string), Event name (e.g. Kissimmee 2026)
- **auction_slug** (string)
- **title** (string), Full title from og:title meta (e.g. '1971 Plymouth Hemi Cuda Convertible')
- **year** (integer)
- **make** (string)
- **model** (string)
- **body_style** (string), Parsed body type (Convertible, Coupe, Roadster, Fastback, etc.)
- **engine** (string), Parsed engine designation (Hemi, V8, Twin-Turbo, Boss, GTO, etc.)
- **color** (string), Exterior color as listed
- **interior** (string), Interior color / material
- **transmission** (string)
- **vin** (string), VIN / chassis serial when displayed
- **odometer** (number)
- **odometer_units** (string), 'M' (miles) or 'K' (kilometers)
- **estimate_low** (number)
- **estimate_high** (number)
- **current_bid** (number), Live current bid; null when not actively bidding
- **hammer_price** (number)
- **sold** (boolean)
- **bid_status** (string), 'Sold', 'Active bidding', or 'Unsold or upcoming' — computed from hammer + current_bid
- **description** (string), Full lot description (publicRemarks) or og:description fallback
- **photos** (array), Photo URLs (Cloudinary), scoped to this lot only
- **photo_count** (integer)
- **listing_url** (string)


### Quick start

1. Click **Try for free**.
2. Leave the input at defaults, or paste the recommended input from lower on this page.
3. Click **Start**. The default run finishes in under a minute with a small sample.
4. Open the **Dataset** tab to inspect the shape.
5. Once you like the output, click **Schedule** and pick a cadence. Daily is typical.

### How a run works

1. **Scan**, walks mecum.com from the seed URL, paginating through list pages.
2. **Fetch**, visits each detail page and extracts the fields listed above.
3. **Diff**, compares each record against the snapshot in your named key-value store, labelling it `new`, `changed` or `unchanged`.
4. **Persist**, the new snapshot is saved for the next run.

#### What is a delta feed and why does it save money?

A delta feed only pays for what changed since your last run. Instead of re-scraping every record each night, this scraper compares against your stored snapshot and only fully processes rows that added, changed or first appeared. Enable `onlyChanged` to skip unchanged rows entirely (they are billed at a discounted rate).

#### What differentiates this scraper?

Only Apify Store actor for Mecum with lot-level condition rating and restoration status. Kissimmee alone runs 3,500+ lots per event (world's largest collector-car auction). Complements a RM Sotheby's scraper (prestige) - together they define the muscle-car and classic market.

### Common use cases

- Bi-weekly post-event refresh capturing hammer prices
- Live-event bid monitoring during Kissimmee, Indy, Dallas events
- Historical make/model price-tracking across events and years
- Restoration-status vs condition analysis for appraisers
- Sold vs no-sale rate benchmarking by category


### How to interpret the fields

#### What does Hammer price vs estimate range mean?

Estimate low and high are Mecum's pre-sale forecasts. Hammer price is the actual sold value (0 or null when not sold). A hammer well above estimate high signals a hot market; well below signals soft demand or a reserve-not-met scenario.

#### What does Sold flag mean?

True when the lot met reserve and sold. False when withdrawn, no-sale, or reserve not met. Not-sold lots often relist at future Mecum events, so tracking the sold flag over time reveals sell-through rates.

#### What does Restoration status mean?

Common Mecum tags: original, restored, resto-mod, unrestored. Original + numbers-matching typically commands the highest premium. Resto-mod trades cheaper but has broader driver-market appeal.



### How this compares to alternative scrapers

#### Mecum scraper vs RM Sotheby's scraper

Mecum is volume (Kissimmee is 3,500+ lots per event). RM Sotheby's is prestige (single-owner curated lots at $100k+ average). Different segments of the same market. Together they cover the American classic + European exotic markets.

#### Mecum scraper vs classic.com or Hemmings

classic.com is a price-history aggregator across many auction houses (secondary source). Hemmings is dealer inventory + private-party marketplace (not auction). Mecum scraper is a primary source direct from the auctioneer.



### How much does it cost to scrape mecum.com?

Pay-per-event pricing:

- **Actor start**: $0.00500 per GB of memory, one event per run.
- **Lot scraped**: $0.00800 per record delivered to the dataset.
- **Lot checked, unchanged**: $0.00150 per row when `onlyChanged` is on and the row was unchanged. Roughly 19% the cost of a full record.

There are no per-request charges and no page-count charges. Costs come only from records you actually receive. A scheduled monitor in delta mode typically costs cents per day; a first-time full crawl is the expensive case that the delta model is designed to avoid on subsequent runs.

#### Concrete cost examples

Rule-of-thumb cost per run (assumes primary event only, no delta discount):

- **100 records** = about $0.80 in records + one actor-start fee
- **500 records** = about $4.00
- **1,000 records** = about $8.00
- **10,000 records** = about $80.00

With delta mode + `onlyChanged: true`, a daily monitor of 1,000 properties where 5% change costs roughly **$1.83 per run** (50 full charges + 950 delta-priced skips).

### Common questions

#### Does this scraper need a Mecum account?

No. All lot data is scraped from public /lots/{id} detail pages. Bidding requires an account on bidnow.mecum.com but this scraper does not touch that.

#### How does the scraper handle recycled lot IDs?

Past-auction lot IDs are occasionally purged and redirect to 404 pages. The scraper detects these via the blockAddress NotFoundPage marker and skips them without pushing partial records.

#### Which events are covered?

All events published on mecum.com/auctions/, which includes 12+ annual collector-car events (Kissimmee, Kansas City, Indy, Dallas, Monterey, Harrisburg, etc.) plus motorcycle and road-art auctions.

#### Is VIN always included?

Only when displayed on the Mecum lot page. Some lots show partial VIN (last few digits masked); others show none. The field is null when not displayed.

#### What is condition rating?

Mecum uses a numeric condition scale, typically 1-6 (1 = concours restoration, 6 = parts car). Extracted when present in the lot description.

#### Does this scraper need an account with mecum.com?

No. The scraper reads only public pages. You do not need credentials.

#### Why do I need to enable Apify Proxy?

Most sites at scale trigger rate limits or challenges against datacenter IPs. Apify Proxy (residential recommended) handles this. The default input keeps `useApifyProxy: true`.

#### Why does the state store need a name?

Delta mode compares each run against the previous snapshot. Apify wipes the default (unnamed) key-value store on every run, which would erase the snapshot. A NAMED store (`stateStoreName: "mecum-auctions-scraper-state"`) persists across runs.

#### Can I run in delta mode without paying for unchanged rows?

Yes. Set `onlyChanged: true`. Unchanged rows are billed at the discounted `record-checked` rate; changed rows at the full `lot` rate. New rows are always full price.

### Recommended daily-schedule input

```json
{
  "eventSlug": "kissimmee-2026",
  "maxItems": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

For a full-catalogue first run, raise `maxItems` to `0` (no cap) and leave `onlyChanged: false`. For daily monitoring, set `onlyChanged: true` and keep `maxItems` at `0`.

### Turn it into a live alert with Schedules and Webhooks

Combine this scraper with an Apify **Schedule** and a **Webhook** to get "new listing in my buy box" alerts without writing code.

1. Configure the input with your buy-box filters (yield floor, price ceiling, markets, etc).
2. Create a Schedule (Actor page, right rail, Schedule) at your cadence. Daily 06:00 UTC is typical.
3. Add a Webhook (Integrations tab on this actor):
   - Event: `ACTOR.RUN.SUCCEEDED`
   - URL: your Slack / Discord / Zapier / n8n endpoint
   - Payload template: pass `resource.defaultDatasetId` so the receiver can pull only the delta rows

For Slack, wrap the payload in a `text` field and push through an [incoming webhook](https://api.slack.com/messaging/webhooks). For Zapier or n8n, use the "Webhook by Apify" trigger and map dataset fields to your downstream tool of choice.

Pair this with `onlyChanged: true` and the actor becomes a pure alert feed. Delta-priced rows keep the bill flat on quiet days.

### Related scrapers from this publisher

- **James Suckling Wine Scraper - Scores & Drink Windows**, Scrape jamessuckling.

### Video walkthrough

Video walkthrough placeholder. Add a YouTube URL to `readme.video_url` in the yaml to auto-embed once one is published.

### Notes and limits

- Keep concurrency modest to stay polite to mecum.com. Default is 5.
- Field schemas can shift when the target site restyles. If a field starts returning `null`, report it and it will be patched.
- The default input is engineered to complete in under 5 minutes so the platform's daily automated test passes and the actor does not get flagged for maintenance.

### Legal

Reads only public /lots/ detail pages. Bidding subdomain (bidnow.mecum.com) is off-limits and not touched by this scraper. Mecum's robots.txt blocks several bots by user agent; this scraper uses a legitimate browser UA and moderate crawl rate. You are responsible for compliance with applicable law and Mecum's terms of service.

# Actor input Schema

## `eventSlug` (type: `string`):

The event URL segment (e.g. kissimmee-2026, indy-2026, dallas-2025).

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

0 = no cap.

## `onlyChanged` (type: `boolean`):

Delta mode (skip unchanged lots)

## `stateStoreName` (type: `string`):

State store name

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

Proxy

## `maxConcurrency` (type: `integer`):

Max concurrency (DETAIL Cheerio phase)

## `listConcurrency` (type: `integer`):

Max concurrency (LIST Playwright phase)

## `maxRequestRetries` (type: `integer`):

Max retries per request

## `requestHandlerTimeoutSecs` (type: `integer`):

Per-request timeout (seconds)

## Actor input object example

```json
{
  "eventSlug": "kissimmee-2026",
  "maxItems": 3,
  "onlyChanged": false,
  "stateStoreName": "mecum-state",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5,
  "listConcurrency": 1,
  "maxRequestRetries": 3,
  "requestHandlerTimeoutSecs": 120
}
```

# Actor output Schema

## `results` (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 = {
    "eventSlug": "kissimmee-2026",
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("growth-installations/mecum-auctions-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 = {
    "eventSlug": "kissimmee-2026",
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("growth-installations/mecum-auctions-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 '{
  "eventSlug": "kissimmee-2026",
  "maxItems": 3
}' |
apify call growth-installations/mecum-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mecum Auctions Scraper - Collector Car Lots & Results",
        "description": "Scrape Mecum Auctions for collector-car lots across live and past events: year, make, model, body style, engine, transmission, VIN partial, estimate range, hammer price, sold flag, condition, and photos. Covers Kissimmee (world's largest collector-car auction) and 12+ annual events.",
        "version": "0.0",
        "x-build-id": "ew4qfxLOcWwhoN38m"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/growth-installations~mecum-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-growth-installations-mecum-auctions-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/growth-installations~mecum-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-growth-installations-mecum-auctions-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/growth-installations~mecum-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-growth-installations-mecum-auctions-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": {
                    "eventSlug": {
                        "title": "Event slug",
                        "type": "string",
                        "description": "The event URL segment (e.g. kissimmee-2026, indy-2026, dallas-2025).",
                        "default": "kissimmee-2026"
                    },
                    "maxItems": {
                        "title": "Maximum lots",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = no cap.",
                        "default": 3
                    },
                    "onlyChanged": {
                        "title": "Delta mode (skip unchanged lots)",
                        "type": "boolean",
                        "description": "Delta mode (skip unchanged lots)",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "State store name",
                        "default": "mecum-state"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency (DETAIL Cheerio phase)",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Max concurrency (DETAIL Cheerio phase)",
                        "default": 5
                    },
                    "listConcurrency": {
                        "title": "Max concurrency (LIST Playwright phase)",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Max concurrency (LIST Playwright phase)",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max retries per request",
                        "default": 3
                    },
                    "requestHandlerTimeoutSecs": {
                        "title": "Per-request timeout (seconds)",
                        "minimum": 20,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Per-request timeout (seconds)",
                        "default": 120
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
