# IAAI Scraper — Salvage Auction Lots, VIN & ACV (`crawloop/iaai-scraper`) Actor

Scrape IAAI (Insurance Auto Auctions / IAA) salvage lots in the US and Canada. Extract salvage ID, stock number, VIN, damage, odometer, ACV, Buy Now, sale date, branch GPS, and photos. Search by URL or make/model filters; monitor new lots.

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

## Pricing

from $1.99 / 1,000 vehicles

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Salvage Auction Lots, VIN & ACV

> **Disclaimer:** This is an unofficial integration developed independently. It is not affiliated with, sponsored by, or endorsed by IAA, Insurance Auto Auctions, Ritchie Bros., or any of their subsidiaries.
>
> **IAAI**, **IAA**, and related names are trademarks of their respective owners. Data is read from publicly accessible auction search and vehicle pages. No IAAI member login is required.
>
> This Actor is provided **for informational, research, and price monitoring purposes only**. You are solely responsible for complying with applicable laws, IAAI's terms of use, and your organization's policies.

**IAAI scraper** / **IAA scraper** / **Insurance Auto Auctions scraper** for US and Canadian salvage, clean-title, and Buy Now lots. Scrape IAAI search results and VehicleDetail pages into JSON/CSV via Apify — **salvage ID, stock number, VIN, damage, odometer, ACV, Buy Now, sale date, branch GPS, and photos**. Search by a copied IAAI URL, stock number, salvage ID, or make/model/year/state filters. Optional **monitor mode** emits only new lots and Buy Now / sale-date changes. Fast HTTP path (no headless browser) with residential proxy. Use as an **IAAI API alternative** from **Python**, **Node.js**, cURL, or **MCP** / AI assistants.

**Masked VIN is still usable.** IAAI hides the production serial for anonymous visitors (`2T1BURHE4FC******`). Keep `decodeVin` on (default): the first 11 characters go to NHTSA vPIC and you get manufacturer, make, model year, plant country/city, and body class — no buyer login. `isVinMasked` is true when the serial is starred. The full 17-character VIN is member-only.

> **Crawloop US Salvage Suite** — salvage auctions and used-parts comps.

| Copart | IAAI | Car-Part |
| :--- | :--- | :--- |
| [Copart Scraper](https://apify.com/crawloop/copart-scraper) | IAAI Scraper ◄── you are here | [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) |

### Who this is for

| Who | Job | Paste this |
| :--- | :--- | :--- |
| Salvage buyer / dealer | Morning Run-and-Drive or Buy Now sweep in one state | `make` + year band + `state` + `runAndDriveOnly` + `decodeVin` |
| Parts yard | Year / make / model plus plant and body from a masked VIN | Keyword or Start URL + `decodeVin` |
| Insurance / comps | ACV, sale date, loss type, VIN prefix | `searchQuery` + `scrapeDetails` |
| Auction desk | New lots and Buy Now / sale-date moves | `monitorMode` on a schedule |

### When to use this Actor

- **Salvage inventory sourcing** — Sweep Toyota / Ford / Tesla lots by state, year, Run and Drive, or Buy Now.
- **Exact browser-filter replication** — Apply filters on IAAI, copy the `Search` URL (including `url=` tokens), paste into Start URLs.
- **Branch / shipping planning** — Branch name, city, state, ZIP, latitude, and longitude on each row when details are on.
- **Parts and rebuild research** — Primary/secondary damage, title type, keys, odometer brand, engine and drivetrain.
- **Scheduled watch** — Turn on `monitorMode` to keep only new vehicles and Buy Now / sale-date / start-code changes.

### When not to use this Actor

- **Member-only fields** — Full 17-character VIN serial, live bid history, and seller names are often masked for anonymous visitors.
- **Placing bids** — This Actor is read-only. It does not log in or bid.
- **Heavy equipment auctions** — Use [Ritchie Bros Auction Scraper](https://apify.com/crawloop/rbauction-scraper) or [GovPlanet Scraper](https://apify.com/crawloop/govplanet-scraper).
- **EU retail cars** — Use [AutoScout24 Scraper](https://apify.com/crawloop/autoscout24-scraper) or [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper).

### Key features

- **US + Canada** — Public IAAI inventory, including Canadian branches when they appear in search.
- **URL + filter modes** — Paste search / VehicleDetail / Vehiclelisting URLs, or build a search from keyword, make, model, year, state, branch, damage, loss type, title type, Buy Now, and Run and Drive.
- **Direct lookup** — Pass `salvageIds` or `stockNumbers` when you already have identifiers.
- **Search cards or full details** — `scrapeDetails` enriches GPS, title state, specs, and 360 links; `includePhotos` adds the gallery.
- **Monitor mode** — Key-Value store baseline; later runs emit only **new** vehicles or **Buy Now / sale-date / start-code** changes, with early-stop on known lots.
- **VIN decode** — NHTSA vPIC on the public prefix (works when the serial is masked). Adds manufacturer, make/model/year, plant country, body class. Cached per prefix. Toggle `decodeVin`.
- **Lightweight HTTP** — `curl_cffi` Chrome TLS impersonation; 128–512 MB RAM; no Playwright.

### Input

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `startUrls` | Array | `[]` | IAAI Search, Vehiclelisting, or VehicleDetail URLs. |
| `searchQuery` | String | — | Keyword, VIN fragment, or stock number. Used when Start URLs are empty. |
| `make` / `model` | String | — | Facet filters (TOYOTA / CAMRY). |
| `yearFrom` / `yearTo` | Integer | — | Model year range. |
| `state` | String | — | Yard state/province (`TX`, `Texas`, `ON`). |
| `branch` | String | — | Branch name (`Dallas`, `Orlando (FL)`). |
| `damage` / `lossType` / `titleType` | String | — | IAAI facet labels (Front End, Collision, Clear, …). |
| `zipCode` | String | — | Distance search ZIP / postal code. |
| `buyNowOnly` / `runAndDriveOnly` | Boolean | `false` | Facet shortcuts. |
| `salvageIds` / `stockNumbers` | Array | — | Direct IDs. |
| `maxItems` | Integer | `50` | Cap per run. |
| `scrapeDetails` | Boolean | `true` | Fetch VehicleDetail JSON. |
| `includePhotos` | Boolean | `false` | Full gallery URL lists. Thumbnail always included. |
| `decodeVin` | Boolean | `true` | NHTSA vPIC decode of the public VIN prefix (works when masked). |
| `monitorMode` | Boolean | `false` | Emit only new lots and status changes after a seed run. |
| `maxConcurrency` | Integer | `8` | Parallel detail fetches. |
| `proxyConfiguration` | Object | US residential | Apify RESIDENTIAL recommended. |

#### Example input

```json
{
  "searchQuery": "toyota camry",
  "yearFrom": 2018,
  "yearTo": 2024,
  "state": "TX",
  "runAndDriveOnly": true,
  "maxItems": 50,
  "scrapeDetails": true,
  "includePhotos": false,
  "decodeVin": true,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

Start-URL mode (filters on the page are kept):

```json
{
  "startUrls": [
    { "url": "https://www.iaai.com/Search?keyword=toyota%20camry" }
  ],
  "maxItems": 100,
  "scrapeDetails": true,
  "decodeVin": true
}
```

#### Ready-to-run recipes

Direct salvage ID / stock lookup:

```json
{
  "salvageIds": ["46279848"],
  "stockNumbers": ["45781024"],
  "scrapeDetails": true,
  "decodeVin": true,
  "includePhotos": false
}
```

Run and Drive + VIN decode (Texas Camry):

```json
{
  "make": "TOYOTA",
  "model": "CAMRY",
  "yearFrom": 2018,
  "yearTo": 2024,
  "state": "TX",
  "runAndDriveOnly": true,
  "maxItems": 40,
  "decodeVin": true
}
```

Buy Now / sale-date monitor (seed once, then schedule):

```json
{
  "searchQuery": "toyota camry",
  "maxItems": 100,
  "monitorMode": true,
  "decodeVin": true
}
```

### Output

Each dataset row is one IAAI vehicle.

| Field | Type | Description |
| :--- | :--- | :--- |
| `id` / `salvageId` / `stockNumber` / `url` | String | Identifiers and canonical page. |
| `title` / `year` / `make` / `model` / `trim` | Mixed | Vehicle identity. |
| `vin` | String | Public VIN (serial may be masked). |
| `isVinMasked` | Boolean | True when the VIN is incomplete or starred. |
| `vinManufacturer` / `vinMake` / `vinModel` / `vinModelYear` | Mixed | NHTSA vPIC decode (`decodeVin`). |
| `vinPlantCountry` / `vinPlantCity` / `vinBodyClass` | String | Assembly plant and body class from vPIC. |
| `odometer` / `odometerBrand` / `odometerUnit` | Mixed | Reading, ACTUAL/NOT ACTUAL, mi or km. |
| `engine` / `cylinders` / `fuelType` / `transmission` / `driveType` | Mixed | Mechanical specs. |
| `primaryDamage` / `secondaryDamage` / `lossType` | String | Damage and loss. |
| `titleType` / `titleState` | String | Sale document and issuing state. |
| `hasKeys` / `runsAndDrives` / `startCode` | Mixed | Condition flags. |
| `buyNowPrice` / `buyNow` / `actualCashValue` | Mixed | Public pricing. |
| `saleDate` / `lane` / `runNumber` | Mixed | Auction timing. |
| `location` | Object | Branch name, city, state, ZIP, lat/lng. |
| `thumbnailUrl` / `images` | Mixed | Preview always; gallery when `includePhotos`. |
| `changeType` | String | Monitor mode: `new` or `status_change`. |
| `scrapedAt` | String | ISO timestamp. |

```json
{
  "id": "46279848",
  "salvageId": "46279848",
  "stockNumber": "45781024",
  "url": "https://www.iaai.com/VehicleDetail/46279848~US",
  "title": "2015 TOYOTA COROLLA S PLUS",
  "year": 2015,
  "make": "TOYOTA",
  "model": "COROLLA",
  "vin": "2T1BURHE4FC******",
  "isVinMasked": true,
  "vinMake": "TOYOTA",
  "vinPlantCountry": "UNITED STATES (USA)",
  "odometer": 194129,
  "odometerBrand": "ACTUAL",
  "odometerUnit": "mi",
  "primaryDamage": "FRONT END",
  "buyNowPrice": null,
  "actualCashValue": 1850,
  "currency": "USD",
  "saleDate": "2026-08-19T13:30:00+00:00",
  "location": {
    "name": "Orlando (FL)",
    "city": "Orlando",
    "state": "FL",
    "country": "USA",
    "latitude": 28.42231,
    "longitude": -81.37821
  },
  "thumbnailUrl": "https://vis.iaai.com/resizer?imageKeys=46279848~SID~I1&width=400&height=300",
  "site": "US"
}
```

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Salvage buying desk** | Buy Now, ACV, damage, Run and Drive, title type |
| **Parts yard sourcing** | Make/model/year + branch GPS + keys / drivetrain |
| **Insurance comps** | ACV, sale date, VIN prefix, loss type |
| **Scheduled watch** | Monitor mode for new lots and Buy Now / sale-date moves |
| **AI / MCP pipelines** | Structured JSON for assistants and BI tools |

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/iaai-scraper').call({
  searchQuery: 'toyota camry',
  yearFrom: 2018,
  maxItems: 50,
  scrapeDetails: true,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'US',
  },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/iaai-scraper").call(
    run_input={
        "searchQuery": "toyota camry",
        "state": "TX",
        "runAndDriveOnly": True,
        "maxItems": 50,
        "scrapeDetails": True,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "US",
        },
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[:5])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/crawloop~iaai-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "tesla",
    "buyNowOnly": true,
    "maxItems": 20,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
  }'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/iaai-scraper`.

Example prompts:

- "Run IAAI Scraper for Toyota Camry 2018–2024 in Texas with runAndDriveOnly and maxItems 40; return salvage ID, VIN, Buy Now, damage, and branch as JSON"
- "Scrape IAAI Buy Now Tesla lots and summarize median actual cash value by model year"
- "Chain IAAI Scraper then [Copart Scraper](https://apify.com/crawloop/copart-scraper) for the same Toyota Camry year band and compare Buy Now vs current bid"
- "Chain IAAI Scraper then [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) to compare recycler asking prices for the engine and transmission of a lot's year/make/model"

### Suite next step

After IAAI lots, run [Copart Scraper](https://apify.com/crawloop/copart-scraper) for the other US salvage auction. Then [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) to compare recycler asking prices for the same year / make / model parts.

### Troubleshooting

| Symptom | What to do |
| :--- | :--- |
| HTTP 403, challenge page, or zero vehicles | Use Apify **RESIDENTIAL** proxy with US. Datacenter IPs often get challenged. |
| VIN looks like `2T1BURHE4FC******` | Expected without a buyer login. Leave `decodeVin` on — make, year, plant, and body class still fill. `isVinMasked` will be true. The production serial is member-only. |
| Current bid is empty | Live/timed high bids are often hidden for anonymous visitors. Use `buyNowPrice` and `actualCashValue` when IAAI shows them. |
| Large pull looks incomplete | Split by make, year band, or state. Keep `scrapeDetails` on for GPS, title state, and specs. |

### FAQ

**Is this an IAAI API?**\
There is no public read API for auction search. This Actor is an IAAI API alternative that returns structured dataset items you can call from Python, Node.js, or MCP.

**IAA vs IAAI — is this the Insurance Auto Auctions scraper?**\
Yes. IAAI is Insurance Auto Auctions (also searched as IAA). This Actor covers public US and Canadian IAAI salvage lots — not live bidding.

**Can I scrape IAAI with Python or Node.js?**\
Yes. Use the Apify client examples above, or call the Actor from an AI assistant via Apify MCP. Export the dataset as JSON or CSV.

**Can I look up a stock number or VehicleDetail URL?**\
Yes. Pass `stockNumbers`, `salvageIds`, or paste `/VehicleDetail/{id}~US` URLs into `startUrls`. That is the IAAI vehicle detail scraper path without copying every field by hand.

**Does this cover IAAI Canada as well as the US?**\
Yes. Canadian branches appear in the same public search. Set `market` to `IAA Canada` or paste a filtered Search URL. State/province codes such as `ON` and `BC` are accepted.

**Why do I need a residential proxy?**\
IAAI may challenge datacenter IPs. Use US residential on Apify for reliable runs.

**Why is part of the VIN masked?**\
IAAI only shows the full 17-character VIN to logged-in buyers. Public search still returns the world manufacturer identifier and vehicle descriptor. With `decodeVin` on (default), the Actor sends that prefix to NHTSA vPIC and fills manufacturer, make, model year, plant country, and body class. The production serial may appear as asterisks; `isVinMasked` is true on those rows.

**Why is current bid empty?**\
Live/timed high bids are often hidden for anonymous visitors. Buy Now prices and ACV are returned when IAAI displays them on the public card or detail page.

**Start URLs or filters?**\
Paste a browser `Search` / `Vehiclelisting` / VehicleDetail URL in `startUrls` to keep every filter you already applied. Leave Start URLs empty and set `searchQuery` / `make` / `model` to build the search in the Actor.

**Cards vs full details vs photos?**\
Keep `scrapeDetails` on (default) for GPS, title state, and specs. Turn it off for faster search-card rows. Enable `includePhotos` only when you need the full gallery — a thumbnail is always stored.

**Can I watch new lots over time?**\
Yes. Run once with `monitorMode` to seed a baseline, then schedule later runs. Only new vehicles and changes to Buy Now, sale date, or start code are written to the dataset.

### Related Actors

| Actor | Role |
| :--- | :--- |
| [Copart Scraper](https://apify.com/crawloop/copart-scraper) | US / CA salvage lots, bids, VIN |
| **IAAI Scraper** ◄── you are here | US / CA salvage lots, VIN, ACV |
| [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) | Used auto parts & recycler stock |
| [Ritchie Bros Auction Scraper](https://apify.com/crawloop/rbauction-scraper) | Heavy equipment on the same parent network |
| [GovPlanet Scraper](https://apify.com/crawloop/govplanet-scraper) | US government surplus auctions |
| [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) | US / EU farm and construction equipment |

# Actor input Schema

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

Paste IAAI search result URLs (Search?keyword=, Search?url=, Vehiclelisting) or individual /VehicleDetail/{id}~US pages. Filters already applied in the browser URL are kept. When Start URLs are set, the filter fields below are ignored for those searches.

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

Free-text query, same as the IAAI search box (toyota camry, f-150, VIN fragment, or stock number). Used when Start URLs are empty.

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

Vehicle make, e.g. TOYOTA, FORD, HONDA. Applied as an IAAI facet when Start URLs are empty.

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

Vehicle model, e.g. CAMRY, F-150, CIVIC. Works best together with Make.

## `yearFrom` (type: `integer`):

Earliest model year, e.g. 2018.

## `yearTo` (type: `integer`):

Latest model year, e.g. 2024.

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

US state or Canadian province. Two-letter codes (TX, ON) are expanded to IAAI facet names (Texas, Ontario).

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

IAAI branch name as shown on the site, e.g. Dallas, Orlando (FL), Toronto.

## `damage` (type: `string`):

IAAI primary-damage label, e.g. Front End, Rear, Hail, Flood, Normal Wear & Tear, Side.

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

Insurance loss category: Collision, Fire, Theft, Water, Other.

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

Title type, e.g. Salvage, Clear, Bill Of Sale, Non-Repairable, Repairable, PartsOnly.

## `zipCode` (type: `string`):

Focus search around a US ZIP or Canadian postal code (IAAI distance sort).

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

Only vehicles offered at a fixed Buy Now price.

## `runAndDriveOnly` (type: `boolean`):

Only lots flagged Start Code = Run & Drive.

## `market` (type: `string`):

Optional IAAI market facet, e.g. IAA United States or IAA Canada.

## `salvageIds` (type: `array`):

One or more IAAI salvage IDs (or /VehicleDetail/{id}~US URLs) to fetch directly, skipping search.

## `stockNumbers` (type: `array`):

IAAI stock numbers to look up via public search.

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

Maximum number of vehicles to collect per run. Split large pulls by make, year, or state.

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

Open each VehicleDetail page for richer specs, GPS, title state, and 360 link. Disable for faster search-card output.

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

Attach gallery image URL lists from the detail page. A thumbnail is always included. Galleries add extra detail requests.

## `decodeVin` (type: `boolean`):

Decode the public VIN prefix via NHTSA vPIC: manufacturer, make, model, year, plant country/city, body class. Works on masked VINs (first 11 characters). Cached per prefix in the run. Turn off for a faster listing-only sweep.

## `monitorMode` (type: `boolean`):

Delta tracking via Key-Value store. First run seeds a baseline (no dataset rows). Later runs emit only new vehicles or changes to Buy Now price, sale date, or start code. Stops early after several already-known lots.

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

How many vehicle-detail requests to run in parallel. Higher is faster; keep moderate to reduce blocks.

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

Apify Proxy. RESIDENTIAL with US is recommended — IAAI may challenge datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.iaai.com/Search?keyword=toyota%20camry"
    }
  ],
  "searchQuery": "toyota camry",
  "buyNowOnly": false,
  "runAndDriveOnly": false,
  "maxItems": 50,
  "scrapeDetails": true,
  "includePhotos": false,
  "decodeVin": true,
  "monitorMode": false,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Default dataset items (one IAAI vehicle per row).

# 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/Search?keyword=toyota%20camry"
        }
    ],
    "searchQuery": "toyota camry",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/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/Search?keyword=toyota%20camry" }],
    "searchQuery": "toyota camry",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/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/Search?keyword=toyota%20camry"
    }
  ],
  "searchQuery": "toyota camry",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/iaai-scraper --silent --output-dataset

```

## MCP server setup

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