# Copart Public Search Scraper (`crawlerbros/copart-public-search-scraper`) Actor

Scrape Copart vehicle auction listings with search by keyword, make, model, damage type, location, and more. Extracts lot number, VIN, year, make, model, damage, odometer, bids, images, title codes, and auction dates.

- **URL**: https://apify.com/crawlerbros/copart-public-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Public Search Scraper

Extract vehicle auction listings from [Copart.com](https://www.copart.com) — the largest online auto auction marketplace. Scrape salvage, clean title, and wholesale vehicles by any search query, make, model, damage type, location, or title type. Returns up to **125,000+ live auction listings** with full vehicle details, pricing, and images.

### What data does it extract?

Each vehicle record contains **35–39 fields**, including:

| Field | Description | Example |
|---|---|---|
| `lot_number` | Unique Copart lot ID | `99714325` |
| `vin` | Vehicle Identification Number (partial) | `WBAVL1C50FV******` |
| `year` | Model year | `2015` |
| `make` | Manufacturer | `BMW` |
| `model` | Model | `X1` |
| `trim` | Trim / sub-model | `XDRIVE28I` |
| `color` | Exterior color | `WHITE` |
| `engine` | Engine description | `2.0L  4` |
| `cylinders` | Number of cylinders | `4` |
| `fuel_type` | Fuel type | `GAS`, `ELECTRIC`, `DIESEL` |
| `transmission` | Transmission type | `AUTOMATIC`, `MANUAL` |
| `drive` | Drive type | `ALL WHEEL DRIVE`, `FWD`, `RWD` |
| `keys` | Keys available | `YES`, `NO` |
| `odometer` | Odometer reading | `69676` |
| `odometer_unit` | Unit of measurement | `MI`, `EXEMPT` |
| `odometer_reading_type` | Reading type | `ACTUAL`, `NOT ACTUAL` |
| `primary_damage` | Primary damage type | `FRONT END`, `REAR END` |
| `secondary_damage` | Secondary damage type | `SIDE` |
| `title_group_code` | Title group code | `TITLEGROUP_S`, `TITLEGROUP_C` |
| `title_group` | Title group description | `SALVAGE TITLE`, `CLEAN TITLE` |
| `title_description` | Full title document name | `CERTIFICATE OF SALVAGE` |
| `title_state` | State that issued the title | `PA`, `FL` |
| `lot_condition` | Vehicle condition category | `RUNS AND DRIVES`, `ENHANCED VEHICLES` |
| `sale_status` | Auction status | `MINIMUM_BID`, `PURE_SALE` |
| `bid_status` | Current bid status | `NEVER_BID` |
| `current_bid` | Current highest bid (USD) | `475.00` |
| `buy_it_now_price` | Buy It Now price (USD) | `2500.00` |
| `acv` | Actual Cash Value / ACV | `9123.00` |
| `estimated_retail_value` | Estimated retail value (USD) | `10065.00` |
| `auction_date` | Auction date/time (ISO 8601 UTC) | `2026-05-06T14:00:00+00:00` |
| `sale_location` | Copart yard name | `PA - PITTSBURGH SOUTH` |
| `sale_yard_number` | Yard number | `85` |
| `state` | US state code | `PA` |
| `country` | Country | `USA` |
| `item_url` | Direct link to lot on copart.com | `https://www.copart.com/lot/99714325` |
| `imageUrl` | Primary thumbnail URL | `https://cs.copart.com/...` |
| `images` | Full-size image URL(s) | `["https://cs.copart.com/..."]` |
| `images_high_res` | High-resolution image URL(s) | `["https://cs.copart.com/..."]` |
| `scraped_at` | Scrape timestamp (ISO 8601) | `2026-05-06T13:09:31Z` |

### How to use

#### 1. Navigate to Copart and apply your filters

Go to [copart.com](https://www.copart.com) and use the search bar or filter panel to find the vehicles you want. You can filter by:
- **Make/Model** (BMW, Toyota, Tesla, etc.)
- **Damage type** (Front End, Rear End, Flood, etc.)
- **Title type** (Salvage, Clean, Certificate)
- **Location/State** (individual Copart yards)
- **Vehicle type** (Cars, SUVs, Trucks, Motorcycles)
- **Year range**
- And many more

#### 2. Copy the URL

Once you have the results you want, **copy the URL from your browser's address bar**.

Example URLs that work:
````

https://www.copart.com/lotSearchResults/?free=true\&query=BMW
https://www.copart.com/lotSearchResults/?free=true\&query=Toyota+Camry
https://www.copart.com/lotSearchResults/?free=true\&query=Tesla
https://www.copart.com/lot/99714325

````

#### 3. Paste into the scraper

Paste the URL into the **Start URL** input field and set the **Max Items** you need.

### Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `startUrl` | String (URL) | Yes | Any Copart search results URL or a single lot URL starting with `https://www.copart.com/` |
| `maxItems` | Integer | No | Maximum number of records to return (default: 100, max: 1,000,000) |

### Use cases

- **Insurance & claims research** — Look up salvage vehicles by VIN prefix or damage type to assess repair costs and market values
- **Auto dealer sourcing** — Find wholesale and rebuilder-eligible vehicles across all US Copart yards
- **Vehicle history research** — Identify vehicles that passed through Copart auctions with damage and title information
- **Pricing analysis** — Track bid trends, ACV vs. retail values, and current bid data for market research
- **Fleet monitoring** — Monitor specific makes/models across all Copart locations
- **Data aggregation** — Build datasets of salvage vehicle inventory for analytics or ML training

### Frequently Asked Questions

#### How much data can I scrape?
The scraper can return up to **125,000+ live listings** in a single run. Copart currently lists approximately 125,799 total vehicles across all locations. The `maxItems` parameter controls how many records you receive.

#### How fresh is the data?
Each run scrapes Copart's live search index. Auction dates, bid prices, and availability are current at scrape time. We recommend running the scraper regularly if you need up-to-date bid information.

#### Why is the VIN partially masked?
Copart's public search API masks the last 6 characters of VINs (e.g., `WBAVL1C50FV******`) in public search results. This is by design from Copart. The full VIN is available to registered Copart members.

#### What Copart search filters are supported?
Any URL you can create by browsing copart.com works as the `startUrl`. The scraper reads the search parameters directly from the URL, so all Copart filter combinations are supported.

#### Can I scrape a single lot?
Yes! Paste a single lot URL (e.g., `https://www.copart.com/lot/99714325`) and the scraper will return that vehicle's details.

#### Can I search globally or only in the US?
Copart operates globally. The scraper supports Copart's international sites if you navigate to them and copy the search URL. The primary focus is US inventory where the `lotSearchResults` URL pattern is used.

#### What is the estimated retail value (ERV)?
The `estimated_retail_value` field is Copart's automated valuation based on vehicle condition, market data, and auction history. The `acv` (Actual Cash Value) represents the insured/appraised value.

#### Are motorcycle and truck listings supported?
Yes — Copart lists all vehicle types including cars, SUVs, trucks, motorcycles, boats, RVs, and heavy equipment. Filter by vehicle type on copart.com and paste the filtered URL.

#### What happens if a lot has no images?
The `imageUrl`, `images`, and `images_high_res` fields will be absent from the record. Only fields with actual data are included in the output.

### Output example

```json
{
  "lot_number": "99714325",
  "vin": "WBAVL1C50FV******",
  "year": 2015,
  "make": "BMW",
  "model": "X1",
  "trim": "XDRIVE28I",
  "color": "WHITE",
  "engine": "2.0L  4",
  "cylinders": 4,
  "fuel_type": "GAS",
  "transmission": "AUTOMATIC",
  "drive": "ALL WHEEL DRIVE",
  "keys": "NO",
  "odometer": 69676,
  "odometer_unit": "MI",
  "odometer_reading_type": "ACTUAL",
  "primary_damage": "FRONT END",
  "secondary_damage": "SIDE",
  "title_group_code": "TITLEGROUP_S",
  "title_group": "SALVAGE TITLE",
  "title_description": "CERTIFICATE OF SALVAGE",
  "title_state": "PA",
  "lot_condition": "ENHANCED VEHICLES",
  "lot_condition_code": "CERT-E",
  "sale_status": "MINIMUM_BID",
  "bid_status": "NEVER_BID",
  "current_bid": 475.0,
  "acv": 9123.0,
  "estimated_retail_value": 10065.0,
  "auction_date": "2026-05-06T14:00:00+00:00",
  "sale_location": "PA - PITTSBURGH SOUTH",
  "sale_yard_number": "85",
  "state": "PA",
  "country": "USA",
  "item_url": "https://www.copart.com/lot/99714325",
  "imageUrl": "https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0126/032ec7d8_thb.jpg",
  "images": ["https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0126/032ec7d8_ful.jpg"],
  "images_high_res": ["https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0126/032ec7d8_hd.jpg"],
  "scraped_at": "2026-05-06T13:09:31.215211+00:00"
}
````

# Actor input Schema

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

A Copart search results URL (e.g. https://www.copart.com/lotSearchResults/?free=true\&query=BMW) or a single lot URL (e.g. https://www.copart.com/lot/12345678). Navigate to copart.com, apply your desired filters, and paste the URL here.

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

Maximum number of vehicle records to return. Set to a large number to get all results.

## Actor input object example

```json
{
  "startUrl": "https://www.copart.com/lotSearchResults/?free=true&query=BMW",
  "maxItems": 100
}
```

# Actor output Schema

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

Dataset containing all scraped Copart vehicle auction records.

# 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 = {
    "startUrl": "https://www.copart.com/lotSearchResults/?free=true&query=BMW",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/copart-public-search-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 = {
    "startUrl": "https://www.copart.com/lotSearchResults/?free=true&query=BMW",
    "maxItems": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrl": "https://www.copart.com/lotSearchResults/?free=true&query=BMW",
  "maxItems": 100
}' |
apify call crawlerbros/copart-public-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Copart Public Search Scraper",
        "description": "Scrape Copart vehicle auction listings with search by keyword, make, model, damage type, location, and more. Extracts lot number, VIN, year, make, model, damage, odometer, bids, images, title codes, and auction dates.",
        "version": "1.0",
        "x-build-id": "v0Lpbug7PMrhFgax1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~copart-public-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-copart-public-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~copart-public-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-copart-public-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~copart-public-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-copart-public-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "pattern": "^https://www\\.copart\\.com/",
                        "type": "string",
                        "description": "A Copart search results URL (e.g. https://www.copart.com/lotSearchResults/?free=true&query=BMW) or a single lot URL (e.g. https://www.copart.com/lot/12345678). Navigate to copart.com, apply your desired filters, and paste the URL here.",
                        "default": "https://www.copart.com/lotSearchResults/?free=true&query=BMW"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of vehicle records to return. Set to a large number to get all results.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
