# Bring a Trailer Scraper — Live Bids & Sold Prices (`crawloop/bring-a-trailer-scraper`) Actor

Scrape Bring a Trailer live auctions and sold prices. Export the current bid or sale amount, no-reserve flag, mileage, location, VIN, and seller for collector-car comps and auction monitoring.

- **URL**: https://apify.com/crawloop/bring-a-trailer-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 $10.00 / 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

## Bring a Trailer Scraper — Live Bids & Sold Prices

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Bring a Trailer or its affiliates. Data is read from publicly accessible auction listing and results pages only. No login and no bidding. You are responsible for complying with applicable law (including GDPR where a seller username appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Scrape **Bring a Trailer** live auctions and **sold prices**. Export **current bid**, **sale amount**, **reserve-not-met** results, **no-reserve**, and — when you turn on listing details — **VIN**, **mileage**, **location**, and **seller**. One Bring a Trailer 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.

| Bring a Trailer | Cars & Bids | eBay sold comps | eBay asking prices |
| :--- | :--- | :--- | :--- |
| **Bring a Trailer Scraper** ◄── you are here | [Cars & Bids Scraper](https://apify.com/crawloop/cars-and-bids-scraper) | [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) |
| Live bids, sold prices, reserve not met | Live bids and closed sale amounts | Completed marketplace sales | Live BIN and auction asking prices |

### When to use this Actor

- **Live auction watch** — current bid, end time, and no-reserve on cars that are still open
- **Sold price comps** — completed auctions with the final sale amount
- **Reserve-not-met comps** — high bid when the car did not sell
- **Scheduled new-lot monitor** — `monitorMode` on an Apify Schedule so repeat runs only charge new auction ids
- **VIN and spec pull** — `includeDetails` adds chassis/VIN, odometer, engine, transmission, location, and seller
- **Make and model research** — search `porsche` or paste a results URL

### When not to use this Actor

- **The other enthusiast auction house** — use [Cars & Bids Scraper](https://apify.com/crawloop/cars-and-bids-scraper) for that catalog
- **Marketplace sold comps** — 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

### Key features

- **Live, sold, and reserve-not-met** in one Actor. Cards already include the current bid or the sold price
- **Optional listing detail** for VIN, mileage, engine, transmission, location, and seller username
- **Monitor mode** stores seen auction ids in a named key-value store and skips them on the next run
- **HTTP listings** — no browser. Leave proxy off unless a run starts returning HTTP 403
- **Deduped rows** across several searches in the same run

### Input

| Field | Required | Description |
| :--- | :--- | :--- |
| `searchQueries` | No | Keywords such as `porsche` or `911`. Each query is its own search |
| `startUrls` | No | Listing URL, live auctions page, results page, or make page |
| `auctionStatus` | No | `live` (default), `sold`, or `unsold` |
| `minimumYear` / `maximumYear` | No | Model-year bounds |
| `maximumBid` | No | Drop rows above this USD bid or sale amount |
| `maxItems` | No | Cap across the whole run. Default 50. The completed archive is hundreds of thousands of lots |
| `includeDetails` | No | Open each listing for VIN, mileage, and seller. Default off |
| `monitorMode` | No | Charge only auction ids not seen in the named store |
| `monitorStoreName` | No | Key-value store name. One name per watch |
| `resetMonitorState` | No | Clear seen ids before this run |
| `proxyConfiguration` | No | Leave off |

```json
{
  "searchQueries": ["porsche"],
  "auctionStatus": "sold",
  "maxItems": 25,
  "includeDetails": false
}
```

A single listing:

```json
{
  "startUrls": [
    { "url": "https://bringatrailer.com/listing/1992-bmw-325i-e30-9/" }
  ],
  "includeDetails": true,
  "maxItems": 1
}
```

### Output

| Field | Description |
| :--- | :--- |
| `title` | Year, make, and model |
| `status` | `live`, `sold`, or `unsold` |
| `currentBid` | High bid in USD |
| `saleAmount` | Final price when the lot sold |
| `soldText` | Sold-for or bid-to line |
| `noReserve` | True when there is no reserve |
| `year` | Model year |
| `auctionEnd` | End time |
| `url` | Listing URL |
| `vin` | VIN or chassis when details are on |
| `mileage` / `mileageText` | Odometer when details are on |
| `location` | Seller location when details are on |
| `sellerUsername` | Public seller name when details are on |
| `engine` / `transmission` | Spec lines when details are on |
| `imageUrl` | Main photo |
| `scrapedAt` | When the row was saved |

```json
{
  "auctionId": "120687587",
  "title": "1992 BMW 325i Convertible",
  "status": "sold",
  "year": 1992,
  "currentBid": 8692,
  "saleAmount": 8692,
  "soldText": "Sold for USD $8,692 on 9/28/2026",
  "noReserve": true,
  "vin": "WBABB2315NEC29545",
  "mileage": 131000,
  "location": "Hudsonville, Michigan 49426",
  "sellerUsername": "isaiaharends",
  "url": "https://bringatrailer.com/listing/1992-bmw-325i-e30-9/"
}
```

### Use cases

- **Dealer comps** — sold Porsche 911s with sale amount, year, and no-reserve, then the same car on eBay
- **Live book** — what is open right now, the current bid, and when it ends
- **Reserve-not-met watch** — cars that failed to sell and the high bid they reached
- **Morning monitor** — a schedule that only returns auctions you have not already stored

### Integration examples

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('crawloop/bring-a-trailer-scraper').call({
  searchQueries: ['porsche'],
  auctionStatus: 'sold',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
  console.log(item.title, item.saleAmount || item.currentBid, item.noReserve);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("crawloop/bring-a-trailer-scraper").call(run_input={
    "searchQueries": ["porsche"],
    "auctionStatus": "sold",
    "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~bring-a-trailer-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["porsche"],"auctionStatus":"sold","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/bring-a-trailer-scraper`.

Example prompts:

- "Run Bring a Trailer Scraper for live porsche auctions, max 20, and return title, currentBid, noReserve, auctionEnd as JSON"
- "Scrape sold Bring a Trailer results for 911 and summarize sale amounts"
- "Chain Bring a Trailer 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 Bring a Trailer sold prices, run [Cars & Bids Scraper](https://apify.com/crawloop/cars-and-bids-scraper) for the other enthusiast auction catalog, then [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).

### FAQ

**Is this a Bring a Trailer API?** Unofficial. It reads the public auction pages and results feed the website uses. There is no separate buyer API to replace it.

**Do result rows include the price?** Yes. Live rows include `currentBid`. Sold rows include `saleAmount`. Reserve-not-met rows keep `currentBid` and leave `saleAmount` empty. `includeDetails` is for VIN, mileage, and seller, 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?** Raise `maxItems` only as far as you need. The completed archive is hundreds of thousands of lots. Start with 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, or ferrari 360. Each query is a separate search. Leave empty to browse the live book or the latest completed results.

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

Listing links, the live auctions page, a results page, or a make page. Listing links return one auction each.

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

Live auctions with the current bid, sold results, or reserve-not-met results. A results URL keeps its own sold or unsold filter.

## `minimumYear` (type: `integer`):

Keep model years on or after this year.

## `maximumYear` (type: `integer`):

Keep model years on or before this year.

## `maximumBid` (type: `integer`):

Drop rows whose current bid or sale amount is above this USD amount.

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

Maximum auction rows to save across every search. The completed archive is hundreds of thousands of lots — raise this only for a large sold-price pull.

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

Open each auction for VIN or chassis, odometer, engine, transmission, location, and seller. Cards already include the current bid or sold price.

## `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. Listings respond without a proxy. Turn a proxy on only if a run fails with HTTP 403.

## Actor input object example

```json
{
  "auctionStatus": "live",
  "maxItems": 20,
  "includeDetails": false,
  "monitorMode": false,
  "monitorStoreName": "bring-a-trailer-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/bring-a-trailer-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/bring-a-trailer-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/bring-a-trailer-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/bring-a-trailer-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/l3feJrwzl1skLPgh7/builds/G3U0ksXJyDd5UQudx/openapi.json