# Bring a Trailer Auctions & Results Scraper (`automation-lab/bring-a-trailer-auctions-results-scraper`) Actor

Extract public live Bring a Trailer auctions and displayed completed results with vehicle identity, bids, prices, status, country, timing, images, and source URLs.

- **URL**: https://apify.com/automation-lab/bring-a-trailer-auctions-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.72 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Bring a Trailer Auctions & Results Scraper

Extract public **Bring a Trailer auctions** and displayed completed results as structured vehicle-market records.

The Actor captures vehicle identity, live bids or final displayed prices, auction status, country, timing, images, descriptions, and canonical source URLs.

Use it for recurring collector-market inventory tracking, appraisal research, comparable-price analysis, and data pipelines.

### What does this Bring a Trailer scraper do?

The Actor supports three useful record scopes:

- current public live auctions;
- displayed completed auction results;
- a balanced snapshot of both live auctions and results.

Live inventory is read from public server-rendered auction data.

Completed results use the public data route called by Bring a Trailer's results page.

No Bring a Trailer login is required.

The Actor does not place bids, watch vehicles, message sellers, or access private account data.

### Who is it for?

**Collector-car analysts** can build recurring snapshots of supply, bids, and final results.

**Appraisers and valuation teams** can collect public comparable-sale records for further review.

**Dealers** can watch live inventory and inspect no-reserve or high-value vehicles.

**Researchers** can export public auction records into spreadsheets or warehouses.

**Automation teams** can schedule runs and trigger downstream webhooks when a dataset is ready.

### Why use this Actor?

Bring a Trailer combines fast-moving live auctions with a large displayed results catalog.

Manual copying is slow and inconsistent.

This Actor normalizes both surfaces into one stable dataset shape.

It offers:

- live, results, and combined modes;
- sold versus reserve-not-met result filtering;
- vehicle keyword filtering;
- country and minimum-price filters;
- bounded pagination with `maxItems`;
- explicit listing URL support;
- typed JSON, CSV, Excel, XML, and API exports through Apify.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `auctionId` | Bring a Trailer public auction/listing identifier when exposed |
| `title` | Vehicle or lot headline |
| `year` | Model year parsed from source data or title |
| `status` | `live`, `sold`, or `unsold` |
| `price` | Numeric displayed bid or result price |
| `priceFormatted` | Source-formatted displayed price |
| `currency` | Displayed currency code |
| `country` | Public country name when exposed |
| `countryCode` | Two-letter country code when exposed |
| `latitude` / `longitude` | Public location coordinates when exposed |
| `endTime` | Auction end time in ISO 8601 format |
| `noReserve` | Whether the source flags the auction as no reserve |
| `premium` | Whether the source flags the lot as premium |
| `repeatListing` | Whether the source flags a repeat listing |
| `categories` | Bring a Trailer category IDs |
| `description` | Public listing excerpt when requested |
| `imageUrl` | Public thumbnail URL |
| `url` | Canonical public auction listing URL |
| `sourceUrl` | Page or route that produced the record |
| `scrapedAt` | UTC extraction timestamp |

Fields can be `null` when Bring a Trailer does not display them for a record.

### How to scrape Bring a Trailer auctions

1. Open the Actor input page.
2. Choose `live`, `results`, or `both`.
3. Optionally enter a make, model, or phrase in `searchQuery`.
4. Optionally select sold or reserve-not-met results.
5. Set `maxItems` to bound the dataset record count.
6. Click **Start**.
7. Open the default dataset to download JSON, CSV, Excel, XML, or RSS.

For a first test, use `mode: "live"` and `maxItems: 10`.

For recurring market analysis, schedule `mode: "both"` and store each run's dataset in your own historical table.

### Input parameters

#### `mode`

Choose which public records to extract:

- `live` for currently active auctions;
- `results` for displayed completed results;
- `both` for a balanced live-and-results snapshot.

Default: `both`.

#### `startUrls`

Optional public Bring a Trailer URLs.

Supported URL types include:

- `https://bringatrailer.com/auctions/`;
- `https://bringatrailer.com/auctions/results/`;
- public `https://bringatrailer.com/listing/.../` pages.

Leave the field empty for normal mode-based discovery.

#### `searchQuery`

A case-insensitive vehicle phrase such as `Porsche`, `E46 M3`, or `Land Cruiser`.

For completed results, the query is sent to the public results filter.

The Actor also applies the filter before saving output.

#### `resultStatus`

For completed auctions, choose:

- `all`;
- `sold`;
- `unsold` for reserve-not-met results.

#### `countryCode`

Optional two-letter filter such as `US`, `CA`, or `GB`.

Some historical completed records do not expose a country and will not match a country filter.

#### `minPrice`

Keep records whose numeric displayed bid or result is at least this value.

The number is interpreted in each record's displayed currency; the Actor does not convert currencies.

#### `maxItems`

Maximum number of matching records to save.

Allowed range: 1 to 10,000.

#### `includeDescription`

Include or omit the public auction excerpt.

Disable it when you need a smaller export.

### Example input: live auctions

```json
{
  "mode": "live",
  "maxItems": 50,
  "minPrice": 10000,
  "includeDescription": true
}
```

### Example input: sold Porsche results

```json
{
  "mode": "results",
  "searchQuery": "Porsche",
  "resultStatus": "sold",
  "maxItems": 25,
  "includeDescription": true
}
```

### Example output

A real run produces records in this shape:

```json
{
  "auctionId": 121240126,
  "title": "West Bend 820-Powered 1965 Model 99 Minibike",
  "year": 1965,
  "status": "live",
  "price": 7600,
  "priceFormatted": "USD $7,600",
  "currency": "USD",
  "country": "United States",
  "countryCode": "US",
  "latitude": 33.6184,
  "longitude": -111.952,
  "endTime": "2026-09-01T20:54:12.000Z",
  "noReserve": true,
  "premium": false,
  "repeatListing": false,
  "categories": ["3", "430", "70"],
  "description": "This 1965 Model 99 minibike was manufactured by Steen's...",
  "imageUrl": "https://bringatrailer.com/wp-content/uploads/2026/08/example.jpg",
  "url": "https://bringatrailer.com/listing/1965-steens-manufacturing-model-99-factory-west-bend-820-mini-bike/",
  "sourceUrl": "https://bringatrailer.com/auctions/",
  "scrapedAt": "2026-09-01T20:55:00.000Z"
}
```

Source values change continuously, so IDs, prices, and timestamps will differ in later runs.

### How much does it cost to extract Bring a Trailer auction records?

The Actor uses pay per event.

Each run has one `start` event.

Each useful dataset record has one `item` event.

Rejected, duplicate, or failed records are not charged as items.

The one-time start event is **$0.005**.

Item prices decrease by Apify plan tier:

| Plan tier | Price per auction record |
| --- | ---: |
| Free | $0.0052164 |
| Bronze | $0.004536 |
| Silver | $0.0035381 |
| Gold | $0.0027216 |
| Platinum | $0.0018144 |
| Diamond | $0.0012701 |

Use `maxItems` to set a predictable upper bound.

At Bronze pricing, a 25-record sold-results job is about **$0.1184** including the start event.

At Bronze pricing, a 100-record recurring snapshot is about **$0.4586** including the start event.

Apify computes the exact amount for your plan tier.

### Live and completed result behavior

`live` mode reads the broad current inventory shown by the public auctions page.

`results` mode paginates public completed records in batches of 36.

`sold` means the source displays a sold result.

`unsold` means the source displays a bid-to or reserve-not-met result.

`both` reserves part of the requested capacity for each status family, so a small run does not fill entirely with live inventory.

### Monitoring auction changes over time

Each Actor run is a point-in-time snapshot.

To monitor changes:

1. schedule the Actor hourly or daily;
2. export each run dataset to a durable database;
3. use `auctionId` or `url` as the stable key;
4. compare `price`, `status`, and `endTime` across snapshots;
5. trigger your own alerts or dashboard updates.

The Actor does not maintain a hidden cross-run history or send alerts by itself.

### Comparable-price research workflow

Use `mode: "results"` with a specific make or model.

Choose `resultStatus: "sold"` when you need displayed sales only.

Export the dataset to a spreadsheet or warehouse.

Review source URLs before making valuation decisions.

Displayed auction results are market observations, not formal appraisals.

### Tips for reliable runs

Start with a low `maxItems` while testing filters.

Use specific search phrases for completed-result research.

Avoid combining a very narrow keyword, country, and high minimum price unless an empty result is expected.

Keep canonical source URLs in your downstream table for auditability.

Schedule recurring work at a cadence appropriate for your use case rather than sending unnecessary repeated runs.

### Limits and failure behavior

The Actor extracts only public data exposed by Bring a Trailer.

It does not access bidder identities, private seller information, watchlists, messages, or account-only fields.

Some older results omit country, coordinates, year, categories, or description.

Direct listing pages can expose fewer structured fields than index/results records.

The Actor retries temporary network, HTTP 429, and server failures up to three times.

It does not blindly retry stable invalid URLs or malformed input.

If the source returns an unexpected data shape, the run fails instead of silently claiming a valid empty result.

Bring a Trailer can change its public pages and fields without notice.

### Export and integration patterns

Download the default dataset as JSON, CSV, Excel, XML, or RSS.

Send completed run data to Google Sheets for analyst review.

Load records into BigQuery, Snowflake, PostgreSQL, or another warehouse.

Use an Apify webhook to notify Make, Zapier, Slack, or your own API after completion.

Join auction URLs with internal appraisal notes in your own system.

Use `auctionId` and `scrapedAt` to build time-series bid observations.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bring-a-trailer-auctions-results-scraper').call({
  mode: 'results',
  searchQuery: 'Porsche 911',
  resultStatus: 'sold',
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bring-a-trailer-auctions-results-scraper').call(run_input={
    'mode': 'both',
    'countryCode': 'US',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(len(items))
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~bring-a-trailer-auctions-results-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"mode":"live","maxItems":25}'
```

Keep your Apify token in a secret or environment variable.

Do not commit it to source control.

### MCP usage

#### Claude Code

Add the Actor to Claude Code through the Apify MCP server:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bring-a-trailer-auctions-results-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Use the following equivalent HTTP MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bring-a-trailer-auctions-results-scraper"
    }
  }
}
```

Example prompt:

> Extract 25 sold Porsche results from Bring a Trailer and summarize the median displayed result by model year.

Another prompt:

> Capture a 50-record live Bring a Trailer snapshot and list no-reserve auctions ending first.

### Responsible use and legality

The Actor accesses public auction information.

You are responsible for complying with applicable laws, contractual terms, privacy rights, and source rules.

Do not use the data for spam, harassment, unauthorized profiling, or automated bidding.

Use reasonable run frequency and retain only the data needed for your lawful purpose.

Verify important market or valuation decisions against the linked source page.

### FAQ

#### Does this Actor require a Bring a Trailer account?

No. It uses public auction and results surfaces.

#### Can it extract both sold and reserve-not-met results?

Yes. Use `resultStatus: "all"`, `"sold"`, or `"unsold"`.

#### Can I scrape a specific listing URL?

Yes. Add a public Bring a Trailer listing URL to `startUrls`.

A direct listing can contain fewer fields than the live or completed index.

#### Why are some fields null?

Bring a Trailer does not expose every field for every historical record.

Null values preserve that distinction instead of inventing data.

#### Why did a filtered run return fewer records?

A keyword, country, result-status, or minimum-price filter can reduce the accepted set.

Increase `maxItems` only if more matching source records exist.

#### What happens if Bring a Trailer changes its page?

Recognizable temporary failures are retried.

An incompatible response fails the run with a diagnostic error rather than returning misleading data.

### Related automation-lab Actors

Browse the `automation-lab` profile on Apify for complementary vehicle-listing, auction, marketplace, and price-research Actors.

Combine them in your own normalized automotive market dataset when the sources and terms fit your use case.

### Support

When reporting a problem, include:

- the Actor run URL;
- a redacted copy of the input;
- one public source URL that demonstrates the issue;
- the expected field or behavior.

Do not include account credentials or private personal data.

# Actor input Schema

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

Choose live auctions, completed results, or both.

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

Specific public listing, live-auctions, or auction-results URLs. Leave empty to use the selected mode.

## `searchQuery` (type: `string`):

Keep auctions matching a make, model, or phrase, for example Porsche 911 or E46 M3.

## `resultStatus` (type: `string`):

For completed auctions, include all displayed results, sold vehicles only, or reserve-not-met results only.

## `countryCode` (type: `string`):

Optional two-letter location filter such as US, CA, or GB.

## `minPrice` (type: `number`):

Keep records at or above this numeric displayed price.

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

Stop after saving this many matching auction records.

## `includeDescription` (type: `boolean`):

Include the public listing excerpt when Bring a Trailer exposes it.

## Actor input object example

```json
{
  "mode": "both",
  "startUrls": [],
  "searchQuery": "",
  "resultStatus": "all",
  "countryCode": "",
  "minPrice": 0,
  "maxItems": 20,
  "includeDescription": true
}
```

# Actor output Schema

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

Open normalized vehicle auction records in the overview dataset view.

# 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 = {
    "mode": "both",
    "startUrls": [],
    "searchQuery": "",
    "resultStatus": "all",
    "countryCode": "",
    "minPrice": 0,
    "maxItems": 20,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bring-a-trailer-auctions-results-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 = {
    "mode": "both",
    "startUrls": [],
    "searchQuery": "",
    "resultStatus": "all",
    "countryCode": "",
    "minPrice": 0,
    "maxItems": 20,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bring-a-trailer-auctions-results-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 '{
  "mode": "both",
  "startUrls": [],
  "searchQuery": "",
  "resultStatus": "all",
  "countryCode": "",
  "minPrice": 0,
  "maxItems": 20,
  "includeDescription": true
}' |
apify call automation-lab/bring-a-trailer-auctions-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/bring-a-trailer-auctions-results-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/ocX5OEsInSmjBFLmD/builds/Do6MaFfnOlbJxvrzC/openapi.json