# Bid.cars Scraper — Vehicle Auction Data Extractor (`wdnameless/bid-cars-scraper`) Actor

Export complete vehicle auction data from bid.cars: VIN, specs, damage, odometer, seller, title, pricing, images, video and sales history.

- **URL**: https://apify.com/wdnameless/bid-cars-scraper.md
- **Developed by:** [W](https://apify.com/wdnameless) (community)
- **Categories:** Automation, Lead generation
- **Stats:** 6 total users, 2 monthly users, 95.1% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.80 / 1,000 exported vehicles

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

## Bid.cars Vehicle Auction Scraper

This Apify Actor scrapes vehicle auction data from [bid.cars](https://bid.cars), an aggregator over the **Copart** and **IAAI** salvage auctions. Extract comprehensive vehicle information — specifications, pricing, damage, images, sellers and auction status — perfect for automotive market research, price tracking and vehicle valuation analysis. A ready-made **bid.cars API alternative**: run on schedule or on demand and get structured JSON, CSV or Excel instead of copying listings by hand.

### 🚀 Key Features

- 🔎 Scrape listings from bid.cars search pages or individual vehicle lot pages
- 🚗 Extract detailed vehicle information (VIN, specs, damage, odometer, title, seller)
- 📍 Location-based filtering across auction sites, live and finished auctions
- 💰 Comprehensive pricing data (prebid, current bid, final bid, estimates, ACV/ERC)
- 🌐 Direct links back to the originating Copart / IAAI lot (`sourceUrl`)
- 🧾 Import-cost breakdown as calculated by bid.cars (auction fees, trucking, shipping, EU tax/VAT)
- 📜 Sales history per lot (auction, date, bid, odometer, status, seller)
- 🖼️ Vehicle images (standard + full-size), video and 360° view URLs
- 📊 Pagination support for large result sets, structured data with 70+ fields
- ⚙️ Residential proxy support for stable, anonymous scraping

### ❓ Why Use This Actor

- ✅ Automate vehicle auction data collection — no manual browsing and copying
- ✅ Build datasets for automotive market analysis and price tracking
- ✅ Monitor vehicle availability, damage mix and pricing trends over time
- ✅ Research vehicle values and auction performance before bidding
- ✅ Feed data into automotive platforms, pricing models and tools via API, schedule or integration

### 👥 Who Is This Actor Suitable For?

- 🚗 Auto dealers and auction buyers
- 📈 Automotive market researchers and analysts
- 🧠 Data scientists studying vehicle markets
- 🧰 Developers building automotive platforms
- 💼 Insurance companies and vehicle appraisers

### 📥 Input

Fill the fields in the **Input** tab — no JSON needed for common cases.

| Field | What it does |
| --- | --- |
| What to scrape | Preset: Search filters / Specific URLs / Finished auctions |
| Make / Model / Keyword | e.g. Honda / Civic / a VIN fragment or seller name; All or empty = everything |
| Vehicle type | Automobile, Motorcycle, Truck, … (15 categories) |
| Auction | All, Copart or IAAI |
| Year from / to | Model-year range |
| Start URLs | Search or lot URLs — used only in the Specific URLs preset |
| How many vehicles | Cap per run; empty = everything matched |
| Full lot details | ON = specs, photos, video, sales history, import cost; OFF = listings only, much faster |
| Advanced filters | Mileage, price, engine, color, transmission, drive, start condition, ordering |
| Proxy configuration | Apify Proxy, Residential preselected |

Own proxies (`proxyUrls` / `proxyListKey`) are optional and stay collapsed unless needed.

### 📤 Output

Each scraped vehicle returns structured data like this:

```json
{
    "lot": "0-46061209",
    "vin": "5J6RM4H79DL028463",
    "name": "2013 Honda CR-V, Ex-L",
    "year": 2013,
    "make": "Honda",
    "model": "CR-V",
    "location": "Concord (NC)",
    "odometer": 172968,
    "primaryDamage": "Normal wear & tear",
    "saleDocument": "Clear-dealer only (North carolina)",
    "seller": "Non-insurance Company",
    "prebidPrice": "$25",
    "estimatedMin": 1850,
    "estimatedMax": 3650,
    "statusLabel": "active",
    "platformCode": "IAAI",
    "sourceUrl": "https://www.iaai.com/Search?Keyword=46061209",
    "imagesLarge": ["https://pluto.bid.car/0-46061209/2013-Honda-CR-V-5J6RM4H79DL028463-1.jpg"],
    "detailUrl": "https://bid.cars/en/lot/0-46061209/2013-Honda-CR-V-5J6RM4H79DL028463",
    "scrapedAt": "2026-09-12T18:23:54.527Z"
}
```

You can download the dataset in JSON, CSV or Excel. The full record carries 70+ fields — specs, condition, seller, pricing, auction state, powertrain, media, platform links, import cost, sales history and provenance. Key fields:

| Field | Description |
| --- | --- |
| `lot` / `vin` / `make` / `model` / `year` | Vehicle identity |
| `location` / `odometer` / `color` | Condition basics |
| `primaryDamage` / `secondaryDamage` / `lossType` | Damage report |
| `saleDocument` / `titleHasLien` | Title paperwork |
| `prebidPrice` / `currentBid` / `finalBid` | Auction pricing |
| `estimatedMin` / `estimatedMax` / `acv` / `erc` | Valuation figures |
| `statusLabel` / `timeLeftFormatted` / `prebidCloseTime` | Auction state |
| `engine` / `transmissionLabel` / `fuelTypeLabel` / `driveTypeLabel` | Powertrain |
| `images` / `imagesLarge` / `videoUrl` / `view360Url` | Media |
| `platformCode` / `sourceUrl` | Originating Copart / IAAI lot |
| `salesHistory` | Past auction attempts for the lot |
| `importCost` | Lot price, auction fees, trucking, shipping, tax/VAT, estimated total |

### 💰 Pricing

Pay-per-event: **from $0.0009 per exported vehicle** (`vehicle` event, the primary event) — tiered by your plan, at or below comparable bid.cars scrapers, with 70+ fields per record (specs, damage, pricing, photos, sales history, import cost). Dataset items carry only a nominal $0.0001 charge. You pay only for records actually delivered — the charge fires after each record is written to the dataset. Set a max cost per run in the run options to cap spending.

### 💡 Tips

- Start with 10–50 vehicles to verify your filters, then scale up.
- Pick **Finished auctions** to research sold prices; live lots are the default.
- Filter by auction (**Copart** / **IAAI**) when you only source from one.
- Prefer Residential proxies for runs beyond a few dozen lots — datacenter IPs get challenged quickly.

### 🤖 Use from AI assistants (MCP)

Any MCP-compatible assistant (Claude, Cursor, VS Code + Copilot) can run this Actor as a tool via the [Apify MCP server](https://mcp.apify.com). One-time setup:

1. Add the server to your client. Easiest: `apify mcp install cursor` (also supports `claude-code`, `vscode`, `codex`), or paste `https://mcp.apify.com` as an MCP server URL and sign in with Apify.
2. Ask in plain language, for example: *“Using wdnameless/bid-cars-scraper, get 50 Honda Civics with full details.”* The assistant discovers the input schema itself and calls the Actor.
3. To pin just this Actor instead of the whole Store: `https://mcp.apify.com?tools=wdnameless/bid-cars-scraper`.

Running Actors through MCP needs an Apify API token ([Settings → Integrations](https://console.apify.com/settings/integrations)); billing follows the same pay-per-event pricing above.

### ❓ FAQ

**Live or finished auctions?** Both. Live lots are the default; set `archived: true` in Search filters for finished ones.

**Do I need my own proxies?** For small runs, no — Apify Proxy (Residential) is the default. For sustained large runs, your own residential list via `proxyUrls` works too.

**How do I get the original Copart / IAAI listing?** Every record has `sourceUrl` pointing at the originating auction lot.

**Can I run this on a schedule or via API?** Yes — use Schedules for recurring runs and the API tab for programmatic access.

**Is there a bid.cars API?** bid.cars publishes no public API. This Actor is the practical alternative: the same listings (live and finished Copart/IAAI lots) as structured data, on schedule or on demand.

**Copart or IAAI direct, or bid.cars?** bid.cars aggregates both auctions in one search. Use the Auction filter for one of them, or run separate searches per platform and merge the datasets.

### ⚖️ Disclaimer

Our Actors are ethical and only extract publicly available data — vehicle listings any visitor can see. Results may contain seller names as published on the listing. Comply with bid.cars Terms of Service, rate limits and applicable regulations (including GDPR where personal data is involved).

### 🛟 Support

Found a field that looks wrong or need an extension? Report it via the **Issues** tab. For programmatic access see the **API** tab.

# Actor input Schema

## `mode` (type: `string`):

Quick preset. 'Search filters' builds a search from the fields below; 'Specific URLs' scrapes the pages listed in Start URLs; 'Finished auctions' searches the archive of sold/ended lots.

## `make` (type: `string`):

Manufacturer, e.g. Honda, Toyota, Ford. Leave as All for every make.

## `model` (type: `string`):

Model, e.g. Civic, Camry. Leave as All for every model.

## `keyword` (type: `string`):

Optional post-filter on title, VIN, lot, seller or damage text (e.g. a VIN fragment or seller name). Leave empty for no filtering.

## `vehicleType` (type: `string`):

Category of vehicle to search.

## `auction` (type: `string`):

bid.cars aggregates two salvage auctions. All searches both.

## `yearFrom` (type: `integer`):

Earliest model year, e.g. 2018.

## `yearTo` (type: `integer`):

Latest model year, e.g. 2026.

## `startUrls` (type: `array`):

Used only when 'What to scrape' is 'Specific URLs'. Paste bid.cars search pages or individual lot pages.

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

Maximum vehicles to export. Start with 10-50 to check your filters; empty means everything the search matches (large runs take a long time).

## `fullDetails` (type: `boolean`):

ON: open every lot page — full specs, photos, video, sales history, import cost. OFF: listings only, much faster but leaner.

## `advanced` (type: `object`):

Optional: mileage, price, engine, color, transmission, drive, start condition, ordering.

## `proxyConfiguration` (type: `object`):

Apify Proxy. Residential is preselected — bid.cars challenges busy datacenter IPs. Accounts without residential access: switch the group to AUTOMATED_DATACENTER or SHADER.

## `proxyUrls` (type: `array`):

Your own proxies instead of Apify Proxy: host:port:user:pass or full URLs, one per line. Keeps the run off your Apify proxy allowance.

## `proxyListKey` (type: `string`):

Name of a Key-Value Store record holding the proxy list, so credentials stay out of the run input.

## Actor input object example

```json
{
  "mode": "Search filters",
  "make": "All",
  "model": "All",
  "vehicleType": "Automobile",
  "auction": "All",
  "yearFrom": 1900,
  "yearTo": 2027,
  "maxItems": 20,
  "fullDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `vehicles` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("wdnameless/bid-cars-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("wdnameless/bid-cars-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 '{}' |
apify call wdnameless/bid-cars-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wdnameless/bid-cars-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/seYaZIbuKghlYpx7f/builds/pEQyKLQUFC1rVtQSM/openapi.json