# Cars & Bids Scraper — Live Bids & Sold Prices (`crawloop/cars-and-bids-scraper`) Actor

Scrape Cars & Bids live auctions and sold prices. Export current bid or sale amount, mileage, location, no-reserve flag, VIN, and auction end time for dealer comps and auction monitoring.

- **URL**: https://apify.com/crawloop/cars-and-bids-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.90 / 1,000 auctions

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

## Cars & Bids Scraper — Live Bids & Sold Prices

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Cars & Bids. Data is read from publicly accessible auction pages only. No login and no bidding. You are responsible for complying with applicable law and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Scrape **Cars & Bids** live auctions and **sold prices**. Export **current bid**, **sale amount**, **mileage**, **location**, **no-reserve**, and — when you turn on listing details — **VIN**, **engine**, and **bid count**. One Cars & Bids scraper for dealer comps, auction monitoring, and enthusiast-car pricing.

**Best for:** dealers, brokers, and analysts who want auction rows in JSON or CSV for sheets, databases, and scheduled watches.

> **Crawloop vehicle pricing suite** — enthusiast auction results, then marketplace comps for the same year, make, and model.

| Cars & Bids | eBay sold comps | eBay asking prices | German dealer inventory |
| :--- | :--- | :--- | :--- |
| **Cars & Bids Scraper** ◄── you are here | [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) |
| Live bids and closed sale amounts | Completed marketplace sales | Live BIN and auction asking prices | Used cars, prices, dealer contacts |

### When to use this Actor

- **Live auction watch** — current bid, end time, mileage, location, and no-reserve on cars that are still open
- **Sold price comps** — closed auctions with the final sale amount
- **Scheduled new-lot monitor** — `monitorMode` on an Apify Schedule so repeat runs only charge new auction ids
- **VIN and spec pull** — `includeDetails` adds VIN, engine, colors, title status, and bid/comment/watcher counts
- **Make and model research** — search `porsche` or `911 turbo`, or paste a search URL

### When not to use this Actor

- **Marketplace sold comps outside this auction house** — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) for the same year, make, and model
- **Live eBay asking prices** — use [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper)
- **Placing bids or logging in** — this Actor only reads public auction data
- **Used auto parts inventory** — use [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) for recycler stock
- **German dealer inventory** — use [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper)

### Key features

- **Live and closed auctions** in one Actor. Search rows already include the current bid or the sale amount
- **Optional listing detail** for VIN, engine, drivetrain, colors, photos, and bid statistics
- **Monitor mode** stores seen auction ids in a named key-value store and skips them on the next run
- **HTTP catalog** — no browser. Leave proxy off unless a run starts returning HTTP 403
- **Deduped rows** across several searches in the same run

### Input

| Field | Required | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchQueries` | No | — | Keywords such as `porsche` or `911 turbo` |
| `make` | No | — | Make, for example `porsche`. With `model`, becomes one search |
| `model` | No | — | Model text searched with `make` |
| `startUrls` | No | — | Auction links or search links |
| `auctionStatus` | No | `live` | `live` or `closed` |
| `sort` | No | `newest` | `newest` or `endingSoon`. Closed and monitor runs use newest |
| `maxItems` | No | `50` | Cap across all searches. The closed archive is large |
| `includeDetails` | No | `false` | VIN, engine, colors, bid count, watchers |
| `monitorMode` | No | `false` | Emit only auction ids not seen in the monitor store |
| `monitorStoreName` | No | `cars-and-bids-monitor` | One name per watch |
| `resetMonitorState` | No | `false` | Clear seen ids before this run |
| `proxyConfiguration` | No | off | Turn on only after HTTP 403 |

#### Example input

```json
{
  "searchQueries": ["porsche 911"],
  "auctionStatus": "closed",
  "maxItems": 25,
  "includeDetails": true
}
```

Auction links also work inside the input JSON:

```json
{
  "startUrls": [
    { "url": "https://carsandbids.com/auctions/3vdlMwVO/2003-porsche-911-turbo" }
  ],
  "includeDetails": true
}
```

### Output

Each dataset row is one auction.

| Field | Description |
| :--- | :--- |
| `auctionId` | Public auction id |
| `url` | Auction URL |
| `title` | Listing title |
| `status` | `live` or `sold` |
| `year` | Model year |
| `make`, `model` | Filled when listing detail is loaded |
| `mileage` | Odometer miles |
| `location` | Seller location |
| `noReserve` | No-reserve flag |
| `currentBid` | Current high bid in USD |
| `saleAmount` | Final sale amount on closed auctions |
| `auctionEnd` | End time |
| `imageUrl` | Main photo |
| `sellerUsername` | Public seller username |
| `vin`, `engine`, `bodyStyle`, `driveTrain` | Listing detail |
| `bidCount`, `commentCount`, `watcherCount`, `viewCount` | Listing detail |
| `scrapedAt` | ISO-8601 timestamp |

#### Example output

```json
{
  "auctionId": "3vdlMwVO",
  "url": "https://carsandbids.com/auctions/3vdlMwVO",
  "title": "2003 Porsche 911 Turbo Coupe",
  "status": "live",
  "year": 2003,
  "mileage": 33700,
  "location": "Las Vegas, NV 89113",
  "noReserve": false,
  "currentBid": 69996,
  "saleAmount": null,
  "auctionEnd": "2026-09-29T19:57:00.000+00:00",
  "sellerUsername": "seller1",
  "vin": null
}
```

`vin` stays empty until `includeDetails` is true. Closed rows set `status` to `sold` and fill `saleAmount`.

### Use cases

- **Dealer desk** — morning list of live no-reserve cars ending today (`sort: endingSoon`)
- **Sold comps** — closed `porsche 911` sales with mileage and sale amount before pricing a car
- **Watch a model** — Schedule plus `monitorMode` so only new lots are charged
- **Spec sheet** — `includeDetails` when the VIN and engine matter, not only the bid

### 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/cars-and-bids-scraper').call({
  searchQueries: ['porsche 911'],
  auctionStatus: 'closed',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
  console.log(item.title, item.saleAmount || item.currentBid, item.mileage);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("crawloop/cars-and-bids-scraper").call(run_input={
    "searchQueries": ["porsche 911"],
    "auctionStatus": "closed",
    "maxItems": 25,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("title"), item.get("saleAmount") or item.get("currentBid"))
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/crawloop~cars-and-bids-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["porsche 911"],"auctionStatus":"closed","maxItems":25}'
```

### 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 this Actor by its Store ID `crawloop/cars-and-bids-scraper`.

Example prompts:

- "Run Cars & Bids Scraper for live porsche auctions, max 20, and return title, currentBid, mileage, auctionEnd as JSON"
- "Scrape closed Cars & Bids results for 911 turbo and summarize sale amounts by mileage"
- "Chain Cars & Bids Scraper then [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) for the same year, make, and model"

### Suite next step

After Cars & Bids sold prices, run [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) for marketplace comps on the same year, make, and model. For cars that are still listed, use [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper). For German dealer inventory, use [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper). For recycler parts on that year and model, use [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper).

### FAQ

**Is this a Cars & Bids API?** Unofficial. It reads the same public catalog JSON the website uses. There is no separate buyer API to replace it.

**Do search rows include the price?** Yes. Live rows include `currentBid`. Closed rows include `saleAmount`. `includeDetails` is for VIN, engine, and bid statistics, not for the price itself.

**How does monitor mode work?** The first run saves every auction id it sees. Later runs with the same `monitorStoreName` skip those ids and only charge new ones. Use one store name per watch, and `resetMonitorState` when you want a fresh baseline.

**Can I pull the whole sold archive?** Yes, by raising `maxItems`. The closed archive is tens of thousands of lots. Start with a make or a keyword so the run stays inside your cap.

**Do I need a proxy?** No. Leave proxy off. Enable Apify Proxy only if a run fails with HTTP 403.

**Does it log in or bid?** No. Public auction fields only.

# Actor input Schema

## `searchQueries` (type: `array`):

Optional keywords such as porsche, 911 turbo, or corvette. Each query is a separate catalog search. Leave empty to browse the live book or the closed archive.

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

Make slug, for example porsche or bmw. Combined with Model into one search. Ignored when Model is empty and a search query is already set — both still run and duplicates are dropped.

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

Model text searched together with Make, for example 911 turbo. Generation slugs such as 996-911 belong in a search URL instead.

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

Auction links or search links. Auction links return one full listing each. Search links use the make and model in the path.

## `auctionStatus` (type: `string`):

Live auctions with the current bid, or closed auctions with the sale amount.

## `sort` (type: `string`):

Newest first, or ending soon. Closed auctions always use newest. Monitor mode always uses newest.

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

Maximum auction rows to save across every search. The closed archive is tens of thousands of lots — raise this only when you want a large sold-price pull.

## `includeDetails` (type: `boolean`):

Open each auction for VIN, engine, colors, title status, photo, bid count, comments, and watchers. Search rows already include the current bid or sale amount.

## `monitorMode` (type: `boolean`):

Save and charge only auction ids that were not seen in a previous run. The first run is the baseline. Pair with an Apify Schedule and a stable monitor store name.

## `monitorStoreName` (type: `string`):

Named Key-Value store for seen auction ids. Use one name per watch.

## `resetMonitorState` (type: `boolean`):

Clear seen auction ids before this run.

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

Leave proxy off. The catalog JSON responds without a proxy. Turn a proxy on only if a run fails with HTTP 403.

## Actor input object example

```json
{
  "auctionStatus": "live",
  "sort": "newest",
  "maxItems": 20,
  "includeDetails": false,
  "monitorMode": false,
  "monitorStoreName": "cars-and-bids-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset items.

# 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 = {
    "auctionStatus": "live",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/cars-and-bids-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 = {
    "auctionStatus": "live",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/cars-and-bids-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 '{
  "auctionStatus": "live",
  "maxItems": 20
}' |
apify call crawloop/cars-and-bids-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/cars-and-bids-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/lcc7QTjTIedfNCIpm/builds/MvScf012R6aOhWsDc/openapi.json