# Bring a Trailer New Auction Monitor (`delta_tools/bringatrailer-new-auction-monitor`) Actor

Watch Bring a Trailer for new auctions matching your keywords. Get only genuinely new listings with current bid and closing time, never the same auction twice. Built for bidders who track specific makes and models.

- **URL**: https://apify.com/delta_tools/bringatrailer-new-auction-monitor.md
- **Developed by:** [Delta Tools](https://apify.com/delta_tools) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 new 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 New Auction Monitor

New auction alerts for the cars you actually want.

Bring a Trailer lists well over a thousand live auctions at any moment, and the good ones do not wait for you to refresh the page. This Actor watches the full live board for the makes and models you care about and reports only the auctions you have not seen before.

Give it keywords such as Porsche, Ford Bronco, or Land Cruiser. Each run reads every live listing, matches your keywords against titles and listing text, and returns the genuinely new matches with the current bid, the closing time, and an ending soon flag for anything closing inside your window. Run it on a schedule and your dataset becomes a clean feed of fresh auctions, ready for bidding research, dealer sourcing, or alerts.

### Why it is different

Other Bring a Trailer scrapers hand you the whole board on every run and charge for every row, every time. This monitor keeps state between runs. An auction is reported once, billed once, and never repeated. Quiet runs with nothing new cost nothing beyond the Actor start.

### Input

**Keywords to watch.** The makes, models, or phrases you track. Matching ignores letter case.

**Minimum and maximum current bid.** Optional price fences in US dollars.

**Ending soon window.** Auctions closing within this many hours are flagged in the results. The default is 24.

**Max new auctions per run.** A safety cap, soonest closing first. Anything beyond the cap stays unreported and surfaces on the next run.

**Report current matches on the first run.** On by default, so the first run shows you the current field. Turn it off to start from a clean baseline.

**Watch name.** Give each schedule its own watch name so separate watches keep separate memories. Runs that share a watch name share dedup state.

### Output

One record per new auction: title, link, current bid, closing time in UTC, time remaining, ending soon flag, country, year, no reserve flag, and the keyword that matched. Every run that reaches the board also writes one summary record with the counts: listings scanned, listings matched, and new auctions reported.

### Pricing

Pay per event: the standard Actor start of $0.001 plus $0.0025 per new auction reported. You never pay for auctions you have already seen, and a failed fetch is never billed.

# Actor input Schema

## `endingWithinHours` (type: `integer`):

Auctions closing within this many hours are flagged as ending soon in the results. Use it to spot the listings that need a bid decision today.

## `keywords` (type: `array`):

Makes, models, or phrases to watch for. Examples: Porsche, Ford Bronco, air cooled. A new auction matches when any keyword appears in its title or listing text. Matching ignores letter case. Leave empty to run a quick demo with a sample keyword.

## `maxCurrentBid` (type: `integer`):

Only report new auctions whose current bid in US dollars is at or below this amount. Leave empty for no maximum.

## `maxResults` (type: `integer`):

Maximum number of new auctions to report in one run, soonest closing first. Auctions beyond the cap are not lost: they stay unreported and surface on the next run.

## `minCurrentBid` (type: `integer`):

Only report new auctions whose current bid in US dollars is at or above this amount. Leave empty for no minimum.

## `reportInitialAsNew` (type: `boolean`):

When on, the first run of a watch reports the auctions that already match, so you see the current field right away. When off, the first run only sets the baseline and later runs report what is genuinely new from then on.

## `stateKey` (type: `string`):

Name your watch to give it its own memory. Runs that share a watch name share dedup state, so a scheduled watch only ever reports genuinely new auctions. Leave empty for a fresh snapshot that resets daily, which suits one off trials.

## Actor input object example

```json
{
  "endingWithinHours": 24,
  "keywords": [
    "Porsche"
  ],
  "maxResults": 100,
  "reportInitialAsNew": true
}
```

# Actor output Schema

## `country` (type: `string`):

Country where the vehicle is located, when the listing provides it.

## `currentBid` (type: `string`):

Current bid in US dollars at the moment the run checked.

## `currentBidFormatted` (type: `string`):

Current bid as the site displays it.

## `detectedAt` (type: `string`):

UTC timestamp of the run that first reported this auction.

## `endingSoon` (type: `string`):

True when the auction closes within your ending soon window (as text).

## `endsAt` (type: `string`):

Auction closing time in UTC, ISO format.

## `error` (type: `string`):

Present only on a fetch error record. Error records are never charged.

## `keywords` (type: `string`):

The keywords the run watched for, on the summary record.

## `listingId` (type: `string`):

Bring a Trailer listing identifier.

## `listingsScanned` (type: `string`):

Live listings read from the auctions page, on the summary record (as text).

## `matchedKeyword` (type: `string`):

The keyword that matched this auction.

## `matchedListings` (type: `string`):

Listings that matched the keywords and filters, on the summary record (as text).

## `newAuctions` (type: `string`):

Genuinely new auctions reported by this run, on the summary record (as text).

## `noReserve` (type: `string`):

True when the listing has no reserve price (as text).

## `recordType` (type: `string`):

The exact record kind: new-auction, run-summary, or fetch-error.

## `runAt` (type: `string`):

UTC timestamp of the run, on the summary record.

## `timeRemaining` (type: `string`):

Human readable time left until the auction closes.

## `title` (type: `string`):

Auction title as listed on Bring a Trailer.

## `url` (type: `string`):

Link to the auction page.

## `year` (type: `string`):

Vehicle year, when the listing provides it.

# 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 = {
    "endingWithinHours": 24,
    "keywords": [
        "Porsche"
    ],
    "maxResults": 100,
    "reportInitialAsNew": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("delta_tools/bringatrailer-new-auction-monitor").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 = {
    "endingWithinHours": 24,
    "keywords": ["Porsche"],
    "maxResults": 100,
    "reportInitialAsNew": True,
}

# Run the Actor and wait for it to finish
run = client.actor("delta_tools/bringatrailer-new-auction-monitor").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 '{
  "endingWithinHours": 24,
  "keywords": [
    "Porsche"
  ],
  "maxResults": 100,
  "reportInitialAsNew": true
}' |
apify call delta_tools/bringatrailer-new-auction-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delta_tools/bringatrailer-new-auction-monitor"
        }
    }
}
```

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/5dPDzlSdRPUncF7SU/builds/08MSKV8Xh1foaTRBz/openapi.json