# CLASSIC.COM Scraper — Global Classic Car Aggregator (`rastriq/classic-com-scraper`) Actor

Scrape classic car listings from CLASSIC.COM (classic.com), the world's largest aggregator with 800K+ listings from auctions, dealers, and private sellers. Extract prices, sources, auction houses, and sold dates for market analysis.

- **URL**: https://apify.com/rastriq/classic-com-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## CLASSIC.COM Scraper — Extract Classic Car Listings at Scale

Scrape classic, exotic, and collector car listings from [classic.com](https://www.classic.com) — the world's largest classic car search engine with 1M+ vehicles from Bring a Trailer, Cars & Bids, Mecum, RM Sotheby's, Collecting Cars, and thousands of dealers. CLASSIC.COM Scraper extracts 25+ structured fields including VIN, engine specs, mileage, pricing, taxonomy, and full vehicle history metadata — all without an API key or login.

> 🚀 **Try it free** — your first $5 of usage is on Apify. No credit card required.


### 📌 What is CLASSIC.COM Scraper?

**CLASSIC.COM Scraper** is an unofficial classic.com API that extracts structured vehicle data from the world's largest classic car aggregator. Unlike manually browsing classic.com — which limits you to 24 results per page across 40,000+ pages — this scraper lets you extract thousands of listings with full spec sheets in minutes.

Use CLASSIC.COM Scraper to:

- 🔍 **Find undervalued classics** — search by make, model, year range, and price to spot opportunities before they sell
- 📊 **Track market trends** — monitor price movements across segments (Porsche 911, Land Cruiser FJ40, Ferrari 250 GT)
- 🏆 **Build dealer inventory feeds** — export structured data for dealership websites, marketplaces, or CRM systems
- 📈 **Research for investment** — analyze asking prices, mileage distributions, and model generation premiums
- 🔄 **Automate recurring reports** — schedule daily/weekly runs and integrate with Google Sheets, Make, or Zapier

The Apify platform gives CLASSIC.COM Scraper superpowers: **scheduling**, **monitoring**, **API access**, and **integrations** with Make, Zapier, Google Sheets, and more — all out of the box.


### 📋 What data does CLASSIC.COM Scraper extract?

CLASSIC.COM Scraper returns structured data with 25+ fields per vehicle:

| Field | Type | Description |
|-------|------|-------------|
| 🏷️ `title` | string | Full listing title (e.g. "1983 Toyota Land Cruiser FJ40") |
| 📅 `model_year` | number | Year of manufacture |
| 🏭 `brand` | string | Manufacturer (Porsche, Toyota, Ferrari...) |
| 🚗 `model_family` | string | Model line (911, Land Cruiser, 250 GT...) |
| 🧬 `model_generation` | string | Generation (991.2, 40 Series, E-Type S1...) |
| 🔧 `model_variant` | string | Variant (GT2 RS, FJ40, Carrera 4S...) |
| ✂️ `model_trim` | string | Trim level (Weissach, The FJ Company...) |
| 🔑 `vin` | string | VIN or chassis number |
| 🛣️ `mileage_value` | number | Odometer reading |
| ⚙️ `engine` | string | Engine specs (3.8L Turbo H6, 4.2L I6...) |
| 🔄 `transmission` | string | Manual / Automatic |
| 🏎️ `drive_type` | string | RWD / AWD / 4WD |
| 🚘 `body_style` | string | Coupe / Convertible / SUV / Sedan... |
| 🎨 `color_exterior` | string | Exterior color group |
| 🪑 `color_interior` | string | Interior color group |
| 💰 `price` | number | Asking price |
| 💱 `price_currency` | string | USD / EUR / GBP |
| 📍 `location` | string | City, state, country |
| 📊 `status` | string | for_sale / sold / off_market |
| 🖼️ `image_url` | string | Primary listing photo URL |
| 🗓️ `listed_date` | string | Date the listing was posted |
| 🌳 `taxonomy_path` | array | Breadcrumb from make to specific variant |
| 🔗 `market_url` | string | Link to the classic.com market page |
| ⭐ `originality` | string | Conservation status (Original, Modified...) |
| 🚪 `doors` | number | Number of doors |

> 💡 Fields like `model_trim`, `originality`, and `color_interior` may not appear in all listings — they depend on what information the seller provided.


### 🚀 How to use CLASSIC.COM Scraper

#### Option A — Paste a search URL (recommended)

1. Go to [classic.com/search](https://www.classic.com/search/) and build your search using their powerful filters
2. Use [classic.com's search syntax](https://www.classic.com/insights/tips-for-searching/): year ranges (`1970-1985`), exact match (`"FJ40"`), exclusions (`-convertible`), OR operator (`(FJ40 OR FJ43)`)
3. Copy the URL from your browser
4. Paste it into the **Search URL** field and click **Save & Run**

#### Option B — Use Make and Model fields

1. Enter a **Make** (e.g. `porsche`) and optionally a **Model** (e.g. `911`)
2. Set year filters if needed
3. Click **Save & Run**

#### Option C — Full catalog crawl

1. Leave all search fields empty
2. Set **Discovery mode** to `Sitemap`
3. Set a reasonable **Max results** limit (start with 1,000)
4. Click **Save & Run**

#### After running

Results appear in the **Dataset** tab. Export to JSON, CSV, Excel, or connect via API. Use the Apify **Scheduler** to automate daily/weekly runs.


### ⚙️ Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `searchUrl` | string | Direct classic.com search URL — takes priority over Make/Model. Supports all search syntax (year ranges, quotes, exclusions, OR). |
| `make` | string | Car manufacturer (e.g. `porsche`, `toyota`). Ignored when Search URL is set. |
| `model` | string | Car model (e.g. `911`, `land cruiser`). |
| `year_min` / `year_max` | integer | Year range filter. Only applied with Make/Model. |
| `max_items` | integer | Maximum listings to return. Default: 100. |
| `max_pages` | integer | Maximum search result pages (24 listings/page). |
| `fetch_details` | boolean | Visit each detail page for 25+ fields. Default: true. |
| `skip_seen` | boolean | Skip previously-scraped vehicles across runs. Default: true. |
| `proxyConfiguration` | object | Optional proxy. Not required — works from datacenter IPs. |


### 📦 Output example

```json
{
  "title": "1983 Toyota Land Cruiser FJ40 by The FJ Company",
  "model_year": 1983,
  "brand": "Toyota",
  "model_family": "Land Cruiser",
  "model_generation": "40 Series (Post-facelift)",
  "model_variant": "FJ40",
  "model_trim": "The FJ Company",
  "vin": "FJ40361569",
  "mileage_value": 950,
  "mileage_unit": "mi",
  "engine": "4.2L I6 (2F)",
  "transmission": "Manual",
  "drive_type": "Four Wheel Drive (4WD/AWD)",
  "body_style": "SUV",
  "doors": 2,
  "color_exterior": "Beige",
  "color_interior": "Beige/Tan",
  "originality": "Original & Highly Original",
  "price": 95000,
  "price_currency": "USD",
  "status": "for_sale",
  "location": "Lubbock, Texas, USA",
  "image_url": "https://images.classic.com/vehicles/329a38...jpeg",
  "listed_date": "Jun 30, 2026",
  "taxonomy_path": ["Toyota", "Land Cruiser", "40 Series", "FJ40"],
  "market_url": "https://www.classic.com/m/toyota/land-cruiser/40-series/fj40/",
  "url": "https://www.classic.com/veh/1983-toyota-land-cruiser-fj40-...",
  "scraped_at": "2026-07-02T18:54:19.649661+00:00",
  "source_site": "classic.com"
}
````

### 💰 How much does it cost to use CLASSIC.COM Scraper?

CLASSIC.COM Scraper runs on Apify's standard Compute Unit (CU) pricing. It is extremely efficient because it uses plain HTTP requests (no browser):

| Run size | Duration | Cost | CUs |
|----------|----------|------|-----|
| 5 listings with details | ~5 seconds | < $0.01 | 0.002 |
| 100 listings with details | ~2 minutes | ~$0.005 | 0.016 |
| 1,000 listings with details | ~20 minutes | ~$0.05 | 0.16 |

> 💡 **Tip**: Set `fetch_details: false` for URL-only mode — approximately 10× faster and cheaper when you only need titles and prices from the search cards.

Your first $5 of platform credit is free — enough for roughly 10,000 listings with full details.

### 🔗 Related Actors

Explore more classic and collector car data scrapers by [Rastriq](https://apify.com/rastriq):

- **[ClassicCars.com Scraper](https://apify.com/rastriq/classiccars-com-scraper)** — scrape America's largest classic car classified site (40K+ listings)
- **[Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper)** — extract auction results from the UK's leading online car auction platform
- **[Classic Trader Scraper](https://apify.com/rastriq/classic-trader-scraper)** — scrape Europe's premium classic car marketplace

### ❓ FAQ

**Does CLASSIC.COM Scraper comply with classic.com's terms?**
This actor only accesses publicly available data that is visible to any visitor. It respects classic.com's `robots.txt` (which explicitly allows `/veh/`, `/search/`, and `/m/` paths) and uses reasonable rate limiting.

**Does it extract data behind the Insider paywall?**
No. Market charts, historical sale comps, and "Vehicle History" timelines behind the $5/mo Insider subscription are never accessed. Only publicly visible listing data is extracted.

**Why is `price` empty on some listings?**
Off-market and sold listings often don't display a current asking price. The `status` field indicates whether the vehicle is `for_sale`, `sold`, or `off_market`.

**Can I scrape the entire catalog (1M+ listings)?**
Yes — leave the search fields empty and set `mode: sitemap`. Use a reasonable `max_items` limit and consider running incrementally with `skip_seen: true`.

**How does the search URL syntax work?**
Classic.com supports powerful search syntax: year ranges (`1970-1985`), exact match with quotes (`"FJ40"`), exclude terms with minus (`-convertible`), and OR operator (`(FJ40 OR FJ43)`). Read the [official tips](https://www.classic.com/insights/tips-for-searching/) and paste the resulting URL into the **Search URL** field.

**Do I need a proxy?**
No. CLASSIC.COM Scraper uses TLS fingerprint impersonation that passes Cloudflare's protection from standard datacenter IPs. Add a proxy only if you experience blocking at very high volumes.

# Actor input Schema

## `searchUrl` (type: `string`):

Paste a classic.com search URL directly. Build your search on <a href='https://www.classic.com/search/' target='_blank'>classic.com/search</a> using filters, year ranges (<code>1970-1985</code>), exact match (<code>"FJ40"</code>), exclusions (<code>-convertible</code>), OR (<code>(FJ40 OR FJ43)</code>), then copy the URL.<br><br>Examples:<br>• <code>https://www.classic.com/search/?q=land+cruiser</code><br>• <code>https://www.classic.com/search/?q=1970-1985+%22FJ40%22</code><br>• <code>https://www.classic.com/search/?q=porsche+911+-turbo</code>

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

Car manufacturer. Ignored when Search URL is set.<br>Examples: <code>porsche</code>, <code>ferrari</code>, <code>toyota</code>

## `model` (type: `string`):

Car model. Ignored when Search URL is set.<br>Examples: <code>911</code>, <code>250 GT</code>, <code>land cruiser</code>

## `year_min` (type: `integer`):

Earliest model year. Only with Make/Model — for Search URL, use year ranges in the query (e.g. <code>1970-1985</code>).

## `year_max` (type: `integer`):

Latest model year. Only with Make/Model.

## `max_items` (type: `integer`):

Maximum listings to return. Start with <b>20</b> for testing. classic.com has 1M+ listings in full catalog mode.

## `max_pages` (type: `integer`):

Maximum search result pages (24 listings/page) or sitemap files to process.

## `fetch_details` (type: `boolean`):

Visit each vehicle's detail page to extract 25+ fields (VIN, engine, mileage, colors, taxonomy). Disable for URL/price-only mode (~10× faster).

## `skip_seen` (type: `boolean`):

Remembers vehicle IDs across runs. Turn off for a full re-scrape.

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

<b>Auto</b>: Search URL → search by Make/Model → sitemap crawl.

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

Optional. This actor works from datacenter IPs without a proxy. Add one only if you experience blocking at high volumes.

## Actor input object example

```json
{
  "make": "porsche",
  "model": "911",
  "max_items": 20,
  "fetch_details": true,
  "skip_seen": true,
  "mode": "auto",
  "proxyConfiguration": {
    "useApifyProxy": false,
    "proxyUrls": []
  }
}
```

# 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 = {
    "make": "porsche",
    "model": "911",
    "max_items": 20,
    "proxyConfiguration": {
        "useApifyProxy": false,
        "proxyUrls": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/classic-com-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 = {
    "make": "porsche",
    "model": "911",
    "max_items": 20,
    "proxyConfiguration": {
        "useApifyProxy": False,
        "proxyUrls": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/classic-com-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 '{
  "make": "porsche",
  "model": "911",
  "max_items": 20,
  "proxyConfiguration": {
    "useApifyProxy": false,
    "proxyUrls": []
  }
}' |
apify call rastriq/classic-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CLASSIC.COM Scraper — Global Classic Car Aggregator",
        "description": "Scrape classic car listings from CLASSIC.COM (classic.com), the world's largest aggregator with 800K+ listings from auctions, dealers, and private sellers. Extract prices, sources, auction houses, and sold dates for market analysis.",
        "version": "0.0",
        "x-build-id": "jc7D9oPDgi4ve79Cz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rastriq~classic-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rastriq-classic-com-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/rastriq~classic-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rastriq-classic-com-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/rastriq~classic-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rastriq-classic-com-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": {
                    "searchUrl": {
                        "title": "Search URL",
                        "type": "string",
                        "description": "Paste a classic.com search URL directly. Build your search on <a href='https://www.classic.com/search/' target='_blank'>classic.com/search</a> using filters, year ranges (<code>1970-1985</code>), exact match (<code>\"FJ40\"</code>), exclusions (<code>-convertible</code>), OR (<code>(FJ40 OR FJ43)</code>), then copy the URL.<br><br>Examples:<br>• <code>https://www.classic.com/search/?q=land+cruiser</code><br>• <code>https://www.classic.com/search/?q=1970-1985+%22FJ40%22</code><br>• <code>https://www.classic.com/search/?q=porsche+911+-turbo</code>"
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Car manufacturer. Ignored when Search URL is set.<br>Examples: <code>porsche</code>, <code>ferrari</code>, <code>toyota</code>"
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Car model. Ignored when Search URL is set.<br>Examples: <code>911</code>, <code>250 GT</code>, <code>land cruiser</code>",
                        "default": ""
                    },
                    "year_min": {
                        "title": "Year from",
                        "minimum": 1886,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Earliest model year. Only with Make/Model — for Search URL, use year ranges in the query (e.g. <code>1970-1985</code>)."
                    },
                    "year_max": {
                        "title": "Year to",
                        "minimum": 1886,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Latest model year. Only with Make/Model."
                    },
                    "max_items": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum listings to return. Start with <b>20</b> for testing. classic.com has 1M+ listings in full catalog mode.",
                        "default": 100
                    },
                    "max_pages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum search result pages (24 listings/page) or sitemap files to process."
                    },
                    "fetch_details": {
                        "title": "Fetch full vehicle details",
                        "type": "boolean",
                        "description": "Visit each vehicle's detail page to extract 25+ fields (VIN, engine, mileage, colors, taxonomy). Disable for URL/price-only mode (~10× faster).",
                        "default": true
                    },
                    "skip_seen": {
                        "title": "Skip previously-seen vehicles",
                        "type": "boolean",
                        "description": "Remembers vehicle IDs across runs. Turn off for a full re-scrape.",
                        "default": true
                    },
                    "mode": {
                        "title": "Discovery mode",
                        "enum": [
                            "auto",
                            "search",
                            "sitemap"
                        ],
                        "type": "string",
                        "description": "<b>Auto</b>: Search URL → search by Make/Model → sitemap crawl.",
                        "default": "auto"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. This actor works from datacenter IPs without a proxy. Add one only if you experience blocking at high volumes."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
