# Copart Scraper - Car Auction Search, Lot Data & VIN Decode (`technicaldost/copart-scraper`) Actor

Scrape Copart public auction search results and lot pages without login: flat rows with odometer, damage, bids, sale dates, images, VIN decode (offline + NHTSA), filters, proxies and watchlist dedup.

- **URL**: https://apify.com/technicaldost/copart-scraper.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Scraper — Salvage Car Auction Search & Lot Data

**Scrape Copart's public vehicle auction listings — search results or single lots — into clean, flat rows with VIN decoding, images, bid data and watchlist dedup. No login required.**

Copart.com lists hundreds of thousands of salvage, clean-title and used vehicles at auction. This Actor reads Copart's own public search JSON API (the same endpoint the copart.com frontend calls) through a real browser session, so you get complete, structured lot data without an account and without brittle HTML scraping.

### Who uses it

| User | What they do with the data |
| --- | --- |
| 🚗 Auto dealers & rebuilders | Track salvage inventory, current bids and sale dates to source vehicles below market |
| 📊 Market analysts | Monitor pricing, damage mix and volume trends across makes, years and locations |
| 🔍 Data brokers & lead generators | Build fresh vehicle/auction datasets on a schedule |
| 🛠️ App & tool developers | Power VIN tools, auction aggregators, price-estimation models |
| 🧑‍🔧 Exporters & parts businesses | Watch specific segments (e.g. flood cars, front-end hits) for new arrivals |

### What it does

- 🔎 **Search URLs or lot URLs** — paste any Copart public search-results URL (with your filters applied, including URLs that carry a `searchCriteria` payload) or a single lot URL like `https://www.copart.com/lot/12345678/...`
- 🧮 **Structured filters** — don't hand-craft URLs: pass `make`, `model`, `yearFrom`, `yearTo`, `damageType`, `maxOdometer` and the Actor builds Copart's server-side filters for you (make, year range and odometer range are pushed into Copart's own query; damage is matched before saving so you never pay for filtered-out lots)
- 🔑 **VIN decoding, even when masked** — Copart hides the last 6 VIN characters for anonymous visitors; this Actor still decodes **manufacturer, country of origin, possible model years and plant code** from the first 11 characters offline, and uses the **free NHTSA vPIC API** automatically when a full VIN is available
- 🖼️ **Image URLs per lot** — full-resolution photo URLs for every vehicle
- 💰 **Bid & sale data** — current bid, bid status, sale status, buy-today bid, auction name, sale date/time with timezone
- 🚚 **Complete vehicle detail** — odometer + status, primary damage, title type, engine, transmission, drive, fuel, color, body style, run-and-drive condition, keys, highlights, seller, estimated retail value, yard location
- 📦 **Batch mode** — process many start URLs in one run
- 🔔 **Watchlist mode (`onlyNew`)** — remembers lots it has already seen in a persistent key-value store and only emits fresh inventory on scheduled runs
- 🛡️ **Proxy passthrough + retry/backoff** — bring your own Apify proxy config; every API call retries with exponential backoff
- 📈 **Up to 1,000,000 results per run** — paginates Copart's API 100 lots per request

### Use cases

#### Source inventory for a rebuild business

Run nightly with `onlyNew: true` on searches like "2019–2023 Toyota Camry under 60k miles" and pipe only fresh lots into a Google Sheet, Airtable, or webhook via Apify integrations.

#### Price & trend analysis

Export 10,000+ rows to CSV/JSON/Excel and analyze hammer prices, damage distribution and regional supply. Every row carries sale date, current bid, damage and location.

#### VIN intelligence

Even though Copart masks VIN suffixes publicly, the first 11 characters identify the manufacturer, origin country, model-year candidates and assembly plant — decoded automatically when `enrichOutput` is on, with no external dependency.

#### Auction alerts

Schedule the Actor every hour on a filtered search and get only new listings pushed to your system — ideal for rare models or specific damage types.

### Why choose this scraper

| Capability | This Actor | Typical Copart scrapers |
| --- | --- | --- |
| No login / no cookies needed | ✅ | Varies |
| Uses Copart's real internal JSON API via a browser session | ✅ | Often fragile HTML parsing |
| VIN decode of masked VINs (first 11 chars) | ✅ built-in, offline | ❌ |
| NHTSA vPIC decode for full VINs | ✅ | ❌ |
| Structured filters input (make/model/year/damage/odometer) | ✅ | ❌ |
| Batch of multiple start URLs | ✅ | Often single URL |
| Image URLs per lot | ✅ | Sometimes |
| Bid history fields (current bid, bid/sale status, buy-today) | ✅ | Sometimes |
| Watchlist mode with cross-run dedup | ✅ | ❌ |
| Proxy passthrough + retry/backoff | ✅ | Varies |
| Price per result | **$0.02** | $0.026+ |

### How it compares

| Actor | Price per result | Users | Notes |
| --- | --- | --- | --- |
| **This Actor (technicaldost/copart-scraper)** | **$0.02** (+ $0.001/start) | new | Full feature set above: VIN decode, filters, images, watchlist, batch |
| parseforge/copart-public-search-scraper | $0.026 (+ $0.005/start) | ~497 | Solid baseline: search URL input, masked-VIN decode, flat rows |
| Other Copart actors on the Store | $0.02–$0.05/1K results or monthly flat | varies | Most are HTML-parsers without VIN enrichment, filters or dedup |

You get every feature of the leading competitor plus images, structured filters, watchlist dedup, NHTSA decoding and batch URLs — for 23% less per result.

### Configure the run

#### Example 1 — filtered search, enriched, watchlist mode

```json
{
  "startUrls": [
    "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry",
    "https://www.copart.com/lot/66231586/clean-title-2015-toyota-camry-se-fl-orlando-south"
  ],
  "filters": {
    "make": "Toyota",
    "model": "Camry",
    "yearFrom": 2018,
    "yearTo": 2024,
    "damageType": "FRONT END",
    "maxOdometer": 120000
  },
  "maxItems": 500,
  "enrichOutput": true,
  "includeImages": true,
  "onlyNew": true
}
```

#### Example 2 — quick single-search pull with proxy

```json
{
  "startUrl": "https://www.copart.com/lotSearchResults/?free=true&query=honda%20civic",
  "maxItems": 100,
  "enrichOutput": true,
  "includeImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Tip: apply filters on copart.com in your browser, copy the resulting URL (it contains a `searchCriteria` parameter) and paste it as a start URL — the Actor replays your exact filters.

### Output

One flat row per lot. Key fields: `lotNumber`, `title`, `year`, `make`, `model`, `vin` (as published; last 6 chars masked by Copart for anonymous users), `odometer`, `odometerStatus`, `primaryDamage`, `currentBid`, `currency`, `bidStatus`, `saleStatus`, `buyTodayBid`, `saleDate`, `saleTimeLocal`, `saleTimeZone`, `auctionName`, `location`, `city`, `state`, `country`, `titleType`, `engine`, `transmission`, `drive`, `fuelType`, `color`, `bodyStyle`, `condition`, `hasKeys`, `highlights`, `seller`, `estimatedRetailValue`, `thumbnailUrl`, `imageUrls`, `url`, `sourceUrl`, `scrapedAt`, and `vinDecode` (manufacturer, countryOfOrigin, possibleModelYears, plantCode, plantName) when `enrichOutput` is enabled.

### Pricing

This Actor uses **pay-per-event** monetization:

- **$0.02 per result** (each lot row saved to the dataset) — 23% cheaper than the leading competitor
- **$0.001 per Actor start**

| Results | Cost |
| --- | --- |
| 100 | $2.00 |
| 1,000 | $20.00 |
| 10,000 | $200.00 |

You are only charged for rows actually saved — lots removed by your damage filter or skipped by watchlist dedup are never billed.

#### Free users

On the Apify Free plan you get a **10-result preview** per run so you can evaluate the output schema and data quality before paying. Upgrade any plan for full volumes.

### Run it

1. Open the Actor on Apify and paste one or more Copart URLs (or set structured filters).
2. Set `maxItems`, toggle `enrichOutput` / `includeImages` / `onlyNew`.
3. Click **Start** — results stream into the dataset as they are scraped.
4. Export as JSON, CSV, Excel, or connect via API, webhooks, or schedule.

From the CLI:

```bash
apify call technicaldost/copart-scraper --input='{"startUrls":["https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry"],"maxItems":100}'
```

Via API: `POST https://api.apify.com/v2/acts/technicaldost~copart-scraper/run-sync-get-dataset-items` with the JSON input above.

### Use with MCP (AI agents)

This Actor is exposed on the Apify MCP server (`https://mcp.apify.com`), so Claude, ChatGPT, Cursor and other MCP clients can call it as a tool: "find 2020+ Ford F-150s with front-end damage under 100k miles on Copart" becomes a single tool call returning structured rows.

### Troubleshooting

**Q: The run returns 0 results for a URL that shows lots in my browser.**
A: Check that the URL is a `lotSearchResults` search URL or a `/lot/` details URL, and that your structured filters aren't over-constraining (e.g. a `damageType` substring that doesn't match Copart's damage labels like `FRONT END`, `HAIL`, `MINOR DENT/SCRATCHES`). Copart's own filter URLs (`searchCriteria=...`) are replayed exactly.

**Q: I'm being blocked / seeing retries.**
A: Copart uses bot protection. The Actor rides a real browser session and retries with backoff, but large runs should enable the proxy option (RESIDENTIAL group recommended).

**Q: The VIN is shown as `4T1BF1FK1FU******`. Can I get the full VIN?**
A: Copart masks the last 6 characters for anonymous visitors — no public scraper can recover them. This Actor still decodes manufacturer, country, model-year candidates and plant from the visible 11 characters.

**Q: `onlyNew` returned nothing on the second run.**
A: That's correct — it means no new lots appeared for that start URL since the previous run. The seen-list lives in the `copart-scraper-watchlist` key-value store; delete that store to reset.

**Q: How do I get more than 1,000 results?**
A: Just raise `maxItems` (up to 1,000,000). The Actor paginates 100 lots per API call automatically.

### FAQ

| Question | Answer |
| --- | --- |
| Do I need a Copart account? | No. Only public data is collected. |
| How fresh is the data? | Real-time — the same API copart.com serves to browsers. |
| Can I scrape a single lot page? | Yes, paste any `/lot/<number>/...` URL. |
| Can I scrape many searches at once? | Yes, `startUrls` accepts a list; `maxItems` is the combined cap. |
| What formats can I export? | JSON, CSV, XLSX, XML, RSS — via the Apify dataset API/UI. |
| Does it decode masked VINs? | Yes: manufacturer, origin country, possible years, plant from the first 11 chars; full VINs go through NHTSA vPIC. |
| Is there a free trial? | Free-plan runs return a 10-result preview. |
| Can I schedule it? | Yes — combine Apify Schedules with `onlyNew` for a delta feed. |

# Actor input Schema

## `startUrl` (type: `string`):

A single Copart public search-results URL or lot URL. Kept for drop-in compatibility with other Copart scrapers; prefer Start URLs for batches.

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

One or more Copart public search-results URLs (with your filters applied, e.g. https://www.copart.com/lotSearchResults/?free=true\&query=toyota%20camry) or single lot URLs (https://www.copart.com/lot/12345678/...). A search URL that contains a Copart searchCriteria parameter is honored fully.

## `filters` (type: `object`):

Build the Copart search for you instead of hand-crafting a URL. make is applied as a Copart server-side make filter, model is added to the search query, yearFrom/yearTo and maxOdometer become server-side range filters, damageType is matched against the primary damage text before a result is saved (you are never charged for filtered-out lots).

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

Maximum number of lots to save across all start URLs.

## `enrichOutput` (type: `boolean`):

Decode the VIN even when Copart masks the last 6 characters: manufacturer, country of origin, possible model years, and plant code from the first 11 characters (offline, built-in). When a full 17-character VIN is available it is decoded with the free NHTSA vPIC API.

## `includeImages` (type: `boolean`):

Fetch the full-resolution image URL list for every lot (one extra request per lot).

## `onlyNew` (type: `boolean`):

Emit only lots not seen in previous runs for the same start URL. Seen lots are remembered in a persistent Apify key-value store, so scheduled runs only return fresh inventory.

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

Optional Apify proxy configuration. Recommended for large runs.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry"
  ],
  "filters": {
    "make": "Toyota",
    "model": "Camry",
    "yearFrom": 2018,
    "yearTo": 2024,
    "damageType": "FRONT END",
    "maxOdometer": 150000
  },
  "maxItems": 100,
  "enrichOutput": true,
  "includeImages": true,
  "onlyNew": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped results as dataset items (CSV, JSON, Excel, XML export).

# 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=toyota%20camry"
    ],
    "filters": {
        "make": "Toyota",
        "model": "Camry",
        "yearFrom": 2018,
        "yearTo": 2024,
        "damageType": "FRONT END",
        "maxOdometer": 150000
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/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=toyota%20camry"],
    "filters": {
        "make": "Toyota",
        "model": "Camry",
        "yearFrom": 2018,
        "yearTo": 2024,
        "damageType": "FRONT END",
        "maxOdometer": 150000,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/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=toyota%20camry"
  ],
  "filters": {
    "make": "Toyota",
    "model": "Camry",
    "yearFrom": 2018,
    "yearTo": 2024,
    "damageType": "FRONT END",
    "maxOdometer": 150000
  }
}' |
apify call technicaldost/copart-scraper --silent --output-dataset

```

## MCP server setup

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