# IAAI Salvage Vehicle Auctions Scraper (`crawlerbros/iaai-salvage-vehicle-auctions-scraper`) Actor

Scrape IAAI (Insurance Auto Auctions) salvage and insurance vehicle listings. Search by keyword/VIN/stock #, make/model/year, or browse by damage type, location, and title type - VIN, odometer, damage, sale date, images, and more.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## IAAI Salvage Vehicle Auctions Scraper

Scrape [IAAI](https://www.iaai.com) (Insurance Auto Auctions) salvage and insurance vehicle listings — search by keyword, VIN, or stock number; search by make/model/year; or browse by damage type, location, and title type. Get VIN, odometer, primary/secondary damage, loss type, title/sale document type, sale date, actual cash value, images, and more. No login, no cookies, no paid proxy required.

### What this actor does

- **Five modes:** `search` (keyword/VIN/stock #), `byMakeModel` (make/model/year), `byDamageType`, `byLocation` (state/branch), `byTitleType`
- **Combinable filters:** any optional filter (damage type, loss type, title type, state, branch, vehicle type, auction type, buyer eligibility, year range, odometer, actual cash value) can be layered onto any mode
- **Rich per-vehicle data:** VIN, year/make/model/trim, damage, odometer, colors, engine, transmission, drivetrain, body style, branch/location, sale date, current Buy Now price, actual cash value, and photo
- **Empty fields are omitted**

### Output per vehicle

- `lotId`, `stockNumber`, `vin` (see VIN note in Limitations below)
- `year`, `make`, `model`, `trim`, `title`
- `primaryDamage`, `secondaryDamage`, `lossType`, `titleType`
- `odometer`, `odometerUnit` (`mi` or `km` — Canadian-branch listings report kilometers), `odometerDisclosure` (e.g. `Not Actual`, `Not Required/Exempt`, `Exceeds Mechanical Limits` — only present when IAAI flags the reading; absence means a standard actual reading)
- `vehicleType`, `vehicleSubType`, `bodyStyle`, `startCode`, `airbags`, `key`
- `exteriorColor`, `interiorColor`, `engine`, `fuelType`, `cylinders`, `transmission`, `driveLineType`, `countryOfOrigin`
- `branch`, `region`, `market`, `laneRun`, `aisleStall`, `vehicleLocation`
- `actualCashValue`, `buyNowPrice`, `currency` (`USD` or `CAD`)
- `newInventoryDateTime`, `saleDateTime`, `saleListUrl`
- `imageUrl`, `detailUrl`, `sourceUrl`
- `recordType: "vehicle"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byMakeModel` / `byDamageType` / `byLocation` / `byTitleType` |
| `searchQuery` | string | `Honda` | Keyword, VIN, or stock number (mode=search) |
| `make` | string | – | Vehicle make (mode=byMakeModel, or extra filter anywhere) |
| `model` | string | – | Vehicle model (narrows `make`) |
| `yearMin` / `yearMax` | int | – | Model-year range |
| `damageType` | select | – | Primary damage taxonomy (mode=byDamageType, or extra filter anywhere) |
| `lossType` | select | – | Insurance loss category |
| `titleType` | select | – | Title/sale document type (mode=byTitleType, or extra filter anywhere) |
| `state` | select | – | US state / Canadian province (mode=byLocation, or extra filter anywhere) |
| `branch` | select | – | Specific IAAI auction branch (mode=byLocation, or extra filter anywhere) |
| `vehicleType` | select | – | High-level vehicle category |
| `auctionType` | select | – | Live / Timed / Buy Now |
| `whoCanBuy` | select | – | Buyer-eligibility category |
| `odometerMax` | int | – | Drop vehicles above this odometer reading |
| `acvMax` | int | – | Drop vehicles above this actual cash value (USD) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–1000) |

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "Honda Accord",
  "maxItems": 25
}
````

#### Example: search by make/model/year

```json
{
  "mode": "byMakeModel",
  "make": "Toyota",
  "model": "Camry",
  "yearMin": 2015,
  "yearMax": 2020,
  "maxItems": 50
}
```

#### Example: browse flood-damage vehicles in Texas

```json
{
  "mode": "byDamageType",
  "damageType": "Flood",
  "state": "Texas",
  "maxItems": 50
}
```

#### Example: browse a specific auction branch

```json
{
  "mode": "byLocation",
  "branch": "Dallas",
  "maxItems": 50
}
```

#### Example: clean-title vehicles only

```json
{
  "mode": "byTitleType",
  "titleType": "Clear",
  "maxItems": 50
}
```

### Use cases

- **Salvage & rebuilder sourcing** — find vehicles by damage type, title status, and location for parts or rebuild
- **Cross-platform arbitrage** — compare IAAI listings against other salvage auction sources
- **Insurance & total-loss research** — analyze damage-type and loss-type distribution by region
- **Export & dealer buying** — filter by buyer-eligibility category and branch to plan pickup logistics
- **Market analysis** — track actual cash value vs. current bid/Buy Now price across makes and model years

### Data Source / Limitations

- IAAI's public search page is scraped directly (no official API is used). All fields shown are those visible to an anonymous, non-logged-in visitor.
- **VIN is partially masked** for anonymous visitors (e.g. `1HGCM55864A******`) — the last several characters are hidden until you register and log in as a bidder on iaai.com. This actor does not use login credentials, so VINs are reported exactly as IAAI displays them publicly.
- **Seller name** is hidden behind a "Please log in as a buyer" prompt for anonymous visitors and is not included in the output.
- Current bid amounts for live/timed auctions in progress are not shown to anonymous visitors; `buyNowPrice` is included when a listing has a Buy Now option.
- Listing availability reflects IAAI's live inventory at scrape time — sold or removed vehicles will no longer appear.
- **Canadian coverage**: native IAAI Canada listings (e.g. Toronto, Montreal, Vancouver, Edmonton branches) are fully supported with correct `km`/`CAD` units. A small share of results filtered by a Canadian **province** (`state`) alone, without a `branch`, keyword, or make/model, come from a third-party auction partner's inventory cross-listed inside IAAI's search UI under a different page template that this actor does not parse (to avoid mixing in another company's catalog) — for reliable Canada-wide coverage, filter by `branch` or combine `state` with a keyword/make.

### FAQ

**Do I need an IAAI account?** No. This actor only reads data visible on the public search page.

**Why is the VIN partially hidden?** IAAI masks part of the VIN for visitors who aren't logged in as a registered bidder. This is a platform limitation, not a scraping issue.

**Can I combine filters, e.g. damage type + state + year range?** Yes — every optional filter field can be combined with any mode. For example, set `mode=byDamageType`, `damageType=Hail`, `state=Texas`, and `yearMin=2018` together.

**What does `titleType` mean?** It reflects the title or sale document IAAI will issue for the vehicle — e.g. `Salvage`, `Clear` (clean), `Non-Repairable`, `Repairable`, or `Bill Of Sale`.

**How many results can I get per run?** Set `maxItems` up to 1000. Larger requests take longer since IAAI serves up to 100 listings per page.

**Does this work outside the US?** Yes — IAAI's `state` filter includes both US states and Canadian provinces, and `branch` includes both US and Canadian auction locations.

# Actor input Schema

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

What to fetch.

## `searchQuery` (type: `string`):

Free-text search — keyword, full/partial VIN, or stock number (mode=search).

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

Vehicle make, e.g. `Toyota`, `Ford`, `Honda` (mode=byMakeModel, or as an extra filter in any mode).

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

Vehicle model, e.g. `Accord`, `Camry`, `F-150` (optional, narrows `make`).

## `yearMin` (type: `integer`):

Drop vehicles built before this year.

## `yearMax` (type: `integer`):

Drop vehicles built after this year.

## `damageType` (type: `string`):

IAAI's primary-damage taxonomy (mode=byDamageType, or as an extra filter in any mode).

## `lossType` (type: `string`):

Insurance loss category (optional filter, any mode).

## `titleType` (type: `string`):

Title or sale-document type, e.g. Salvage, Clear, Non-Repairable (mode=byTitleType, or as an extra filter in any mode).

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

US state or Canadian province where the vehicle is located (mode=byLocation, or as an extra filter in any mode).

## `branch` (type: `string`):

Specific IAAI auction branch (mode=byLocation, or as an extra filter in any mode). More granular than `state`.

## `vehicleType` (type: `string`):

High-level vehicle category (optional filter, any mode).

## `auctionType` (type: `string`):

Live auction, timed auction, or Buy Now listings (optional filter, any mode).

## `whoCanBuy` (type: `string`):

Buyer-eligibility category for the listing (optional filter, any mode).

## `odometerMax` (type: `integer`):

Drop vehicles with a higher recorded odometer reading than this.

## `acvMax` (type: `integer`):

Drop vehicles with a higher insurer-assessed actual cash value (ACV) than this.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Honda",
  "maxItems": 20
}
```

# Actor output Schema

## `vehicles` (type: `string`):

Dataset containing all scraped IAAI vehicle listings.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "Honda",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/iaai-salvage-vehicle-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 = {
    "mode": "search",
    "searchQuery": "Honda",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/iaai-salvage-vehicle-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 '{
  "mode": "search",
  "searchQuery": "Honda",
  "maxItems": 20
}' |
apify call crawlerbros/iaai-salvage-vehicle-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IAAI Salvage Vehicle Auctions Scraper",
        "description": "Scrape IAAI (Insurance Auto Auctions) salvage and insurance vehicle listings. Search by keyword/VIN/stock #, make/model/year, or browse by damage type, location, and title type - VIN, odometer, damage, sale date, images, and more.",
        "version": "1.0",
        "x-build-id": "SGebP2EEsvVapfrzY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~iaai-salvage-vehicle-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-iaai-salvage-vehicle-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/crawlerbros~iaai-salvage-vehicle-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-iaai-salvage-vehicle-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/crawlerbros~iaai-salvage-vehicle-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-iaai-salvage-vehicle-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byMakeModel",
                            "byDamageType",
                            "byLocation",
                            "byTitleType"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (keyword / VIN / stock #)",
                        "type": "string",
                        "description": "Free-text search — keyword, full/partial VIN, or stock number (mode=search).",
                        "default": "Honda"
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Vehicle make, e.g. `Toyota`, `Ford`, `Honda` (mode=byMakeModel, or as an extra filter in any mode)."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Vehicle model, e.g. `Accord`, `Camry`, `F-150` (optional, narrows `make`)."
                    },
                    "yearMin": {
                        "title": "Year (min)",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop vehicles built before this year."
                    },
                    "yearMax": {
                        "title": "Year (max)",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop vehicles built after this year."
                    },
                    "damageType": {
                        "title": "Primary damage type",
                        "enum": [
                            "All Over",
                            "Biohazard",
                            "Charity",
                            "Electrical",
                            "Engine Burn",
                            "Engine Damage",
                            "Engine Fire",
                            "Exterior Burn",
                            "Flood",
                            "Frame",
                            "Fresh Water",
                            "Front",
                            "Front & Rear",
                            "Front End",
                            "Hail",
                            "Interior Burn",
                            "Interior Damage",
                            "Interior Fire",
                            "Left & Right Side",
                            "Left Front",
                            "Left Rear",
                            "Left Side",
                            "Mechanical",
                            "None",
                            "Normal Wear & Tear",
                            "Possible Mech.",
                            "Rear",
                            "Repossession",
                            "Right Front",
                            "Right Rear",
                            "Right Side",
                            "Roll Over",
                            "Rollover",
                            "Roof",
                            "Roof Damage",
                            "Salt Water",
                            "Storm Damage",
                            "Strip",
                            "Suspension",
                            "Theft",
                            "Total Burn",
                            "Transmission Damage",
                            "Undercarriage",
                            "Unknown",
                            "Vandalized",
                            "Water"
                        ],
                        "type": "string",
                        "description": "IAAI's primary-damage taxonomy (mode=byDamageType, or as an extra filter in any mode)."
                    },
                    "lossType": {
                        "title": "Loss type",
                        "enum": [
                            "Collision",
                            "Fire",
                            "Other",
                            "Theft",
                            "Water"
                        ],
                        "type": "string",
                        "description": "Insurance loss category (optional filter, any mode)."
                    },
                    "titleType": {
                        "title": "Title / sale document type",
                        "enum": [
                            "Bill Of Sale",
                            "Clear",
                            "Non-Repairable",
                            "None",
                            "PartsOnly",
                            "Repairable",
                            "Salvage"
                        ],
                        "type": "string",
                        "description": "Title or sale-document type, e.g. Salvage, Clear, Non-Repairable (mode=byTitleType, or as an extra filter in any mode)."
                    },
                    "state": {
                        "title": "Vehicle location — state/province",
                        "enum": [
                            "AB",
                            "Alabama",
                            "Alaska",
                            "Arizona",
                            "Arkansas",
                            "BC",
                            "California",
                            "Colorado",
                            "Connecticut",
                            "Delaware",
                            "Florida",
                            "Georgia",
                            "Hawaii",
                            "Idaho",
                            "Illinois",
                            "Indiana",
                            "Iowa",
                            "Kansas",
                            "Kentucky",
                            "Louisiana",
                            "MB",
                            "Maine",
                            "Maryland",
                            "Massachusetts",
                            "Michigan",
                            "Minnesota",
                            "Mississippi",
                            "Missouri",
                            "Montana",
                            "NB",
                            "NL",
                            "NS",
                            "Nebraska",
                            "Nevada",
                            "New Hampshire",
                            "New Jersey",
                            "New Mexico",
                            "New York",
                            "North Carolina",
                            "North Dakota",
                            "ON",
                            "Ohio",
                            "Oklahoma",
                            "Oregon",
                            "Pennsylvania",
                            "QC",
                            "Rhode Island",
                            "SK",
                            "South Carolina",
                            "South Dakota",
                            "Tennessee",
                            "Texas",
                            "Utah",
                            "Vermont",
                            "Virginia",
                            "Washington",
                            "West Virginia",
                            "Wisconsin",
                            "Wyoming"
                        ],
                        "type": "string",
                        "description": "US state or Canadian province where the vehicle is located (mode=byLocation, or as an extra filter in any mode)."
                    },
                    "branch": {
                        "title": "Vehicle location — IAAI branch",
                        "enum": [
                            "ACE - Carson",
                            "ACE - Perris",
                            "ACE - Perris 2",
                            "AMARANTH-ON",
                            "Abilene",
                            "Akron-Canton",
                            "Albany",
                            "Albuquerque",
                            "Altoona",
                            "Amarillo",
                            "Anaheim",
                            "Anaheim Consolidated",
                            "Anchorage",
                            "Appleton",
                            "Asheville",
                            "Ashland",
                            "Atlanta",
                            "Atlanta East",
                            "Atlanta North",
                            "Atlanta South",
                            "Atlanta West",
                            "Austin",
                            "Austin North",
                            "Avenel New Jersey",
                            "BRANDON-MB-MB",
                            "Baltimore",
                            "Baton Rouge",
                            "Billings",
                            "Birmingham",
                            "Boise",
                            "Boston - Shirley",
                            "Bowling Green",
                            "Bridgeport",
                            "Buckhannon",
                            "Buffalo",
                            "Burlington",
                            "CAN-AM Processing Centre",
                            "CHICAGO-IL",
                            "Calgary South",
                            "Casper",
                            "Central New Jersey",
                            "Charleston",
                            "Charlotte",
                            "Chattanooga",
                            "Chicago-North",
                            "Chicago-South",
                            "Chicago-West",
                            "Cincinnati",
                            "Clearwater",
                            "Cleveland",
                            "Colorado Springs",
                            "Columbus",
                            "Concord",
                            "Corpus Christi",
                            "Culpeper",
                            "Dallas",
                            "Dallas/Ft Worth",
                            "Davenport",
                            "Dayton",
                            "Denver East",
                            "Des Moines",
                            "Detroit",
                            "Dothan",
                            "Dundalk",
                            "EDMONTON-AB",
                            "East Bay",
                            "Edmonton",
                            "El Paso",
                            "Elkton",
                            "Englishtown",
                            "Erie",
                            "Eugene",
                            "Fargo",
                            "Fayetteville",
                            "Flint",
                            "Fontana",
                            "Fort Myers",
                            "Fort Pierce",
                            "Fort Wayne",
                            "Fort Worth North",
                            "Fraser Valley",
                            "Fremont",
                            "Fresno",
                            "Grand Rapids",
                            "Greensboro",
                            "Greenville",
                            "Grenada",
                            "Gulf Coast",
                            "Halifax",
                            "Hamilton",
                            "Hartford",
                            "High Desert",
                            "High Point",
                            "Honolulu",
                            "Houston",
                            "Houston South",
                            "Houston-North",
                            "Huntsville",
                            "Indianapolis",
                            "Indianapolis South",
                            "Jackson",
                            "Jacksonville",
                            "Kansas City",
                            "Kansas City East",
                            "Knoxville",
                            "LETHBRIDGE-AB",
                            "Lafayette",
                            "Lake City",
                            "Las Vegas",
                            "Lexington",
                            "Lincoln",
                            "Little Rock",
                            "London",
                            "Long Island",
                            "Longview",
                            "Los Angeles",
                            "Los Angeles South",
                            "Louisville North",
                            "Lower Mainland",
                            "Lubbock",
                            "MONTREAL-QC",
                            "Macon",
                            "Manchester",
                            "Manitoba",
                            "McAllen",
                            "Memphis",
                            "Metro DC",
                            "Miami-North",
                            "Milwaukee",
                            "Minneapolis South",
                            "Minneapolis/St. Paul",
                            "Missoula",
                            "Mobile",
                            "Moncton",
                            "Monticello",
                            "Montreal East",
                            "Montreal West",
                            "Moose Jaw",
                            "NORTH-EAST-MD",
                            "Nanaimo",
                            "Nashville",
                            "New Castle",
                            "New Orleans East",
                            "Newburgh",
                            "North Battleford",
                            "North Hollywood",
                            "Northern Interior",
                            "Northern Virginia",
                            "ORLANDO-FL",
                            "Oklahoma City",
                            "Omaha",
                            "Omaha South",
                            "Orlando",
                            "Orlando-North",
                            "Ottawa",
                            "PHOENIX-AZ",
                            "PRINCE-GEORGE-BC",
                            "Paducah",
                            "Pensacola",
                            "Permian Basin",
                            "Philadelphia",
                            "Phoenix",
                            "Pittsburgh",
                            "Pittsburgh-North",
                            "Port Murray",
                            "Portage",
                            "Portland",
                            "Portland - Gorham",
                            "Portland South",
                            "Portland West",
                            "Prince Albert",
                            "Providence",
                            "Provo",
                            "Pulaski",
                            "Quebec City",
                            "Raleigh",
                            "Regina",
                            "Reno",
                            "Richmond",
                            "Riverside",
                            "Roanoke",
                            "Rochester",
                            "Sacramento",
                            "Sacramento West",
                            "Sacramento, CA",
                            "Salt Lake City",
                            "San Antonio-South",
                            "San Diego",
                            "Santa Clarita",
                            "Saskatoon",
                            "Savannah",
                            "Sayreville",
                            "Scranton",
                            "Seattle",
                            "Shady Spring",
                            "Shreveport",
                            "Sioux Falls",
                            "South Bend",
                            "Southern Interior",
                            "Southern New Jersey",
                            "Specialty Division",
                            "Spokane",
                            "Springfield",
                            "St. Cloud",
                            "St. John's",
                            "St. Louis",
                            "Staten Island",
                            "Stockton",
                            "Sudbury",
                            "Suffolk",
                            "Syracuse",
                            "TRURO-NS",
                            "Tampa",
                            "Tampa North",
                            "Taunton",
                            "Templeton",
                            "Tidewater",
                            "Tifton",
                            "Toronto",
                            "Toronto North",
                            "Toronto West",
                            "Tucson",
                            "Tulsa",
                            "Vancouver",
                            "Victoria",
                            "West Palm Beach",
                            "Western Colorado",
                            "Wichita",
                            "Wilmington",
                            "Winnipeg",
                            "York Springs",
                            "Yorkton"
                        ],
                        "type": "string",
                        "description": "Specific IAAI auction branch (mode=byLocation, or as an extra filter in any mode). More granular than `state`."
                    },
                    "vehicleType": {
                        "title": "Vehicle type",
                        "enum": [
                            "Automobiles",
                            "Classics",
                            "Fleet Vehicles",
                            "Light Trucks",
                            "Motorcycles",
                            "Pick-up Trucks",
                            "Recreational/ Miscellaneous",
                            "Rental Vehicles",
                            "SUVs",
                            "Vans"
                        ],
                        "type": "string",
                        "description": "High-level vehicle category (optional filter, any mode)."
                    },
                    "auctionType": {
                        "title": "Auction type",
                        "enum": [
                            "Buy Now",
                            "Live Auctions",
                            "Timed Auctions"
                        ],
                        "type": "string",
                        "description": "Live auction, timed auction, or Buy Now listings (optional filter, any mode)."
                    },
                    "whoCanBuy": {
                        "title": "Who can buy",
                        "enum": [
                            "Available to the public",
                            "Dealer",
                            "Dismantler",
                            "Exporter",
                            "Non-Auto Licensed Business",
                            "Other Licensed Business",
                            "Rebuilder",
                            "Scrapper"
                        ],
                        "type": "string",
                        "description": "Buyer-eligibility category for the listing (optional filter, any mode)."
                    },
                    "odometerMax": {
                        "title": "Max odometer (miles)",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Drop vehicles with a higher recorded odometer reading than this."
                    },
                    "acvMax": {
                        "title": "Max actual cash value (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop vehicles with a higher insurer-assessed actual cash value (ACV) than this."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
