# Copart Salvage Auction Scraper — Lots, Bids & VINs (`bovi/copart-lot-scraper`) Actor

Scrape Copart salvage vehicle auction lots by keyword or search URL. Returns lot number, VIN, year/make/model/trim, damage, title code, odometer, current bid, buy-it-now price, auction time, location, and images.

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

## Pricing

from $22.59 / 1,000 lot-items

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

**Extract salvage auction data from Copart in seconds — lot details, VINs, damage, title codes, odometer readings, bids, and full image galleries for any make, model, or keyword search.**

This Copart scraper delivers structured salvage car data at scale. Search by keyword, make/model/year, or paste any Copart search URL to pull every matching lot. Includes inline VIN decode — engine type, transmission, drivetrain, fuel type, and cylinder count are enriched automatically from the VIN for each lot.

### Features

- **Search by keyword or URL** — enter a make/model keyword (e.g. `honda`, `ford f-150`) or paste a full `copart.com/lotSearchResults` URL to replicate any existing search
- **Filter by make, model, and year range** — narrow results without touching the URL
- **Inline VIN enrichment** — engine, transmission, drive, fuel, and cylinders decoded and merged per lot
- **Full image gallery** — complete photo list per lot, not just the thumbnail
- **Auto-paginate** — walks all result pages up to your `maxItems` cap
- **Session resilience** — if the site's session expires mid-run, the scraper re-warms automatically and continues from where it left off; no lost data
- **Pay per result** — you are charged only for lots actually returned, never for pages browsed

### What data you get

Each record is one salvage lot. Fields are sourced from Copart's search and detail endpoints and merged into a single flat object.

| Field | Fill rate | Notes |
|---|---|---|
| `lot_number` | 100% | Copart lot identifier |
| `vin` | 100% | Full 17-char VIN |
| `year` | 100% | Model year |
| `make` | 100% | e.g. HONDA, FORD |
| `model` | 100% | e.g. CIVIC, F-150 |
| `trim` | 100% | Trim level when listed |
| `engine_type` | 100% | e.g. 3.5L V6, 4 CYL |
| `cylinders` | 100% | Cylinder count |
| `transmission` | 100% | AUTO / MANUAL |
| `drive` | 100% | AWD / FWD / RWD / 4WD |
| `fuel` | 100% | GASOLINE / HYBRID / ELECTRIC / DIESEL |
| `color` | 100% | Exterior color |
| `has_keys` | 100% | Y / N |
| `lot_condition` | 100% | Lot condition description |
| `primary_damage` | 100% | e.g. FRONT END, HAIL |
| `sale_location` | 100% | Auction yard name |
| `sale_status` | 100% | e.g. ON MINIMUM BID, FUTURE SALE |
| `auction_time` | 100% | ISO-8601 UTC datetime |
| `item_url` | 100% | Direct link to the lot page |
| `currency` | 100% | Always USD |
| `estimated_retail_value` | ~93% | Estimated ACV in USD; not set on all lots |
| `title_code` | ~93% | e.g. CERT-D, NO-TITLE; depends on state filing |
| `odometer` | ~80% | Miles; EXEMPT on some salvage titles |
| `body_style` | Varies | Not always provided by the source |
| `secondary_damage` | Varies | Present when a second damage area is noted |
| `seller` | Varies | Seller company name when disclosed |
| `lot_notes` | Varies | Free-text auction notes |
| `current_bid` | Pre-auction | Null on lots not yet at auction ("Pure Sale" stage) |
| `buy_it_now_price` | Pre-auction | Null on lots without an active BIN price |
| `images` | 100% | List of full-resolution CDN image URLs |
| `latitude` / `longitude` | 100% | Yard coordinates |
| `scraped_at` | 100% | ISO-8601 UTC timestamp of the run |

### Input

```json
{
  "query": "honda civic",
  "make": "HONDA",
  "model": "CIVIC",
  "yearFrom": 2018,
  "yearTo": 2023,
  "maxItems": 200,
  "fetchDetails": true,
  "fetchImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

You can also pass `"searchUrl"` instead of `"query"` — paste any `copart.com/lotSearchResults` URL and the scraper replicates that exact search. When `searchUrl` is provided it takes priority over `query`.

**Key parameters:**

| Parameter | Default | Description |
|---|---|---|
| `query` | — | Keyword search (required unless `searchUrl` is set) |
| `searchUrl` | — | Paste a Copart search URL to replicate it |
| `make` | — | Optional make filter (e.g. `FORD`) |
| `model` | — | Optional model filter (e.g. `MUSTANG`) |
| `yearFrom` / `yearTo` | — | Optional year range |
| `maxItems` | 100 | Max lots to return; set to `0` for unlimited |
| `fetchDetails` | true | Fetch richer detail fields (VIN, secondary damage, retail value) |
| `fetchImages` | true | Fetch full image gallery per lot |

### Pricing

**Pay per result — $0.02329 per lot** (charge event: `lot-item`).

You are only charged for lots actually pushed to your dataset. Browsing pages, retrying sessions, and fetching images do not add to your bill. At this rate, 1,000 lots costs roughly $23.29 — about 10% below the comparable market rate.

The actor runs on a residential proxy for reliable access; proxy usage is billed to your Apify account at platform rates as part of the normal run cost, with no surcharge from us.

### FAQ

**Do I need an API key or a Copart account?**
No. The scraper needs no Copart login, no API key, and no external credentials. Just run it — it handles the site's challenge internally using a residential proxy and a resilient browser warm-up.

**Are current bids and buy-it-now prices always present?**
Not always. Copart has a "Pure Sale" pre-auction stage where lots are listed but bidding has not opened yet. On those lots `current_bid` and `buy_it_now_price` will be `null`. Once the lot enters active auction these fields populate normally.

**Can I scrape a specific Copart search I already have open?**
Yes. Copy the URL from your browser — it will look like `https://www.copart.com/lotSearchResults/?...` — and paste it into the `searchUrl` input. The scraper decodes all the filter parameters automatically.

**How many lots can I pull per run?**
There is no hard limit on our side. Set `maxItems: 0` to pull all available results. Copart's search returns up to 10,000 lots per query (100 pages × 100 lots). For larger datasets, combine multiple keyword or make/model runs.

**What happens if the site's session drops mid-run?**
The scraper detects session expiry (the site's challenge cookie has a ~25-minute TTL) and re-warms the session automatically, then resumes from the same page. You will not lose data already collected, and you are not charged twice for the same lot.

### Use cases

- **Salvage dealers and rebuilders** — monitor specific makes, models, and damage types across all Copart yards to build a live acquisition pipeline
- **Parts businesses** — identify high-value donor cars (low-odometer, specific engine/trim) before they go to auction
- **Insurance and total-loss analysts** — track title codes, estimated retail values, and primary damage distributions for reserve-setting and subrogation research
- **Arbitrage and export** — compare Copart hammer prices against retail and export market values; VIN data plugs straight into any valuation API
- **Research and pricing tools** — build salvage-car price indices, damage-to-ACV models, or regional supply dashboards using structured lot data
- **Notification systems** — run the scraper on a schedule and alert on new lots matching your target criteria before auction day

# Actor input Schema

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

Keyword search for lots (e.g. 'honda', 'toyota camry', 'ford f-150'). Either this or searchUrl is required.

## `searchUrl` (type: `string`):

Paste a copart.com/lotSearchResults URL to replicate that search. If provided, overrides the query field.

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

Filter by vehicle make (e.g. HONDA, TOYOTA, FORD). Case-insensitive.

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

Filter by vehicle model (e.g. CIVIC, CAMRY, F-150). Case-insensitive.

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

Minimum model year. Leave blank for no lower bound.

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

Maximum model year. Leave blank for no upper bound.

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

Maximum number of auction lots to return. Default 100. Set to 0 for unlimited (you are charged per lot returned).

## `fetchDetails` (type: `boolean`):

ON (default): fetch the lot detail page for richer fields — VIN, secondary damage, title code, estimated retail value. OFF: fast mode — search-API fields only.

## `fetchImages` (type: `boolean`):

ON (default): fetch full-resolution image URLs for each lot. OFF: thumbnail only (faster).

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

Required. Copart uses Imperva Incapsula — a residential proxy is needed to clear the JS challenge. Apify RESIDENTIAL proxy is billed to your run at no extra cost.

## Actor input object example

```json
{
  "query": "honda",
  "maxItems": 20,
  "fetchDetails": true,
  "fetchImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of Copart lot records (lot\_number, vin, year, make, model, trim, engine, transmission, drive, fuel, body\_style, color, odometer, primary\_damage, secondary\_damage, title\_code, sale\_status, sale\_location, auction\_time, current\_bid, buy\_it\_now, estimated\_retail\_value, currency, images, item\_url, scraped\_at).

# 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": "honda",
    "maxItems": 20,
    "fetchDetails": false,
    "fetchImages": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/copart-lot-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": "honda",
    "maxItems": 20,
    "fetchDetails": False,
    "fetchImages": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/copart-lot-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "honda",
  "maxItems": 20,
  "fetchDetails": false,
  "fetchImages": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/copart-lot-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/copart-lot-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ypucEuexCMIEyuK7r/builds/aoW7Ef74hhgkVcCfX/openapi.json