# IAA Featured Vehicle Inventory Scraper (`automation-lab/iaa-featured-vehicle-inventory-scraper`) Actor

🚗 Extract current IAA featured and Buy Now vehicle lots with prices, mileage, damage, location, stock IDs, condition flags, and images.

- **URL**: https://apify.com/automation-lab/iaa-featured-vehicle-inventory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## IAA Featured Vehicle Inventory Scraper

Collect current vehicle-lot cards from IAA's anonymous US homepage and turn them into clean, export-ready records.

The Actor captures vehicle IDs, stock numbers, year/make/model/series, Buy Now price, current bid, odometer, transmission, loss type, condition flags, branch/state, image, and lot URL.

Use it for recurring inventory snapshots, sourcing lists, price monitoring, and lightweight auction-market research without manually copying homepage cards.

> **Scope:** this Actor covers the current featured / Buy Now inventory visible on IAA's public US homepage. It does not claim full IAA search or detail-page coverage.

### What does the IAA Featured Vehicle Inventory Scraper do?

The scraper requests IAA's public US homepage and reads the structured vehicle-card payloads already delivered to anonymous visitors.

It then:

- 🚗 finds every current featured vehicle card;
- 🧾 normalizes lot and stock identifiers;
- 💵 converts displayed prices and bids to numbers;
- 🛣️ converts odometer readings to numeric values and units;
- 📍 captures branch and state;
- 🔑 records key and Run & Drive flags;
- 🖼️ preserves the source image and lot URLs;
- ♻️ removes duplicate card links;
- 📦 saves one vehicle lot per dataset row.

### Who is it for?

#### Used-car and salvage dealers

Schedule a small daily snapshot to spot featured inventory relevant to sourcing workflows.

#### Exporters and rebuilders

Export stock, location, condition, and price fields to a spreadsheet before deciding which lots deserve deeper manual review.

#### Auto-parts sellers

Watch year, make, model, series, damage type, and location for potential donor vehicles.

#### Insurers and valuation teams

Create timestamped samples of publicly featured salvage inventory for internal analysis.

#### Data teams

Feed normalized IAA lot-card records into warehouses, dashboards, alerts, or enrichment pipelines.

### Why use this Actor?

Manual copying is slow and inconsistent. This Actor gives each homepage vehicle the same stable field names and data types.

- **Repeatable:** run the same extraction on a schedule.
- **Typed:** prices, years, mileage, and booleans are normalized.
- **Traceable:** every row includes source and scrape timestamps.
- **Focused:** v1 makes no false promise of full challenged search coverage.
- **Integration-ready:** use datasets, webhooks, API clients, Zapier, Make, or MCP.

### What IAA vehicle data can I extract?

| Field | Type | Description |
|---|---|---|
| `detailUrl` | string | Public IAA lot URL linked by the card |
| `itemId` | string | IAA item identifier |
| `vehicleId` | string | IAA salvage / vehicle identifier |
| `stockNumber` | string | IAA stock number |
| `year` | number | Model year |
| `make` | string | Vehicle make |
| `model` | string | Vehicle model |
| `series` | string | Series or trim shown on the card |
| `title` | string | Combined year, make, model, and series |
| `buyNowPrice` | number or null | Numeric Buy Now price when present |
| `currentBid` | number or null | Numeric current bid when present |
| `currency` | string or null | Currency code, usually USD |
| `odometer` | number or null | Numeric odometer reading |
| `odometerUnit` | string or null | `mi` or `km` |
| `odometerBrand` | string or null | Odometer brand/status text when exposed |
| `transmission` | string or null | Transmission shown by IAA |
| `lossType` | string or null | Collision, water, other, or displayed loss type |
| `runAndDrive` | boolean | Whether the card shows Run & Drive |
| `keyAvailable` | boolean | Whether the card shows Key Available |
| `branch` | string or null | IAA branch |
| `state` | string or null | US state |
| `imageUrl` | string or null | Vehicle image URL |
| `isBuyNow` | boolean | Whether Buy Now is available |
| `isSold` | boolean | Sold flag from the card payload |
| `sourceUrl` | string | Homepage source URL |
| `scrapedAt` | string | UTC extraction timestamp |

### How to scrape IAA featured vehicle inventory

1. Open the Actor input page.
2. Choose the maximum number of lots to save.
3. Optionally enter exact state names.
4. Optionally enable **Buy Now only**.
5. Click **Start**.
6. Review results in the **Dataset** tab.
7. Export as JSON, CSV, Excel, XML, RSS, or HTML.

The public surface is finite, so a typical run completes quickly and returns only the cards currently featured by IAA.

### Input

A broad snapshot needs only:

```json
{
  "maxItems": 24
}
````

Filter by state:

```json
{
  "maxItems": 24,
  "states": ["Georgia", "New Jersey"]
}
```

Collect Buy Now cards only:

```json
{
  "maxItems": 24,
  "buyNowOnly": true
}
```

### Input options

#### `maxItems`

An integer from 1 to 100. The source itself usually exposes fewer cards than this cap.

#### `states`

An optional list of exact state names matched case-insensitively. Unknown names simply match no current cards.

#### `buyNowOnly`

Set to `true` to keep cards with Buy Now availability or a displayed Buy Now price.

#### `proxyConfiguration`

Optional Apify Proxy settings for environments where the homepage is transiently restricted. Direct HTTP is the default and normally costs less.

### Output example

```json
{
  "detailUrl": "https://www.iaai.com/us/VehicleDetail/44557845~US",
  "itemId": "64926352",
  "vehicleId": "44557845",
  "stockNumber": "44062062",
  "year": 2022,
  "make": "FORD",
  "model": "ESCAPE",
  "series": "SE",
  "title": "2022 FORD ESCAPE SE",
  "buyNowPrice": 3575,
  "currentBid": null,
  "currency": "USD",
  "odometer": 44974,
  "odometerUnit": "mi",
  "transmission": "Automatic",
  "lossType": "Collision",
  "runAndDrive": true,
  "keyAvailable": true,
  "branch": "Southern New Jersey",
  "state": "New Jersey",
  "imageUrl": "https://vis.iaai.com/resizer?imageKeys=44557845~SID~I1&width=400&height=300",
  "isBuyNow": true,
  "isSold": false,
  "sourceUrl": "https://www.iaai.com/us/home",
  "scrapedAt": "2026-07-19T00:00:00.000Z"
}
```

Current inventory changes continuously, so example values are illustrative rather than guaranteed.

### How much does it cost to scrape IAA featured inventory?

This Actor uses pay-per-event pricing. A run start costs **$0.005**, then each saved vehicle lot is charged at the plan-specific rate below.

| Apify plan tier | Price per saved vehicle lot |
|---|---:|
| FREE | $0.000059801 |
| BRONZE | $0.000052001 |
| SILVER | $0.000040561 |
| GOLD | $0.0000312 |
| PLATINUM | $0.0000208 |
| DIAMOND | $0.00001456 |

The Apify Console shows the exact maximum charge before each run. Filtered runs charge only for rows actually saved.

### Inventory monitoring workflow

For a simple new-lot monitor:

1. Create an Apify schedule for every morning.
2. Keep `maxItems` at 24.
3. Filter to relevant states if needed.
4. Export the dataset to your database.
5. Compare `vehicleId` or `stockNumber` with the previous snapshot.
6. Alert on unseen IDs or changed Buy Now prices.

Because the homepage selection is curated and finite, this is a featured-inventory monitor, not a complete auction-catalog mirror.

### Dealer sourcing workflow

Export rows to CSV and sort by:

- state and branch;
- Buy Now price;
- year, make, and model;
- loss type;
- Run & Drive status;
- key availability;
- odometer reading.

Open `detailUrl` for manual due diligence before bidding or purchasing.

### Tips for reliable runs

- Keep scheduled jobs at conservative intervals.
- Use exact state names such as `Georgia`.
- Do not expect `maxItems: 100` to manufacture 100 cards.
- Treat the lot URL as a review link, not a promise of detail-page enrichment.
- Configure a proxy only if logs show direct homepage access is blocked.
- Use `vehicleId` plus `stockNumber` for snapshot deduplication.

### Apify integrations

#### Google Sheets

Use an Apify integration or Make scenario to append each scheduled dataset to a sourcing sheet.

#### Webhooks

Trigger a webhook after successful runs, fetch the dataset, and compare it with prior vehicle IDs.

#### Zapier and Make

Create no-code alerts when a filtered dataset contains a matching make, state, or price threshold.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, PostgreSQL, or another analytics store.

#### Slack and email

Send a compact daily digest containing title, price, branch, and lot link for newly seen vehicles.

### Use the Actor with the Apify API

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/iaa-featured-vehicle-inventory-scraper').call({
  maxItems: 24,
  buyNowOnly: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/iaa-featured-vehicle-inventory-scraper').call(
    run_input={'maxItems': 24, 'states': ['Georgia']}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~iaa-featured-vehicle-inventory-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":24,"buyNowOnly":true}'
```

### Use the Actor through MCP

#### Claude Code MCP setup

Connect Apify's MCP server with the exact Claude Code command:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/iaa-featured-vehicle-inventory-scraper'
```

#### Claude Desktop MCP setup

Add this HTTP MCP server in Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/iaa-featured-vehicle-inventory-scraper"
    }
  }
}
```

#### Cursor MCP setup

Open **Cursor Settings → Tools & Integrations → MCP**, add a remote HTTP server named `apify`, and use:

```text
https://mcp.apify.com?tools=automation-lab/iaa-featured-vehicle-inventory-scraper
```

#### VS Code MCP setup

In VS Code, add an HTTP MCP server to `.vscode/mcp.json` with the same Apify MCP URL, then start the server from the MCP tools view.

Example prompts:

- “Run the IAA featured inventory scraper and show Buy Now vehicles.”
- “Collect current IAA homepage lots and group them by state.”
- “Return vehicle IDs, prices, loss types, and lot links as a table.”

### Data freshness

Every run requests the live anonymous homepage. `scrapedAt` records when the row was extracted.

IAA chooses which cards appear and may update them at any time. Repeated runs can therefore produce changed selection, price, or status values.

### Limits and known constraints

- The Actor covers the US homepage featured / Buy Now cards only.
- It does not paginate the full IAA auction catalog.
- It does not extract VIN, engine, sale date, or detail-only fields.
- Search and detail pages may present Incapsula challenges.
- IAA can change its homepage markup or embedded payload shape.
- State filters can legitimately produce zero rows.
- Images and linked pages remain controlled by IAA.

### Error handling

The Actor retries the homepage request up to three times.

If IAA returns no parseable cards after all attempts, the run fails instead of reporting a misleading successful empty extraction.

Malformed individual cards are skipped. Duplicate anchors for the same vehicle and stock number are emitted once.

### Is it legal to scrape IAA data?

Public web data can be subject to website terms, database rights, copyright, privacy, and jurisdiction-specific rules.

You are responsible for ensuring your collection and use are lawful and comply with IAA's terms and applicable regulations. Do not use the Actor to bypass access controls, impersonate users, or make automated purchase decisions without review.

This tool extracts the anonymous public homepage surface; it does not provide legal advice.

### Troubleshooting

#### The run returns zero rows after I set `states`

Verify that each value is an exact state name and that IAA currently features a card from that state. Remove the filter to inspect available states.

#### The run fails with an HTTP or no-card error

IAA may be temporarily restricting the homepage or may have changed its markup. Retry later, or configure an Apify Proxy after confirming direct access is blocked.

#### I requested 100 rows but received fewer

`maxItems` is a cap. The source displays a finite current card set, commonly far fewer than 100.

#### Why is VIN missing?

VIN is not exposed in the proven homepage card payload. This Actor intentionally avoids claiming challenged detail-page enrichment.

### FAQ

#### Does this scrape all IAA vehicles?

No. It extracts current cards on IAA's anonymous US homepage.

#### Does it require an IAA account?

No account is needed for the supported homepage surface.

#### Can I filter by make or price?

Those filters are not input fields in v1. Apply them to the resulting dataset or in your downstream workflow.

#### Can I run it on a schedule?

Yes. Apify schedules are useful for daily or hourly snapshots at a responsible frequency.

#### Are Buy Now prices numbers?

Yes. Displayed values such as `USD 3,575` become `buyNowPrice: 3575` and `currency: "USD"`.

#### How are duplicates handled?

Cards are deduplicated using the vehicle ID and stock number.

### Related automotive scrapers

Combine this Actor with other Automation Lab automotive data products:

- [AutoTrader Canada Vehicle Listings Scraper](https://apify.com/automation-lab/autotrader-canada-vehicle-listings-scraper)
- [Cars.com Vehicle Listings Scraper](https://apify.com/automation-lab/cars-com-vehicle-listings-scraper)
- [BOVAG Vehicle Listings Scraper](https://apify.com/automation-lab/bovag-vehicle-listings-scraper)
- [NHTSA Vehicle Complaints Scraper](https://apify.com/automation-lab/nhtsa-vehicle-complaints-scraper)

These cover different sources and workflows; they are not substitutes for IAA featured inventory.

### Support

If a run fails unexpectedly, share the run URL and a short description through the Actor's **Issues** tab.

Useful reports include:

- the exact input;
- expected versus actual rows;
- the time of the run;
- whether a proxy was enabled;
- one affected vehicle or state when applicable.

This makes source changes and parsing regressions easier to diagnose.

# Actor input Schema

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

Maximum number of current homepage vehicle cards to save. The source is a finite featured-inventory surface.

## `states` (type: `array`):

Optional exact US state names, for example Georgia or New Jersey. Leave empty for all featured lots.

## `buyNowOnly` (type: `boolean`):

Keep only vehicle cards that currently expose Buy Now availability or a Buy Now price.

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

Optional Apify Proxy configuration for transient IAA homepage blocking. Direct HTTP is used by default.

## Actor input object example

```json
{
  "maxItems": 12,
  "states": [],
  "buyNowOnly": false
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 12,
    "states": [],
    "buyNowOnly": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/iaa-featured-vehicle-inventory-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 12,
    "states": [],
    "buyNowOnly": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/iaa-featured-vehicle-inventory-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 12,
  "states": [],
  "buyNowOnly": false
}' |
apify call automation-lab/iaa-featured-vehicle-inventory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/iaa-featured-vehicle-inventory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IAA Featured Vehicle Inventory Scraper",
        "description": "🚗 Extract current IAA featured and Buy Now vehicle lots with prices, mileage, damage, location, stock IDs, condition flags, and images.",
        "version": "0.1",
        "x-build-id": "ah6ekIZJyHTVIVPPc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~iaa-featured-vehicle-inventory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-iaa-featured-vehicle-inventory-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/automation-lab~iaa-featured-vehicle-inventory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-iaa-featured-vehicle-inventory-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/automation-lab~iaa-featured-vehicle-inventory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-iaa-featured-vehicle-inventory-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": {
                    "maxItems": {
                        "title": "🚗 Maximum vehicle lots",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of current homepage vehicle cards to save. The source is a finite featured-inventory surface.",
                        "default": 24
                    },
                    "states": {
                        "title": "📍 State names",
                        "type": "array",
                        "description": "Optional exact US state names, for example Georgia or New Jersey. Leave empty for all featured lots.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyNowOnly": {
                        "title": "💵 Buy Now only",
                        "type": "boolean",
                        "description": "Keep only vehicle cards that currently expose Buy Now availability or a Buy Now price.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration for transient IAA homepage blocking. Direct HTTP is used by default."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```