Copart Intelligence — Lot Monitor

Get notified about new and updated lots on Copart matching your filter, before others do.

💸 You pay only for new and changed lots — never for the same listing twice. Each filter keeps its own memory across runs. A lot is charged once when first found (lot_new, $0.05), and again only if its price/condition later changes (lot_updated, $0.02). Re-running the same filter costs nothing for lots that haven't changed — unlike per-row scrapers that re-bill the entire result list on every single run. Set includeUpdated: false to pay for new lots only.

This Actor watches Copart's public auction listings on a schedule you control, applies the filter you configure (make, year, damage type, yard, condition), and emits each matching lot to an Apify Dataset and/or your own HTTPS webhook. You pay only for lots the Actor delivers — not for compute minutes or proxy bandwidth.

---

What this Actor does

• Crawls Copart's public listing API through Apify Proxy with real-browser TLS fingerprint, headers, and JS-challenge handling.
• Detects new lots and price/condition changes by hashing each lot's canonical field set; previous hashes are persisted in the Actor's KV store, so subsequent runs only surface deltas — no duplicate alerts.
• Outputs to Apify Dataset and/or your webhook. Webhook deliveries are HMAC-SHA256 signed (when you provide a secret), sent with up to 3 attempts (1s, 2s backoff), and queued to a per-filter DLQ if all attempts fail.
• Pay only for results, not compute. Two pay-per-event prices: lot_new and lot_updated. Empty runs cost only the standard apify-actor-start event (~$0.00005 — effectively free).

---

Example use cases

• "All 2018-2024 BMW with minor damage at the TX Dallas yard" — hourly, posts each match to Slack via webhook.
• "Toyotas under 80,000 mi, clean title" — every 4 hours, dataset only.
• "All Tesla salvage titles in the US" — daily, fed to a custom dashboard via webhook.

---

Why monitor Copart in real-time?

Copart processes hundreds of thousands of lots monthly across ~220 yards in the US and Canada. For dealers and resellers, daily manual browsing misses deals — competitors find them first. This Actor solves three concrete problems:

• Deal hunting: catch lots matching your specific criteria (make + budget + yard + damage) within minutes of Copart adding them.
• Multi-yard tracking: monitor 50+ yards in parallel — impossible with manual browsing.
• Pipeline automation: webhook delivery integrates directly with your CRM, bidding tool, Slack, or spreadsheet — no intermediate dashboard needed.

---

Getting started

1. Click "Run" or "Start" at the top of this page.
2. Configure your filters:
   • Pick vehicle makes from the dropdown (BMW, Toyota, etc.) or type custom brand names (e.g. LUCID, RIVIAN).
   • Set year / odometer / vehicle type / body style / fuel / drive train / damage codes.
   • Choose location: pick US states / Canadian provinces (["TX", "CA"]) — auto-expands to every Copart yard in those states — or specific yards from the dropdown (271 options — 55 states/provinces + 216 yards).
   • Set a sale-date window via quick preset (next_7_days) or custom from/to dates.
3. Pick output format: compact (default — full buyer detail), full (adds damage photos + thumbnail + seller), or minimal (headline fields only).
4. (Optional) Set a webhook in webhookUrl + webhookSecret to receive each lot in your own system.
5. Run — first run on a fresh filter takes 30-90s, subsequent runs 10-30s.

Each filter has its own state. Run twice with identical input → second run only emits changed lots, doesn't re-charge for unchanged ones.

---

Pricing

Pay-per-event — and only for deltas. Thanks to per-filter memory, a lot is billed when it's first found or when it changes, and never again while it stays unchanged. There's no per-row re-billing on repeat runs: monitoring a 500-lot filter hourly costs just a handful of delta charges per run after the first — not 500 charges every time. That's the core difference from per-result scrapers that re-charge for the whole list on every run.

The two events you pay for:

Event	Price	When charged
lot_new	$0.05	A lot the Actor has never seen in this filter's history is found.
lot_updated	$0.02	A lot already seen in this filter's history shows a different content hash (price, condition, etc.). Set includeUpdated: false in input to opt out and pay only for new lots.

Typical cost scenarios

Workload	First run	Subsequent runs (deltas only)
Narrow filter — one yard, specific make/year	$0.50 - $2 (10-40 new lots)	$0.05 - $0.25 (1-5 deltas)
Medium filter — one state, 2-3 makes	$2.50 - $10 (50-200 lots)	$0.25 - $1.50 (5-30 deltas)
Broad filter — multi-state, no make/damage limit	$10 - $50 (200-1000 lots)	$1.50 - $5 (30-100 deltas)

Empty runs (filter matches nothing today) = $0.00005 (the standard apify-actor-start event charge that fires once per Actor start, regardless of outcome). Practically rounds to zero.

Cost control

• maxResultsPerRun: 100 — hard cap on rows per run. Default 500, max 10000. Use 100 on first run with a broad filter to protect against unexpected charges.
• includeUpdated: false — only pay for lot_new events, never for lot_updated. Useful when you only care about fresh listings.
• ACTOR_MAX_TOTAL_CHARGE_USD — standard Apify env var. Actor checks it on every charge and exits cleanly when budget is reached.

Apify subscription credits (Free / $49 Starter / $499 Scale plans) apply platform-wide across all Actors you run, not just this one. See the Apify pricing page for the full subscription model. The per-event prices above ($0.05 / $0.02) are what this Actor charges per matching lot — they're billed against your Apify usage like any other PPE Actor.

---

Input

All filter fields are optional. Empty input means "every active lot Copart is showing right now" — useful for discovery, but expect a large first run.

Common fields:

Filter — what to monitor

Field	Type	Purpose
makes	string[]	Hybrid dropdown — top 40 Copart brands suggested (BMW, Toyota, ...) + you can also type custom make names (Lucid, VinFast, classics). Case-sensitive for custom entries.
models	string[]	Free-text models. Best combined with makes to avoid name collisions ("1500" exists for Chevy + RAM).
yearMin/yearMax	integer	Inclusive year range. Either bound is optional.
odometerMax	integer	Upper bound on miles.
vehicleTypes	enum[]	Multi-select — "Automobiles", "Motorcycles", "RVs", etc. 15 types.
titleGroups	enum[]	"Clean Title", "Salvage", "Nonrepairable".
damageCodes	enum[]	25 Copart damage categories — "Front End", "Hail", "Minor Dent / Scratches", "Water / Flood", "Rollover", and more.
sources	enum[]	Why the vehicle is at Copart — Donated / Fleet / Impound / Repossession / Theft Recovery / Water-Flood.
fuelTypes	enum[]	Powertrain — Gas / Diesel / EV / Hybrid / Flex Fuel / Hydrogen / CNG.
driveTrains	enum[]	FWD / RWD / AWD / 4×4 (front-based) / 4×4 (rear-based) / 4×2 (truck). Aliases handled.
bodyStyles	enum[]	Sedan / SUV / Pickup / Hatchback / Coupe / Convertible / Wagon / Vans / Cab-Chassis / Cutaway.
location	enum[]	Single location filter — pick US states / Canadian provinces (entire state, auto-expands to all yards there) and/or specific yards, in one multi-select. Mix freely — any match is included (union). Example: "Texas — all yards" + "CA - Vallejo". 271 options (55 states + 216 yards). Note: the Washington DC yard is filed under Maryland (MD) — there's no standalone "DC" state option.
runsAndDrivesOnly	boolean	Only lots with the Run and Drive (CERT-D) condition.
engines	string[] (free-text)	Engine description (e.g. 2.0L 4, 3.0L 6, 5.0L 12 — one space before the cylinder count). ⚠️ Case- and space-sensitive — copy verbatim from Copart's Engine facet. Multiple selections OR'd.
transmissions	enum[]	AUTOMATIC / MANUAL. BMW-verified; CVT added later if broader-make probe confirms.
cylinders	enum[]	Cylinder count: 0 (EV) / 3 / 4 / 6 / 8 / 10 / 12. Field is string-typed in Copart's Solr — schema enforces strings.
colors	string[] (free-text)	Exterior color (e.g. GRAY, BLACK, WHITE). ⚠️ Case-sensitive UPPERCASE. Capability beyond Copart UI parity — Copart's UI doesn't expose color filter, but the field is filter-usable.
saleDatePreset	enum	Quick window: today / tomorrow / next_7_days / next_30_days. Wins over custom dates.
saleDateFrom/saleDateTo	string (YYYY-MM-DD)	Custom date window. Ignored if saleDatePreset is set. UTC.

Filter — inventory features

Field	Type	Purpose
features	enum[]	Copart UI "Featured items" sidebar toggles — multi-select OR'd. Values: used, no_license_required, hot_items, featured_vehicles, offsite_sales, engine_start, enhanced, classics, inspected, public_and_general_business, bank_repossessed, pure_sale. Some Featured items live in dedicated fields above (Buy It Now / Run and Drive / Electric/Hybrid / Recovered Thefts / Fleet & Lease).
newlyAddedWithinDays	integer (1–30)	Filter to lots added to Copart inventory within last N days (range 1–30). Common presets: 1 (last 24h), 7 (last week), 30 (last month). Distinct from saleDatePreset — this is inventory-add date, not auction date.
classicsYearsOld	integer (1–100)	Override the 25-year default Classics threshold. Only applies when features includes classics.

Filter — auction state

Field	Type	Purpose
salePlatforms	enum[]	Include only specific Copart sale platforms (CPRTUSA / PWUSA / NCS). Leave empty to include all.
excludeSalePlatforms	enum[]	Exclude specific platforms — typical use: exclude Purple Wave (PWUSA) which has higher buyer fees. Cannot overlap with salePlatforms.
excludeOnApproval	boolean	Skip lots that require seller approval (On Approval status). Equivalent to Copart UI's "Pure Sale Items" filter.

Filter — price & budget

Field	Type	Purpose
currentBidMin	integer (USD)	Lowest current bid to include (inclusive). ⚠️ Client-side filter — see caveat below.
currentBidMax	integer (USD)	Highest current bid to include (inclusive). Pre-bid lots (no current bid) are treated as $0.
buyItNowOnly	boolean	Only lots with a Buy It Now price (~4.4% of inventory). Server-side filter — no extra fetch cost.

⚠️ Client-side filtering caveat (applies to currentBidMin / currentBidMax): Copart's API does not expose a server-side current-bid filter. To apply the range, this Actor fetches up to 3× more pages from Copart per run and discards off-range lots before they're charged. Net effect:

• PPE cost is unaffected — you only pay per matching lot, not per fetched lot.
• Run wall-clock can be 2-3× longer for narrow price bands.
• Very narrow bands (max - min < 1000 on a broad search) may hit the page cap before finding enough matching lots — narrow your makes / models filter instead.

Search by identifier (advanced)

Field	Type	Purpose
vin	string (17 chars)	Look up by Vehicle Identification Number. Regex ^[A-HJ-NPR-Z0-9]{17}$ (excludes I/O/Q). Combines with bucket filters via AND.
lotNumbers	string[] (digits)	Look up a specific lot by its 8-digit number. Phase 1 supports a single lot per run; multi-lot lookup is a Phase 2 enhancement.
freeFormQuery	string	Full-text keyword search across lot fields. Multi-token AND. Example: low miles BMW.

⚠️ Mutual exclusion: at most one of vin, lotNumbers, freeFormQuery may be set per run — they all map to Copart's single search-text slot. The Actor rejects input with multiple identifier fields. Combining an identifier with other filters (makes, years, states, etc.) is fully supported and AND'd at the Solr layer.

Delivery (optional)

Field	Type	Purpose
webhookUrl	string (URL)	If set, each emitted lot is POSTed to this URL.
webhookSecret	string (secret)	HMAC-SHA256 secret. Apify encrypts this at rest.

Run behavior

Field	Type	Purpose
maxResultsPerRun	integer (default 500)	Hard cap on lots per run. Protects against runaway charges on broad filters.
includeUpdated	boolean (default true)	Emit lot_updated events; set false to pay only for lot_new.
outputFormat	enum	compact (default — full buyer detail), full (adds damages[] + thumbnail + seller + ldu), minimal (lot id + vehicle + bid + odometer + primary damage + title + location).
sortBy	enum	Sort order, mirroring Copart's UI "Sort by" dropdown: auction_date / odometer / year / make / model / item_number / buy_it_now / current_bid / sale_light. Leave empty for Copart's default (sale-light priority). "Location distance" (nearest ZIP) coming in a future release.

---

Output

Each lot is written as a single row to the default Apify Dataset, plus optionally posted to your webhook.

Dataset row example (outputFormat: "compact" — default)

{
  "_metadata": {
    "ref": "apify-actor",
    "isNew": true,
    "captured_at": "2026-05-17T10:42:13.383Z",
    "lotHash": "EHrBVqBcfT/NCPtyC03YPvtQZcRgVf6TnDXxpa2Bh1I=",
    "lastUpdatedMs": 1778866098000
  },
  "lotNumber": 95786325,
  "make": "TOYOTA",
  "model": "CAMRY",
  "year": 2022,
  "currentBid": 3100,
  "odometer": 66119,
  "primaryDamage": "MINOR DENT/SCRATCHES",
  "titleGroup": "CLEAN TITLE",
  "yardName": "TX - DALLAS SOUTH",
  "locationState": "TX",
  "description": "2022 TOYOTA CAMRY SE",
  "vehicleType": "AUTOMOBILE",
  "vin": "4T1G11AK4NU******",
  "saleDateUtc": "2026-05-18T16:00:00.000Z",
  "secondaryDamage": null,
  "titleType": "CERTIFICATE OF TITLE",
  "color": "CHARCOAL",
  "driveTrain": "Front-wheel Drive",
  "fuelType": "GAS",
  "engine": "2.5L 4",
  "cylinders": "4",
  "runCondition": "RUNS AND DRIVES",
  "hasKeys": "YES",
  "odometerBrand": "ACTUAL",
  "inspected": true,
  "buyItNowPrice": 0,
  "buyItNowAvailable": true,
  "carfaxAvailable": false,
  "saleBrand": "COPART",
  "currency": "USD",
  "locationCountry": "USA"
}

outputFormat: "full" adds the per-panel damages[] array (with image URLs), thumbnailUrl, seller, and the Copart lot slug ldu. outputFormat: "minimal" keeps only _metadata, lotNumber, make, model, year, currentBid, odometer, primaryDamage, titleGroup, yardName, locationState.

Trim: description carries the full vehicle description including trim (e.g. "CAMRY SE") — the trim isn't in the separate make/model/year fields.

Damage: primaryDamage is the headline summary and is populated even for freshly-listed lots. The detailed per-panel damages[] array (full format) is filled in only after Copart's inspection — it may be empty for very fresh lots.

---

Webhook delivery

Each emitted lot is POSTed to your webhookUrl with Content-Type: application/json. Headers:

Header	Value
User-Agent	CopartIntelligence-Apify/1.0
X-CopartIntelligence-Delivery-Id	Unique UUID per delivery — dedup key on the receiver side.
X-CopartIntelligence-Signature	sha256=<hex> — present only when webhookSecret is set. HMAC-SHA256 of body.

Retry policy: 3 attempts per delivery with exponential backoff (1s, 2s). HTTP 410 Gone = endpoint disabled — silent skip, no retry. Other non-2xx / network errors → per-filter DLQ, retried at the start of the next run. After 5 consecutive failed retry rounds on the same queued delivery (on top of the initial 3-attempt send), the Actor sets webhookDisabled in KV and skips webhooks until you clear that flag in Apify Console.

Webhook payload example

{
  "event": "lot.alert",
  "alert_type": "new",
  "lot": {
    "_metadata": {
      "ref": "apify-actor",
      "isNew": true,
      "captured_at": "2026-05-17T10:42:13.383Z",
      "lotHash": "EHrBVqBcfT/NCPtyC03YPvtQZcRgVf6TnDXxpa2Bh1I=",
      "lastUpdatedMs": 1778866098000
    },
    "lotNumber": 95786325,
    "make": "TOYOTA",
    "model": "CAMRY",
    "year": 2022,
    "currentBid": 3100,
    "odometer": 66119,
    "primaryDamage": "MINOR DENT/SCRATCHES",
    "titleGroup": "CLEAN TITLE",
    "yardName": "TX - DALLAS SOUTH",
    "locationState": "TX",
    "description": "2022 TOYOTA CAMRY SE",
    "vehicleType": "AUTOMOBILE",
    "vin": "4T1G11AK4NU******",
    "saleDateUtc": "2026-05-18T16:00:00.000Z",
    "secondaryDamage": null,
    "titleType": "CERTIFICATE OF TITLE",
    "color": "CHARCOAL",
    "driveTrain": "Front-wheel Drive",
    "fuelType": "GAS",
    "engine": "2.5L 4",
    "cylinders": "4",
    "runCondition": "RUNS AND DRIVES",
    "hasKeys": "YES",
    "odometerBrand": "ACTUAL",
    "inspected": true,
    "buyItNowPrice": 0,
    "buyItNowAvailable": true,
    "carfaxAvailable": false,
    "saleBrand": "COPART",
    "currency": "USD",
    "locationCountry": "USA",
    "damages": [
      {
        "itemDescription": "Front Bumper",
        "damageDescription": "Heavy Scratch",
        "severityDescription": "3 To 4 Inches",
        "combinedDescription": "Front Bumper, Heavy Scratch, 3 To 4 Inches",
        "damageArea": "OTHER",
        "detectionArea": null,
        "imageUrl": "https://c-static.copart.com/.../8299414a46e747fb96aa576a9475c915_hrs.jpg",
        "thumbnailUrl": "https://c-static.copart.com/.../8299414a46e747fb96aa576a9475c915_thb.jpg"
      }
    ],
    "thumbnailUrl": "https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/1225/72b41288_thb.jpg",
    "seller": "HOLMAN",
    "ldu": "clean-title-2022-toyota-camry-se-tx-dallas-south"
  },
  "delivered_at": "2026-05-17T10:42:13.384Z",
  "delivery_id": "40c3c175-6134-4a2a-91f2-164ebc155f5c"
}

This example shows the full outputFormat. The lot field shape matches your outputFormat input: full adds the per-panel damages[] array + thumbnailUrl + seller + ldu on top of compact; compact (default) carries the full flat buyer detail (odometer, damage, title, color, drivetrain, run condition, keys, …); minimal keeps the headline fields (lotNumber/make/model/year/currentBid/odometer/primaryDamage/titleGroup/yardName/locationState) + _metadata. Pick compact to reduce webhook bandwidth.

Signature verification (Node.js)

const crypto = require('node:crypto');

function verifyWebhook(rawBody, signatureHeader, secret) {
  if (!signatureHeader || !signatureHeader.startsWith('sha256=')) return false;
  const expected = 'sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
  // `timingSafeEqual` requires equal-length buffers; fall back to false otherwise.
  const a = Buffer.from(signatureHeader);
  const b = Buffer.from(expected);
  if (a.length !== b.length) return false;
  return crypto.timingSafeEqual(a, b);
}

// Test vector — match this exactly to confirm your verifier works:
//   body    = '{"hello":"world"}'
//   secret  = 'topsecret'
//   signature = 'sha256=afd00617ceb8f63e65ea5c310f06bf78c3901e7a713db532e25da26ad63c7236'

Signature verification (Python)

import hmac, hashlib

def verify_webhook(raw_body: bytes, signature_header: str, secret: str) -> bool:
    if not signature_header.startswith("sha256="):
        return False
    expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(signature_header, expected)

Always pass the raw request body bytes (not a parsed/re-serialized JSON object) into the HMAC — any whitespace difference breaks the signature.

---

Scheduling

Set the run cadence in Apify Console → Schedules. Recommended starting points:

• Hourly — active buyers tracking specific makes/yards. Typical cost: $1–$5/day on a narrow filter.
• Every 15 minutes — serious users on time-sensitive auctions. Higher cost; check maxResultsPerRun against your daily budget.
• Daily — browsing or weekly-priced lots. Lowest cost.

The Actor uses a per-filter lock so two concurrent runs of the same filter (e.g. an accidental double-trigger) don't double-charge — the second run exits cleanly with a "previous run still active" status message.

---

Tips for getting the most out of this Actor

• Start narrow, broaden later — first run with one yard + one make. Once you trust the filter, expand to a state or multiple makes. Helps you calibrate maxResultsPerRun budget against real inventory volumes.
• Use a state code in location for state-wide monitoring — picking "TX" auto-expands to all 18 TX yards. Cleaner than listing each yard. Mix with specific yard slugs in the same field if you want a state plus a yard from elsewhere.
• Combine sources: ["repossession", "theft_recovery"] for repossessions + theft recoveries — often the cleanest lots with minimal damage. Pair with damageCodes: ["minor_dent"] (Minor Dent) for inventory you can flip without bodywork.
• outputFormat controls both Dataset and webhook payload verbosity. compact (default) carries the full flat buyer detail without the heavy per-panel damages array; use full if your receiver wants the damages[] array + thumbnail + seller + ldu; use minimal for the headline fields only (lot, vehicle, bid, odometer, primary damage, title, location).
• Cap maxResultsPerRun: 100 on your first run with a broad filter — protects against unexpected $25+ charges while you're still calibrating.
• Schedule cadence matches your responsiveness — if you check Slack hourly, schedule hourly. Daily checkers should schedule daily — no point paying for lot_updated events you won't react to. Set includeUpdated: false if you're a daily checker who only cares about new listings.
• Treat webhookSecret like an API key — Apify encrypts it at rest via isSecret: true, but it's your responsibility to verify HMAC signatures on every webhook to prevent forgery. See Signature verification above.

---

FAQ

Do I need a Copart account? No. The Actor reads only Copart's public listing data.

How fresh is the data? As fresh as the cadence you set — each run hits Copart in real time, no internal cache.

Only new lots, never updates? Set includeUpdated: false. Only lot_new events are charged.

Only BMWs in Texas? Set makes: ["BMW"] and location: ["TX"] — all TX yards are picked automatically. Or pick specific yards: location: ["tx_houston", "tx_dallas"]. You can mix: location: ["TX", "ca_vallejo"] = all of Texas plus that one California yard.

Only BMW X5 specifically? Set makes: ["BMW"] and models: ["X5"]. Make+model combined avoids cross-make name collisions (e.g. "1500" exists for both Chevy and RAM).

Only auctions this week? Set saleDatePreset: "next_7_days". Or use custom saleDateFrom: "2026-06-01" + saleDateTo: "2026-06-07". Preset wins if both set.

Only repos or theft-recovery (often clean cars)? Set sources: ["repossession", "theft_recovery"].

Only EVs? Set fuelTypes: ["electric", "electric_and_gas_hybrid"].

Only AWD or 4×4 in snowy markets? Set driveTrains: ["awd", "4x4_front", "4x4_rear"]. Aliases are handled — picking fwd matches both FRONT WHEEL DRIVE and Front-wheel Drive underneath.

Only SUVs / sedans / pickups? Set bodyStyles: ["suv", "pickup"]. Copart's body-style data is noisy (59 raw variants), but our 12 canonical options absorb all the typo / variant spellings.

Filter by engine size (e.g. only V6+)? Set engines: ["3.0L 6", "4.4L 8", "5.0L 12"]. ⚠️ Free-text + case- and space-sensitive — must match Copart's exact spelling. Engine descriptions look like <displacement>L <cylinders> with one space before the cylinder count (e.g. 2.5L 4). Likely thousands of variants — copy a known canonical string verbatim from Copart's UI Engine facet. Multiple selections OR'd.

Filter by transmission (Automatic / Manual only)? Set transmissions: ["MANUAL"] if you want manual-only inventory (~3% of BMW; varies by make). BMW-verified values; CVT may be added in a future release.

Filter by cylinders (e.g. only 6-cyl and 8-cyl)? Set cylinders: ["6", "8"]. Values are strings (Copart's Solr field is string-typed). EVs are "0" (no cylinders) — handy if you want to filter out pure electric.

Filter by exterior color (e.g. only black or white)? Set colors: ["BLACK", "WHITE"]. ⚠️ Case-sensitive UPPERCASE — must match Copart's canonical spelling (GRAY, SILVER, MAROON, etc.). This field is not in Copart's UI sidebar — this Actor exposes it as an advanced capability beyond Copart UI parity.

Find lots added in last 24 hours? Set newlyAddedWithinDays: 1. Useful for daily-check schedules where you only want today's fresh inventory. Range is 1–30 days. Note: this is when the lot APPEARED in Copart's inventory, not when its auction runs (use saleDatePreset for that).

Only Hot Items / Featured Vehicles / Offsite Sales? Set features: ["hot_items"] (or any combination — multi-select OR'd). Each value maps to a Copart UI "Featured items" sidebar toggle. Some Featured items (Buy It Now, Run and Drive, Electric, Hybrid, Recovered Thefts, Fleet/Lease) live in dedicated fields above for cleaner UX.

Only Inspected lots (Copart-certified inspection)? Set features: ["inspected"]. Copart's UI uses an opaque compound predicate behind this toggle (Copart-internal seller list + flag check) — this Actor replicates the exact predicate Copart's UI sends.

Only Bank/Repossessed inventory? Set features: ["bank_repossessed"]. Tighter than just sources: ["repossession"] — this also requires the lot to have Copart's blucar_flag:true set, which is the same predicate the UI's "Bank/Repossessed" toggle uses.

Only classic cars (≥ 25 years old)? Set features: ["classics"]. To customize the threshold (e.g. 15 years), also set classicsYearsOld: 15. Uses Solr date-math lot_year_date:[* TO NOW/YEAR-NYEARS] so the cutoff updates automatically as years pass.

Public / General Business sellers only (vs insurance)? Set features: ["public_and_general_business"]. Mirrors Copart's "Public and General Business" UI toggle — opaque seller-number compound replicated verbatim.

Why exclude On Approval lots? Lots marked On Approval require the seller to approve the winning bid post-sale — they often don't actually sell at first auction. Dealers who want lots that will transact on sale day set excludeOnApproval: true. This is equivalent to Copart UI's "Pure Sale Items" Featured filter.

Why exclude Purple Wave (PWUSA)? Purple Wave is a partner platform on Copart with higher buyer fees than standard Copart USA lots. Dealers optimizing for margin often exclude it: excludeSalePlatforms: ["PWUSA"]. Include only CPRTUSA if you want strictly Copart-direct inventory.

Filter by budget (e.g. lots under $5000)? Set currentBidMax: 5000. ⚠️ This is a client-side filter — Copart's API doesn't expose price as a server-side filter, so this Actor fetches up to 3× more pages and trims off-range lots after fetching. PPE cost is the same per matching lot, but a run with a narrow price band can take 2-3× longer. Combine with makes/models for tighter filtering and faster runs.

Filter by exact budget range (e.g. between $1000 and $5000)? Set both currentBidMin: 1000 and currentBidMax: 5000. Bounds are inclusive. Pre-bid lots (no current bid yet, effectively $0) are kept when currentBidMin is 0 or unset.

Only Buy It Now lots (skip auction-only)? Set buyItNowOnly: true. About 4.4% of Copart inventory has a Buy It Now price — useful for dealers who want predictable instant-buy pricing without bidding wars. No extra fetch cost (server-side filter).

Look up a specific VIN? Set vin: "5UX53DP02N9F12345" — Copart returns matching lots (usually 0 or 1). VINs are 17 chars, A-Z/0-9 excluding I/O/Q. Combine with makes: ["BMW"] to assert "this VIN should be a BMW" — if the lot exists but isn't a BMW, you get zero results.

Find a specific lot by number? Set lotNumbers: ["12345678"]. Phase 1 supports a single lot per run; multi-lot lookup is a Phase 2 enhancement. Lot numbers are typically 8 digits — find them in Copart listing URLs (/lot/12345678/...).

Free-form keyword search? Set freeFormQuery: "low miles" — Copart's Solr does a full-text search across description, make, model, and other lot fields. Multi-token AND. Combine with bucket filters for narrower scope. ⚠️ Only one of vin / lotNumbers / freeFormQuery may be set per run — they all share Copart's single search-text slot.

My brand isn't in the dropdown? The makes field is a hybrid dropdown — just type the brand name (e.g. "LUCID", "RIVIAN") and it'll be passed through to Copart. Case-sensitive — verify exact spelling at the Copart search page (click "Make" filter to see Copart's own canonical names).

Why lot_updated events on the first run? A fresh filter starts with an empty KV → everything is lot_new. If you see lot_updated instead, the same filter input was run before and persisted state. Change one input field (new filter hash, fresh state) or clear copart-state-<hash> in Apify Console.

Webhook is down — what happens? Up to 3 attempts (initial + 2 retries, 1s then 2s backoff) on the failed delivery, then DLQ; next run replays each queued delivery once. After 5 consecutive failed retry rounds on the same queued delivery, webhookDisabled: true is set in KV and webhooks pause until you clear it. Dataset output is independent and keeps working.

Run multiple filters in parallel? Yes — different input shapes produce different filter hashes, each with its own KV namespace.

When will I see results? First run on a narrow filter: 30–90s. Subsequent runs: 10–30s.

Affiliated with Copart? No. Independent third-party tool reading public listings.

---

Limits and caveats

• Solr enum coverage: all 25 damage_type_code + 3 title_group_code + 15 vehicle_type_code values are exposed in the input — extracted from Copart's own search-results facet response (last refresh 2026-05-17). Missing rare codes — file an Issue.
• Yards reference data: 216 yards (207 US + 9 Canada) captured 2026-05-17 from Copart's referenceData/graph endpoint. The static seed is refreshed quarterly. Brand-new yards appear when we re-capture.
• No lifecycle transitions: the Actor emits lot_new / lot_updated only — sold / withdrawn terminals are not surfaced in this version.

---

Full canonical Lot shape and field provenance: 08-apify-actor.md.