# IAAI Scraper — IAA Salvage Auction Vehicle Listings (`s-r/iaai-scraper`) Actor

Export IAA salvage auction vehicles by keyword, make, year, damage or location: stock ID, masked VIN, mileage, damage, title status, auction date, branch, ACV, Buy Now price and photo. For exporters, rebuilders and appraisers.

- **URL**: https://apify.com/s-r/iaai-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 vehicle listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## IAAI Scraper

This IAAI scraper exports public IAA vehicle auction listings for salvage buyers, vehicle exporters, repair businesses and valuation teams. Search by keyword or paste an IAA search URL, then narrow the results by make, model, year, damage, title document or location. Each dataset row represents one vehicle listing and includes the identifiers needed to revisit that vehicle on IAA.

Insurance Auto Auctions (IAA, iaai.com) is one of the largest salvage auctions in the United States: insurers, rental companies and dealers sell damaged, recovered-theft and clean-title vehicles there. The site is built for browsing one vehicle at a time. This actor turns the same public salvage auction search into a structured table you can filter, compare, join with your own data and schedule.

The actor collects information shown on public search results. VINs remain masked, and current or highest bids are not available to visitors who are not signed in. These limitations are reflected in the output rather than replaced with inferred values. Buy-Now prices and actual cash values are separate fields, so an estimate of pre-damage value cannot accidentally be treated as a purchase price.

### What the IAAI scraper collects

- Vehicle identity: IAA item ID, stock number, detail URL, title, year, make, model, series and masked VIN.
- Condition: odometer with its unit, primary and secondary damage, loss type, title or sale document, start code, airbags and keys.
- Build: engine, fuel type, cylinders, transmission, driveline, body style, exterior colour and vehicle type.
- Auction: branch with state, branch ID, market, region, lane and run, aisle and stall, auction date as displayed and in UTC.
- Money: Buy-Now price where offered and the actual cash value (ACV) estimate, each with its currency.
- Photo: the primary vehicle image URL.

### IAAI scraper input

Start with `query`, `search_url` or at least one vehicle filter. A keyword such as `toyota` searches the vehicle inventory using the source's own search behaviour. A pasted search URL must be an HTTPS URL on `www.iaai.com` with the `/Search` path and either the `Keyword` parameter or the saved `url` parameter. Other website paths and URLs containing credentials are rejected.

Use `make` and `model` to select a manufacturer or model. The optional `year_min` and `year_max` fields set inclusive model-year bounds between 1900 and 2100. If you specify only one bound, the other side remains open within that range. A minimum year greater than the maximum is rejected before the search starts.

Damage and document filters are `primary_damage`, `loss_type` and `title_type`. Location filters are `state` and `branch`. For US states, use the full name shown by IAA, such as `Texas`. For Canadian provinces, use IAA's abbreviation: `AB`, `BC`, `MB`, `NB`, `NL`, `NS`, `ON`, `QC` or `SK`. Canadian branch names do not display their province, so the actor relies on IAA's province filter. For US listings, the actor also checks the displayed branch state and skips branches with a different or missing state, including online-only branches, with a counted warning. An unknown facet label may give unexpected results because the source decides how to interpret it. `vehicle_type` selects an inventory category. `auction_type` accepts `live`, `timed` or `buy_now`.

All supplied filters are combined with the search. Filters added to a saved search URL further narrow that search. The saved search's original sort order is not inherited: set `sort` explicitly to select an order. The default is `auction_date_asc`, including for saved URLs; alternatives are `auction_date_desc`, `year_desc` and `year_asc`. `limit` sets the maximum number of unique rows, defaults to 100 and accepts values from 1 to 5000. The actor follows continuation pages automatically when more than one request is needed.

The following input was used for the saved, real Honda/Texas search response:

```json
{"make":"Honda","year_min":2018,"year_max":2020,"primary_damage":"Front End","state":"Texas","limit":3}
```

### Output fields and export

The default dataset contains one row per unique `listing_id`. Both the IAA item identifier and `stock_number` are retained, because they are different identifiers. `url` links to the vehicle detail page, while `title`, `year`, `make`, `brand`, `model` and `series` describe the vehicle. `image_url` gives the primary photograph URL. `source` identifies this product and `fetched_at` records when the page was retrieved.

`vin_masked` contains the exact public VIN with masked characters. The actor does not fill in those characters or claim that the value is a complete VIN. `odometer` contains the displayed number and `odometer_unit` preserves miles or kilometres. No automatic distance conversion is applied. If the source provides no numeric reading, the number is null. `odometer_note` preserves caveats such as an exempt reading when they appear.

Damage and vehicle condition fields include `primary_damage`, `secondary_damage`, `loss_type`, `title_status`, `start_code`, `airbags` and `keys`. Build information includes engine, fuel, cylinders, transmission, driveline, body style and exterior colour when displayed. Missing optional values are null, including `vin_masked` and `primary_damage` when IAA leaves them blank for trailers, equipment or motorcycles.

IAA United States and IAA Canada listings are supported. Canadian rows retain their full `Imp_` or `ICB_` item and branch identifiers, `country: "CA"` and the source's CAD currency. If an ICB item ID has no country suffix, the country comes from its source metadata. Every search is limited to the IAA United States and IAA Canada markets, so Ritchie Bros. listings are excluded at the source; any that still appear are skipped with a counted warning. An incomplete listing is also skipped with a warning while the other valid rows remain available. The source's `total_results` can therefore exceed the number of supported listings delivered.

Auction fields include `branch`, `branch_id`, `market`, `region`, `lane_run`, `aisle_stall` and the source inventory status. Online-only branches can have a null `region`. They remain available when no state filter is supplied; a US state filter requires a matching displayed branch state. Canadian province filters rely on IAA's search selection and do not require a province in the branch name. `auction_date_text` preserves the displayed auction date and time-zone abbreviation. `auction_at` expresses a recognised, assigned auction time in UTC; it is null when the auction has not been assigned or its time cannot be interpreted. Inventory flags indicate Buy-Now, timed auction and pre-bid availability.

`price` is exclusively a displayed Buy-Now price. An auction-only vehicle has a null price. `acv` is the source's actual cash value estimate before damage, and is stored separately. A missing or zero ACV becomes null. `currency` applies to these amounts and comes from the vehicle metadata. The `country` field describes the auction market, not the manufacturing country. Neither current bids nor seller information requiring an account are included.

Download the dataset as JSON, CSV or Excel using Apify's dataset exports. The run output also records `total_results`, the submitted search, and any warnings about incomplete collection. Inventory changes between pages can affect the reported total; the actor removes repeated vehicle identifiers before delivery.

The following row comes from the saved public Buy-Now response retrieved on 5 October 2026:

```json
{
  "listing_id": "46777524~US",
  "stock_number": "46277407",
  "title": "2014 FORD FOCUS ST",
  "vin_masked": "1FADP3L93EL******",
  "odometer": 159503,
  "odometer_unit": "mi",
  "primary_damage": "Mechanical",
  "title_status": "Clear",
  "branch": "Jacksonville (Florida)",
  "auction_at": "2026-10-06T13:30:00.000Z",
  "price": 1650,
  "acv": null,
  "currency": "USD",
  "image_url": "https://vis.iaai.com/resizer?imageKeys=46777524~SID~I1&width=400&height=300"
}
```

A second real row, from the saved Honda/Texas search above (front-end damage, 2018–2020, Texas):

```json
{
  "listing_id": "46525713~US",
  "url": "https://www.iaai.com/VehicleDetail/46525713~US",
  "stock_number": "46026322",
  "title": "2019 HONDA ACCORD LX",
  "year": 2019,
  "make": "HONDA",
  "model": "ACCORD",
  "vin_masked": "1HGCV1F12KA******",
  "odometer": 109664,
  "odometer_unit": "mi",
  "primary_damage": "Front End",
  "loss_type": "Collision",
  "title_status": "Salvage",
  "airbags": "Intact",
  "keys": "Key Available",
  "branch": "Fort Worth North (Texas)",
  "auction_date_text": "Tue Oct 06, 9:30am CDT",
  "auction_at": "2026-10-06T14:30:00.000Z",
  "is_buy_now": true,
  "price": 5800,
  "acv": 16185,
  "currency": "USD"
}
```

A third real row, from a saved Tesla Buy-Now search (`{"make":"Tesla","auction_type":"buy_now"}`), shows a vehicle at an online-only IAA branch. That branch shows no region, so `region` stays null. The lane is not yet assigned (`lane_run: "TBD"`), but the displayed auction time is available and converted to UTC in `auction_at`:

```json
{
  "listing_id": "46684709~US",
  "stock_number": "46184849",
  "title": "2019 TESLA MODEL 3",
  "vin_masked": "5YJ3E1EAXKF******",
  "odometer": 105797,
  "odometer_unit": "mi",
  "odometer_note": "Not Actual",
  "primary_damage": "Left Side",
  "title_status": "Salvage",
  "fuel_type": "Electric",
  "branch": "Electric Vehicle Auctions",
  "branch_id": "816",
  "region": null,
  "lane_run": "TBD",
  "auction_date_text": "Thu Oct 08, 12pm CDT",
  "auction_at": "2026-10-08T17:00:00.000Z",
  "is_buy_now": true,
  "price": 5900,
  "acv": 13065,
  "currency": "USD"
}
```

### Use cases

- **Vehicle exporters** pull every salvage auction lot of a make and year range across all branches, then filter on damage type, keys and run-and-drive status before shipping costs are calculated.
- **Rebuilders and body shops** watch front-end or hail damage vehicles near their own state and plan which auction days to attend.
- **Salvage buyers** export IAA Buy Now inventory with `auction_type: "buy_now"` and compare the Buy-Now price with the ACV to shortlist vehicles worth an immediate purchase.
- **Appraisers and valuation teams** collect comparable vehicles with mileage, damage and title status to support total-loss and diminished-value reports.
- **Marketplaces and data teams** schedule the actor daily and keep an up-to-date feed of upcoming IAA auction lots in their own database or spreadsheet.

### IAA Buy Now listings

Many IAA vehicles can be bought immediately before the auction. Set `auction_type` to `buy_now` to restrict the search to those vehicles. `is_buy_now` marks them in every search, and `price` holds the displayed Buy-Now amount. For vehicles that are only sold at auction, `price` stays null; the actor never fills it with a bid or with the ACV.

### Comparison with other ways to get IAA auction data

| approach | what you get | limitations |
|---|---|---|
| Browsing iaai.com by hand | Every detail of one vehicle at a time | No export; slow for hundreds of lots |
| IAA buyer account | Bids, seller details, purchase tools | Requires registration and fees; not a data feed |
| Vehicle detail scrapers | Deep data for a list of known vehicle URLs | You need the URLs first |
| VIN history sites | Past sale prices for one VIN | Historic, not upcoming inventory |
| **This IAAI scraper** | Upcoming public search results as rows, filtered by make, year, damage, title and location, up to 5000 per run | Masked VINs and no live bids, exactly as the public site shows |

The actor is a search-level scraper: one run returns the full list of matching vehicles with their key attributes, which is usually what you need to decide which lots deserve a closer look. Because every row carries the detail URL and item ID, you can pass a shortlist to a detail tool afterwards.

### Pricing

The billable event is `listing`: one event for each vehicle row delivered to the dataset. There is no actor start event configured for this product. An empty search delivers no listing events. The current event price is shown in the actor's Apify pricing panel; that panel is the source for the amount charged to your account.

Non-paying users are limited to ten delivered rows per run. Paying users can request up to 5000 rows, subject to the number of matching listings available. The same vehicle is counted once within a run, including when collection continues across several pages. A partial run charges only the rows delivered, and its warnings explain why the requested volume was not reached.

### FAQ

#### Does this IAAI scraper return complete VINs?

No. Public IAA results show masked VINs, and `vin_masked` preserves that representation. This actor does not authenticate as a buyer or reconstruct hidden characters. Use the vehicle identifier and detail URL to revisit the original listing.

#### Can I get live bids or repair cost estimates?

Current and highest bids, seller information and repair estimates requiring a signed-in account are outside this public search product. The available monetary fields are a displayed Buy-Now price and an actual cash value estimate. Both remain null if the page does not provide them.

#### What happens when a search returns no vehicles?

The run records a no-results message and delivers an empty dataset. No listing events are charged. An upstream access failure has a different error code, so it is distinguishable from a valid search with no matches.

#### How should I handle an incomplete run?

Review the run output and its warnings. Rows already collected remain available. The actor automatically follows continuation pages within its run budget; if an upstream page fails or the run ends before completion, only the collected unique rows are delivered. Reduce the requested volume or narrow the filters for a later run if needed.

#### Can I combine a saved search with extra filters?

Yes. Supply the saved `search_url` and additional filter fields together. The filters are added to the search using the source's intersection behaviour. Keep manufacturer, damage and location labels in the form displayed by IAA, and check the exported rows before using them in an automated purchasing workflow.

#### Is IAA the same as IAAI or Insurance Auto Auctions?

Yes. Insurance Auto Auctions trades as IAA, and its website is iaai.com, which is why buyers search for both names. This actor reads the public IAA United States and IAA Canada vehicle search. Copart is a separate company and is not covered.

#### Why do some IAA vehicles have no region or state?

Some US IAA branches, such as the electric vehicle auctions, are online-only and do not show a physical state or region. Those vehicles are included in searches without a location filter, with `region` set to null and `branch_id` and `market` still filled. With a US `state` filter, branches without that displayed state are skipped with a counted warning. Canadian branch names also omit the province; use its abbreviation, such as `ON`, and the actor preserves vehicles selected by IAA's province filter.

#### Can I schedule the scraper and get only new vehicles?

Schedule the actor in Apify with the same input, for example every morning. Each row has a stable `listing_id` and a `new_inventory_text` field, so you can keep only identifiers you have not stored before.

# Actor input Schema

## `query` (type: `string`):

Free-text vehicle search, combined with any supplied filters.

## `search_url` (type: `string`):

IAA search URL with Keyword or the saved url parameter; only https://www.iaai.com/Search is accepted. Saved filters are preserved; saved sort order is not inherited. Set sort explicitly or use the auction_date_asc default.

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

Manufacturer as used by IAA, such as Honda.

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

Model as used by IAA.

## `primary_damage` (type: `string`):

Primary damage label, such as Front End.

## `loss_type` (type: `string`):

Loss label, such as Collision.

## `title_type` (type: `string`):

Title or sale document label, such as Salvage.

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

IAA StateDesc value: full US state name, such as Texas, or Canadian province abbreviation (AB, BC, MB, NB, NL, NS, ON, QC, SK). Canadian province filtering relies on IAA; US branches without a matching displayed state are skipped with a counted warning.

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

IAA branch name.

## `vehicle_type` (type: `string`):

Inventory type as used by IAA.

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

Inclusive model-year lower bound. The open side defaults to 1900 or 2100.

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

Inclusive model-year upper bound. The open side defaults to 1900 or 2100.

## `auction_type` (type: `string`):

Auction type to include.

## `sort` (type: `string`):

Sort order; auction_date_asc is the default, including saved search URLs. The saved search's original sort order is not inherited.

## `limit` (type: `integer`):

Maximum unique vehicle rows across all continuation requests; 100 by default.

## `cursor` (type: `string`):

Opaque continuation token returned by a previous response. Keep the original search and sort options.

## Actor input object example

```json
{
  "query": "toyota",
  "sort": "auction_date_asc",
  "limit": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One row per unique public vehicle listing.

## `output` (type: `string`):

Collected rows and partial-result warnings.

## `summary` (type: `string`):

Delivered row counts and run status.

# 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 = {
    "query": "toyota"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/iaai-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 = { "query": "toyota" }

# Run the Actor and wait for it to finish
run = client.actor("s-r/iaai-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "toyota"
}' |
apify call s-r/iaai-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/iaai-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NQROqTJ6p8JOYjMgs/builds/z3qJdomukxuPHDoZC/openapi.json