# Copart Auction Scraper — Salvage Lots in 8 Countries (`memo23/copart-scraper`) Actor

Scrape Copart salvage and used-vehicle auction lots in 8 countries: USA, Canada, UK, Ireland, Germany, Spain, Finland, Middle East. Paste a search URL or a single lot URL, or filter by make, model, year, odometer. Flat JSON/CSV: specs, damage, bids, dates, images, VIN decoding.

- **URL**: https://apify.com/memo23/copart-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 142 total users, 43 monthly users, 99.8% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.75 / 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.

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

## Copart Auction Scraper — Salvage Lots in 8 Countries

**Unlock Copart auction lot data across the USA, Canada, UK, Ireland, Germany, Spain, Finland and the Middle East** - Scrape salvage and used vehicle listings from [Copart USA](https://www.copart.com), [Copart Canada](https://www.copart.ca), [Copart UK](https://www.copart.co.uk), [Copart Ireland](https://www.copart.ie), [Copart Germany](https://www.copart.de), [Copart Spain](https://www.copart.es), [Copart Finland](https://www.copart.fi) and [Copart Middle East](https://www.copartmea.com) by driving the same mobile search and lot-detail APIs the member app uses. Ideal for inventory monitoring, pricing research, and building structured datasets from lot search URLs or actor filters—with exports in JSON and CSV.

*Scrape Copart salvage and used-vehicle auction lots in 8 countries: USA, Canada, UK, Ireland, Germany, Spain, Finland, Middle East. Paste a search URL or a single lot URL, or filter by make, model, year, odometer. Flat JSON/CSV: specs, damage, bids, dates, images, VIN decoding.*

### Overview

The Copart scraper collects **lot detail** records for vehicles (and related inventory) matching your **Copart lot search** on **copart.com**, **copart.ca**, **copart.co.uk**, **copart.ie**, **copart.de**, **copart.es**, **copart.fi** or **copartmea.com**. It starts from either **full `lotSearchResults` URLs** (including the `searchCriteria` query) or **in-actor filters** (featured chips, extra FETI clauses, or “search all vehicles”). It calls the mobile **`POST /srch/`** search endpoint, then **`POST /lots-api/v1/lot-details`** per lot, and writes **flattened** rows to the dataset (no raw `mobileRequest` payload).

The **country is detected automatically from each URL's host**, so USA (`copart.com`, USD/miles), Canada (`copart.ca`, CAD), UK (`copart.co.uk`, GBP/miles), Ireland (`copart.ie`, EUR/km), Germany (`copart.de`, EUR/km), Spain (`copart.es`, EUR/km), Finland (`copart.fi`, EUR/km) and the Middle East (`copartmea.com`, AED/km) lots use the same output schema and can be mixed in a single run. For filter-based runs, a **`site`** input picks the storefront. (Every market except Germany reuses the UK mobile session; Germany has its own.)

### What does the Copart Scraper do?

The Copart scraper enables you to:

#### Comprehensive data collection

- **Lot listings**
  - Pull full lot detail fields returned by the mobile lot-details API (vehicle, damage, yard, auction, bids, title, odometer, etc.)
  - Collect **full-size image URLs** in `lotImages` plus a **thumbnail** in `thumbnail_image`
  - Preserve the **search hit** context in `searchResult` (snake_case fields from the search index)
  - Attach **`sourceUrl`** so you know which search produced each lot

#### Advanced behaviour

- **Search criteria mapping**: Translates web `searchCriteria` JSON (FETI, MAKE, MODL, YEAR, ODM, RNCD, LOC, etc.) into the mobile `/srch/` filter format where captured (see codebase `copartMobileMapper.ts`).
- **Pagination**: Follows search pages until your `maxItems` limit is met or the result set runs out — including across pages where every hit was filtered as an offsite partner lot.
- **Deduplication**: Uses extended unique keys so identical POST URLs with different bodies are not collapsed incorrectly.

#### Flexible input

- **Search URLs**: Paste one or more `lotSearchResults` links from any of the eight Copart sites, e.g.\
  `https://www.copart.com/lotSearchResults?...&searchCriteria=...`\
  `https://www.copart.de/lotSearchResults?...&searchCriteria=...`\
  The site is detected per-URL, so you can mix links from different countries in one run.
- **Single lot URLs**: Paste a lot page link to scrape that one vehicle without running a search, e.g.\
  `https://www.copart.com/lot/73672065/salvage-2021-kia-forte-gt-line-tx-dallas`\
  Both forms go in the same `startUrls` list and can be mixed freely.
- **Filters only**: Leave `startUrls` empty, pick the **`site`** (any of `uk`, `de`, `us`, `es`, `fi`, `mea`, `ca`, `ie`), then use **Search all vehicles**, structured filters (make, model, year, odometer), **Featured filters** (multi-select), and/or **Extra FETI clauses** (raw Solr-style fragments as on the site URL).

This tool is ideal for:

- Salvage and used-vehicle market research across all eight Copart markets
- Tracking lots by make, model, yard, damage, or odometer bands
- Pulling one specific lot on demand from its URL
- Building datasets aligned with Copart search UI behaviour

### Features

- **Eight markets, one actor**: Copart **USA** (`copart.com`, CPRTUS, USD/miles), **Canada** (`copart.ca`, CPRTCA, CAD), **UK** (`copart.co.uk`, CPRTUK, GBP/miles), **Ireland** (`copart.ie`, CPRTIE, EUR/km), **Germany** (`copart.de`, CPRTDE, EUR/km), **Spain** (`copart.es`, CPRTES, EUR/km), **Finland** (`copart.fi`, CPRTFI, EUR/km) and the **Middle East** (`copartmea.com`, CPRTMEA, AED/km), auto-selected from the URL host or the `site` input. Identical output schema for all eight.
- **Three input modes**: search URLs, **single lot URLs**, or 30+ filter fields (URLs win when both are provided).
- **Filter by anything Copart indexes**: damage category, title group, vehicle type, fuel, drivetrain, body style, cylinders, engine, trim, state, yard, current-bid range, sale-date window, newly-added window, sale platform, VIN, lot number or free text — plus **exterior colour**, which Copart's own site cannot filter on.
- **VIN decoding** (optional): adds `vin*` columns — manufacturer, country of origin, model year, trim, body class, engine, fuel, transmission, assembly plant. Works on the 11-char prefix Copart leaves visible on masked VINs. Free, no API key.
- **Flattened output**: `lotDetails` fields at the top level; `lotImages` as string URLs only.
- **Full image galleries**: every full-size photo URL in `lotImages`, the **high-resolution copies** in `lotImagesHd`, and a thumbnail — not just the thumbnail.
- **No junk records**: NPA / Purple Wave partner lots — which Copart's own lot-details API rejects — are filtered out before they reach your dataset.
- **Concurrency & retries**: Configurable `maxConcurrency`, `minConcurrency`, `maxRequestRetries`.
- **Proxy support**: Apify proxy configuration (residential recommended for member API traffic).
- **Exports**: Dataset JSON/CSV (e.g. `data.json`, `data.csv` when exported from runs).

### Coming from another Copart scraper?

Most Copart actors on the Store cover **copart.com only** and take **one search URL per run**. Here is what changes when you switch:

| What you need | This actor |
|---|---|
| Countries | All 8 — USA, Canada, UK, Ireland, Germany, Spain, Finland, Middle East, mixable in a single run |
| Search URLs per run | Unlimited — `startUrls` is a list, not a single field |
| One specific vehicle | Paste its lot URL directly; no search runs, one URL costs one result |
| No URL to hand | Build the search from 30+ filter fields — damage, title group, vehicle type, fuel, drivetrain, body, colour, state, yard, bid range, sale date, platform, VIN, free text |
| VIN detail | Optional decoding to manufacturer, country of origin, model year, trim, body class, engine, fuel, transmission and assembly plant — works on Copart's masked VINs |
| Photos | Every full-size URL in `lotImages`, every high-resolution copy in `lotImagesHd`, plus `thumbnail_image` |
| Row size | Pick full, compact or minimal detail instead of always carrying ~130 columns |
| Proxies | Included and pre-configured per country; no proxy setup or extra proxy bill |
| Offsite partner lots | Dropped before they cost you a record. Copart's US search is mostly NPA / Purple Wave lots that its own detail API rejects; `includeOffsiteLots` keeps them if you want them |
| Pagination | Keeps paging until your item limit is met, rather than stopping on the first partly-filtered page |
| Scheduled watching | Monitor mode reports only new and changed lots, so a daily schedule does not re-bill you for the same inventory |
| Alerts | Signed webhook delivery to your endpoint, Slack or Discord |

### Advanced filters

Option B builds the search from filter fields instead of a URL. Beyond make, model, year and odometer:

| Filter | What it does |
|---|---|
| **Primary / secondary damage** | All 25 Copart damage categories — front end, hail, water/flood, rollover, stripped, burn, frame damage and the rest |
| **Vehicle type** | Automobiles, motorcycles, boats, trailers, ATVs, jet skis, snowmobiles, RVs, buses, box trucks, farm equipment |
| **Title group** | Clean, salvage, or non-repairable |
| **Fuel / drive / transmission / cylinders / engine / body style / trim** | The full drivetrain and body facets |
| **Exterior colour** | Copart's own site has no colour filter — this one does |
| **State or yard** | Every Copart yard in a state, or named yards |
| **Current bid range** | Min and max, on Copart's index rather than by over-fetching pages |
| **Sale date** | Today, tomorrow, next 7 or 30 days, any upcoming sale, or a custom `YYYY-MM-DD` range |
| **Newly added within N days** | When the lot appeared in inventory, not when it sells |
| **Sale platform** | Include or exclude Copart USA, Select, NCS, Canada, Purple Wave, NPA |
| **Lot number / VIN / free text** | Look up specific lots, match a VIN prefix, or search by phrase |
| **Runs and drives · Has keys · Buy It Now · Exclude On Approval · Classics (25+ yrs)** | Copart's own featured-item clauses |
| **Sort** | Auction date, odometer, year, current bid, make, lot number |

Values inside one filter OR together, so picking Front End and Rear End widens the damage search. Separate filters AND together, so damage plus state plus bid range narrows it.

Every code in the dropdowns was harvested from Copart's live search index and then checked one at a time: the code had to narrow the result count, and a returned lot had to echo the same code back in its own record. That matters more than it sounds — `VEHTYPE_M` reads like "motorcycle" but Copart uses it for **boats**, and the motorcycle code is `VEHTYPE_C`.

Copart also stores one concept under several spellings, and the split is not cosmetic. `fuel_type_desc` holds 243,616 lots under `GAS` and another 78,497 under `GAS` padded with trailing spaces; `cylinders` holds 174,219 under `4` and 41,020 under `4 `. Filtering on the value you would reasonably type therefore used to drop a quarter of the matches with no error at all. Each dropdown option now covers every spelling Copart uses for it, so picking **Gasoline** returns 323,114 lots where the tidy spelling alone returned 243,616. Make and model match as a prefix, so `CHEV` also finds `CHEVROLET`; body style matches as a substring, so `SEDAN` also finds "SEDAN 4DR".

Colour is the one filter Copart's index cannot serve, so it is applied to each lot after it is fetched. Non-matching lots are dropped before they reach the dataset, so they are never charged for, but a colour-filtered run is slower than the index-side filters.

### Monitor mode

A scheduled run normally re-reports the same inventory every time, and you pay for it every time.
Monitor mode remembers what this search already returned and emits only what is **new** or what
**moved** — price, sale date, sale status, odometer, damage, title or run condition. Everything else
is skipped before it reaches the dataset, so it costs nothing.

Each reported row carries `monitorStatus` (`new` or `updated`) and `monitorFirstSeenAt`.

The first run reports everything, because it has nothing to compare against. From the second run on
you get the difference. Turning off **Include changed lots** narrows it further to brand-new lots
only, which is the cheapest way to watch a large search.

Memory is kept per search, keyed by its start URLs, so two schedules watching different filters never
overwrite each other. **Set a monitor state name** to pin it explicitly, or to reset a watch by
pointing it at a fresh name.

Cross-run memory needs stored state, and Apify scheduling is itself a paid feature, so persistence is
paid-plan only. A free run still works: it behaves as a first run every time and returns every match.

#### Webhook

Set a **webhook URL** and every reported lot is POSTed there in batches of 50, after it is safely
saved to the dataset — a webhook outage can never cost you the data. Failed batches are retried three
times with backoff, and anything still undelivered is written to the run's key-value store as
`webhook-undelivered` rather than dropped.

Add a **signing secret** and each delivery carries `X-Copart-Signature: sha256=<hmac>` computed over
the exact request body, so your endpoint can verify the call.

The JSON format sends full lot records, which is what Make, n8n, Zapier or a custom endpoint want.
The Slack and Discord formats send a readable one-line-per-lot message those two accept directly.

### Row detail

A full lot record runs to about 130 columns. **Row detail** trims that without touching what the
filters, VIN decode or monitor see — the cut happens last, right before the row is saved.

| Profile | Columns | What it holds |
|---|---|---|
| **Full** (default) | ~128 | Everything |
| **Compact** | ~66 | The buying decision: vehicle, damage, title, condition, pricing, VIN, drivetrain, yard, coordinates, both image lists |
| **Minimal** | ~14 | Lot, link, year/make/model, odometer, primary damage, current bid, sale date, yard, thumbnail |

Full stays the default, so nothing you already read disappears. VIN-decode and monitor columns are
kept in every profile — you only get those by switching a feature on, so a profile should not take
them away. Smaller rows also mean smaller webhook payloads.

### How to use

#### Scraping lots

1. **Set up**: Apify account and this actor on the Apify platform (or run locally with Apify SDK / Crawlee).
2. **Configure input** (choose one primary path):
   - Add **Start URLs**: full `lotSearchResults` links from `copart.com`, `copart.ca`, `copart.co.uk`, `copart.ie`, `copart.de`, `copart.es`, `copart.fi` **or** `copartmea.com` **including** `searchCriteria` when you copy from the browser; and/or single lot links like `https://www.copart.com/lot/73672065/…`, **or**
   - Leave **Start URLs** empty: choose the **`site`** (`uk`, `de`, `us`, `es`, `fi`, `mea`, `ca` or `ie`), then set make / model / year / odometer, **Search all vehicles**, and/or **Featured filters** per the input schema.
   - Optionally switch on **VIN enrichment** to add the `vin*` columns.
3. **Adjust limits**: Set `maxItems`, concurrency, retries, and **proxy** as needed.
4. **Run** the actor.
5. **Collect** dataset items (JSON/CSV). Each item is one lot with flattened detail fields.

### Input configuration

Example input (URLs + limits + proxy):

```json
{
    "startUrls": [
        "https://www.copart.co.uk/lotSearchResults?qId=example&searchCriteria=%7B%22query%22%3A%5B%22*%22%5D%2C%22filter%22%3A%7B%7D%7D"
    ],
    "searchAllVehicles": false,
    "featuredChips": ["buyItNow", "highValueItems"],
    "extraFetiClauses": [],
    "maxItems": 1000,
    "maxConcurrency": 10,
    "minConcurrency": 1,
    "maxRequestRetries": 60,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

Example input (Germany, filter-based — no URLs):

```json
{
    "site": "de",
    "searchAllVehicles": true,
    "maxItems": 500,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

#### Input fields explanation

- **`startUrls`** (Array of strings): Copart URLs from any of the eight sites — **USA** (copart.com), **Canada** (copart.ca), **UK** (copart.co.uk), **Ireland** (copart.ie), **Germany** (copart.de), **Spain** (copart.es), **Finland** (copart.fi) or **Middle East** (copartmea.com). Two shapes are accepted and can be mixed in one list:

  - **Search URLs** — `https://www.copart.com/lotSearchResults?...&searchCriteria=...`. The actor paginates the search and pulls full details for every hit.
  - **Single lot URLs** — `https://www.copart.com/lot/73672065/...` (the legacy `/lotdetails/73672065` form works too). No search is run; the actor fetches that lot's details directly, so one URL costs exactly one result.

  If this array is **non-empty**, the actor **ignores** the filter section below. The **site is detected from each URL's host**, so links from different countries can be mixed. If **empty**, you must satisfy the filter rules below.
- **`site`** (String, `uk`, `de`, `us`, `es`, `fi`, `mea`, `ca` or `ie`, default `uk`): For **filter-based** runs only (when `startUrls` is empty), selects the storefront the filters run against — `uk` = copart.co.uk (GBP/miles), `de` = copart.de (EUR/km), `us` = copart.com (USD/miles), `es` = copart.es (EUR/km), `fi` = copart.fi (EUR/km), `mea` = copartmea.com / Middle East (AED/km), `ca` = copart.ca (CAD), `ie` = copart.ie (EUR/km). Ignored for URL-based runs.
- **`searchAllVehicles`** (Boolean): When `startUrls` is empty, set to `true` to run a very broad search on the selected `site` (default year facet behaviour in the mapper). If `false`, you need at least one meaningful filter or extra FETI clause.
- **`featuredChips`** (Array of strings, multi-select): “Featured items” style facets. Fully wired fragments in code include e.g. `vehiclesForAuction`, `buyItNow`, `highValueItems`, `hotItems`; other chip IDs may log a warning until mapped in `src/lib/copartFeaturedChips.ts`.
- **`extraFetiClauses`** (Array of strings): Additional Solr-style FETI lines copied from a real `searchCriteria` URL on copart.com, copart.ca, copart.co.uk, copart.ie, copart.de, copart.es, copart.fi or copartmea.com—appended after featured chip fragments.
- **`enrichVin`** (Boolean, default `false`): Decode each lot's VIN and add flat `vin*` columns (see [VIN enrichment](#vin-enrichment-fields) below). Uses the free public NHTSA vPIC database — no API key, no extra charge, cached per run.
- **`includeOffsiteLots`** (Boolean, default `false`): Keep NPA / Purple Wave partner lots. Copart's **US** search index mixes these in, but Copart's lot-details API rejects them, so by default they are dropped before they cost you a record. On a default copart.com search they are the **majority** of hits — a live sample of the first 20 was 11 Purple Wave, 7 NPA and 2 Copart — so leaving this off is usually what you want. Non-US markets contain no partner lots and are unaffected.
- **`maxItems`** (Integer): Maximum number of **lot detail** records to push to the dataset (subject to Apify account limits / actor logic).
- **`maxConcurrency`** / **`minConcurrency`** (Integer): Crawler concurrency bounds for HTTP requests.
- **`maxRequestRetries`** (Integer): Retries per failed request.
- **`proxy`** (Object): Apify proxy configuration; residential groups are commonly used for Copart member endpoints.

### Output structure

The dataset contains **one object per lot**. Data comes from the mobile **lot-details** response, **flattened** (no nested `lotDetails` wrapper), with `lotImages` as URL strings, plus `sourceUrl`, `searchResult`, and `thumbnail_image`. **All eight markets share the same schema** — the difference is in the values: US/UK lots report **miles** (USD / GBP), Canada **CAD**, the Middle East **AED**, and Ireland/Germany/Spain/Finland **EUR** — with metric (**kilometres**) odometers outside the US/UK (`currencyCode`, `odometerUOM`). The sample below is a UK lot.

#### Sample JSON output (first object from `data.json`, pretty-printed)

```json
{
    "auctionAssignmentNumber": 0,
    "auctionDateType": "F",
    "bodyStyle": "ESTATE",
    "buyTodayBid": 0,
    "color": "GREY",
    "drive": "2 AXLE RIGID BODY",
    "runCondition": "S",
    "fuel": "DIESEL",
    "gridRow": "4L10",
    "keys": "YES",
    "hasOwnerManual": "No",
    "hasTransmission": "Yes",
    "hasEngine": "Yes",
    "highlights": "ENGINE START PROGRAM",
    "lotCountry": "GBR",
    "lotMakeCode": "VOLV",
    "lotModelDesc": "XC60 R DES",
    "lotMakeDesc": "VOLVO",
    "lotYear": 2019,
    "trim": "",
    "category": "S REPAIRABLE STRUCTURAL",
    "lotDescription": "2019 VOLVO XC60 2.0 D4 R DESIGN 5DR GEARTRONIC",
    "navigation": "No",
    "offsiteFlag": false,
    "lotNumber": 47493436,
    "notes": "PHYSICAL V5 AVAILABLE",
    "odometer": 80668,
    "goAppUser": "",
    "primaryDamage": "FRONT END",
    "primaryDamageCode": "DAMAGECODE_FR",
    "secDamage": "SIDE",
    "repairEst": 0,
    "vatTosale": "No",
    "vehicleTypeCode": "VEHTYPE_V",
    "vehicleTypeDesc": "VEHICLES UNDER 7.5 TONNES",
    "siteCode": [
        "CPRTUK"
    ],
    "sellerSource": "",
    "transmission": "8 SPEED AUTO",
    "transmissionType": "8 SPEED AUTO",
    "prop65Warning": false,
    "maskedVIN": "*****************",
    "isLotOwner": false,
    "vehicleRegistrationNumber": "*******",
    "yardName": "BRISTOL",
    "yardNumber": 415,
    "yardZipCode": "BS10 7SF",
    "yardCityName": "AVONMOUTH, BRISTOL",
    "yardTwoLetterState": "GB",
    "buildSheetFlag": false,
    "lotIconCodes": [
        "ADDL-INFO",
        "CERT-S",
        "IV",
        "VHDRP"
    ],
    "hasVehicleReport": true,
    "isInsuranceSeller": true,
    "titleState": "GB",
    "saleTitleType": "S",
    "titleDescription": "S REPAIRABLE STRUCTURAL",
    "titleGroupCode": "TITLEGROUP_C",
    "titleGroupDescription": "Clean",
    "auctionHostName": "BRISTOL",
    "auctionHostId": 415,
    "currencyCode": "GBP",
    "saleDate": "2026-04-22T09:00:00Z",
    "lastUpdated": "04/10/2026, 12:00 am",
    "isSealedBid": false,
    "engine": "1969 cc",
    "estRetailValue": 16902.67,
    "sublotFlag": false,
    "subLotLocation": null,
    "subLotMapsLocation": null,
    "soldFlag": false,
    "timeZone": "BS",
    "isBuyTodayLot": false,
    "latitude": 51.53199,
    "longitude": -2.65965,
    "physicalYardNumber": 415,
    "showJapanSaleDisclaimer": false,
    "currentBid": 0,
    "displayBidAmount": 0,
    "isCopartWholesaleLot": false,
    "showConditionReportV2": false,
    "nonGoApSellerCompanyLot": "",
    "sellerInfo": {},
    "bidState": "PRELIMBID",
    "bidStatus": "NEVERBID",
    "saleStatus": "PURESALE",
    "allowStartingBidAmount": true,
    "isMakeAnOfferLot": false,
    "firstRegistrationDate": "20190610",
    "saleLightColor": "",
    "additionalNotes": [
        {
            "NOTEDATE": "27/03/2026",
            "ESQNBR": 77,
            "NOTE": "NUMBER OF KEYS 2                                                           "
        }
    ],
    "enableUpdatedOffsiteLotPilot": false,
    "autoCheckFlag": false,
    "lotImages": [
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/7713961ca0f2421fb821c61db431e534_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/124caef72e9e4f6f86b1905be87ff4f8_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/cd9b47738f5d4f37a2b1b0bcb6bdbfe4_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/99c62b66014c406eab505c340bdf651f_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/84c7f56f2a044796b0c9a0c9191247cd_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/d1fc528e27fe45e38408e89866464a9d_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/76e66da09a1c474f8a6081112a254198_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/234da12212c4431bb5568170ac780d68_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/8fb75afa77624dfca6354372f51e47e0_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/bfcb79d9df5b4182bba5cc7d026eceb8_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0426/389ca93b773e4affb80945e61724db8d_ful.jpg",
        "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/443afe2735e64b0db3db5f4e1b3e0b59_ful.jpg"
    ],
    "sourceUrl": "https://www.copart.co.uk/lotSearchResults?qId=cdb3c72e-e25e-4bc6-8b25-bc22009f1e36-1775984478013&intcmp=web_homepage_banner&searchCriteria=%7B%22query%22:%5B%22*%22%5D,%22filter%22:%7B%22MAKE%22:%5B%22lot_make_desc:%5C%22VOLVO%5C%22%22%5D,%22MODL%22:%5B%22manufacturer_model_desc:%5C%22XC60%5C%22%22%5D,%22YEAR%22:%5B%22lot_year:%5B2018%20TO%202024%5D%22%5D,%22ODM%22:%5B%22odometer_reading_received:%5B75001%20TO%20100000%5D%22%5D%7D,%22searchName%22:%22%22,%22watchListOnly%22:false,%22freeFormSearch%22:false%7D",
    "searchResult": {
        "auction_host_name": "BRISTOL",
        "auction_host_id": 415,
        "buy_it_now_price": 0,
        "currency_code": "GBP",
        "sealed_bid_flag": false,
        "auction_date_utc": "2026-04-22T09:00:00Z",
        "auction_date_type": "F",
        "auction_assignment_number": 0,
        "lot_desc": "2019 VOLVO XC60 2.0 D4 R DESIGN 5DR GEARTRONIC",
        "lot_number": 47493436,
        "odometer_reading_received": 80668,
        "lot_thumbnail_image_path": "cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0326/7713961ca0f2421fb821c61db431e534_thb.jpg",
        "yard_name": "BRISTOL",
        "yard_number": 415,
        "title_desc": "S REPAIRABLE STRUCTURAL",
        "lot_icon_codes": [
            "ADDL-INFO",
            "CERT-S",
            "IV",
            "VHDRP"
        ],
        "purple_wave_url": "",
        "show_updated_offsite_lot_text": false,
        "hide_odometer": false,
        "full_vin": "*****************"
    },
    "thumbnail_image": "https://c-static.copart.com/v1/AUTH_svc.pdoc00001/ids-c-prod-lpp/0326/7713961ca0f2421fb821c61db431e534_thb.jpg"
}
```

*This sample matches the first element of `data.json` (same values; indentation added for readability).*

### Output fields explanation

Fields below match the **first object** in `data.json` (flattened Copart mobile lot detail + actor-added fields). Types reflect typical values; Copart may add or omit fields over time.

#### Auction & sale

- **`auctionAssignmentNumber`** (Number): Lane/assignment identifier for the sale event (0 if not assigned in sample).
- **`auctionDateType`** (String): Auction date classification code from Copart (e.g. `F`).
- **`saleDate`** (String, ISO 8601): Scheduled sale / auction datetime (UTC).
- **`lastUpdated`** (String): Human-readable last update string from the API.
- **`saleStatus`** (String): Sale lifecycle code (e.g. `PURESALE`).
- **`saleLightColor`** (String): Sale light indicator (empty if none).
- **`isSealedBid`** (Boolean): Whether the lot is a sealed-bid sale.
- **`timeZone`** (String): Yard/sale timezone code (e.g. `BS`).
- **`auctionHostName`** (String): Host location name for the auction (often matches yard).
- **`auctionHostId`** (Number): Numeric host / auction location id.

#### Vehicle identity & specs

- **`lotNumber`** (Number): Copart lot number (primary key for the listing).
- **`lotDescription`** (String): Full text description line for the vehicle.
- **`lotYear`** (Number): Model year.
- **`lotMakeDesc`** / **`lotMakeCode`** (String): Make label and internal make code.
- **`lotModelDesc`** (String): Model / trim description string.
- **`trim`** (String): Trim field (may be empty).
- **`bodyStyle`** (String): Body style label (e.g. `ESTATE`).
- **`color`** (String): Exterior colour label.
- **`fuel`** (String): Fuel type label.
- **`drive`** (String): Drivetrain / axle description.
- **`engine`** (String): Engine displacement or description text.
- **`transmission`** / **`transmissionType`** (String): Transmission description (often duplicated).
- **`odometer`** (Number): Odometer reading (miles context for UK listings in typical use).
- **`runCondition`** (String): Run-and-drive style code (e.g. `S`, `N`—Copart-coded).
- **`keys`** (String): Whether keys are present (e.g. `YES` / `NO`).
- **`hasOwnerManual`** / **`hasTransmission`** / **`hasEngine`** (String): Yes/No flags from condition checklist.
- **`highlights`** (String): Highlight line (e.g. programme name).
- **`navigation`** (String): Navigation present flag (e.g. `No`).
- **`vehicleTypeCode`** / **`vehicleTypeDesc`** (String): Vehicle category code and description.
- **`category`** (String): Damage / listing category line (e.g. repairable structural).
- **`firstRegistrationDate`** (String): Registration date, often `YYYYMMDD`.

#### Damage & valuation

- **`primaryDamage`** / **`primaryDamageCode`** (String): Primary damage description and Copart damage code.
- **`secDamage`** (String): Secondary damage description.
- **`repairEst`** (Number): Repair estimate amount (currency implied by `currencyCode`).
- **`estRetailValue`** (Number): Estimated retail value.

#### Title & legal

- **`titleState`** (String): Title jurisdiction (e.g. `GB`).
- **`saleTitleType`** (String): Title type code (e.g. `S`).
- **`titleDescription`** (String): Human-readable title / category line.
- **`titleGroupCode`** / **`titleGroupDescription`** (String): Title group code and label (e.g. Clean group).
- **`notes`** (String): Free-text notes line (e.g. V5 availability).
- **`vatTosale`** (String): VAT treatment flag for sale (e.g. `Yes` / `No`).
- **`prop65Warning`** (Boolean): Prop 65 flag (often false for UK).

#### Yard & location

- **`lotCountry`** (String): Country code for the lot (e.g. `GBR`).
- **`siteCode`** (Array of strings): Site codes (e.g. `CPRTUK`).
- **`yardName`** (String): Yard display name.
- **`yardNumber`** / **`physicalYardNumber`** (Number): Yard identifiers.
- **`yardZipCode`** (String): Yard postal code.
- **`yardCityName`** (String): City / area label for the yard.
- **`yardTwoLetterState`** (String): Region code (e.g. `GB`).
- **`latitude`** / **`longitude`** (Number): Geocoordinates for the yard / lot location.
- **`offsiteFlag`** (Boolean): Offsite lot flag.
- **`sublotFlag`** (Boolean): Sub-lot flag.
- **`subLotLocation`** / **`subLotMapsLocation`** (null|String): Sub-lot location fields when applicable.

#### Seller & flags

- **`sellerSource`** (String): Seller source string (may be empty).
- **`sellerInfo`** (Object): Seller metadata object (often empty `{}`).
- **`isInsuranceSeller`** (Boolean): Insurance-seller indicator.
- **`isLotOwner`** (Boolean): Lot owner flag for the viewing user context.
- **`nonGoApSellerCompanyLot`** (String): Non–GO seller company marker when set.
- **`isCopartWholesaleLot`** (Boolean): Wholesale lot flag.
- **`isBuyTodayLot`** / **`buyTodayBid`** (Boolean|Number): Buy-It-Now style flags and amount.
- **`isMakeAnOfferLot`** (Boolean): Make-an-offer eligibility.
- **`gridRow`** (String): Yard grid / row locator for physical location.

#### VIN & registration

- **`maskedVIN`** (String): Masked VIN for display.
- **`vehicleRegistrationNumber`** (String): Masked or partial registration number.

#### Bidding & display

- **`currentBid`** / **`displayBidAmount`** (Number): Current bid values shown to the user.
- **`bidState`** (String): Bid state machine code (e.g. `PRELIMBID`).
- **`bidStatus`** (String): User bid status (e.g. `NEVERBID`).
- **`allowStartingBidAmount`** (Boolean): Whether starting bid rules apply as shown.
- **`soldFlag`** (Boolean): Whether the lot is marked sold.

#### Icons, reports, misc

- **`lotIconCodes`** (Array of strings): Feature / badge codes (e.g. certificate, inspection).
- **`hasVehicleReport`** (Boolean): Vehicle report available flag.
- **`buildSheetFlag`** (Boolean): Build sheet available flag.
- **`showConditionReportV2`** (Boolean): Condition report UI flag.
- **`showJapanSaleDisclaimer`** (Boolean): Japan sale disclaimer flag.
- **`enableUpdatedOffsiteLotPilot`** (Boolean): Feature pilot flag.
- **`autoCheckFlag`** (Boolean): AutoCheck (or similar) flag.
- **`goAppUser`** (String): GO app user field (often empty in exports).

#### Notes array

- **`additionalNotes`** (Array of objects): Yard/auction notes.
  - **`NOTEDATE`** (String): Note date string.
  - **`ESQNBR`** (Number): Sequence / id number for the note.
  - **`NOTE`** (String): Note body text (often padded).

#### VIN enrichment fields

Present only when **`enrichVin`** is `true`. Copart masks the last six characters of the VIN on public lots (`3KPF44AC0ME******`); the visible 11-character prefix carries the manufacturer, model line, model year and assembly plant, which is all the decoder needs. Lots whose VIN is **fully** masked (`*****************`, common on UK/IE listings) get `vinDecoded: false` and no other `vin*` columns.

- **`vinDecoded`** (Boolean): Whether the VIN resolved. `false` means the VIN was fully masked, too short, or the decoder was unreachable — the lot row itself is still complete.
- **`vinWmi`** (String): World Manufacturer Identifier, the VIN's first three characters.
- **`vinCountryOfOrigin`** (String): Country the vehicle was built in, derived from the WMI (e.g. `Japan`, `Germany`, `South Korea`, `Mexico`).
- **`vinMake`** / **`vinManufacturer`** (String): e.g. `KIA` / `KIA MEXICO S.A. DE C.V.`
- **`vinModel`** / **`vinSeries`** / **`vinTrim`** (String): Decoded model line, series and trim.
- **`vinModelYear`** (String): Model year from the VIN's year code — useful as a cross-check against Copart's own `lotYear`.
- **`vinBodyClass`** / **`vinVehicleType`** / **`vinDoors`** (String): e.g. `Sedan/Saloon`, `PASSENGER CAR`, `4`.
- **`vinEngineCylinders`** / **`vinDisplacementL`** / **`vinEngineHP`** (String): Engine block.
- **`vinFuelType`** / **`vinTransmission`** / **`vinDriveType`** / **`vinGvwr`** (String): Drivetrain and rating.
- **`vinPlantCountry`** / **`vinPlantCity`** / **`vinPlantCompanyName`** (String): Assembly plant, when the decoder resolves it.
- **`vinErrorCode`** (String): Raw decoder status. `0` is a complete decode; `6` means "incomplete VIN", which is the normal, expected result for Copart's masked 11-character prefixes and does **not** indicate a problem.

#### Media & provenance (added by scraper)

- **`lotImages`** (Array of strings): Full-resolution image URLs (`*_ful.jpg` style paths on Copart CDN).
- **`thumbnail_image`** (String): Thumbnail taken from the first image row’s `thumbnailUrl` in the lot-details response (or that row’s `url` if `thumbnailUrl` is missing). Usually a `*_thb.jpg` URL on the Copart CDN when the API returns absolute URLs. `searchResult.lot_thumbnail_image_path` is the separate search-index path and may omit the scheme.
- **`sourceUrl`** (String): The URL that produced this lot in the run — the search URL (including encoded `searchCriteria` when copied from the browser), or the single lot URL when one was supplied directly.
- **`lotDetailsAvailable`** (Boolean): `true` for a full lot-details record. `false` on the rare hits where Copart's search index returns an **offsite partner lot** (NPA / Purple Wave, marked `sale_platform_code: "NPAUSA"` with an `npa_url`) — Copart's lot-details API does not serve those, so the row carries the search-index fields under `searchResult` instead of a blank record.

#### `searchResult` object (search index hit, snake_case)

These fields mirror the **search** payload for this lot before lot-details enrichment. Names stay in snake_case as in the API.

- **`auction_host_name`** (String): Auction host / sale location name (e.g. yard name).
- **`auction_host_id`** (Number): Numeric id for the auction host location.
- **`buy_it_now_price`** (Number): Buy-it-now price from the search index (0 if none / not applicable).
- **`currency_code`** (String): Currency for monetary fields in the search hit (e.g. `GBP`).
- **`sealed_bid_flag`** (Boolean): Whether the search index marks the lot as sealed bid.
- **`auction_date_utc`** (String, ISO 8601): Scheduled auction datetime from the search index (UTC).
- **`auction_date_type`** (String): Auction date type code (e.g. `F`), same meaning as top-level `auctionDateType`.
- **`auction_assignment_number`** (Number): Assignment / lane number from the search index (often mirrors `auctionAssignmentNumber`).
- **`lot_desc`** (String): Short lot description line as indexed for search (mirrors `lotDescription` in plain language).
- **`lot_number`** (Number): Copart lot number (same logical id as top-level `lotNumber`).
- **`odometer_reading_received`** (Number): Odometer reading on the search document (mirrors top-level `odometer` when unchanged).
- **`lot_thumbnail_image_path`** (String): Thumbnail path or URL fragment from search (may omit scheme; compare with `thumbnail_image`).
- **`yard_name`** (String): Yard name from the search index.
- **`yard_number`** (Number): Yard number from the search index.
- **`title_desc`** (String): Title / damage category description as indexed (mirrors `titleDescription` / category wording).
- **`lot_icon_codes`** (Array of strings): Badge / icon codes on the search hit (same codes as `lotIconCodes`, different naming convention).
- **`purple_wave_url`** (String): Purple Wave (or related) URL when present; empty string if none.
- **`show_updated_offsite_lot_text`** (Boolean): UI flag from search for offsite lot messaging.
- **`hide_odometer`** (Boolean): When true, the product UI would hide odometer; false means odometer is shown.
- **`full_vin`** (String): VIN field from search (typically masked the same way as `maskedVIN` on the detail payload).

***

### Explore more scrapers

If you find this actor useful, see more tools on [memo23's Apify profile](https://apify.com/memo23).

### Support

- For issues or feature requests, use the **Issues** tab for this actor in the [Apify Console](https://console.apify.com/).
- Customization or questions:
  - Website: <https://muhamed-didovic.github.io/>
  - Email: <muhamed.didovic@gmail.com>

### Additional services

- Customization or full dataset delivery: <muhamed.didovic@gmail.com>
- Other scraping needs or actor changes: <muhamed.didovic@gmail.com>
- API-style use of this scraper (commercial arrangements): <muhamed.didovic@gmail.com>

***

### 🤖 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/copart-scraper`).

**Purpose:** Extract Copart vehicle auction lot detail across 8 markets (US/CA/UK/IE/DE/ES/FI/MEA) — one flattened row per lot with specs, damage, VIN, odometer, yard, auction dates, bids and images, from `lotSearchResults` URLs or in-actor filters.

**Minimal input (URL mode):**

```json
{
    "startUrls": ["https://www.copart.co.uk/lotSearchResults?searchCriteria=%7B%22query%22%3A%5B%22*%22%5D%2C%22filter%22%3A%7B%7D%7D"],
    "maxItems": 50,
    "maxConcurrency": 10,
    "minConcurrency": 1,
    "maxRequestRetries": 60,
    "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

Filter mode (leave `startUrls` empty): set `"site": "de"` and either `"searchAllVehicles": true` or narrowing filters `make`, `model`, `yearMin`/`yearMax`, `odometerMin`/`odometerMax`, `featuredChips` (e.g. `["buyItNow","highValueItems"]`), `extraFetiClauses`.

**Output:** one flattened dataset row per lot — lotNumber, lotDescription, lotYear, lotMakeDesc, lotModelDesc, bodyStyle, color, fuel, odometer, primaryDamage, secDamage, estRetailValue, repairEst, titleDescription, currencyCode, saleDate, currentBid, siteCode, lotCountry, yardName, yardZipCode, latitude, longitude, maskedVIN, lotImages, thumbnail_image, sourceUrl, searchResult (snake_case search-index hit), additionalNotes.

**Behaviors an agent should know:**

- When `startUrls` is non-empty it wins — the whole filter section (`site`, `make`, `model`, etc.) is ignored for that run.
- The country/currency is auto-detected from each URL host, so US/CA/UK/IE/DE/ES/FI/MEA links can be mixed in one run; all markets share one output schema.
- Always set `maxItems` (default 1000). Search pages are followed until the cap or no more results.
- Use a residential proxy for the member-API traffic (`apifyProxyGroups: ["RESIDENTIAL"]`); datacenter proxies are frequently blocked.
- `featuredChips` only fully supports `vehiclesForAuction`, `buyItNow`, `highValueItems`, `hotItems`; other chip IDs are accepted but skipped with a warning until mapped in code.
- Billing: Pay-per-event billing — see the Pricing tab on the actor page.

***

### ⚠️ Disclaimer

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

The scraper accesses only publicly available Copart lot search and lot-detail data — no authenticated member-account features or content behind the Copart login wall are used to place bids or transact. Users are responsible for ensuring their use complies with Copart's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

copart scraper, scrape copart, copart API, copart auction scraper, Apify copart, salvage vehicle scraper, car auction data scraper, used car listings scraper, vehicle lot data extraction, copart uk scraper, copart germany scraper, copart canada scraper, copart spain scraper, copart ireland scraper, copart finland scraper, copart middle east scraper, copart usa scraper, copart.co.uk scraper, copart.de scraper, copart.ca scraper, copartmea scraper, salvage car market research, vin decoder scraper, vin odometer data, auction pricing analysis, vehicle inventory monitoring, salvage auction monitor, copart webhook alerts, damaged car data, automotive auction intelligence, copart lot search export, copart damage filter, copart yard search

# Actor input Schema

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

<b>Use this OR Option B below — not both.</b> Two kinds of link are accepted, and they can be mixed:<br><br><b>1. Search URLs</b> — run your search on any Copart site, then copy the whole address bar, e.g.<br><code>https://www.copart.com/lotSearchResults?searchCriteria=...</code><br><br><b>2. Single lot URLs</b> — scrape one specific vehicle, no search needed, e.g.<br><code>https://www.copart.com/lot/73672065/salvage-2021-kia-forte-gt-line-tx-dallas</code><br><br>Works with <b>copart.com</b>, <b>copart.ca</b>, <b>copart.co.uk</b>, <b>copart.ie</b>, <b>copart.de</b>, <b>copart.es</b>, <b>copart.fi</b> and <b>copartmea.com</b>. The site is detected from each URL’s host, so links from different countries can go in the same run.<br><br><b>If this list has any URL, Option B is ignored.</b> Leave it empty to use Option B instead.

## `site` (type: `string`):

<b>Only applies when Option A (URLs) is empty.</b> Which storefront the filters below run against: <b>USA</b> (copart.com, USD/miles), <b>Canada</b> (copart.ca, CAD), <b>United Kingdom</b> (copart.co.uk, GBP/miles), <b>Ireland</b> (copart.ie, EUR/km), <b>Germany</b> (copart.de, EUR/km), <b>Spain</b> (copart.es, EUR/km), <b>Finland</b> (copart.fi, EUR/km) or <b>Middle East</b> (copartmea.com, AED/km). For URL-based scraping this is ignored — the site comes from each URL's host.

## `searchAllVehicles` (type: `boolean`):

<b>Only applies when Option A (URLs) is empty.</b><br><br>When <b>on</b>, runs a very broad search on the selected <i>site</i> (default long year list only—add make/model below if you want to narrow).<br><br>When <b>off</b>, set at least one of: make, model, year, odometer, or a featured chip.<br><br><b>Everything in Option B combines</b> into one <code>searchCriteria</code>, like ticking several filters on the Copart site.

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

Manufacturer as Copart lists it, e.g. <code>FORD</code>, <code>BMW</code>. Matched as a prefix, so <code>CHEV</code> also finds <code>CHEVROLET</code> and <code>NISS</code> also finds <code>NISSAN</code> — Copart stores several makes under both forms.<br><br>Maps to <code>lot_make_desc</code>.

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

Model as Copart lists it, e.g. <code>CAMRY</code>, <code>F150</code>. Matched as a prefix. Best combined with a make.<br><br>Maps to <code>manufacturer_model_desc</code>.

## `yearMin` (type: `integer`):

Minimum model year. Together with <i>Year (maximum)</i> builds <code>filter.YEAR</code> → <code>lot_year:\[min TO max]</code>.<br><br>If you only set one bound, the other side defaults to a wide range (floor 1940 / ceiling current calendar year + 1).<br><br><b>Example pair:</b> 2018 and 2024 → only vehicles in that year band (plus your other filters).

## `yearMax` (type: `integer`):

Maximum model year; see <i>Year (minimum)</i>.

## `odometerMin` (type: `integer`):

Minimum odometer reading (miles on UK listings). With <i>Odometer (maximum)</i> builds <code>filter.ODM</code> → <code>odometer_reading_received:\[min TO max]</code>.<br><br>Single bound only: open end uses 0 or 9,999,999 as appropriate.<br><br><b>Example pair:</b> 75000 and 100000 = vehicles showing roughly 75k–100k miles.

## `odometerMax` (type: `integer`):

Maximum odometer (miles); see <i>Odometer (minimum)</i>.

## `featuredChips` (type: `array`):

Same idea as Copart’s <i>Featured items</i> on the search page. Selected chips add extra search constraints <b>together with</b> the visible fields above.<br><br><b>Fully wired in code:</b> Vehicles for Auction, Buy it Now, High Value Items, Hot Items. Other labels are accepted in the form but currently log a warning and are skipped until mapped in code.<br><br><b>Example:</b> select <i>Buy it Now</i> with Make <code>VOLVO</code> above to require both.

## `damageTypes` (type: `array`):

Copart's primary damage category. Pick several to widen — they OR together. Verified against the live index: every code here returns only lots carrying it.<br><br>Maps to <code>damage_type_code</code>.

## `secondaryDamageTypes` (type: `array`):

Secondary damage category, when Copart records one. Maps to <code>secondary_damage_code</code>.

## `vehicleTypes` (type: `array`):

Automobiles, motorcycles, boats, trailers, RVs, farm and industrial equipment. Maps to <code>vehicle_type_code</code>.<br><br>Three real codes carry no public name — they sit in Copart's heavy/industrial groups — so they are offered by code rather than under an invented label.

## `titleGroups` (type: `array`):

Clean, salvage, or non-repairable. Maps to <code>title_group_code</code>.

## `lossTypes` (type: `array`):

Copart's loss/sale type. Only three carry a name Copart actually publishes; the rest are listed by raw code with their share of inventory, because a guessed label on a filter that silently returns the wrong cars is worse than an honest code.<br><br>Maps to <code>loss_type_code</code>.

## `fuelTypes` (type: `array`):

Powertrain. Pick several — they widen the search.<br><br>Each option covers every spelling Copart stores for it — <code>fuel_type_desc</code> holds the same value under 35 different strings, and matching only the tidy one silently drops the rest. A raw Copart value still works if you pass one.

## `driveTypes` (type: `array`):

Drive configuration.<br><br>Each option covers every spelling Copart stores for it — <code>drive</code> holds the same value under 20 different strings, and matching only the tidy one silently drops the rest. A raw Copart value still works if you pass one.

## `transmissionTypes` (type: `array`):

Transmission type.<br><br>Each option covers every spelling Copart stores for it — <code>transmission_type</code> holds the same value under 5 different strings, and matching only the tidy one silently drops the rest. A raw Copart value still works if you pass one.

## `cylinders` (type: `array`):

Engine cylinder count. <code>0</code> is an electric vehicle.<br><br>Each option covers every spelling Copart stores for it — <code>cylinders</code> holds the same value under 19 different strings, and matching only the tidy one silently drops the rest. A raw Copart value still works if you pass one.

## `bodyStyles` (type: `array`):

e.g. <code>SEDAN</code>, <code>PICKUP</code>, <code>SPORT UTILITY</code>. Matched as a substring, so <code>SEDAN</code> also finds "SEDAN 4DR" — Copart has ~170 body-style spellings.<br><br>Maps to <code>body_style</code>.

## `engines` (type: `array`):

Engine description exactly as Copart writes it, e.g. <code>2.0L 4</code>, <code>3.5L 6</code>. Maps to <code>engine</code>.

## `trims` (type: `array`):

Trim level, e.g. <code>SE</code>, <code>LIMITED</code>, <code>SPORT</code>. Maps to <code>manufacturer_trim_desc</code>.

## `colors` (type: `array`):

<b>Bonus capability</b> — Copart's own site has no colour filter, so this one is applied to each finished lot record instead of the search index. Matching is case-insensitive and partial, so <code>GRAY</code> also catches "DARK GRAY". Non-matching lots are dropped before they are saved, so you are not charged for them.<br><br>Because it runs after the lot is fetched, a colour filter makes a run slower than the index-side filters above.

## `locationStates` (type: `array`):

Covers every Copart yard in the state. Pick several to widen.<br><br>Maps to <code>location_state</code>.

## `yardNames` (type: `array`):

Specific yards as Copart names them, e.g. <code>TX - HOUSTON</code>, <code>IL - CHICAGO NORTH</code>. Combine with or instead of the state filter. Maps to <code>yard_name</code>.

## `currentBidMin` (type: `integer`):

Lowest current bid to include, in the lot's own currency. Runs on Copart's index, so unlike most scrapers it costs no extra pages. Maps to <code>current_high_bid</code>.

## `currentBidMax` (type: `integer`):

Highest current bid to include. Lots with no bid yet count as 0.

## `saleDatePreset` (type: `string`):

Upcoming auctions within a fixed window. Ignored when the custom dates below are set. Maps to <code>auction_date_utc</code>.

## `saleDateFrom` (type: `string`):

Inclusive lower bound, <code>YYYY-MM-DD</code> (UTC). Overrides the quick window.

## `saleDateTo` (type: `string`):

Inclusive upper bound, <code>YYYY-MM-DD</code> (UTC).

## `newlyAddedWithinDays` (type: `integer`):

Lots that <b>appeared in Copart's inventory</b> in the last N days — which is not the same as when their auction runs. <code>1</code> = last 24 hours, <code>7</code> = last week. Maps to <code>expected_sale_assigned_ts_utc</code>.

## `salePlatforms` (type: `array`):

Limit to specific Copart sale platforms. Leave empty for all. Maps to <code>sale_platform_code</code>.

## `excludeSalePlatforms` (type: `array`):

Drop specific platforms. Ignored when the include list above is set.<br><br>Note the separate <b>Include offsite partner lots</b> toggle already removes Purple Wave and NPA by default, because Copart's detail API cannot serve them at all.

## `lotNumbers` (type: `array`):

Look up specific lots by number, e.g. <code>73672065</code>. Maps to <code>lot_number</code>.

## `vin` (type: `string`):

Full or partial VIN; a partial value matches as a prefix. Maps to <code>full_vin</code>.

## `freeTextQuery` (type: `string`):

Keyword search across the lot description, e.g. <code>tesla model 3</code>. Every word must appear. Use this when you would rather type a phrase than pick make and model.

## `runsAndDrivesOnly` (type: `boolean`):

Only lots Copart certified as running and driving (<code>lot_condition_code:CERT-S</code>).

## `hasKeysOnly` (type: `boolean`):

Only lots where keys are present.

## `buyItNowOnly` (type: `boolean`):

Only lots carrying a Buy It Now price — a small share of inventory.

## `excludeOnApproval` (type: `boolean`):

Skip lots needing seller approval after the sale; these often do not sell first time. Same as Copart's "Pure Sale" featured filter.

## `classicsOnly` (type: `boolean`):

Only vehicles at least 25 model years old, using Copart's own Classics clause.

## `sortBy` (type: `string`):

Mirrors Copart's own "Sort by" dropdown. Leave empty to keep each site's default ordering.

## `outputFormat` (type: `string`):

<b>Full</b> (default) keeps every column — around 130 per lot.<br><br><b>Compact</b> keeps the buying decision: what the vehicle is, damage, title, condition, pricing, VIN, drivetrain, yard, coordinates and both image lists, without the long tail of flags and internal ids.<br><br><b>Minimal</b> is the headline only: lot, link, year/make/model, odometer, primary damage, current bid, sale date, yard and thumbnail.<br><br>VIN-decode and monitor columns are kept in every profile, since you only get those by asking for them. Smaller rows also mean smaller webhook payloads.

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

Remembers which lots this search already returned, so a scheduled run gives you only what is <b>new</b> or what <b>moved</b> (price, sale date, sale status, odometer, damage, title, run condition) instead of the same inventory every time. Unchanged lots are skipped before they are saved, so you are not charged for them.<br><br>Each row gains <code>monitorStatus</code> (<code>new</code> or <code>updated</code>) and <code>monitorFirstSeenAt</code>.<br><br><b>The first run reports everything</b> — it has nothing to compare against yet. From the second run on you get the difference.<br><br><b>Paid plans only for the memory part.</b> Cross-run state needs stored data, and Apify scheduling is itself a paid feature. On a free run this still works but behaves as a first run every time, returning every match.

## `monitorIncludeUpdated` (type: `boolean`):

On (default): report both brand-new lots and ones whose price or condition changed. Off: only brand-new lots, which is the cheapest way to watch a large search.

## `monitorStateKey` (type: `string`):

By default each distinct search keeps its own memory, keyed by its URLs. Set a name here to pin that memory explicitly — useful when several schedules share one saved input, or when you want to reset a watch by pointing it at a fresh name.

## `webhookUrl` (type: `string`):

Every reported lot is POSTed here in batches of 50, after it is safely saved to the dataset — a webhook outage can never cost you the data. Failed batches are retried three times with backoff; anything still undelivered is written to the run's key-value store as <code>webhook-undelivered</code> rather than dropped.

## `webhookSecret` (type: `string`):

When set, each delivery carries <code>X-Copart-Signature: sha256=\<hmac></code> computed over the exact request body, so your endpoint can verify the call really came from this run.

## `webhookFormat` (type: `string`):

<b>JSON</b> sends the full lot records — the one to use for Make, n8n, Zapier or your own endpoint. <b>Slack</b> and <b>Discord</b> send a readable one-line-per-lot message that those two accept directly as an incoming webhook.

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

Turn on to add flat <code>vin\*</code> columns to every lot: <b>manufacturer</b>, <b>country of origin</b>, <b>model year</b>, <b>model & trim</b>, <b>body class</b>, <b>engine cylinders</b>, <b>displacement</b>, <b>fuel type</b>, <b>transmission</b>, <b>drive type</b> and <b>assembly plant</b>.<br><br>Copart masks the last 6 characters of the VIN on public lots — only the first 11 are needed, so this still works on masked VINs (e.g. <code>3KPF44AC0ME\*\*\*\*\*\*</code> → 2021 Kia Forte GT, built in Mexico). Lots where the VIN is fully masked get <code>vinDecoded: false</code> instead.<br><br>Uses the free public <b>NHTSA vPIC</b> database. No API key, no extra charge, cached per run.

## `includeOffsiteLots` (type: `boolean`):

Copart's <b>US</b> search index mixes in lots auctioned on partner platforms — <b>NPA</b> and <b>Purple Wave</b> — and Copart's lot-details API returns an error for every one of them. On a default copart.com search these are the <b>majority</b> of results (a live sample of the first 20 hits was 11 Purple Wave, 7 NPA, 2 Copart), so leaving this <b>off</b> means you are not billed for records that can never carry lot details.<br><br>Turn it <b>on</b> to keep them anyway — they arrive with <code>lotDetailsAvailable: false</code> and the search-index fields under <code>searchResult</code>.<br><br>UK, Ireland, Germany, Spain, Finland, Canada and Middle East searches contain no partner lots, so this setting has no effect there.

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

Maximum number of lot detail records to save.

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

Maximum number of API requests that can be processed at the same time.

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

Minimum number of API requests that will be processed at the same time.

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

Number of times the crawler will retry a failed request before giving up.

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

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.copart.com/lotSearchResults?free=true&query="
  ],
  "site": "uk",
  "searchAllVehicles": false,
  "make": "VOLVO",
  "model": "XC60",
  "yearMin": 2018,
  "yearMax": 2024,
  "odometerMin": 75000,
  "odometerMax": 100000,
  "featuredChips": [],
  "damageTypes": [],
  "secondaryDamageTypes": [],
  "vehicleTypes": [],
  "titleGroups": [],
  "lossTypes": [],
  "fuelTypes": [],
  "driveTypes": [],
  "transmissionTypes": [],
  "cylinders": [],
  "bodyStyles": [
    "PICKUP"
  ],
  "engines": [
    "2.0L 4"
  ],
  "colors": [
    "GRAY"
  ],
  "locationStates": [],
  "salePlatforms": [],
  "excludeSalePlatforms": [],
  "runsAndDrivesOnly": false,
  "hasKeysOnly": false,
  "buyItNowOnly": false,
  "excludeOnApproval": false,
  "classicsOnly": false,
  "outputFormat": "full",
  "monitorMode": false,
  "monitorIncludeUpdated": true,
  "webhookFormat": "json",
  "enrichVin": false,
  "includeOffsiteLots": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 60
}
```

# 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.copart.com/lotSearchResults?free=true&query="
    ],
    "make": "VOLVO",
    "model": "XC60",
    "yearMin": 2018,
    "yearMax": 2024,
    "odometerMin": 75000,
    "odometerMax": 100000,
    "bodyStyles": [
        "PICKUP"
    ],
    "engines": [
        "2.0L 4"
    ],
    "colors": [
        "GRAY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/copart-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.copart.com/lotSearchResults?free=true&query="],
    "make": "VOLVO",
    "model": "XC60",
    "yearMin": 2018,
    "yearMax": 2024,
    "odometerMin": 75000,
    "odometerMax": 100000,
    "bodyStyles": ["PICKUP"],
    "engines": ["2.0L 4"],
    "colors": ["GRAY"],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/copart-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.copart.com/lotSearchResults?free=true&query="
  ],
  "make": "VOLVO",
  "model": "XC60",
  "yearMin": 2018,
  "yearMax": 2024,
  "odometerMin": 75000,
  "odometerMax": 100000,
  "bodyStyles": [
    "PICKUP"
  ],
  "engines": [
    "2.0L 4"
  ],
  "colors": [
    "GRAY"
  ]
}' |
apify call memo23/copart-scraper --silent --output-dataset

```

## MCP server setup

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