🚗 Car Auction Lot Finder — Live Copart Salvage & Used Lots

Live auction-lot data from Copart — full vehicle specs, odometer, title & damage status, current bid, estimated value, yard location, auction date — by make/model, VIN, or lot number. No login, no proxy needed (as tested). Optional filters for year, odometer, US state, or distance from a ZIP, plus a free, best-effort VIN decode.

Keywords: copart scraper, salvage car auction data, vehicle auction api, car auction lot finder, VIN decode, salvage title lookup, used car auction data, copart api.

🌟 Why this one

There are several Copart scrapers on Apify already. This one is built from a direct, confirmed-working read of Copart's own search API, with real differences:

• No proxy needed — confirmed by direct testing: a plain outbound request, with just the anonymous session Copart's own homepage hands out, reaches the real search API successfully. Some competing Copart actors default to a residential proxy; this one doesn't need it, which keeps the cost down.
• robots.txt-respecting by design — Copart's robots.txt disallows the /public/data/... path tree (which is where the detailed per-lot image gallery endpoint lives) but explicitly does not disallow the /public/lots/... search endpoint this Actor uses. It only calls the allowed path.
• Free VIN confirmation — Copart masks part of every VIN on its public search results, but the unmasked prefix is still enough for a free NHTSA vPIC decode to confirm make/model/year/body class on most lots — a bonus cross-check this Actor runs automatically (optional, free, no key).
• Real client-side filters, not a guess at Copart's internal filter codes: year range, max odometer, US state, and distance-from-ZIP (computed from each lot's own coordinates) — reliable because they're applied to real returned data, not a fragile reverse-engineered filter parameter.
• Honest about rate limits: Copart can rate-limit (HTTP 429) or serve a bot-check page under heavy burst traffic. The Actor backs off and retries automatically, and a sustained failure comes back as one clear error row — never a silently empty result.

⚙️ How it works

1. Gets an anonymous session from Copart's own homepage (the same session any visitor's browser gets — no login).
2. Calls Copart's own public search API (the same one copart.com's search page calls) with your search term.
3. If a ZIP code is set, resolves it to coordinates via a free, no-key lookup, then computes real distance to every lot using the lot's own coordinates — and sorts nearest-first.
4. Applies your year / odometer / state filters to the real data returned.
5. If VIN decode is on, batches every lot's VIN prefix through the free NHTSA vPIC database and attaches the confirmed make/model/year/body class.

🚀 Quick start

{ "searches": ["honda civic"], "maxResultsPerSearch": 20 }

Or via the API, once published:

curl "https://api.apify.com/v2/acts/car-auction-lot-finder/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searches": ["ford f150"], "yearMin": 2018, "maxOdometer": 100000}'

📥 Input

Field	Type	Default	Description
searches	array (required)	—	Make+model, lot number, or VIN/fragment — one per line
maxResultsPerSearch	integer	20	Max lots fetched per search, before filters (1–500)
yearMin / yearMax	integer	—	Keep only lots in this model-year range
maxOdometer	integer	—	Keep only lots at or below this odometer reading
states	array	—	Keep only lots in these 2-letter US state codes
zipCode	string	—	Sort nearest-first and filter to radiusMiles of this ZIP
radiusMiles	integer	100	Only used when zipCode is set
decodeVin	boolean	true	Free best-effort NHTSA VIN confirmation

⚠️ Filters apply after fetching: if you set a tight filter (e.g. yearMin: 2022 + a small state list), raise maxResultsPerSearch so there's enough raw data to filter from — a filter can't un-skip lots that were never fetched because the raw page was too small.

📤 Output

Field	Description
lot_number, vin_masked, lot_url	Identity + direct link to the lot on copart.com
year, make, model, trim_or_series	Vehicle identity
odometer, odometer_status	Mileage + whether it's reported as actual/exempt/etc.
engine, cylinders, transmission, drive_type, fuel_type	Mechanical specs
color, body_style, condition, has_keys	Condition specs
primary_damage, title_description, title_group	Damage + title status
current_bid, estimated_value, sale_status	Auction status
city, state, zip, latitude, longitude, distance_miles	Yard location (+ distance, when zipCode is set)
auction_date, auction_time, timezone	When it's up for sale
seller, has_carfax, thumbnail_url	Extras
decoded_make, decoded_model, decoded_year, decoded_body_class	Free NHTSA VIN confirmation (when decodeVin is on)
additional_raw_fields	Every other raw field Copart returns that isn't mapped above — nothing is thrown away

{
  "record_type": "auction_lot",
  "lot_number": 49566366,
  "year": 2017,
  "make": "HONDA",
  "model": "CIVIC",
  "odometer": 123018,
  "primary_damage": "FRONT END",
  "title_description": "CERTIFICATE OF TITLE",
  "current_bid": 150.0,
  "city": "Indianapolis",
  "state": "IN",
  "distance_miles": 41.5,
  "decoded_make": "HONDA",
  "decoded_model": "Civic",
  "decoded_year": "2017",
  "lot_url": "https://www.copart.com/lot/49566366/clean-title-2017-honda-civic-in-indianapolis"
}

A search that fails outright produces one record_type: "error" row with a real error message — never a silent empty result.

🎯 Use cases

• Dealer / rebuilder sourcing — find salvage lots by make/model/year/mileage near you
• Price research — track current bids and estimated values across a model
• Parts sourcing — locate specific damaged vehicles for parts-out
• Insurance / appraisal research — title and damage status at scale
• Market monitoring — run on a schedule to catch new listings matching your criteria

🔌 Integration examples

Python (apify-client):

from apify_client import ApifyClient
client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("car-auction-lot-finder").call(
    run_input={"searches": ["honda civic"], "zipCode": "90001", "radiusMiles": 200}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["year"], item["make"], item["model"], item["current_bid"])

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('car-auction-lot-finder').call({
    searches: ['ford f150'], yearMin: 2018, maxOdometer: 100000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

📊 Performance & reliability

Metric	Value (measured, not estimated)
Cost per run (1 search, 8 lots, VIN decode on)	~$0.0014 (real cloud run, tracked via Apify REST API)
Proxy required	No — confirmed by direct testing, plain outbound request
Login / API key required	No
Data source	Copart's own public search API (the one copart.com's search page calls)
robots.txt compliance	Only calls the explicitly-allowed /public/lots/... path, never the disallowed /public/data/... tree
VIN decode	Free NHTSA vPIC database, best-effort (VINs are partially masked by Copart)
Rate-limit handling	Automatic backoff + retry on HTTP 429; a sustained block surfaces as one clear error row

❓ FAQ

Does this need a Copart login or API key? No — it calls the same public endpoint Copart's own search page calls, anonymously.

Is this affiliated with Copart? No. It's an independent tool reading the same public data Copart's own website serves to any visitor — not an official Copart product.

Why is the VIN only partially shown? Copart itself masks the last several characters of the VIN on public search results (a Copart policy, not something this Actor can change). The unmasked prefix is enough for a useful year/make/model/body-class confirmation via NHTSA, just not a full, authoritative decode.

Can I place bids with this? No. This Actor only reads public listing data — it doesn't bid, log in, or interact with your Copart account in any way.

What happens if Copart rate-limits or bot-checks the run? The Actor backs off and retries automatically. If you're running many searches, keep maxResultsPerSearch reasonable and avoid very high concurrency — that's the sweet spot for staying under the radar in normal use.

Found a bug or a search that fails unexpectedly? A failed row always includes a real error message — worth reporting through the Actor's Issues tab if it doesn't match a known limitation above.

⚖️ Notes

Reads only Copart's own public, already-listed auction data — no login, no bidding, no private account data.