# Auction Bid Tracker (BidJS) (`gertz_harman/auction-bid-tracker`) Actor

BidJS(Bidlogix) 기반 webcast 경매 사이트의 실시간 입찰 이벤트(현재 최고입찰가, 입찰수, 마감시각 등)를 웹소켓으로 수집합니다.

- **URL**: https://apify.com/gertz\_harman/auction-bid-tracker.md
- **Developed by:** [GERTZ HARMAN](https://apify.com/gertz_harman) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 bid updates

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Track **live bidding data** from [BidJS (Bidlogix)](https://www.bidjs.com/)-powered webcast auction sites — confirmed working on [BPI Auctions](https://www.bpiauctions.com/), [Hobbs Parker](https://www.hobbsparker.co.uk/), and [AH Asset Solutions](https://www.ahassetsolutions.com/), and built to work on other machinery, industrial, and asset-disposal auctioneers running the same platform — the moment a new bid comes in. This Actor listens to the same real-time WebSocket feed the auction site's own browser page uses, so data arrives instantly instead of on a delayed refresh cycle. BidJS deployments vary in their exact message format between sites; this Actor recognizes both variants observed so far (branded as "artisio" and the native BidJS broadcast format) and normalizes them to one consistent output. Just give it one or more auction page URLs and it does the rest — no login, no API key required.

### Why use Auction Bid Tracker?

Timed and webcast auctions for machinery, plant equipment, vehicles, and industrial assets move fast in the final minutes, and refreshing a browser tab manually means missing price movement. This Actor is built for:

- **Equipment dealers and resellers** who track several concurrent lots across auction houses and want a live feed of the current winning bid, bid count, and time remaining.
- **Auction sniping / last-minute bid alert tools** that need sub-second bid updates rather than a periodically-scraped snapshot.
- **Price intelligence and market research** on used industrial equipment, building a historical dataset of sold prices and bidding velocity.
- **Developers building dashboards or notification bots** (Telegram, Slack, email) on top of live auction activity, using Apify's API, webhooks, and scheduling instead of hosting their own scraper infrastructure.

### How to use Auction Bid Tracker

1. Find a live or upcoming auction lot page on a BidJS-powered site (the URL usually contains `#/auctions/<uuid>`).
2. Paste one or more of these URLs into the **Auction URLs** input field.
3. Set **Max monitoring duration** to roughly how long you want to listen (e.g. the remaining time before the auction closes).
4. Run the Actor. Every time a lot's price, bid count, or status changes, a new record is written to the dataset in real time — you can watch it fill in live from the **Output** tab.
5. Export the dataset as JSON, CSV, or Excel, or pull it via the Apify API into your own app.

### Input

| Field | Type | Description |
|---|---|---|
| `auction_urls` | array of URLs | One or more BidJS auction detail page URLs to monitor |
| `max_duration_secs` | integer | How long (in seconds) to keep listening before the run ends (default: 120) |

```json
{
  "auction_urls": [
    { "url": "https://www.bpiauctions.com/auctions/#/auctions/7696e8eb-e7b6-4d97-80f4-506c61bc2524" }
  ],
  "max_duration_secs": 120
}
```

### Output

Each dataset item represents one observed bid/lot-status update:

```json
{
  "source_url": "https://www.bpiauctions.com/auctions/#/auctions/387659e2-96d8-4792-ad50-338a75290e90",
  "dialect": "artisio",
  "event_type": "socket__lot_updated",
  "auction_uuid": "387659e2-96d8-4792-ad50-338a75290e90",
  "lot_uuid": "eb643552-14f2-4347-965a-74cd8afd0132",
  "status": "published",
  "current_bid_amount": 5350.0,
  "num_of_bids": 8,
  "reserve": null,
  "start_price": 5000.0,
  "buy_now_price": null,
  "end_date": "2026-09-24 11:00:20+00:00",
  "bidder_ref": "00161248",
  "auto_bid": false,
  "bid_created_at": "2026-09-19 15:50:01.566338+00:00",
  "observed_at": "2026-09-22T15:57:27.925490+00:00"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data table

| Field | Description |
|---|---|
| `dialect` | Which BidJS message format this site uses (`artisio` or `bidjs_native`) — informational, doesn't affect the other fields' meaning |
| `lot_uuid` | Unique ID of the auction lot |
| `current_bid_amount` | Current highest bid on the lot |
| `num_of_bids` | Total number of bids placed so far (not always available depending on site) |
| `bidder_ref` | Identifier for the current leading bidder (paddle number or account reference, depending on site) |
| `auto_bid` | Whether the leading bid was placed by an automatic/proxy bid |
| `reserve`, `start_price`, `buy_now_price` | Lot pricing details, where set |
| `end_date` | Scheduled close time of the lot |
| `observed_at` | Timestamp when this Actor captured the update |

### Pricing / Cost estimation

This Actor uses the pay-per-event pricing model — you pay only for each new bid/status update actually captured (event: `bid-update`), not for idle monitoring time. A quiet lot with no new bids costs nothing beyond the initial page load.

### Tips

- Point this at a lot that's actively nearing its close for the highest density of updates.
- Combine `auction_urls` with Apify's [Scheduler](https://docs.apify.com/platform/schedules) to automatically start a run a few minutes before a known auction closing time.
- Pipe the dataset into an Apify [webhook](https://docs.apify.com/platform/integrations/webhooks) to trigger your own alert (Telegram, email, Slack) when a run finishes with new bid data.

#### Quick start: get a Telegram message when a lot's price changes

No coding required — this uses Apify's built-in [Telegram integration](https://docs.apify.com/platform/integrations/telegram):

1. Run this Actor once against the lot you care about, with `max_duration_secs` set to cover the time window you want to watch.
2. On the run's page, open the **Integrations** tab and add the **Telegram** integration, connecting your own bot and chat.
3. Set it to trigger on **Run succeeded** — it will post a message (optionally including the dataset contents) once the run finishes.
4. For near-live alerts, pair this with the Scheduler (previous tip) to re-run every few minutes during an auction's final stretch, so each run's finish acts as a fresh alert.

### FAQ & disclaimers

This Actor only reads data that a normal visitor's browser already receives when viewing a public auction page — it does not place bids, log in, or bypass any access control. It is intended for personal research, price monitoring, and building notification tools. Always respect the target site's Terms of Service for your specific use case. Auction site structures can change; if this Actor stops returning data, please open an issue.

# Actor input Schema

## `auction_urls` (type: `array`):

BidJS(Bidlogix) 기반 경매 상세 페이지 URL 목록 (예: BPI Auctions, Hobbs Parker 등의 개별 경매 링크)

## `max_duration_secs` (type: `integer`):

이 시간(초) 동안 실시간 입찰 이벤트를 수집한 뒤 종료합니다.

## Actor input object example

```json
{
  "auction_urls": [
    {
      "url": "https://www.bpiauctions.com/auctions/#/auctions/7696e8eb-e7b6-4d97-80f4-506c61bc2524"
    }
  ],
  "max_duration_secs": 120
}
```

# Actor output Schema

## `results` (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 = {
    "auction_urls": [
        {
            "url": "https://www.bpiauctions.com/auctions/#/auctions/7696e8eb-e7b6-4d97-80f4-506c61bc2524"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gertz_harman/auction-bid-tracker").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 = { "auction_urls": [{ "url": "https://www.bpiauctions.com/auctions/#/auctions/7696e8eb-e7b6-4d97-80f4-506c61bc2524" }] }

# Run the Actor and wait for it to finish
run = client.actor("gertz_harman/auction-bid-tracker").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 '{
  "auction_urls": [
    {
      "url": "https://www.bpiauctions.com/auctions/#/auctions/7696e8eb-e7b6-4d97-80f4-506c61bc2524"
    }
  ]
}' |
apify call gertz_harman/auction-bid-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gertz_harman/auction-bid-tracker"
        }
    }
}
```

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/IE849A2vcI1M03BR7/builds/F43vCUyBgWRNfRFv6/openapi.json