# 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
- **Features:** Limited permissions
- **Stats:** 6 total users, 3 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/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 Auction Lots, Bids & VINs

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Copart, Inc or its affiliates. Data is read from publicly accessible pages only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

**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.

**Masked VIN is still usable.** Copart hides the production serial for anonymous visitors (`4T1G11AK8PU******`). Keep `decodeVin` on (default): the first 11 characters go to NHTSA vPIC and you get manufacturer, make, model year, plant country/city, and body class — no member login. `isVinMasked` is true when the serial is starred. The full 17-character VIN is member-only.

> **Crawloop US Salvage Suite** — salvage auctions, yard rows, and used-parts comps.

| Actor | What it returns |
| :--- | :--- |
| **Copart Scraper** ◄ you are here | Salvage auction lots, bids, and VINs |
| [IAAI Scraper](https://apify.com/crawloop/iaai-scraper) | Salvage auction lots, VIN, and ACV |
| [Row52 Scraper](https://apify.com/crawloop/row52-scraper) | Junkyard donor cars: VIN, yard, row |
| [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper) | Self-service yard inventory: VIN, row |
| [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) | Used part prices from US recyclers |
| [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) | Used part price, grade, and yard |
| [LKQ Online Scraper](https://apify.com/crawloop/lkqonline-scraper) | Used OEM price, interchange, and yard |

### Who this is for

| Who | Job | Paste this |
| :--- | :--- | :--- |
| Salvage buyer / dealer | Morning Run-and-Drive sweep in one state | `make` + year band + `state` + `runAndDriveOnly` + `decodeVin` |
| Parts yard | Year / make / model plus plant and body from a masked VIN | Keyword or Start URL + `decodeVin` |
| Insurance / comps | Retail, repair cost, sale date, VIN prefix | `searchQuery` + `scrapeDetails` |
| Auction desk | New lots and bid / Buy It Now moves | `monitorMode` on a schedule |

### 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.
- **VIN decode** — NHTSA vPIC on the public prefix (works when the serial is masked). Adds manufacturer, make/model/year, plant country, body class. Cached per prefix. Toggle `decodeVin`.
- **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. |
| `decodeVin` | Boolean | `true` | NHTSA vPIC decode of the public VIN prefix (works when masked). |
| `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,
  "decodeVin": true,
  "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,
  "decodeVin": true
}
```

#### Ready-to-run recipes

Direct lot lookup:

```json
{
  "lotNumbers": ["27059380", "87654321"],
  "scrapeDetails": true,
  "decodeVin": true,
  "includePhotos": false
}
```

Run and Drive + VIN decode (Texas Camry):

```json
{
  "make": "TOYOTA",
  "model": "CAMRY",
  "yearFrom": 2018,
  "yearTo": 2024,
  "state": "TX",
  "runAndDriveOnly": true,
  "maxItems": 40,
  "decodeVin": true
}
```

Bid monitor (seed once, then schedule):

```json
{
  "searchQuery": "toyota camry",
  "site": "US",
  "maxItems": 100,
  "monitorMode": true,
  "decodeVin": 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). |
| `isVinMasked` | Boolean | True when the VIN is incomplete or starred. |
| `vinManufacturer` / `vinMake` / `vinModel` / `vinModelYear` | Mixed | NHTSA vPIC decode (`decodeVin`). |
| `vinPlantCountry` / `vinPlantCity` / `vinBodyClass` | String | Assembly plant and body class from vPIC. |
| `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",
  "isVinMasked": false,
  "vinMake": "DODGE",
  "vinPlantCountry": "CANADA",
  "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 [IAAI Scraper](https://apify.com/crawloop/iaai-scraper) for the same Toyota Camry year band and compare current bid vs Buy Now"
- "Chain Copart Scraper then [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) to compare recycler asking prices for the engine and transmission of a lot's year/make/model"

### Suite next step

After Copart lots, run [IAAI Scraper](https://apify.com/crawloop/iaai-scraper) for the other US salvage auction. Then [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper) for the donor's yard row, and [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) or [LKQ Online Scraper](https://apify.com/crawloop/lkqonline-scraper) to compare used-part prices for the same year / make / model.

### Troubleshooting

| Symptom | What to do |
| :--- | :--- |
| HTTP 403, challenge page, or zero lots | Use Apify **RESIDENTIAL** proxy. US for copart.com, CA for copart.ca. Datacenter IPs usually fail. |
| VIN looks like `4T1G11AK8PU******` | Expected without a buyer login. Leave `decodeVin` on — make, year, plant, and body class still fill. `isVinMasked` will be true. The production serial is member-only. |
| Run stops around 1,000 lots | Copart caps a single public search. Split by make, year band, or state and run again. |
| Bids look stale / missing seller | Keep `scrapeDetails` on. Search cards omit live bid state and seller. |

### 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. With `decodeVin` on (default), the Actor sends that prefix to NHTSA vPIC and fills manufacturer, make, model year, plant country, and body class. The production serial may appear as asterisks; `isVinMasked` is true on those rows.

**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

| Actor | Role |
| :--- | :--- |
| **Copart Scraper** ◄── you are here | US / CA salvage lots, bids, VIN |
| [IAAI Scraper](https://apify.com/crawloop/iaai-scraper) | US / CA salvage lots, VIN, ACV |
| [Row52 Scraper](https://apify.com/crawloop/row52-scraper) | Junkyard donor cars, VIN, yard, row |
| [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper) | Self-service yard inventory, VIN, row |
| [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) | Used auto parts & recycler stock |
| [LKQ Online Scraper](https://apify.com/crawloop/lkqonline-scraper) | Used OEM price, interchange, and yard |
| [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 |

# 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. Store / Console Try prefill leaves this off so the 5-minute quality check can finish; turn on for full lot records.

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

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

## `decodeVin` (type: `boolean`):

Decode the public VIN prefix via NHTSA vPIC: manufacturer, make, model, year, plant country/city, body class. Works on masked VINs (first 11 characters). Cached per prefix in the run. Turn off for a faster listing-only sweep.

## `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": 8,
  "scrapeDetails": false,
  "includePhotos": false,
  "decodeVin": true,
  "monitorMode": false,
  "maxConcurrency": 3,
  "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": 8,
    "scrapeDetails": false,
    "maxConcurrency": 3,
    "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": 8,
    "scrapeDetails": False,
    "maxConcurrency": 3,
    "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": 8,
  "scrapeDetails": false,
  "maxConcurrency": 3,
  "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/fHs7gHhAhJfc0rFab/openapi.json