# IAAI Scraper \[Only $1💰] | Salvage Cars | VIN | Auction Data (`ahmed_jasarevic/iaai-scraper`) Actor

Scrape IAAI salvage and used-vehicle auction lots across the US and Canada for dealer and rebuilder research: VIN, damage, title, odometer, ACV, bids, buy-now price, branch and photos.

- **URL**: https://apify.com/ahmed_jasarevic/iaai-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 results

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

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

Scrape IAAI (IAA / Insurance Auto Auctions) salvage and used-vehicle auction lots across the US and Canada for dealer, rebuilder and market research: VIN, year, make, model and trim, damage and loss type, title brand and sale document, odometer, ACV and estimated repair cost, current bid, minimum bid and buy-now price, auction date, branch location and the full lot photo gallery.

The actor reads IAAI's server-rendered listing and lot pages over plain HTTP, so each lot is one cheap request, and it reads the embedded `ProductDetailsVM` JSON on a lot page for the full specification set.

### Main Use Cases

- Dealer and rebuilder inventory sourcing from salvage auctions
- Salvage vehicle market research and price benchmarking (ACV, bids, buy-now)
- Building a structured vehicle and VIN database across US and Canada auctions
- Damage, title-brand and loss-type analysis for risk and pricing models
- Auction monitoring for specific makes, models, keywords or VIN fragments
- Parts and rebuild-cost estimation from damage and repair-cost fields

### How It Works

IAAI listing pages render each lot as a server-side card, and a lot detail page carries an embedded `ProductDetailsVM` JSON block with the full vehicle data. The actor walks the listing pages and, when lot details are enabled, reads that JSON per lot:

| Data | Source |
| --- | --- |
| Listing rows (one card per lot) | Server-rendered listing and search pages, 100 lots per page. |
| Listing pagination | IAAI's own `POST /Search` endpoint. |
| Full lot details | The lot page's embedded `ProductDetailsVM` JSON (odometer, ACV, buy-now, photos, branch coordinates, specs). |
| Photos | The public IAAI image resizer (`vis.iaai.com`) gallery URLs. |

IAAI runs bot protection (Imperva / Incapsula). The actor leans on the server-rendered markup and the public JSON surfaces rather than challenge pages, and concurrency can be lowered if challenges appear.

### Scrape IAAI Auction Lots And VINs Without An Official API

IAAI does not publish a self-serve public API for auction data. The internal `Vehiclelisting` API the site uses is not documented for third parties, and the practical alternatives are commercial providers that normalize Copart and IAAI data. This actor reads the same public pages a visitor sees:

- Start from listing, search or single-lot URLs in `startUrls`, or let the actor build a search URL from `keyword`, `category` or `make` when `startUrls` is empty.
- Walk up to `maxPages` result pages per start URL (100 lots per page) using IAAI's own search endpoint.
- Enrich each lot with its detail page (`scrapeDetails`) for odometer, ACV, repair cost, bids, buy-now, branch coordinates and specs.
- Keep or drop the photo gallery with `includePhotos`.

Note on cross-auction use: IAAI and Copart describe the same conditions differently (for example title brands and damage wording), so fields such as `primaryDamage`, `lossType` and `titleBrand` reflect IAAI's own vocabulary and should be normalized before you combine them with another auction's data.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | Toyota cars listing | IAAI listing, search or lot URLs. Category listings, search pages and single lot pages are all supported. |
| `keyword` | string | No | empty | Free-text search (make, model, VIN fragment). Used only when `startUrls` is empty. Builds a search URL. |
| `category` | string | No | `Cars` | Vehicle category used to build the listing URL when `startUrls` is empty and no keyword is given. |
| `make` | string | No | empty | Vehicle make (for example Toyota) used to build a category listing URL when `startUrls` is empty and no keyword is given. |
| `maxItems` | integer | No | `50` | Maximum lots to save. Free users are capped at 10. |
| `maxPages` | integer | No | `1` | Maximum result pages walked per start URL (100 lots per page). Pagination uses IAAI's own search endpoint. |
| `maxConcurrency` | integer | No | `8` | Parallel pages. Higher is faster, but IAAI runs bot protection; drop to 2 to 3 if you see challenge pages instead of lot data. |
| `scrapeDetails` | boolean | No | `true` | Fetch each lot detail page and read its `ProductDetailsVM` JSON for full data. Each successfully parsed detail lot bills one `lot-detail` event; failed detail fetches are not billed. |
| `includePhotos` | boolean | No | `true` | Include the full photo gallery URLs on each lot. |
| `proxy` | object | No | Apify Proxy off | Proxy configuration used for the requests. |

### Output Fields

One item per lot in the default dataset:

- Identity: `itemId`, `salvageId`, `stockNumber`, `url`, `title`, `year`, `make`, `model`, `trim`.
- VIN: `vin`, `vinMasked`, `vinStatus`.
- Body and specs: `bodyStyle`, `exteriorColor`, `interiorColor`, `engine`, `cylinders`, `fuelType`, `transmission`, `driveLineType`, `displacement`, `countryOfOrigin`, `vehicleType`, `vehicleSubType`, `vehicleClass`, `segment`.
- Damage and title: `primaryDamage`, `primaryDamageCode`, `secondaryDamage`, `secondaryDamageCode`, `lossType`, `lossTypeCode`, `titleType`, `titleCode`, `titleState`, `titleStateName`, `titleBrand`, `saleDocument`.
- Condition: `odometer`, `odometerUnit`, `odometerBrand`, `keysAvailable`, `keyFob`, `airbagState`, `startsDesc`, `startsCode`, `runAndDrive`, `operable`, `inventoryStatus`, `vehicleGrade`, `whoCanBuy`.
- Auction: `auctionDateTime`, `auctionDate`, `lane`, `slot`, `aisle`, `stall`, `currency`, `currentBid`, `minimumBidAmount`, `bidIncrement`, `buyNowPrice`, `buyNowAvailable`, `acv`, `estimatedRepairCost`, `saleHistory`, `seller`.
- Location: `branchName`, `market`, `region`, `providerGroup`, `location`.
- Media: `photoUrls`, `photoCount`, `thumbnail`, `image360Url`, `engineVideoExists`, `link360`.
- Meta: `scrapedAt`, `source`.

Dataset view: `overview`.

### Example Input And Output

Example input:

```json
{
  "startUrls": [{ "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota" }],
  "maxItems": 50,
  "maxPages": 2,
  "scrapeDetails": true,
  "includePhotos": true
}
```

Example output row:

```json
{
  "itemId": "46837687",
  "salvageId": "46837687",
  "stockNumber": "46837687",
  "url": "https://www.iaai.com/VehicleDetail/46837687~US",
  "title": "2021 Toyota Camry SE",
  "year": 2021,
  "make": "Toyota",
  "model": "Camry",
  "trim": "SE",
  "vin": "4T1G11AK0MU000000",
  "vinMasked": false,
  "bodyStyle": "Sedan",
  "fuelType": "Gasoline",
  "transmission": "Automatic",
  "driveLineType": "Front Wheel Drive",
  "primaryDamage": "Front End",
  "lossType": "Collision",
  "titleType": "Salvage",
  "titleBrand": "Salvage",
  "odometer": 41235,
  "odometerUnit": "mi",
  "runAndDrive": true,
  "keysAvailable": true,
  "currentBid": 5200.0,
  "buyNowPrice": 7900.0,
  "buyNowAvailable": true,
  "acv": 21500.0,
  "estimatedRepairCost": 8600.0,
  "auctionDateTime": "2026-10-20T15:30:00",
  "branchName": "Dallas",
  "region": "Southwest",
  "photoUrls": ["https://vis.iaai.com/resizer?imageKeys=46837687~SID~B1~S0~I1&width=640"],
  "photoCount": 14,
  "scrapedAt": "2026-10-13T09:00:00.000Z",
  "source": "iaai"
}
```

### Integrations & Automation

Export results as JSON, CSV or Excel, read them through the Apify API, or push rows to a database, spreadsheet or BI tool with webhooks, Zapier or Make. For auction monitoring, schedule the actor daily (or a few times a day for fast-moving sales) with the same `startUrls` or `keyword`, so each run captures new lots and their current bids. Recurring runs also help the actor surface better in the Apify Store.

### Related Actors

- [easyapi/iaai-vehicle-detail-scraper](https://apify.com/easyapi/iaai-vehicle-detail-scraper)
- [shahidirfan/IAAI-Vehicles-Scraper](https://apify.com/shahidirfan/IAAI-Vehicles-Scraper)
- [scrapestorm/iaai-vehicles-scraper---cheap](https://apify.com/scrapestorm/iaai-vehicles-scraper---cheap)
- [benthepythondev/iaai-vehicle-scraper](https://apify.com/benthepythondev/iaai-vehicle-scraper)
- [memo23/copart-scraper](https://apify.com/memo23/copart-scraper)

### FAQ

#### Is there an official IAAI API?

No self-serve public one. IAAI (IAA) uses an internal vehicle-listing API for its own site, but it is not published for third parties. Teams that want IAAI data in bulk normally either scrape the public pages or buy normalized feeds from a commercial provider that combines Copart and IAAI. This actor reads the public pages and returns the lot-level fields directly.

#### What are the alternatives to this actor for IAAI data?

Alternatives include other Apify Store actors focused on IAAI lot details, and cross-auction data providers such as auctionsapi-style or apibara-style services that normalize Copart and IAAI. This actor returns IAAI lot rows (with optional enriched details and photos) priced per item.

#### How is IAAI data different from Copart data?

Both sell similar insurance-salvage inventory, but they label the same conditions differently. IAAI uses a stock number and an item ID per listing, Copart uses a lot number, and the same condition or title can be worded differently on each site. The same VIN can also appear on both auctions over its life. Normalize `primaryDamage`, `lossType` and `titleBrand` before combining the two.

#### Why am I getting fewer lots than `maxItems`?

Two reasons. Non-paying users are capped at 10 lots per run. Also, the number of lots also depends on how many result pages the run walks (`maxPages`) and how many `startUrls` you give it.

#### Do I need a proxy?

Not by default. The actor works without a proxy on normal IPs, and `proxy` is available if you want to spread load on very large or repeated runs. If IAAI starts returning challenge pages, lowering `maxConcurrency` to 2 or 3 usually helps more than a proxy.

#### Can I keep photos out of the output?

Yes. Set `includePhotos` to false to drop the photo gallery URLs. Photo counts and the thumbnail are still returned.

### SEO Keywords

iaai scraper, iaai api, iaai salvage cars, salvage car auction data, copart iaai data, salvage auto auction scraper, insurance auto auctions, vin lookup auction, rebuildable cars data, auto dealer inventory, auction lot data, iaai vehicle detail, salvage title data, odometer data auction, acv data, buy now price auction, copart vs iaai, vehicle auction dataset, car auction api, dealer lead generation, salvage car database, us canada auction data, iaai without api, auto auction price data, rebuilders inventory

### For AI Agents & LLM Apps

Purpose: return IAAI salvage and used-vehicle auction lot rows (VIN, damage, title, odometer, ACV, bids, buy-now, branch) for a set of listing/search/lot URLs or a keyword.

Minimal working input:

```json
{ "startUrls": [{ "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota" }] }
```

Variant using a keyword with photos off:

```json
{ "keyword": "honda civic", "maxItems": 100, "includePhotos": false }
```

Output fields: `itemId`, `salvageId`, `stockNumber`, `url`, `title`, `year`, `make`, `model`, `trim`, `vin`, `vinMasked`, `vinStatus`, `bodyStyle`, `exteriorColor`, `interiorColor`, `engine`, `cylinders`, `fuelType`, `transmission`, `driveLineType`, `displacement`, `countryOfOrigin`, `vehicleType`, `vehicleSubType`, `vehicleClass`, `segment`, `primaryDamage`, `primaryDamageCode`, `secondaryDamage`, `secondaryDamageCode`, `lossType`, `lossTypeCode`, `titleType`, `titleCode`, `titleState`, `titleStateName`, `titleBrand`, `saleDocument`, `odometer`, `odometerUnit`, `odometerBrand`, `keysAvailable`, `keyFob`, `airbagState`, `startsDesc`, `startsCode`, `runAndDrive`, `operable`, `inventoryStatus`, `vehicleGrade`, `whoCanBuy`, `auctionDateTime`, `auctionDate`, `lane`, `slot`, `aisle`, `stall`, `currency`, `currentBid`, `minimumBidAmount`, `bidIncrement`, `buyNowPrice`, `buyNowAvailable`, `acv`, `estimatedRepairCost`, `branchName`, `market`, `region`, `providerGroup`, `photoUrls`, `photoCount`, `thumbnail`, `image360Url`, `engineVideoExists`, `link360`, `saleHistory`, `seller`, `location`, `scrapedAt`, `source`.

Behaviors an agent should know:

- `startUrls` takes priority. `keyword`, `category` and `make` are used only when `startUrls` is empty, and only the first of those that is set builds the URL (keyword first, then make, then category).
- `scrapeDetails` defaults to true and adds one billed `lot-detail` event per successfully parsed lot; a failed detail fetch is not billed for that event.
- `includePhotos` defaults to true and only controls the photo gallery URLs.
- `maxItems` is capped at 10 for non-paying users; `maxPages` bounds pagination at 100 lots per page.
- `maxConcurrency` defaults to 8; IAAI runs bot protection, so lower it to 2 to 3 if challenge pages appear.

Billing: pay-per-event. `apify-actor-start` (about $0.00005), one `apify-default-dataset-item` per lot (about $0.001) and one `lot-detail` per enriched lot (about $0.001), lower at higher loyalty tiers.

### Legal & Compliance Disclaimer

This actor is independent and is not affiliated with, endorsed by or sponsored by IAA (Insurance Auto Auctions, Inc.) or its affiliates. It reads only publicly available pages and the public JSON the site itself embeds: it does not log in, does not bypass authentication, does not solve CAPTCHAs and does not place bids.

Users are responsible for complying with IAAI's Terms of Service and with applicable data-protection law in their own jurisdiction. Where the output contains seller, dealer or branch contact data or other personal data, that data must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `startUrls` (type: `array`):

IAAI listing / search / lot URLs. Category listing pages (https://www.iaai.com/Vehiclelisting/Cars/Toyota), search pages (https://www.iaai.com/Search?Keyword=toyota) and single lot pages (https://www.iaai.com/VehicleDetail/46837687~US) are all supported.

## `keyword` (type: `string`):

Free-text search (make, model, VIN fragment...). Used only when Start URLs is empty. Builds a https://www.iaai.com/Search?Keyword=... URL.

## `category` (type: `string`):

Vehicle category used to build the listing URL when Start URLs is empty and no keyword is given.

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

Vehicle make (e.g. Toyota) used to build a category listing URL when Start URLs is empty and no keyword is given.

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

Maximum number of vehicle lots to save. Free users are capped at 10.

## `maxPages` (type: `integer`):

Maximum number of search-result pages to walk per start URL (100 lots per page). Pagination uses IAAI's own POST /Search endpoint.

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

How many pages are fetched at the same time. Higher is faster (8 ≈ 3x faster than the old fixed 3), but IAAI runs bot protection - drop it to 2-3 if you start seeing challenge pages instead of lot data.

## `scrapeDetails` (type: `boolean`):

Fetch each lot detail page and read its embedded ProductDetailsVM JSON for full data (odometer, ACV, buy-now, photos, branch coordinates, specs). Turn off for a fast card-only run. Each successfully parsed detail lot bills one 'lot-detail' pay-per-event charge; rows where the detail fetch failed are never billed for it.

## `includePhotos` (type: `boolean`):

Include the full photo gallery URLs (public vis.iaai.com resizer) on each lot.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota"
    }
  ],
  "category": "Cars",
  "maxItems": 50,
  "maxPages": 1,
  "maxConcurrency": 8,
  "scrapeDetails": true,
  "includePhotos": true,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota"
        }
    ],
    "maxConcurrency": 8,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "startUrls": [{ "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota" }],
    "maxConcurrency": 8,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "startUrls": [
    {
      "url": "https://www.iaai.com/Vehiclelisting/Cars/Toyota"
    }
  ],
  "maxConcurrency": 8,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/iaai-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/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/iHmMqdw8DcRyhsv23/builds/ddkvq21gwM4dh6uf9/openapi.json