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

Scrape Copart US and Canada salvage auctions. Extract lot number, VIN, current bid, Buy It Now, damage, title brand, odometer, yard GPS, and photos. Search by URL or make/model filters; monitor bid changes.

- **URL**: https://apify.com/crawloop/copart-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.90 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Copart Scraper — Salvage Auction Lots, Bids & VINs

> **Disclaimer:** This is an unofficial integration developed independently. It is not affiliated with, sponsored by, or endorsed by Copart, Inc. or any of its subsidiaries.
>
> **Copart** and related names are trademarks of their respective owners. Data is read from publicly accessible auction search and lot pages. No Copart member login is required.
>
> This Actor is provided **for informational, research, and price monitoring purposes only**. You are solely responsible for complying with applicable laws, Copart's terms of use, and your organization's policies.

**Copart scraper** / **Copart auction scraper** for US and Canadian salvage and clean-title vehicle auctions. Scrape Copart search results and individual lots into JSON/CSV via Apify — **lot number, VIN, current bid, Buy It Now, damage, title brand, odometer, yard GPS, and photos**. Search by a copied Copart URL or by make/model/year/state filters. Optional **monitor mode** emits only new lots and bid/status changes. Fast HTTP path (no headless browser) with residential proxy. Use as a **Copart API alternative** from **Python**, **Node.js**, cURL, or **MCP** / AI assistants.

**Best for:** salvage buying, used-parts sourcing, dealer auction desks, insurance total-loss comps, and VIN-level inventory monitoring.

> **Crawloop Marketplace Suite** — classifieds and vehicle scrapers for EU / US listings intelligence.

| Copart | AutoScout24 | Mobile.de | TractorHouse |
| :--- | :--- | :--- | :--- |
| **Copart Scraper** ◄── you are here | [AutoScout24 Scraper](https://apify.com/crawloop/autoscout24-scraper) | [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) | [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) |

### When to use this Actor

- **Salvage inventory sourcing** — Sweep Toyota / Ford / Tesla lots by state, year, Run and Drive, or Buy It Now.
- **Live bid tracking** — Schedule the Actor and turn on `monitorMode` to keep only new lots and bid/status changes.
- **Exact browser-filter replication** — Apply filters on Copart, copy the `lotSearchResults` URL, paste into Start URLs.
- **Yard / shipping planning** — Yard name, city, state, ZIP, latitude, and longitude on each row.
- **Parts and rebuild research** — Primary/secondary damage, title brand, keys, odometer brand, engine and drivetrain.

### When not to use this Actor

- **Member-only fields** — Full 17-character VIN serial, bid history for logged-in buyers, and broker tools are not on the public site.
- **UK / DE / ES / MEA Copart sites** — This Actor covers the United States and Canada. EU retail cars: [AutoScout24 Scraper](https://apify.com/crawloop/autoscout24-scraper) or [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper).
- **Account features** — No login, watch lists, or bidding.

### Key features

- **US + Canada** — `copart.com` and `copart.ca` from Start URLs or the `site` filter.
- **URL + filter modes** — Paste search / lot URLs, or build a search from keyword, make, model, year, state, damage, Buy It Now, and Run and Drive.
- **Direct lot lookup** — Pass `lotNumbers` when you already have Copart lot IDs.
- **Search cards or full details** — `scrapeDetails` enriches live bid state, title, seller, and specs; `includePhotos` adds the gallery.
- **Monitor mode** — Key-Value store baseline; later runs emit only **new** lots or **bid / Buy It Now / sale-status** changes, with early-stop on known lots.
- **Lightweight HTTP** — `curl_cffi` Chrome TLS impersonation; 128–512 MB RAM; no Playwright.

### Input

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `startUrls` | Array | `[]` | Search or lot URLs from copart.com / copart.ca. |
| `searchQuery` | String | — | Keyword, e.g. `toyota camry`. Used when Start URLs are empty. |
| `site` | String | `US` | `US` or `CA` for filter-based runs. |
| `make` / `model` | String | — | Facet filters (TOYOTA / CAMRY). |
| `yearFrom` / `yearTo` | Integer | — | Model year range. |
| `state` | String | — | Yard state/province (`CA`, `TX`, `ON`). |
| `damage` | String | — | Primary damage (`FRONT END`, `HAIL`, `FLOOD`). |
| `buyItNowOnly` / `runAndDriveOnly` | Boolean | `false` | Facet shortcuts. |
| `lotNumbers` | Array | — | Direct lot IDs. |
| `maxItems` | Integer | `50` | Cap per run (site search often caps ~1,000 hits). |
| `scrapeDetails` | Boolean | `true` | Fetch lot-detail JSON. |
| `includePhotos` | Boolean | `false` | Full gallery URL lists. Thumbnail always included. |
| `monitorMode` | Boolean | `false` | Emit only new lots and bid/status changes after a seed run. |
| `maxConcurrency` | Integer | `8` | Parallel detail fetches. |
| `proxyConfiguration` | Object | US residential | Apify RESIDENTIAL recommended. |

#### Example input

```json
{
  "searchQuery": "toyota camry",
  "site": "US",
  "yearFrom": 2018,
  "yearTo": 2024,
  "state": "TX",
  "runAndDriveOnly": true,
  "maxItems": 50,
  "scrapeDetails": true,
  "includePhotos": false,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

Start-URL mode (filters on the page are kept):

```json
{
  "startUrls": [
    { "url": "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry" }
  ],
  "maxItems": 100,
  "scrapeDetails": true
}
```

### Output

Each dataset row is one Copart lot.

| Field | Type | Description |
| :--- | :--- | :--- |
| `id` / `lotNumber` / `url` | String | Lot identifier and canonical page. |
| `title` / `year` / `make` / `model` / `trim` | Mixed | Vehicle identity. |
| `vin` | String | Public VIN (serial may be masked). |
| `odometer` / `odometerBrand` / `odometerUnit` | Mixed | Reading, ACTUAL/NOT ACTUAL, MI or KM. |
| `engine` / `cylinders` / `fuelType` / `transmission` / `driveType` | Mixed | Mechanical specs. |
| `primaryDamage` / `secondaryDamage` | String | Damage codes. |
| `titleDescription` / `titleGroup` / `titleState` | String | Title brand. |
| `hasKeys` / `runsAndDrives` | Boolean | Condition flags. |
| `currentBid` / `buyItNowPrice` / `buyItNow` | Mixed | Live auction pricing. |
| `estimatedRetailValue` / `estimatedRepairCost` | Integer | Copart valuations when published. |
| `saleStatus` / `saleDate` / `saleTimeZone` | Mixed | Auction timing. |
| `location` | Object | Yard name, city, state, ZIP, lat/lng. |
| `thumbnailUrl` / `images` | Mixed | Preview always; gallery when `includePhotos`. |
| `changeType` | String | Monitor mode: `new` or `bid_change`. |
| `scrapedAt` | String | ISO timestamp. |

```json
{
  "id": "27059380",
  "lotNumber": "27059380",
  "url": "https://www.copart.com/lot/27059380/2018-dodge-challenger-mi-detroit",
  "title": "2018 DODGE CHALLENGER GT",
  "year": 2018,
  "make": "DODGE",
  "model": "CHALLENGER",
  "vin": "2C3CDZGGXJH289026",
  "odometer": 15317,
  "odometerBrand": "ACTUAL",
  "odometerUnit": "MI",
  "primaryDamage": "MINOR DENT/SCRATCHES",
  "currentBid": 225,
  "buyItNowPrice": null,
  "estimatedRetailValue": 24998,
  "currency": "USD",
  "saleStatus": "Pure Sale",
  "location": {
    "name": "MI - DETROIT",
    "city": "DETROIT",
    "state": "MI",
    "country": "USA",
    "latitude": 42.3314,
    "longitude": -83.0458
  },
  "thumbnailUrl": "https://cs.copart.com/v1/AUTH_svc.pdoc00001/PIX240/example.JPG",
  "site": "US"
}
```

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Salvage buying desk** | Bids, Buy It Now, damage, Run and Drive, title brand |
| **Parts yard sourcing** | Make/model/year + yard GPS + keys / drivetrain |
| **Insurance comps** | Estimated retail, repair cost, sale date, VIN prefix |
| **Scheduled watch** | Monitor mode for new lots and bid moves |
| **AI / MCP pipelines** | Structured JSON for assistants and BI tools |

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/copart-scraper').call({
  searchQuery: 'toyota camry',
  site: 'US',
  yearFrom: 2018,
  maxItems: 50,
  scrapeDetails: true,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'US',
  },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/copart-scraper").call(
    run_input={
        "searchQuery": "toyota camry",
        "site": "US",
        "state": "TX",
        "runAndDriveOnly": True,
        "maxItems": 50,
        "scrapeDetails": True,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "US",
        },
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[:5])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/crawloop~copart-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "tesla",
    "site": "US",
    "maxItems": 20,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
  }'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/copart-scraper`.

Example prompts:

- "Run Copart Scraper for Toyota Camry 2018–2024 in Texas with runAndDriveOnly and maxItems 40; return lot number, VIN, current bid, damage, and yard as JSON"
- "Scrape Copart Buy It Now Tesla lots in California and summarize median current bid by model year"
- "Chain Copart Scraper then [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) to compare salvage cars vs used equipment inventory in the same US region"

### Suite next step

After Copart salvage coverage, switch to retail/used inventory with [AutoScout24 Scraper](https://apify.com/crawloop/autoscout24-scraper) (Europe) or [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) (Germany). For US heavy equipment, run [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper).

### FAQ

**Is this a Copart API?**\
There is no public read API for auction search. This Actor is a Copart API alternative that returns structured dataset items you can call from Python, Node.js, or MCP.

**Can I scrape Copart with Python or Node.js?**\
Yes. Use the Apify client examples above, or call the Actor from an AI assistant via Apify MCP. Export the dataset as JSON or CSV.

**Does this cover Copart Canada as well as the US?**\
Yes. Set `site` to `CA` or paste a Copart Canada search/lot URL. UK/DE/ES storefronts are out of scope.

**Why do I need a residential proxy?**\
Copart uses bot protection (Akamai / similar). Datacenter IPs often get HTTP 403. Use US residential for the US marketplace and CA residential for Canada.

**Why is part of the VIN masked?**\
Copart only shows the full 17-character VIN to logged-in members. Public search still returns the world manufacturer identifier and vehicle descriptor — enough to decode make, model, engine, year, and plant. The production serial may appear as asterisks.

**How many lots can one search return?**\
Copart typically caps a single public search around 1,000 hits. Split by make, year band, or state to go deeper.

**Start URLs or filters?**\
Paste a browser `lotSearchResults` / `lotsByMake` / lot URL in `startUrls` to keep every filter you already applied. Leave Start URLs empty and set `searchQuery` / `make` / `model` to build the search in the Actor.

**Cards vs full details vs photos?**\
Keep `scrapeDetails` on (default) for live bid state, title, and seller. Turn it off for faster search-card rows. Enable `includePhotos` only when you need the full gallery — a thumbnail is always stored.

**Can I watch bids over time?**\
Yes. Run once with `monitorMode` to seed a baseline, then schedule later runs. Only new lots and changes to current bid, Buy It Now, or sale status are written to the dataset.

### Related Actors

- [AutoScout24 Scraper](https://apify.com/crawloop/autoscout24-scraper) — Europe used-car listings
- [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) — German vehicle listings
- [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) — US / EU farm and construction equipment
- [GovPlanet Scraper](https://apify.com/crawloop/govplanet-scraper) — US government surplus auctions
- [Facebook Marketplace Scraper](https://apify.com/crawloop/facebook-marketplace-scraper) — US/local listings + vehicles

# Actor input Schema

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

Paste Copart search result URLs (lotSearchResults, lotsByMake, vehicleFinder) or individual /lot/{number} pages from copart.com or copart.ca. Filters already applied in the browser URL are kept. When Start URLs are set, the filter fields below are ignored for those searches.

## `searchQuery` (type: `string`):

Free-text query, same as the Copart search box (toyota camry, f-150, flood). Used when Start URLs are empty. Leave empty and set make/model filters to browse by facets.

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

Copart storefront for filter-based runs. Ignored when Start URLs already contain a host.

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

Vehicle make, e.g. TOYOTA, FORD, BMW. Applied as a Copart facet when Start URLs are empty.

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

Vehicle model, e.g. CAMRY, F150, X5. Works best together with Make.

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

Earliest model year, e.g. 2018.

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

Latest model year, e.g. 2024.

## `state` (type: `string`):

Two-letter yard location code, e.g. CA, TX, FL, ON, BC.

## `damage` (type: `string`):

Copart damage description, e.g. FRONT END, REAR END, HAIL, FLOOD, SIDE, MINOR DENT/SCRATCHES.

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

Only lots that can be purchased immediately at a fixed Buy It Now price.

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

Only lots flagged as Run and Drive.

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

One or more Copart lot numbers (or /lot/{number} URLs) to fetch directly, skipping search.

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

Maximum number of lots to collect per run. Copart search is typically capped around 1,000 hits per query — split by make, year, or state to go deeper.

## `scrapeDetails` (type: `boolean`):

Call Copart lot-detail JSON for richer specs, live bid state, seller, and title fields. Disable for faster search-card output.

## `includePhotos` (type: `boolean`):

Attach full-size and high-resolution image URL lists. A thumbnail is always included. Galleries add extra lot-detail requests.

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

Delta tracking via Key-Value store. First run seeds a baseline (no dataset rows). Later runs emit only new lots or changes to current bid, Buy It Now, or sale status. Stops early after several already-known lots.

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

How many lot-detail requests to run in parallel. Higher is faster; keep moderate to reduce blocks.

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

Apify Proxy. RESIDENTIAL with US (copart.com) or CA (copart.ca) is recommended — Copart uses bot protection and often blocks datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry"
    }
  ],
  "searchQuery": "toyota camry",
  "site": "US",
  "buyItNowOnly": false,
  "runAndDriveOnly": false,
  "maxItems": 50,
  "scrapeDetails": true,
  "includePhotos": false,
  "monitorMode": false,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Default dataset items (one Copart lot per row).

# 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": [
        {
            "url": "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry"
        }
    ],
    "searchQuery": "toyota camry",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/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": [{ "url": "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry" }],
    "searchQuery": "toyota camry",
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/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": [
    {
      "url": "https://www.copart.com/lotSearchResults/?free=true&query=toyota%20camry"
    }
  ],
  "searchQuery": "toyota camry",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/copart-scraper --silent --output-dataset

```

## MCP server setup

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