# IAAI Scraper — Salvage Auction Lots & VIN Decoding (`memo23/iaai-scraper`) Actor

Scrape IAAI salvage auction lots into 200+ flat fields per vehicle. Reads each lot's own structured record, so damage, keys and engine come back filled in where selector-based scrapers return blanks. Decodes IAAI's masked VINs to make, plant, year and engine. No login needed.

- **URL**: https://apify.com/memo23/iaai-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, Lead generation, AI
- **Stats:** 17 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $8.00 / 1,000 lots

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?

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

Turn any IAAI vehicle listing into a structured stream of salvage auction lots.
Start from a category and make, or paste lot URLs directly, and get 200+ fields per vehicle — damage codes, loss type, odometer, title state, branch location with coordinates, auction date and lane, plus decoded VINs.
No login, no API key. Export to JSON, CSV, Excel or XML.

### Why Use This Scraper?

- ✅ Browse by category and make, or paste lot URLs — no account needed
- ✅ 200+ fields per lot, read from IAAI's own structured record rather than scraped off the page
- ✅ Optional VIN decoding that works on IAAI's masked VINs
- ✅ Branch address, phone and GPS coordinates on every row
- ✅ Damage, loss type, start code, keys and airbag status as separate coded fields
- ✅ Flat rows ready for spreadsheets, databases and BI tools

### Overview

The IAAI Scraper is built for salvage buyers, dealers, exporters and market analysts who need structured auction data from [iaai.com](https://www.iaai.com).

The output is **lot-shaped rows**. Whether you start from a category page, a category-and-make page, or a single lot URL, the dataset is a stream of one row per vehicle — not separate category or branch rows.

Each row is read from the structured record IAAI ships with the lot page, not from the rendered HTML. That distinction matters: most values on an IAAI lot page are populated by client-side bindings and are blank in the page source, so selector-based scrapers return empty damage, keys and engine columns. Reading the underlying record returns all of them.

### Supported Inputs

#### URL types

| URL type | Pattern | Example |
|---|---|---|
| Category listing | `/Vehiclelisting/{category}` | `https://www.iaai.com/Vehiclelisting/Cars` |
| Category + make listing | `/Vehiclelisting/{category}/{make}` | `https://www.iaai.com/Vehiclelisting/PickupTrucks/Ford` |
| Single lot | `/VehicleDetail/{salvageId}~{tenant}` | `https://www.iaai.com/VehicleDetail/46314273~US` |

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.iaai.com/Vehiclelisting/Cars/Toyota",
    "https://www.iaai.com/Vehiclelisting/PickupTrucks/Ford",
    "https://www.iaai.com/VehicleDetail/46314273~US"
  ],
  "maxItems": 100
}
```

#### Filter mode

Leave `startUrls` empty and the actor builds listing URLs from `categories` and `makes`, crossing every category with every make:

```json
{
  "categories": ["Cars", "SUVs"],
  "makes": ["Toyota", "Honda"],
  "maxItems": 200
}
```

Available categories: `Cars`, `SUVs`, `PickupTrucks`, `Motorcycles`, `HeavyTrucks`, `Buses`, `Rvs`, `Trailers`, `ElectricVehicles`, `RentalRides`.

#### Not supported

- **IAAI search URLs** (`/Search?...`). IAAI's robots.txt disallows `/Search`, so this actor sources lots only from the vehicle-listing taxonomy. Arbitrary filter combinations aren't reachable; coverage is partitioned by category and make instead.
- **Auction bidding data behind the login wall.** Current high bid, your-bid status and reserve are only served to authenticated members and are not scraped.
- **Non-US tenants.** Rows carry a `tenant` field, and the public listing taxonomy serves the `US` tenant.

### Use Cases

| Audience | What they use it for |
|---|---|
| Salvage buyers | Screen lots by damage, start code, odometer and vehicle grade before bidding |
| Used-car dealers | Build a daily feed of fresh inventory in a category and make |
| Exporters | Filter by country of origin, title state and title code for overseas resale |
| Market analysts | Track inventory volumes and actual cash values across branches over time |
| Rebuilders | Find run-and-drive lots with intact airbags and keys present |
| Logistics planners | Route pickups using branch address, phone and GPS coordinates |

### How It Works

![How the IAAI Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/iaai/how-it-works-iaai.png)

1. **Seed.** You paste listing or lot URLs, or pick categories and makes and let the actor build the listing URLs.
2. **Warm.** Each session first loads a vehicle-listing page so the site's edge layer issues its cookies. Detail pages are only served to a session that already holds them.
3. **Collect.** Every listing page yields up to 100 lot links, which are queued as individual detail requests carrying the listing page as referer.
4. **Parse.** Each lot page ships a structured record that the actor reads directly and flattens into one row of 200+ fields.
5. **Enrich (optional).** If `enrichVin` is on, the visible portion of each VIN is decoded into manufacturer, country of origin, model year, plant and drivetrain columns.

### Input Configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | Vehicle-listing or single-lot URLs. Takes precedence over `categories` / `makes`. |
| `categories` | array | `["Cars"]` | Categories to sweep when `startUrls` is empty. |
| `makes` | array | — | Makes crossed with each category. Empty means the bare category index. |
| `maxItems` | integer | `100` | Stop after this many lots. Free runs are capped at 100. |
| `enrichVin` | boolean | `false` | Decode the visible VIN characters into manufacturer, country, year and plant columns. |
| `maxConcurrency` | integer | `5` | Parallel requests. Above 5 the block rate climbs sharply. |
| `minConcurrency` | integer | `1` | Lower bound on parallelism. |
| `maxRequestRetries` | integer | `5` | Retries per request before it is abandoned. |
| `proxy` | object | — | Proxy override. Paying runs use a sticky US residential pool by default. |

#### Example — one make, with VIN decoding

```json
{
  "categories": ["PickupTrucks"],
  "makes": ["Ford"],
  "maxItems": 100,
  "enrichVin": true
}
```

#### Example — specific lots only

```json
{
  "startUrls": [
    "https://www.iaai.com/VehicleDetail/46314273~US",
    "https://www.iaai.com/VehicleDetail/46298685~US"
  ],
  "enrichVin": true
}
```

### Output Overview

One row per lot. Each row carries IAAI's full attribute set for that vehicle — identity, damage, condition, title, branch, auction scheduling and media links — as flat top-level keys, so it drops straight into a spreadsheet or a database table without unnesting.

Field count varies slightly between lots (roughly 225–246) because IAAI populates a different attribute set for different vehicle types. CSV export takes the union of the columns present.

A handful of page-formatted values are also kept under `display*` names, so you get both the machine value and the human string: `ODOValue: "37824"` alongside `displayOdometer: "37,824 mi (Actual)"`.

### Output Samples

Real row, trimmed from 225 fields to the useful core. Produced from `https://www.iaai.com/Vehiclelisting/PickupTrucks/Ford`.

```json
{
  "url": "https://www.iaai.com/VehicleDetail/46314273~US",
  "salvageId": "46314273",
  "stockNumber": "45815396",
  "tenant": "US",
  "Year": "2024",
  "Make": "FORD",
  "Model": "MAVERICK",
  "Series": "XL",
  "YearMakeModelSeries": "2024 FORD MAVERICK XL",
  "InventoryType": "AUTOMOBILE",
  "PrimaryDamageCode": "BO",
  "PrimaryDamageDesc": "FRONT & REAR",
  "SecondaryDamageDesc": "RIGHT SIDE",
  "LossTypeDesc": "Other",
  "Keys": "True",
  "KeyFOB": "True",
  "StartsDesc": "Starts",
  "RunAndDrive": "True",
  "ODOValue": "37824",
  "ODOBrand": "ACTUAL",
  "ODOUoM": "mi",
  "AirbagState": "Intact",
  "VIN": "3FTTW8B91RR******",
  "VINStatus": "OK",
  "Title": "BillOfSale",
  "TitleCode": "CLR",
  "TitleStateName": "Michigan",
  "VehicleGrade": "16",
  "BranchName": "Flint (MI)",
  "Address": "3088 S DYE RD",
  "City": "Flint",
  "State": "MI",
  "Zip": "48507",
  "Phone": "8107200981",
  "LocLatitude": "42.98429",
  "LocLongitude": "-83.78340",
  "AuctionDateTime": "8/25/2026 1:30:00 PM +00:00",
  "Lane": "B",
  "Slot": "32",
  "Currency": "USD",
  "WhoCanBuy": "DEA,DIS,EXP,REB,SCR",
  "EngineInformation": "2.0L I4 FI DOHC 16V NF4",
  "Cylinders": "4",
  "Transmission": "Automatic",
  "DriveLineTypeDesc": "AWD",
  "FuelTypeDesc": "Gasoline",
  "ExteriorColor": "WHITE",
  "BodyStyleName": "PICKUP 4 DOOR",
  "VehicleClass": "Compact Pickup",
  "CountryOfOrigin": "Mexico",
  "KeyImageLink": "https://vis.iaai.com/dimensions?imageKeys=46314273~SID",
  "displayActualCashValue": "$21,100 USD",
  "displayOdometer": "37,824 mi (Actual)",
  "scrapedAt": "2026-08-22T10:22:35.828Z"
}
```

With `enrichVin: true`, these columns are appended:

```json
{
  "vinDecoded": true,
  "vinWmi": "1FT",
  "vinCountryOfOrigin": "United States",
  "vinManufacturer": "FORD MOTOR COMPANY",
  "vinModelYear": "2010",
  "vinBodyClass": "Pickup",
  "vinPlantCity": "CLAYCOMO",
  "vinEngineCylinders": "8",
  "vinDisplacementL": "5.4",
  "vinEngineHP": "310",
  "vinDriveType": "4WD/4-Wheel Drive/4x4",
  "vinGvwr": "Class 2F: 7,001 - 8,000 lb (3,175 - 3,629 kg)"
}
```

### Key Output Fields

**Identity** — `salvageId`, `stockNumber`, `tenant`, `url`, `Year`, `Make`, `Model`, `Series`, `YearMakeModelSeries`, `VIN`, `VINStatus`

**Damage & condition** — `PrimaryDamageCode`, `PrimaryDamageDesc`, `SecondaryDamageDesc`, `LossTypeCode`, `LossTypeDesc`, `StartsCode`, `StartsDesc`, `RunAndDrive`, `Keys`, `KeyFOB`, `AirbagState`, `NoOfAirbags`, `VehicleGrade`, `OperableInd`

**Odometer** — `ODOValue`, `ODOBrand`, `ODOUoM`, `displayOdometer`

**Title & eligibility** — `Title`, `TitleCode`, `TitleBrand`, `TitleState`, `TitleStateName`, `TitleNotes`, `WhoCanBuy`, `CertState`

**Specification** — `EngineInformation`, `DisplLiters`, `Cylinders`, `CylindersDesc`, `Transmission`, `DriveLineTypeDesc`, `FuelTypeDesc`, `BodyStyleName`, `VehicleClass`, `ExteriorColor`, `InteriorColor`, `RestraintType`, `CountryOfOrigin`

**Branch & location** — `BranchName`, `BranchNumber`, `BranchState`, `Address`, `City`, `State`, `Zip`, `Phone`, `LocLatitude`, `LocLongitude`, `IsOffsite`, `HoursOfOperation`, `PickupInstructions`

**Auction** — `AuctionId`, `AuctionDateTime`, `Lane`, `Slot`, `Aisle`, `Stall`, `Currency`, `MinimumBidAmount`, `TimedAuctionIndicator`, `PublicAuctionInd`, `displayActualCashValue`

**Media** — `KeyImageLink`, `Link360`, `EngineSoundLink`, `ConditionReportURL`

**VIN enrichment** (only with `enrichVin: true`) — `vinDecoded`, `vinWmi`, `vinManufacturer`, `vinCountryOfOrigin`, `vinModelYear`, `vinBodyClass`, `vinPlantCity`, `vinEngineCylinders`, `vinDisplacementL`, `vinEngineHP`, `vinDriveType`, `vinGvwr`

### FAQ

**Do I need an IAAI account?**
No. The actor reads only public vehicle-listing and lot pages.

**Why is the VIN partly masked?**
IAAI publishes only the first 11 VIN characters on public lots and hides the last six. That is IAAI's masking, not a limitation of the scraper. The 11 visible characters are exactly the manufacturer, descriptor, check digit, model year and plant code, so `enrichVin` still returns manufacturer, country of origin, model year, plant, engine and drivetrain.

**Can I scrape an IAAI search URL with my own filters?**
No. IAAI's robots.txt disallows `/Search`, so this actor deliberately sources lots from the vehicle-listing taxonomy instead. Use `categories` and `makes` to target inventory.

**How many lots can one category and make return?**
Up to 100 per bucket. To go wider, cross more categories with more makes — the taxonomy holds roughly 253 valid combinations.

**Why did a category and make combination return nothing?**
Some pairs don't exist in IAAI's taxonomy — `PickupTrucks/BMW`, for instance. The actor logs the bucket as empty and moves on without spending retries on it.

**Does it return the current high bid?**
No. Live bid amounts, reserve and bidder status are served only to logged-in members. Public lots expose `MinimumBidAmount` and the actual cash value instead.

**Are all fields filled on every row?**
No. Core identity, damage, odometer, title, branch and auction fields are present on essentially every lot. Some are genuinely sparse in IAAI's own data — a 360° view link appears on roughly a fifth of lots, and secondary damage on about two-thirds.

**What are the `display*` fields?**
The page-formatted version of a value that also exists as a machine value, so you get `ODOValue: "37824"` and `displayOdometer: "37,824 mi (Actual)"` side by side.

### Support

Found a bug or need a field that isn't there? Open an issue on the actor's **Issues** tab and it gets looked at.

- Issues: the Issues tab on this actor's Apify Store page
- Email: muhamed.didovic@gmail.com
- More actors: [muhamed-didovic.github.io](https://muhamed-didovic.github.io/)

### Additional Services

Need a tailored export, a different schedule, a custom field set, or a scraper for a site that isn't covered yet? Custom builds are available — get in touch by email with what you need.

### Explore More Scrapers

- [Copart Scraper](https://apify.com/memo23/copart-scraper) — salvage auction lots across 8 countries
- [Auction.com Scraper](https://apify.com/memo23/auction-com-scraper) — foreclosure and bank-owned property auctions
- [Cars.com Scraper](https://apify.com/memo23/cars-scraper) — VIN, price history, dealer data
- [AutoScout24 Scraper](https://apify.com/memo23/autoscout24-scraper) — European used-car listings
- [Autotrader UK Scraper](https://apify.com/memo23/autotrader-cheerio) — UK used-car marketplace
- [Carsales Scraper](https://apify.com/memo23/carsales-cheerio) — Australian vehicle listings

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/iaai-scraper`).

**Purpose:** Scrapes public salvage-auction lots from iaai.com into flat rows of 200+ fields, including VIN decoding that works on IAAI's masked VINs.

**Minimal input:**

```json
{ "categories": ["Cars"], "makes": ["Toyota"], "maxItems": 25, "enrichVin": true }
```

**Output:** one dataset row per lot — url, salvageId, stockNumber, tenant, Year, Make, Model, Series, VIN, VINStatus, PrimaryDamageCode, PrimaryDamageDesc, SecondaryDamageDesc, LossTypeDesc, StartsDesc, RunAndDrive, Keys, KeyFOB, AirbagState, VehicleGrade, ODOValue, ODOBrand, ODOUoM, Title, TitleCode, TitleStateName, WhoCanBuy, EngineInformation, Cylinders, Transmission, DriveLineTypeDesc, FuelTypeDesc, BodyStyleName, VehicleClass, ExteriorColor, CountryOfOrigin, BranchName, Address, City, State, Zip, Phone, LocLatitude, LocLongitude, AuctionDateTime, Lane, Slot, Currency, MinimumBidAmount, KeyImageLink, Link360, displayActualCashValue, displayOdometer, scrapedAt, plus vin\* columns when enrichVin is true.

**Behaviors an agent should know:**

- Always set `maxItems`. An uncapped sweep of all categories and makes can reach roughly 25,000 lots.
- `startUrls` overrides `categories` and `makes` when both are supplied.
- Each category/make bucket yields at most 100 lots; widen coverage by adding makes, not by paging.
- Billing is $0.005 per run start plus $0.008 per lot written. Listing pages, retries, empty category buckets and withdrawn lots are never charged beyond the start fee.
- Free-tier runs are capped at 100 items regardless of `maxItems`.
- Live bid amounts and reserve are login-gated and are not returned. IAAI search URLs (`/Search`) are not supported.
- Field count varies per lot (roughly 225–246); treat the schema as a superset, not fixed.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by IAA Holdings, LLC, RB Global, Inc., or any of their subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available vehicle-listing and lot pages — no authenticated endpoints, paid features, or content behind the iaai.com login wall, and no paths disallowed by the site's robots.txt. Users are responsible for ensuring their use complies with iaai.com's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

iaai scraper, scrape iaai, iaai api, iaai.com scraper, insurance auto auctions scraper, salvage auction scraper, salvage car data, salvage vehicle scraper, auto auction scraper, vehicle auction data, car auction api, vin decoder scraper, salvage title data, damaged car listings, wrecked car data, copart alternative scraper, dealer inventory sourcing, vehicle export data, auto salvage intelligence, used car market data, rebuilt title research, auto dismantler leads

# Actor input Schema

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

Paste vehicle-listing URLs (https://www.iaai.com/Vehiclelisting/Cars/Ford) or single lot URLs (https://www.iaai.com/VehicleDetail/46427093~US). Leave empty to use the category and make filters below.

## `categories` (type: `array`):

Vehicle categories to sweep when startUrls is empty. One of: Cars, SUVs, PickupTrucks, Motorcycles, HeavyTrucks, Buses, Rvs, Trailers, ElectricVehicles, RentalRides. Each category is crossed with every entry in makes. Example: \["Cars", "SUVs"]. Default: \["Cars"].

## `makes` (type: `array`):

Makes to cross with the categories, e.g. Ford, Toyota, BMW. Each category/make pair returns up to 100 lots. Leave empty to scrape the category index itself.

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

Stop after this many lots have been written to the dataset. Lots are billed at $0.008 each on top of a $0.005 run-start fee, so this caps the variable part of the cost. Free-tier runs are capped at 100 regardless of this value. Example: 500. Default: 100.

## `enrichVin` (type: `boolean`):

IAAI masks the last six VIN characters. The eleven that remain still decode to manufacturer, country of origin, model year and assembly plant — this adds those columns.

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

Upper bound on parallel requests. IAAI sits behind Imperva; 5 held with zero blocks in testing, and the block rate climbs sharply above that. Example: 5. Default: 5.

## `minConcurrency` (type: `integer`):

Lower bound on parallel requests; the crawler will not scale below this. Leave at 1 unless you have a reason to keep more connections warm. Default: 1.

## `maxRequestRetries` (type: `integer`):

How many times a request is retried before it is abandoned. Retries fire on an Imperva block so the request lands on a fresh session; empty category/make buckets are skipped without retrying. Example: 5. Default: 5.

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

Paying runs use a sticky US residential pool by default; this only overrides the free-tier proxy.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.iaai.com/Vehiclelisting/Cars/Ford"
  ],
  "categories": [
    "Cars"
  ],
  "makes": [
    "Ford"
  ],
  "maxItems": 100,
  "enrichVin": false,
  "maxConcurrency": 5,
  "minConcurrency": 1,
  "maxRequestRetries": 5
}
```

# Actor output Schema

## `lots` (type: `string`):

Every scraped lot as a flat row: identity, damage and loss-type codes, start condition, odometer, title state, branch address and coordinates, auction scheduling, media links, plus decoded VIN columns when enrichVin is on.

# 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": [
        "https://www.iaai.com/Vehiclelisting/Cars/Ford"
    ],
    "makes": [
        "Ford"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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": ["https://www.iaai.com/Vehiclelisting/Cars/Ford"],
    "makes": ["Ford"],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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": [
    "https://www.iaai.com/Vehiclelisting/Cars/Ford"
  ],
  "makes": [
    "Ford"
  ]
}' |
apify call memo23/iaai-scraper --silent --output-dataset

```

## MCP server setup

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