# Copart Scraper: Salvage & Used Car Auctions, VIN, Bids & ACV (`automatic/copart-auction-scraper`) Actor

Copart scraper for salvage and used car auctions: every lot by make, model, year, damage, title, yard or sale date, with current bid, buy-it-now price, retail value (ACV), odometer, VIN, keys and auction date. US, Canada, UK, Ireland, Germany, Spain, Finland. Daily new-lots feed.

- **URL**: https://apify.com/automatic/copart-auction-scraper.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Copart Scraper: Salvage & Used Car Auctions, VIN, Bids & ACV

Pull Copart auction lots into one clean table: every car, truck, motorcycle, boat and piece of equipment for sale, filtered by make, model, year, damage, title type, yard or auction date. Every row has the current bid, buy-it-now price, estimated retail value (ACV), odometer, VIN, keys, run-and-drive status, title, primary and secondary damage, the yard with its map point and the auction date, plus a link to the lot.

Built for the people who buy at Copart every week: rebuilders and body shops, exporters, dismantlers and parts sellers, dealers, flippers, insurers and market analysts.

- **Every lot, one table.** Search all of Copart (more than 450,000 lots in the US alone) or narrow to the lots you buy: make, model, year, mileage, primary damage, clean or salvage title, vehicle type, fuel, run and drive, buy it now, state, yard, distance from a US ZIP code or a map point, or auctions in the next N days.
- **Seven Copart sites:** United States, Canada, United Kingdom, Ireland, Germany, Spain and Finland.
- **Big runs:** up to 50,000 lots per run, saved as they arrive; a 1,000-lot run takes well under a minute.
- **Paste your Copart searches.** Set your filters on copart.com (or any of the other sites), copy the address of the results page and paste it; every filter you chose comes along.
- **A daily buying feed.** Turn on monitor mode and schedule it: after the first run you get only new lots, or new lots plus lots whose bid, buy-it-now price, auction date or sale status changed, each marked with what changed. Unchanged lots cost nothing.
- **Ready for your sheet or system.** Stable lot keys, ISO dates and flat columns; export to Excel, CSV or JSON, or send each run to Slack, email or your own tools with Apify integrations.

**Try it now:** press Start with the prefilled input for the 20 Toyotas going to auction soonest in the next 7 days. An empty input returns the 100 lots going to auction soonest across the US.

### What you get

- **The vehicle:** `title`, `year`, `make`, `model`, `modelGroup`, `trim`, `vin` (as Copart shows it), `bodyStyle`, `vehicleType`, `fuel`, `engine`, `cylinders`, `drive`, `transmission`, `colour`.
- **Condition:** `odometer`, `odometerUnit`, `odometerStatus` (actual, not actual, exempt), `primaryDamage`, `secondaryDamage`, `damageCode`, `condition` (run and drive, engine start, enhanced), `hasKeys`, `highlights`.
- **Money:** `currentBid`, `buyItNowPrice`, `estimatedRetailValue` (ACV), `repairCost` where Copart shows it, `currency`, `saleStatus` (pure sale, minimum bid, on approval), `lotStatus`, `sellerReserveMet`.
- **Title:** `titleType` (clean, salvage, non-repairable...), `titleDescription` (the title document) and `titleState`.
- **Where and when:** `yardName`, `yardNumber`, `city`, `state`, `postalCode`, `locationCountry`, `latitude`/`longitude` (the yard's map point), `auctionDate` (UTC), `auctionTimezone`, `listedAt`, and `sellerName` when Copart shows the seller.
- **For your systems:** `listingKey` (`copart.com:<lot number>`), `lotNumber`, `url`, `thumbnailUrl`, `country`, `searchLabel` (which of your searches found it) and `collectedAt`. Monitor runs add `isNew`, `changedFields`, `previousCurrentBid`, `previousAuctionDate`, `previousSaleStatus` and `firstSeenAt`.

#### Output example

A real row from the prefilled search on 2026-11-16: a 2024 Corolla with rear-end damage and a buy-it-now price, at the Baltimore yard.

```json
{
  "listingKey": "copart.com:51337816",
  "source": "copart",
  "country": "us",
  "lotNumber": 51337816,
  "url": "https://www.copart.com/lot/51337816/salvage-2024-toyota-corolla-le-md-baltimore",
  "title": "2024 TOYOTA COROLLA LE",
  "year": 2024,
  "make": "TOYOTA",
  "model": "COROLLA",
  "modelGroup": "COROLLA",
  "trim": "LE",
  "vin": "5YFB4MDE9RP******",
  "odometer": 15559,
  "odometerUnit": "mi",
  "odometerStatus": "ACTUAL",
  "estimatedRetailValue": 20461,
  "repairCost": 16058.8,
  "currency": "USD",
  "currentBid": 325,
  "buyItNowPrice": 9000,
  "saleStatus": "Minimum Bid",
  "lotStatus": "MINIMUM_BID",
  "sellerReserveMet": false,
  "primaryDamage": "REAR END",
  "secondaryDamage": null,
  "damageCode": "RR",
  "titleType": "SALVAGE TITLE",
  "titleDescription": "CERT OF SALVAGE > 75% DAMAGE",
  "titleState": "MD",
  "condition": "RUNS AND DRIVES",
  "hasKeys": true,
  "vehicleType": "AUTOMOBILE",
  "bodyStyle": "SEDAN",
  "fuel": "GAS",
  "engine": "2.0L 4",
  "cylinders": "4",
  "drive": "FRONT WHEEL DRIVE",
  "transmission": "AUTOMATIC",
  "colour": "BLACK",
  "highlights": ["Hot Items"],
  "sellerName": null,
  "yardName": "MD - BALTIMORE",
  "yardNumber": 102,
  "city": "FINKSBURG",
  "state": "MD",
  "postalCode": "21048 1635",
  "locationCountry": "USA",
  "latitude": 39.51904,
  "longitude": -76.91971,
  "auctionDate": "2026-11-16T15:00:00Z",
  "auctionTimezone": "EST",
  "listedAt": "2026-04-01T07:00:00Z",
  "thumbnailUrl": "https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0426/0d8932ab4b824aa791e82863529d9e15_thb.jpg",
  "searchLabel": "copart.com: TOYOTA auction within 7 days",
  "collectedAt": "2026-11-16T00:04:38Z"
}
```

### How to use it

1. Pick the **Copart site** (United States by default).
2. Add **Makes** and **Models** as Copart writes them (`TOYOTA`, `CAMRY`; any letter case), or leave them empty for every make.
3. Narrow by year, odometer, damage, title type, vehicle type, fuel, run and drive, buy it now, states, yards, distance from a US ZIP code or a map point, or auction date.
4. Set **Maximum lots** (up to 50,000) and press Start.

You can also add **Keyword searches** as you would type them on Copart (`cybertruck`, `f-250`, a VIN), each run with the same filters, or paste up to 10 **Copart search links** (`https://www.copart.com/lotSearchResults?...`). A pasted link keeps every filter you set on Copart.

#### Input examples

Salvage-title Toyota and Honda sedans from 2018 to 2023 with front-end damage, in Texas and Florida:

```json
{
  "makes": ["TOYOTA", "HONDA"],
  "yearMin": 2018,
  "yearMax": 2023,
  "damageTypes": ["frontend"],
  "titleTypes": ["salvagetitle"],
  "states": ["TX", "FL"],
  "maxResults": 2000
}
```

Run-and-drive pickups under 100,000 miles within 100 miles of downtown Dallas, auctioned this week:

```json
{
  "vehicleTypes": ["pickuptrucks"],
  "runAndDriveOnly": true,
  "odometerMax": 100000,
  "zipCode": "75201",
  "radiusMiles": 100,
  "auctionWithinDays": 7
}
```

Every flood-damaged lot with a buy-it-now price, for exporters:

```json
{ "damageTypes": ["waterflood"], "buyItNowOnly": true, "maxResults": 5000 }
```

Audi and BMW lots on Copart Germany:

```json
{ "country": "de", "makes": ["Audi", "BMW"], "maxResults": 500 }
```

A daily feed of new Tesla lots plus bid and auction-date changes (schedule it every morning):

```json
{
  "makes": ["TESLA"],
  "maxResults": 3000,
  "monitorMode": "changes",
  "monitorName": "tesla-daily"
}
```

#### Monitor mode

Set **Monitor** to **New lots only** or **New lots and bid, auction date or sale status changes**, and schedule the same input. The first run returns every lot it checks and remembers them; each later run returns only lots that are new or, in the second mode, whose current bid, buy-it-now price, auction date or sale status changed. Changed rows show `changedFields` and the previous bid, auction date and sale status. In monitor mode, **Maximum lots** is how many lots are checked each run, newest lots first unless you choose another order; set it above the number of lots your search holds to watch every lot's bid. Give the monitor a name to keep its memory when you edit its filters.

#### Run summary

Each run saves a summary in the `OUTPUT` record of its key-value store: how many lots each search held and delivered, any search that was skipped and why (for example a misspelled make or a link that is not a Copart search), and whether the run stopped early at your cost limit.

### Pricing

**$2.00 per 1,000 lots ($0.002 per lot) plus $0.005 per run start.** Higher Apify plans pay less per lot, down to $1.50 per 1,000. You pay only for lots delivered to your dataset; in monitor mode, unchanged lots are not charged. The start fee is charged per GB of memory, with a minimum of one; the default 512 MB run is one start event.

| Example at 512 MB (Free plan prices) | Lots | Cost |
| --- | ---: | ---: |
| Prefilled input (Toyotas, next 7 days) | 20 | $0.045 |
| One make, 1,000 lots | 1,000 | $2.005 |
| A large market scan | 10,000 | $20.005 |
| Daily monitor, nothing new | 0 | $0.005 |

Set **Maximum cost per run** to cap any run; the run stops cleanly at the cap and keeps every lot already saved.

### Good to know

- Rows contain what Copart shows visitors who are not signed in: the VIN with its last six characters masked (fully masked on the UK and Irish sites), the current bid at the moment the page was read, and one photo thumbnail per lot. Final sale prices, bid history and member-only photos are not included, and nothing behind a Copart sign-in is collected.
- Every filter works on the US and Canada sites. The UK and Ireland sites take make, model, year, odometer, damage, yard, auction date, buy it now and run and drive, and the UK site also vehicle type (automobiles, motorcycles, RVs and farm equipment); Germany, Spain and Finland take make, year, odometer, damage, yard and auction date, and Germany and Spain also buy it now. For any other filter, set it on Copart and paste the link.
- Filters on the form apply to the keyword searches and to the all-lots search, not to pasted links, which keep their own filters.
- To search near a place, set **ZIP code** (a 5-digit US ZIP; its map point comes from the US Census Bureau's ZIP table, so a ZIP that table has no point for is skipped and named in the run summary) or a latitude and longitude. Distance is measured in a straight line to the yard; lots Copart keeps off its yards without a map point are included when Copart places them inside the radius.
- Without a chosen **Order**, an empty input and searches with an auction-date window list upcoming auctions, soonest first, and leave out lots whose auction date has passed or is not set yet; other searches keep Copart's own order and include every lot. Pick an order to change this.
- `latitude`/`longitude` are the yard's location as Copart gives it; the UK and European sites do not publish one, so they are empty there. `auctionDate` is empty for lots still waiting for a sale date.
- Odometer readings come in the unit Copart shows for the lot, named in `odometerUnit`: miles for US and UK yards, km for Canadian yards (also on copart.com) and the European sites. The Irish site shows readings without a unit; they are given as km. Amounts are in the site's currency.
- copart.com also lists the Canadian yards; copart.ca shows Canadian lots in Canadian dollars.
- Keyword searches work like Copart's search box: several words match lots with any of them (`mustang gt` also finds other GTs), so use Makes and Models for an exact model.
- A misspelled make, model or yard returns no lots for that search; the run lists it in the summary and the other searches still run. Up to 10 searches and 50,000 lots per run.
- Monitor mode reports lots that are new or changed; a lot that sells or is withdrawn simply stops appearing in later runs.
- In very large runs, a few lots can move between pages while Copart updates its lists; each lot is still delivered only once per run.

# Actor input Schema

## `country` (type: `string`):

Which Copart site to search. copart.com also lists the Canadian yards. Every filter below works on the US and Canada sites; the UK and Ireland sites take make, model, year, mileage, damage, yard, sale date, buy-it-now and run-and-drive (the UK site also vehicle type: automobiles, motorcycles, RVs and farm equipment); Germany, Spain and Finland take make, year, mileage, damage, yard and sale date (Germany and Spain also buy-it-now). A pasted search link always uses its own site.

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

Makes as Copart writes them, e.g. TOYOTA, FORD, MERCEDES-BENZ (any letter case). Several makes return lots of any of them. A misspelled make returns no lots and the run says so.

## `models` (type: `array`):

Model names, e.g. CAMRY, F150, CIVIC (Copart's model group, so CAMRY includes every Camry trim). Best used with a make.

## `searchQueries` (type: `array`):

Optional free-text searches, one per line, as typed in Copart's search box (e.g. 'cybertruck', 'f-250', a VIN). Like Copart's search box, several words match lots with any of them, so use Makes and Models for an exact model. Each runs as its own search with the filters on this form; leave empty to search with the filters alone.

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

Optional: paste up to 10 Copart results-page links (copart.com/lotSearchResults?...; also copart.ca, copart.co.uk, copart.ie, copart.de, copart.es, copart.fi). Each link keeps every filter you set on Copart, including 'Search near ZIP code'. The filters on this form are not added to pasted links.

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

Oldest model year.

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

Newest model year.

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

Lowest odometer reading, in the lot's own unit (miles for US and UK yards, km for Canadian yards, also on copart.com, and elsewhere).

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

Highest odometer reading, in the lot's own unit.

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

Only lots whose primary damage is one of these.

## `titleTypes` (type: `array`):

Clean, salvage or non-repairable title (US and Canada sites).

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

Cars, SUVs, pickups, motorcycles, boats, RVs, trucks, equipment and more (US and Canada sites; on the UK site automobiles, motorcycles, RVs and farm equipment).

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

Gas, diesel, electric, hybrid or flex fuel (US and Canada sites).

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

Only lots Copart marks Run and Drive.

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

Only lots with a buy-it-now price.

## `states` (type: `array`):

Two-letter codes of the yard's state or province, e.g. TX, FL, ON (US and Canada sites).

## `yards` (type: `array`):

Yard names exactly as Copart shows them, e.g. 'TX - DALLAS', 'CA - LOS ANGELES', 'BRISTOL', 'Frankfurt'.

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

Only lots at yards within the radius of this US ZIP code, e.g. 75201 or 02134 (5 digits; US and Canada sites). The map point comes from the US Census Bureau's ZIP table bundled with this Actor; a ZIP it has no point for is skipped and named in the run summary.

## `nearLatitude` (type: `string`):

With Near longitude: only lots at yards within Radius of this point (US and Canada sites), e.g. 32.7767. For a US ZIP code use ZIP code above instead; for a search Copart builds on its site, paste the link.

## `nearLongitude` (type: `string`):

E.g. -96.7970.

## `radiusMiles` (type: `integer`):

Distance from the ZIP code or map point above: 25, 50, 75, 100, 125, 150, 175 or 200 miles. Default 50.

## `auctionWithinDays` (type: `integer`):

Only lots whose auction is scheduled in the next N days.

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

Only lots auctioned on or after this date (UTC). Use this or 'Auction within', not both.

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

Only lots auctioned on or before this date (UTC).

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

Leave empty for the usual choice: an empty input or a search with an auction-date window shows upcoming auctions, soonest first; other searches keep Copart's own order so every lot is included; monitors look at the newest lots first. A choice made here is always used as given.

## `maxResults` (type: `integer`):

Most lots to deliver per run, shared fairly across your searches (up to 50,000). With monitoring on, this is how many lots are checked each run. About 2 s per 100 lots.

## `monitorMode` (type: `string`):

For scheduled runs. The first run returns every lot and remembers them; later runs return only new lots, or new and changed ones, marked with what changed. Unchanged lots are not charged.

## `monitorName` (type: `string`):

Optional name that keeps the monitor's memory when you edit its filters. Without it, each distinct set of searches and filters has its own memory.

## `source` (type: `string`):

The auction to search. Copart today.

## Actor input object example

```json
{
  "country": "us",
  "makes": [
    "TOYOTA"
  ],
  "auctionWithinDays": 7,
  "maxResults": 20,
  "monitorMode": "off"
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "makes": [
        "TOYOTA"
    ],
    "auctionWithinDays": 7,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/copart-auction-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 = {
    "makes": ["TOYOTA"],
    "auctionWithinDays": 7,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/copart-auction-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 '{
  "makes": [
    "TOYOTA"
  ],
  "auctionWithinDays": 7,
  "maxResults": 20
}' |
apify call automatic/copart-auction-scraper --silent --output-dataset

```

## MCP server setup

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