🚗 Copart Scraper — Salvage Lots, Damage, Title & Bids

Every vehicle lot listed on Copart, with the salvage disclosure a buyer actually needs. Year, make, model, trim, the masked VIN, primary and secondary damage, title group and title state, odometer with its brand, run-and-drive certification, keys, the current bid, buy-it-now price, Copart's own estimated retail value and estimated cost of repair, the sale date, and the yard the car is physically sitting in — name, number, city, state, ZIP and coordinates.

$0.60 per 1,000 rows. No start fee. You are charged for rows delivered, and for nothing else.

🏷️ Which carrier is liquidating the car — and the cheapest way to get it

On 18.2% of lots Copart names the consigning company, and this Actor returns it in sellerName. Measured over 1,600 rows: GEICO (152), USAA (68), Bristol West (18), CSAA (15), Farmers (14), AIG, National Powersport Auctions.

That turns a salvage-price feed into something that also answers who is writing these off: track one carrier's total-loss volume by damage type, model and yard; spot which insurer is dumping a model line this month; size a carrier's salvage flow into a region before you bid.

Two of the 26 other Copart Actors also return it — scrapers_lat/copart-scraper at $0.008/row and bovi/copart-lot-scraper at $0.0233/row, checked in their own latest builds' READMEs. This Actor returns the same field at $0.0006/row: 13× and 39× cheaper.

The honest half: the other 81.8% are consigned anonymously and sellerDisclosed is false. It is a company name on a vehicle record — there is no person, email, phone or address behind it here or on any public Copart surface. Filter on sellerName being present when you need the carrier; treat the 18.2% as the real coverage, not a rounding error.

---

📊 What this Actor does

Copart publishes 417,320 lots in its public index (counted on 2026-09-18 from Copart's own totalElements, not estimated). This Actor reads them through Copart's own search API — the same endpoint copart.com's front end calls — and returns one clean, typed row per lot.

• 🚙 Vehicle identity — year, make, model, model group, trim, engine, cylinders, fuel, transmission, drive, colour, Copart's vehicle type
• 🔑 Salvage disclosure — primary damage, secondary damage, Copart's damage code, title group, title description, title state, title doc type, odometer + odometer brand, run-and-drive and engine-start certification, keys
• 🏷️ The consigning carrier — sellerName on the 18.2% of lots Copart discloses (GEICO, USAA, Bristol West, CSAA, Farmers, AIG). Only 2 of the 26 other Copart Actors return it, at 13× and 39× this price.
• 💰 The money — current bid, whether any bid exists, buy-it-now price, Copart's estimated retail value, estimated value, estimated cost of repair, currency, sale type
• 📅 The sale — sale date, sale time, time zone, auction name, lot status
• 📍 The yard — yard name, yard number, city, state, country, ZIP, latitude, longitude
• 🧾 Provenance on every row — which partition, which query and which page produced it
• 🆓 Copart's whole filter vocabulary, written to the key-value store free of charge on every run

Who buys this

Auto dismantlers and recyclers sourcing donor vehicles by make/model/year/yard · salvage rebuilders screening lots on damage code, title group and the bid-to-retail ratio · used-car exporters building shipping lists by yard and state · VIN-history and valuation vendors · Copart brokers reselling access to non-licensed buyers.

---

⚖️ What this is NOT — read this before you buy

This is a salvage-lot DATA product. It is not a contact or lead product, and it is not sold as one. On 18.2% of lots (291 of 1,600 measured) Copart names the consigning company — GEICO, USAA, Bristol West, CSAA, Farmers, AIG — and that name ships in sellerName. Those are the insurers writing the vehicle off: corporate entities attached to a vehicle record. The other 81.8% are consigned anonymously. Either way there is no person, no email, no phone number and no address anywhere on this surface, and the location on every lot is Copart's own yard rather than a third party's premises. Nothing here is a lead list.

Why the data is public at all. Salvage and junk vehicle designations are a disclosure regime. State salvage-title statutes, and federal NMVTIS (49 U.S.C. §30502, implemented at 28 CFR Part 25), require salvage/junk status to be reported and disclosed to buyers — which is why Copart publishes title type, damage and odometer against every lot in the first place. That is a disclosure obligation about vehicles, not a contact register about people, and this Actor stays on the vehicle side of that line.

---

🎯 Honest limits (measured, not hedged)

Limit	The measurement
VIN is masked	Copart returns the first 11 of 17 characters to anonymous callers — KNDJT2A64C7******. Measured: 1,560 of 1,560 standard 17-character VINs masked, always the last 6, always exactly 11 visible. Every row carries vinMasked and vinVisibleChars, so it can never be mistaken for a full VIN. No surface reachable without a Copart membership returns the full VIN, and this Actor does not claim otherwise.
Not every lot has a VIN at all	40 of 1,600 rows (2.5%) carry a shorter manufacturer serial instead — forklifts and industrial equipment mostly, plus a few boats, jet skis and trailers. Those come back unmasked, and vinMasked: false says so rather than dressing them up as masked VINs.
Seller is named on a minority of lots	sellerName is present on 18.2% of rows and is the consigning insurer, never a person. See the section above.
No sold prices	Copart does not publish realized/hammer prices to anonymous callers. Every lot in the public index is an open lot (lotStatus: "O" on 1,600 of 1,600). currentBid is the live high bid at the moment of the request; there is no sold-price field and none is implied.
Only 34.3% of lots have a sale date	143,154 of 417,320 lots have an auction date in the future. The rest are listed but not yet scheduled. The default scope is the scheduled ones — see the FAQ, because this one has a sharp edge.
No body style	Copart lets you filter on body style but does not return it in the search record. It is cut rather than shipped as a column of nulls — use rawFilters with body_style:"4DR SEDAN" to filter on it.
No grid/row position	Copart's "Grid/Row" yard-position column came back as the empty string on 1,600 of 1,600 records. Cut, not shipped.
One thumbnail, not a gallery	Full photo galleries need a per-lot request this Actor does not make. thumbnailUrl is the one image the search record carries (99.9% filled).
Copart is Imperva-walled	copart.com intermittently serves an HTTP 200 carrying an Incapsula challenge page to unproxied IPs — a block that does not announce itself as an error. This Actor sniffs for it, retries on a fresh proxy session, and never records it as "end of data". Apify's datacenter pool was measured clean; see the proxy FAQ.

---

📈 Measured field fill

From a real run, counted against the raw bytes Copart returned, over 1,600 records spanning 18 different scopes (whole index, single yard, single year, single state, by vehicle type, by title group, buy-it-now only, free-text search, and a four-filter buyer query):

Field	Fill	Field	Fill
lotNumber, lotUrl, vin, year, make, model	100%	titleGroup, titleGroupCode, titleDescription, titleDocType	94.4%
primaryDamage, damageTypeCode	100%	saleDate (default scope)	93.8%
currentBid, hasBids, estimatedRetailValue	100%	fuel	89.9%
saleType, saleTime, saleTimeZone, auctionName	100%	drive	86.6%
yardName, yardNumber, city, state, zip, latitude, longitude	100%	engine, cylinders	86.1%
keysStatus, color, thumbnailUrl	99.9%	estimatedValue	83.2%
titleState	99.8%	odometer	81.3%
modelGroup	99.4%	trim	75.9%
runAndDrive, engineStartProgram, lotFeatureCodes	98.3%	repairCost	60.5%
transmission	97.1%	bidToRetailRatio (needs a bid)	46.3%
hasKeys, odometerBrand, conditionCode	95%+	secondaryDamage	43.2%

Every one of those gaps is Copart's, not the parser's: the offline suite asserts field-by-field that our fill equals the fill in the raw bytes, and the build fails if it does not.

---

🧭 How the fields were named

Copart's search JSON names its columns with two- to four-letter keys — hb, la, lotPlugAcv, orr, dd, tgd, syn. Guessing at those is how a scraper ships a confidently wrong column: la and lotPlugAcv are both money in the same order of magnitude, and picking the wrong one puts "estimated retail value" on a field that means something else, at 100% fill, with no error anywhere.

So none of it was guessed. The mapping was read out of Copart's own front end — the messages_CPRTUS_en bundle it loads on every page, which carries the column dictionaries Copart uses for its own search grid and CSV export:

Copart's label id	Copart's own text	Our field
app.label.csv.lotAcv	Est. Retail value	estimatedRetailValue
app.label.csv.lotPlugAcv	Estimated value	estimatedValue
lotsearch.header.label.highBid	Current bid	currentBid
lotsearch.header.label.repairCost	Est. Cost of repair	repairCost
lotsearch.header.label.buyItNowPrice	Buy it now price	buyItNowPrice
lotsearch.header.label.odometerReadingReceived	Mileage	odometer
lotsearch.header.label.saleTitleType	Doc Type	titleDocType

currentBid was then cross-checked a second way: it equals dynamicLotDetails.currentBid on 1,600 of 1,600 rows, and the offline suite re-asserts that every build.

---

⚙️ Input

Field	Type	Default	Notes
searchTerm	string	—	Free text, exactly as Copart's own search box works. ANDs with every filter below.
maxItems	integer	50	Hard spend cap — rows are charged only as delivered. 0 = everything in scope.
onlyUpcomingSales	boolean	true	Restrict to lots with a future auction date. Read the FAQ before turning this off.
states	array	—	Two-letter yard states, e.g. ["TX","CA"]. Filters Copart's location_state.
yardNames / yardNumbers	array	—	e.g. "TX - DALLAS" / 371. The full list for your scope lands in COPART_FACETS.
makes / models / years	array	—	OR'd within each.
yearFrom / yearTo	integer	—	Model-year range.
odometerMin / odometerMax	integer	—	Odometer range.
titleGroups	array	—	clean, salvage, non-repairable.
vehicleTypes	array	—	17 Copart categories from automobile to agriculture-farm-equipment.
damageTypes	array	—	All 25 Copart primary-damage codes.
lotFeatures	array	—	16 Copart quick picks (run-and-drive, buy-it-now, electric, classic, recovered-theft…). AND'd, so two features narrow.
saleDateFrom / saleDateTo	string	—	YYYY-MM-DD.
sortBy	enum	sale-date-soonest	Also latest-first, Copart's own order, lot number, odometer.
partitionBy	enum	auto	auto / yard / year / make / none.
rawFilters	array	—	Raw clauses against Copart's index for anything the above misses.
pageSize	integer	100	Copart's own ceiling — it rejects 200 with an error.
concurrency	integer	4
proxyConfiguration	object	Apify proxy	See the proxy FAQ.

Example input

{
  "titleGroups": ["salvage"],
  "lotFeatures": ["run-and-drive"],
  "makes": ["TOYOTA"],
  "yearFrom": 2018,
  "odometerMax": 80000,
  "states": ["TX", "CA"],
  "maxItems": 500
}

---

📤 Output

One row per lot. A real row from a real run, untouched:

{
  "lotNumber": "41584556",
  "lotUrl": "https://www.copart.com/lot/41584556/salvage-2025-cadillac-escalade-esv-sport-vt-rutland",
  "vin": "1GYS9PRL5SR******",
  "vinMasked": true,
  "vinVisibleChars": 11,
  "year": 2025,
  "make": "CAD",
  "model": "ESCALADE E",
  "modelGroup": "ESCALADE",
  "trim": "SPORT",
  "title": "2025 CADILLAC ESCALADE ESV SPORT",
  "vehicleType": "SUV",
  "odometer": null,
  "odometerBrand": null,
  "primaryDamage": "FRONT END",
  "secondaryDamage": null,
  "damageTypeCode": "FR",
  "conditionCode": "CERT-E",
  "conditionDescription": "ENHANCED VEHICLES",
  "runAndDrive": false,
  "hasKeys": true,
  "keysStatus": "YES",
  "titleGroup": "SALVAGE TITLE",
  "titleState": "VT",
  "currentBid": 21800,
  "hasBids": true,
  "buyItNowPrice": null,
  "estimatedRetailValue": 60000,
  "estimatedValue": 96700,
  "repairCost": 41000,
  "bidToRetailRatio": 0.3633,
  "currency": "USD",
  "saleType": "Pure Sale",
  "saleDate": "2026-09-29T17:00:00.000Z",
  "auctionName": "VT - RUTLAND",
  "yardName": "VT - RUTLAND",
  "yardNumber": 88,
  "city": "RUTLAND",
  "state": "VT",
  "zip": "05701",
  "latitude": 43.5872,
  "longitude": -72.9784,
  "sellerDisclosed": false,
  "sourcePartition": "yard:Vt - Rutland",
  "sourceQuery": "UPCOMING=auction_date_utc:[NOW TO *] AND LOC=yard_name:\"VT - RUTLAND\"",
  "sourcePage": 0
}

Plus two key-value store records, neither of them billed:

• RUN_SUMMARY — the filters actually sent, how many lots Copart said matched, what each partition declared versus delivered, rows delivered (= rows charged), duplicates and empty records skipped, per-field fill measured on your own run, every failed page split into WAF blocks versus transport errors, and the honest-limits list.
• COPART_FACETS — Copart's entire filter vocabulary for your scope: every yard, make, model, year, body style, engine, damage type, title group and sale date in it, each with its live count. This is the input to your next, narrower run.

---

🏆 What this does that the alternatives do not

There are 26 other Copart Actors on the store (counted from the full store sitemap, all 12 shards). This one is the cheapest of them, and it differs in five ways that are checkable rather than claimed:

1. sellerName — the consigning carrier, on 18.2% of lots. Checked against all 26 other READMEs pulled from their own latest builds: 2 return it (scrapers_lat $0.008/row, bovi $0.0233/row), one returns Copart's raw seller flags without resolving a name (memo23), and the other 23 do not return it at all. We return it at $0.0006/row.
2. Coverage you can verify. Every run reports Copart's own count for the scope against what was delivered, partition by partition, and fails loudly if a sweep comes back short. A short parse is otherwise indistinguishable from a small scope.
3. Provenance on every row. sourcePartition, sourceQuery and sourcePage mean a plausible-but-wrong result set is obvious at a glance instead of being taken on trust.
4. Fields named from Copart's own dictionary, not from inference — and re-asserted against the bytes on every build.
5. No start fee, against a lane where 22 of 26 rivals charge one.

---

💵 Pricing

Event	Rate
Per lot returned (lot-scraped)	$0.0006 per row — $0.60 per 1,000
Actor start	none — there is no start fee
Everything else (RUN_SUMMARY, COPART_FACETS, retries, skipped duplicates, unreadable records)	free

Rows are charged as they are delivered, per item. If you set a budget cap, you keep exactly the rows you paid for — you will never be handed rows you were not billed for, or billed for rows you were not handed. A duplicate skipped across partitions, a record with no lot number, and a retried request all cost you nothing.

The default maxItems of 50 means an empty input costs $0.03.

---

❓ FAQ

Why does onlyUpcomingSales default to true, and what happens if I turn it off?

Because of a sharp edge worth knowing about. Copart's public index holds 417,320 lots, but only 143,154 (34.3%) have an auction date in the future — the rest are listed but not yet scheduled. Copart's index sorts the undated lots first on any ascending date sort, so a "soonest first" run over the whole index returns 100 lots nobody can bid on and looks completely healthy doing it. Leaving this on gives you the lots that are actually for sale. Turn it off when you want total inventory, including cars that have arrived at a yard but have no sale scheduled yet.

Is the VIN complete?

No. Copart returns 11 of the 17 characters to anonymous callers: KNDJT2A64C7******. Every row says so explicitly via vinMasked and vinVisibleChars. The visible 11 still carry the WMI, vehicle descriptor and check digit — enough to decode make, model, body, engine, restraint system and model year, and enough to match against a VIN you already hold — but they are not enough to uniquely identify the vehicle on their own. Any Copart Actor showing you a full 17-character VIN in its sample output is not showing you what the anonymous API returns.

Can I get sold prices or auction results?

Not from this Actor, and not from Copart's public surface. Copart does not publish realized prices to anonymous callers — every lot in the public index is an open lot. currentBid is the live high bid when the request was made. For pre-sale price context the row carries Copart's own estimatedRetailValue, estimatedValue and repairCost, plus a derived bidToRetailRatio.

Who is the seller?

On 18.2% of lots Copart names the consigning company in sellerName — the insurers writing these vehicles off. Measured over 1,600 rows: GEICO (152), USAA (68), Bristol West (18), CSAA (15), Farmers (14), AIG, National Powersport Auctions. On the other 81.8% Copart consigns anonymously and sellerDisclosed is false. Two of the 26 other Copart Actors return this field too, at $0.008 and $0.0233 per row. It is a company name on a vehicle record — there is no person, email, phone or address behind it, on this surface or any other public one. This is vehicle data, not contact data.

Why is estimatedRetailValue sometimes null when Copart shows a number?

It is null when Copart has no value for it. Watch for this if you are parsing Copart yourself: Copart writes -1, not 0 and not null, as its not-published sentinel on that field — on 269 of 1,600 measured rows. A zero check does not catch it, so it sails through as a retail value of minus one dollar and poisons anything derived from it. Here it becomes null, and the offline suite fails the build if a negative ever reaches a money column.

yardNumber and the auction don't always match — why?

Because they are different things, and this trips up naive Copart parsers. yardNumber is the physical yard the car sits in; auctionHostNumber is the sale it has been assigned to, and Copart runs virtual sales (MEDIUM DUTY CLEAN TITLE SALE, RENTAL VEHICLE SALE) out of physical yards. Filtering yard 371 returns 200 cars all physically at 371, 8 of which belong to sale 832 or 838. yardNumber here always agrees with yardName; the sale keeps its own field.

Which proxy should I use?

The default (Apify's automatic/datacenter pool) was measured clean across several hundred requests on 2026-09-18 and is the fastest (~1.7 s/request). If you see blocks, switch to residential: {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"} — measured working at ~4.0 s/request. Your own proxies work too. Running unproxied is not recommended: copart.com sits behind Imperva and intermittently serves an HTTP 200 carrying a challenge page to bare IPs (it did exactly that to the machine this was built on, then stopped about ninety minutes later).

What happens when Copart blocks a request?

It is retried on a fresh proxy session — retrying a flagged IP through the same IP is a slower way to get the same answer. A block is never recorded as "no more results": the Actor tells apart a transport failure, a WAF challenge served under HTTP 200, a malformed query and a genuinely empty result set, because those need opposite fixes. Failed pages are itemised in RUN_SUMMARY.

How do you handle Copart's pagination limits?

Copart caps page size at 100 (it rejects 200 outright) but deep paging works: pages at start=120,000 and beyond were measured returning real, distinct rows with zero overlap against page 0. The catch is that the index is live — rows shift between requests, so a single long walk silently loses whatever slides backwards past the cursor. Large scopes are therefore split along a facet Copart itself publishes (yard, then year, then make), each partition small enough to close in seconds and each checked against Copart's own count for it. It is also cheaper: Copart repeats a ~425 KB facet dictionary on every page, and a narrower filter shrinks it by 36–56%.

Does partitioning miss anything?

It would, if it were done naively — Copart's yard facet panel caps at 400 values and names fewer lots than the scope contains. So every partitioned run computes the shortfall and sweeps it with an explicit remainder query that excludes the named values, and reports the arithmetic in RUN_SUMMARY.

Can I filter on something that isn't in the input list?

Yes — rawFilters takes raw clauses against Copart's own index, AND'd with everything else, e.g. body_style:"4DR SEDAN" or lot_features_code:LOTFEATURE_X. The complete vocabulary for your scope, with live counts, is written to COPART_FACETS on every run.

How many requests does a row cost?

One request per 100 rows, and no per-lot request at all — all the fields arrive in the search response. That is why this runs at 512 MB with no browser.

Will this get me Copart bidding access?

No. This reads public listing data. Buying at Copart requires a Copart membership and, for many lots, a dealer or dismantler licence in the relevant state. lotFeatures: ["no-license-required"] filters to lots Copart marks as open to the public.

What does robots.txt say?

www.copart.com/robots.txt disallows a set of member-account paths. The two lines that bear on this Actor, verbatim:

Disallow: /public/data/
Allow: /lotSearchResults$

The endpoint this Actor uses, /public/lots/search-results, matches no Disallow line. The /public/data/ lot-detail endpoint does match one — so it is not used, which also costs nothing, because it adds only 12 low-value flags over the search record. The gated member areas (/myBids/, /dashboard/, /downloadSalesData) are never touched, and the offline suite fails the build if any source file acquires a request to a disallowed path.

Is this legal to use?

This Actor reads publicly published listing data — no login, no account, no circumvention of an access control, and no personal data. What you do with it is your call: check your own jurisdiction and Copart's Terms of Use before commercial redistribution. Salvage-title disclosure is a federal and state requirement (NMVTIS, 49 U.S.C. §30502 / 28 CFR Part 25), which is why these vehicle facts are published in the first place.

---

🔧 How it works

POST /public/lots/search-results   page 1 of the scope  ->  totalElements + the facet index
  └─ plan the walk                 split large scopes along a facet Copart publishes
     └─ POST .../search-results    pages 2..N, <= 100 rows each, 4 in flight, deduped by lot number
        └─ push + charge           atomically, per item, only for rows actually delivered
           └─ floor-assert         delivered vs Copart's own count; a short sweep FAILS the run

No browser, no per-lot hop, no headless Chrome — one JSON endpoint, 512 MB, and the discipline to tell a block from an empty page.