# HiBid Auction Scraper - Lots, Bid History & Auction Results (`parseforge/hibid-scraper`) Actor

Extract HiBid auction lots with current bids, the public bid ledger and hammer prices from the archive, plus full auction terms and auction-house contact details. Also returns auction events and HiBid's auction-house directory. No login, no API key, no proxy.

- **URL**: https://apify.com/parseforge/hibid-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.23 / 1,000 results

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### HiBid Auction Scraper - Lots, Bid History & Auction Results

Scrape HiBid, the auction marketplace that carries **1.27 million live lots across 3,600 auctions** and an archive of **301 million closed lots** — estate auctions, farm and construction equipment, coins, jewelry and vehicles. Get back **47 fields on a default row** and up to **110 with every optional block ticked** — including the public bid ledger with timestamps, the hammer price from the archive, the auction's full terms, and the auction house's phone and email. No login, no API key, no proxy. Export to CSV, JSON, Excel, or XML.

HiBid publishes no documented API. Its site runs on a GraphQL endpoint that answers anonymous callers, and this Actor reads that endpoint directly — no browser, no HTML parsing, no rate limits hit in testing.

| Who uses it | What they scrape HiBid for |
| --- | --- |
| Resellers and pickers | Live lots under a price ceiling, filtered to reserve-met and shipping-offered, so every row is actually buyable |
| Appraisers and insurers | Realized hammer prices out of the archive, by category and date, as defensible comps |
| Auction-tech and aggregators | A whole sale event in one pass with `auctionIds`, past the 10,000-row ceiling a keyword search hits |
| Market researchers | Bid counts, unique bidders and the full bid ledger — how demand actually formed, not just where it ended |
| Sales teams selling to auction houses | HiBid's auction-house directory with phone, email, postal address and website |

### What it does

This Actor reads HiBid three ways, chosen with `mode`.

🔨 **Lots** — one row per item, live or archived, with price, status, images, category and the auction it belongs to.

🏛️ **Auctions** — one row per sale event, with lot counts, open/close times, bidding format and shipping policy.

🏢 **Auction houses** — HiBid's company directory, with the contact block attached.

On top of that:

💰 **Auction results, not just current bids.** Turn on the archive and `priceRealized` carries the hammer price the lot actually sold for, alongside `quantitySold` and `priceRealizedPerEach`.

📜 **The public bid ledger.** `bidHistory` returns every bid on the lot — amount, timestamp, and the bidder handle as HiBid publishes it. `uniqueBidders`, `firstBidAt` and `lastBidAt` come derived.

📋 **The auction's actual terms.** Terms and conditions, payment info, shipping and pickup info, the bid increment table, accepted cards and the registration type — the things that decide whether a lot is worth bidding on.

📞 **The auction house behind the lot.** Phone, email, postal address and website, resolved once per auction and cached across every lot in it.

🗂️ **HiBid's category tree.** Category names are resolved against HiBid's live tree and **rejected if unknown** — because HiBid silently ignores an unknown category id and returns the entire catalogue instead of erroring.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with HiBid data

📊 **Build a sold-price comp set.**

Run with `archive` on, a category, a date window and `onlyWithRealizedPrice`. Every row that comes back sold; the blanks are dropped before you are charged for them. Tick `includeRealizedPrice` to get the hammer price as a column — or leave it off and just use the filter, which reads the price without selling it to you.

🎯 **Find underbid lots closing soon.**

`status: CLOSING`, a `maxCurrentBid` ceiling and `onlyReserveMet` gives you lots that will sell, at a price you set, in the next few hours.

📈 **Track one auction house over time.**

Run in Auctions mode filtered by state, key on `auctionId`, and watch `openLotCount` and `bidCloseDateTime` roll forward.

🧠 **Study how bidding actually forms.**

`includeBidHistory` plus the base row's `bidIncrement` shows whether a lot climbed in one late flurry or ground up over a week — the difference between a hot category and a quiet one.

### Why choose this scraper

| What you get | |
| --- | --- |
| 110 fields per row | Every field HiBid's own endpoint publishes to anonymous callers, each one verified against live data rather than guessed. 47 of them ride on the base row. |
| The bid ledger | `bidHistory` with amounts and timestamps. No other HiBid Actor on the Store lists it. |
| Realized prices | `priceRealized` from the archive, which goes back years, with a working date window. |
| Auction terms and contacts | T\&Cs, payment, shipping, bid increments, accepted cards, plus the auction house's phone and email. |
| 23 ways to narrow the run | Eight run inside the Actor, so **rejected rows are never written and never charged** — and they read the full row, so you can filter on a block without buying it. |
| Nothing extra is forced on you | Seven optional blocks, every one off by default behind its own checkbox. A default run bills one per-row price and nothing else. |
| Three modes | Lots, auction events, and the auction-house directory — one Actor, not three. |
| Past the 10,000 ceiling | A keyword search stops at 10,000 lots. `auctionIds` walks entire auctions instead, 500 lots per request. |
| No proxy, no login | HiBid answers plain anonymous requests. A run costs you nothing in proxy traffic. |
| Honest empties | A field HiBid does not publish is absent from the row — never a null, never a guessed value. |
| Four export formats | CSV, JSON, Excel, and XML, from the dashboard or the API. |

### How it compares

The competitor columns reflect what each Actor's own public listing states, not a test run of it.

| Feature | ParseForge | scrapersdelight | lulzasaur | solidcode | getascraper | rainminer |
| --- | --- | --- | --- | --- | --- | --- |
| Bid history with timestamps | Yes | Not stated | Not stated | Not stated | Not stated | Not stated |
| Realized hammer prices | Yes, with a date window | Not stated | Not stated | Not stated | Closed listings | Not stated |
| Auction terms, payment, shipping | Yes | Not stated | Not stated | Not stated | Not stated | Not stated |
| Auction-house phone and email | Yes | Auctioneer named | Auction house named | Auctioneer named | Not stated | Not stated |
| Auction-house directory mode | Yes | No | No | No | No | No |
| Auction-event mode | Yes | Yes | No | No | No | No |
| Filter before you pay | 8 in-Actor filters, rejected rows unbilled | Not stated | Not stated | Not stated | Not stated | Not stated |
| Whole-auction walk past 10,000 | Yes, via `auctionIds` | Not stated | Not stated | Paste auction URLs | Not stated | Not stated |
| ZIP + radius search | Yes | Yes | Not stated | Not stated | Not stated | Not stated |
| Base price per lot row | $0.007 | $0.005 | $0.005 | $0.001 | Not stated | Not stated |
| Extra data is opt-in | Every block, off by default | Not stated | Not stated | Not stated | Not stated | Not stated |

`solidcode` is cheaper per row. Come here when you need the bid ledger, the hammer price, the auction terms or the contact block — none of which appear on any other HiBid listing — or when you want to filter hard before paying.

### What a lot looks like

Every lot returns as one flat JSON row. Here is a real record from a run with **every optional block ticked**, with the long text fields shortened. A default run returns the same row minus the description, category, image list, bid ledger and auction-terms blocks:

```json
{
  "lotId": 317645036,
  "lotUrl": "https://hibid.com/lot/317645036",
  "title": "Rolex Boxes",
  "lotNumber": "207",
  "itemId": 20213,
  "saleOrder": 207,
  "description": "Rolex Boxes\nRoom: Bedroom",
  "quantity": 1,
  "currentBid": 13,
  "nextMinimumBid": 14,
  "bidIncrement": 1,
  "bidCount": 3,
  "reserveMet": true,
  "showsReserveStatus": false,
  "isSealedBid": false,
  "choiceType": "SINGLE_LOT",
  "status": "OPEN",
  "isClosed": false,
  "isArchived": false,
  "isLive": false,
  "timeLeft": "7d  10h  23m",
  "timeLeftSeconds": 642219,
  "softCloseMinutes": 3,
  "imageUrl": "https://cdn.hibid.com/img.axd?id=8410259711&...",
  "thumbnailUrl": "https://cdn.hibid.com/img.axd?id=8410259711&...&h=350&w=350",
  "imageCount": 6,
  "images": ["https://cdn.hibid.com/img.axd?id=8410259711&...", "..."],
  "categoryId": 40265,
  "categoryName": "Men's Watches",
  "categoryPath": "Jewelry, Watches & Gemstones - Watches - Men's Watches",
  "categoryUrl": "https://hibid.com/lots/jewelry--watches-and-gemstones/watches/mens-watches",
  "categoryBreadcrumb": ["Jewelry, Watches & Gemstones", "Watches", "Men's Watches"],
  "shippingOffered": true,
  "freightQuoteUrl": "https://app.fr8star.com/transport-estimate?...",
  "bidHistory": [
    { "amount": 13, "bidder": "1xbuck", "bidderMasked": false, "bidCount": 1, "placedAt": "2026-08-19T18:19:00", "placedAtRaw": "8/19/2026 6:19 PM" },
    { "amount": 12, "bidder": "****E", "bidderMasked": true, "bidCount": 1, "placedAt": "2026-08-19T23:07:00", "placedAtRaw": "8/19/2026 11:07 PM" },
    { "amount": 10, "bidder": "topbidevaluator95147", "bidderMasked": false, "bidCount": 1, "placedAt": "2026-08-19T14:09:00", "placedAtRaw": "8/19/2026 2:09 PM" }
  ],
  "bidHistoryCount": 3,
  "uniqueBidders": 3,
  "firstBidAt": "2026-08-19T14:09:00",
  "lastBidAt": "2026-08-19T23:07:00",
  "bidCurrency": "USD",
  "auctionId": 769175,
  "auctionUrl": "https://hibid.com/auction/769175",
  "auctionName": "Jen Rosie Designs - Online Estate Auction 87 Lane Park",
  "auctionCity": "Dallas",
  "auctionState": "TX",
  "auctionZip": "75225",
  "auctionLotCount": 234,
  "bidType": "INTERNET_ONLY",
  "bidAmountType": "MAX_BIDDING",
  "currency": "USD",
  "buyerPremium": "19% Buyer's Premium",
  "buyerPremiumPercent": 19,
  "bidOpenDateTime": "2026-08-18T09:00:00",
  "bidCloseDateTime": "2026-08-27T20:00:00",
  "eventDateInfo": "Auction begins Tuesday, August 18, 2026 at 8:00am CST and will close Thursday, August 27, 2026 at 7:00pm CST.",
  "sourceType": "AFLEX",
  "termsAndConditions": "Online bidding only. All bidding starts at $1. 19% Buyer's Premium...",
  "paymentInfo": "Credit card on file will be charged at the end of auction...",
  "shippingAndPickupInfo": "Buyer is responsible for pickup...",
  "registrationType": "CREDIT_CARD_EVERY_TIME",
  "cardsAccepted": ["Visa", "Mastercard", "Amex", "Discover"],
  "bidIncrements": [{ "upToAmount": 99, "increment": 1 }, { "upToAmount": 195, "increment": 5 }],
  "auctioneerId": 89390,
  "auctioneerName": "Jen Rosie Designs",
  "auctioneerPhone": "2148762466",
  "auctioneerEmail": "Jen@jenrosiedesigns.com",
  "auctioneerAddress": "4042 Hockaday Drive",
  "auctioneerCity": "Dallas",
  "auctioneerState": "TX",
  "auctioneerWebsite": "https://www.jenrosiedesigns.com/",
  "scrapedAt": "2026-08-20T15:19:20.386Z"
}
```

An archived lot that sold adds `priceRealized`, `priceRealizedPerEach`, `quantitySold` and `isSold`.

### Configure the run

| Setting | What it does |
| --- | --- |
| `mode` | `lots` (default), `auctions`, or `auctioneers`. |
| `searchText` | Keyword HiBid matches against lot titles and descriptions. |
| `archive` | Off searches live auctions. On searches the closed-lot archive, which is where hammer prices live. |
| `status` | `OPEN`, `CLOSING`, `CLOSED`, `HOT`, `TOP`, `FEATURED`, `ALL`. Leave it empty and it follows the archive switch. |
| `lotType` | Bidding format: online-only, webcast, absentee, biddable, or catalogue-only listing. |
| `category` | A category name or id. Validated against HiBid's live tree and rejected if unknown. |
| `lotUrls` | Fetch exact lots, skipping discovery. Full URL, `/lot/<id>` path, or bare numeric id. |
| `auctionIds` | Walk every lot in these auctions. The only way past the 10,000-result ceiling. |
| `state` / `countryName` | Two-letter state or province code; `United States` or `Canada`. |
| `zip` + `miles` | Search within a radius. Sort by **Nearest first** to also get `distanceMiles` back. |
| `shippingOffered` | Drops pickup-only sales. |
| `closedAfter` / `closedBefore` | Date window. **Archive only** — HiBid ignores it on a live search, and **requires both ends** in Auctions mode. |
| `sortBy` | 19 orders, from `NO_ORDER` (fastest) to price, bid count, views, watches and time left. |
| `maxItems` | Ceiling on rows written. Not a target — a narrow filter returns fewer. |
| `proxyConfiguration` | Off by default. HiBid answers plain requests; turn it on only if you get rate-limited. |

#### Narrow the run without paying for the rejects

These eight run inside the Actor, after HiBid answers but **before the row is written**, so a rejected lot costs you nothing.

| Filter | What it keeps |
| --- | --- |
| `minCurrentBid` / `maxCurrentBid` | Lots inside a price band. Uses the realized price when the lot has sold, otherwise the current high bid. |
| `minBidCount` | Lots that already drew at least N bids. |
| `onlyWithBids` | Drops lots nobody has bid on. |
| `onlyWithRealizedPrice` | Keeps only lots with a hammer price. Pair with `archive` for a clean comp set. |
| `onlyWithImages` | Drops lots with no photo. |
| `onlyReserveMet` | Keeps lots that will actually sell at the current bid. |
| `excludeKeywords` | Drops lots whose title or description contains any of your words, e.g. `replica`, `parts only`. |

#### What every row carries, always

These come with the base row. They are not optional, not separately billed, and not something you have to tick.

| Group | Fields |
| --- | --- |
| The lot | `lotId`, `lotUrl`, `title`, `lotNumber`, `itemId`, `saleOrder`, `ringNumber`, `quantity` |
| Price now | `currentBid`, `nextMinimumBid`, `openingBid`, `bidIncrement`, `bidCount`, `reserveMet`, `isSealedBid`, `estimateLow`, `estimateHigh` |
| Timing | `status`, `timeLeft`, `timeLeftSeconds`, `softCloseMinutes`, `isClosed`, `isArchived`, `isLive` |
| Lead photo | `imageUrl`, `thumbnailUrl`, `imageCount` |
| The auction | `auctionId`, `auctionUrl`, `auctionName`, `auctionCity`, `auctionState`, `auctionZip`, `bidType`, `currency`, `buyerPremium`, `buyerPremiumPercent`, `bidOpenDateTime`, `bidCloseDateTime`, `auctionStatus`, `auctionLotCount`, `shippingType` |
| The auction house | `auctioneerId`, `auctioneerName` |
| Shipping | `shippingOffered`, `freightQuoteUrl`, `distanceMiles` |

That is **47 fields on a default lot row** — enough to price, rank and locate a lot on its own. In Auction houses mode the directory entry *is* the base row, contact details included.

#### Optional blocks, each behind its own checkbox

Every block below is **off by default**. A block you do not tick is never fetched, never delivered and never charged — the row is trimmed before it is written, and the bill is read off the trimmed row, so the two cannot drift apart.

| Tick this | You get | Billed as | Extra requests |
| --- | --- | --- | --- |
| `includeDescription` | `description` | `description-text` | None, it rides along with the search |
| `includeCategory` | `categoryId`, `categoryName`, `categoryPath`, `categoryUrl`, `categoryBreadcrumb` | `category-path` | One per lot |
| `includeAllImages` | `images` — every photo, not just the lead one | `image-set` | One per lot, shared with the category block |
| `includeBidHistory` | `bidHistory`, `bidHistoryCount`, `uniqueBidders`, `firstBidAt`, `lastBidAt`, `bidCurrency` | `bid-history` | One per lot |
| `includeRealizedPrice` | `priceRealized`, `priceRealizedPerEach`, `priceRealizedMessage`, `quantitySold`, `isSold` | `realized-price` | None, it rides along with the search |
| `includeAuctionTerms` | `termsAndConditions`, `paymentInfo`, `shippingAndPickupInfo`, `checkoutDateInfo`, `previewDateInfo`, `bidIncrements`, `cardsAccepted`, `registrationType`, `buyerPremiumRate`, `holdAmount`, `bidAmountType` | `auction-detail` | One per **auction**, cached across its lots |
| `includeAuctioneerContact` | `auctioneerPhone`, `auctioneerEmail`, `auctioneerAddress`, `auctioneerCity`, `auctioneerState`, `auctioneerPostalCode`, `auctioneerCountry`, `auctioneerWebsite` | `auctioneer-contact` | Shares its request with the auction terms block |

#### You can filter on a block without buying it

Filters run against the **complete** row, before anything is trimmed away. That ordering is deliberate and it is worth money:

- `onlyWithRealizedPrice` gives you only lots that actually sold — without ticking `includeRealizedPrice`, so you pay for neither the blanks nor the price column.
- `minCurrentBid` / `maxCurrentBid` compare against the realized price when a lot has one, again without buying it.
- `excludeKeywords` reads the description to throw out `replica` or `parts only` lots, without buying `includeDescription`.

#### What HiBid will not do, and what the Actor does about it

These are limits of HiBid's own endpoint, measured 20/08/2026. The Actor handles each one rather than letting you discover it as an empty dataset.

**A keyword search stops at 10,000 lots.** HiBid caps it, and the Actor logs when you hit it. To go deeper, run in Auctions mode first, collect the `auctionId` values you care about, then feed them to `auctionIds` — a scoped walk has no such cap and pulls 500 lots per request instead of 100.

**The date window only works on the archive.** On a live search HiBid accepts `closedAfter`/`closedBefore` and ignores them, returning everything. The Actor warns you when you set a date window without `archive`.

**Archived auctions need both ends of the date window.** Ask HiBid for archived auctions with only one date and it answers 400; ask with no dates at all and it spends 20 seconds before returning a gateway timeout. The Actor checks up front and tells you, instead of retrying into the same wall.

**Archived auctions cannot be searched by keyword or category.** HiBid accepts `searchText` and `category` on that query and ignores them — a nonsense keyword returned the same 4,716 auctions as no keyword. The Actor warns you, and you should use `mode: lots` with `archive` on, where both filters genuinely work.

**Status and archive contradict each other.** `status: OPEN` against the archive returns 161 lots out of 10,000, and zero auctions. Leave `status` empty and the Actor picks `OPEN` for live and `CLOSED` for the archive.

### Pricing

This Actor is **pay per event**. You are charged for what a run actually delivers, never for rows a filter rejected, and never for a block you did not tick.

**Two events fire on a default run:**

| Event | Price | When it fires |
| --- | --- | --- |
| `result-item` | $0.007 | One row written to the dataset. |
| `search-page` | $0.01 | One page of results read from HiBid — up to 100 rows, or 500 when walking a single auction or the directory. Shared across every row that page yields. |
| `apify-actor-start` | $0.02 | Once when the run starts, per GB of memory. The Actor runs at 512 MB, so this is exactly one event. |

**Everything else is opt-in and only bills when you tick its box:**

| Event | Price | Turned on by |
| --- | --- | --- |
| `description-text` | $0.001 | `includeDescription` |
| `category-path` | $0.002 | `includeCategory` |
| `image-set` | $0.002 | `includeAllImages`, and only when the lot has more than one photo |
| `bid-history` | $0.005 | `includeBidHistory`, and only when the lot actually had bids |
| `realized-price` | $0.003 | `includeRealizedPrice`, and only when the lot carries a hammer price |
| `auction-detail` | $0.003 | `includeAuctionTerms` |
| `auctioneer-contact` | $0.003 | `includeAuctioneerContact` |

**What a run actually costs.** A default run is **$7.10 per 1,000 rows** — $7.00 of results plus a dime of pagination — and the $0.02 start fee once per run on top. A measured 500-row run billed $3.57, or $7.14 per 1,000 with the start fee included. Tick everything and a fully loaded row costs **$26 per 1,000**, and that is three extra requests per lot doing real work.

We are more expensive per row than every other HiBid Actor on the Store, and deliberately so: the two competitors that publish a price charge $5 per 1,000 for roughly a dozen fields, and none of them return the bid ledger, the hammer price, the auction terms or the contact block at any price. If you only need a lot title and a current bid, buy the cheaper one.

### Free users

Apify free-plan runs are capped at **100 rows per run**. Everything else works the same: all 110 fields, all 23 controls, all three modes. Upgrade your Apify plan to lift the cap.

### Run it

1. Open the Actor in Apify Console, pick a `mode`, and set a `searchText`, a `category`, or a `state`.
2. Set `maxItems` to the number of rows you want.
3. Click **Start**, then export the dataset as CSV, JSON, Excel, or XML.

Or from the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/parseforge~hibid-scraper/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"lots","searchText":"john deere","archive":true,"status":"CLOSED","onlyWithRealizedPrice":true,"closedAfter":"2026-01-01","maxItems":500}'
```

### Use with AI agents (MCP)

The Actor is exposed over Apify's MCP server, so an agent can call it as a tool:

```
https://mcp.apify.com/sse?actors=parseforge/hibid-scraper
```

Ask things like *"what did John Deere tractors sell for on HiBid this year"* and the agent fills the input itself.

### Troubleshooting

**No rows came back.**

The filters are ANDed. A keyword plus a category plus a price band plus a state can genuinely match nothing. Drop one filter at a time. If you are looking for closed lots, remember they live in the archive — set `archive` to true.

**Fewer rows than `maxItems`.**

`maxItems` is a ceiling, not a target. A keyword search also stops at HiBid's own 10,000-result cap, and the in-Actor filters remove rows after HiBid answers. The log prints how many HiBid reported and how many were written.

**`priceRealized` is missing on archived lots.**

Auction houses upload hammer prices voluntarily and most either upload for a whole sale or not at all — measured over 4,000 archived lots across 95 auctions, 48% of lots carried a price and 81% of auctions were all-or-nothing. `priceRealizedMessage` tells you which case you hit, usually "Price Realized Not Uploaded". Use `onlyWithRealizedPrice` and you never pay for the blanks — and note the filter works whether or not you ticked `includeRealizedPrice`, because filters run before the row is trimmed.

**`bidHistory` is missing.**

Either you did not tick `includeBidHistory` — it is off by default, like every optional block — or the lot has no bids yet. Around a third of open lots are in that state; add `onlyWithBids` to skip them.

**A column I expected is not in the output.**

Check the optional-blocks table above. Seven blocks are off by default and each has its own checkbox. The base row is 47 fields; anything outside it has to be ticked.

**`distanceMiles` is missing.**

HiBid only computes it when the search is sorted by distance. Set `sortBy` to **Nearest first** along with `zip` and `miles`.

**`buyerPremiumRate` is missing but `buyerPremium` says 15%.**

HiBid only fills its numeric rate field when it chooses to publish it — measured on 1 of 18 live auctions. The Actor parses the percentage out of the text into `buyerPremiumPercent` instead, which fills on about two thirds of auctions.

**The category filter returned everything.**

It cannot, from this Actor — an unknown category is rejected before the run starts, precisely because HiBid itself would ignore it and bill you for the whole catalogue.

**Auctions mode with the archive returned nothing, or an error about dates.**

HiBid needs both `closedAfter` and `closedBefore` to search archived auctions, and it ignores `searchText` and `category` on that query. For a keyword or category search across closed sales, use `mode: lots` with `archive` on.

**I set a date and got a 400 from HiBid.**

You should not — the Actor normalises `2026-08-01` into the full timestamp HiBid's API requires before sending it. If you still see this, send us the run ID.

**A field stopped filling.**

HiBid changed its GraphQL schema. Email us with your run ID so we can update the query.

### FAQ

| Question | Answer |
| --- | --- |
| Do I need a HiBid account or API key? | No. This reads HiBid's public GraphQL endpoint, which answers anonymous callers. There is nothing to register or authenticate. |
| Does it need a proxy? | No. It runs proxy-free by default. A 25-request burst was answered 25/25 with no proxy and no challenge. |
| Does it cover Canada? | Yes. Set `countryName` to `Canada`, or filter by province in `state`. |
| How far back does the archive go? | Years. A 2020 date window returns rows; the practical limit is what the auction house left online. |
| Are bidder names real? | Partly. HiBid masks most handles itself before publishing them. `bidderMasked` marks which rows are masked, and the amounts and timestamps are always real. |
| Can I fetch one specific lot? | Yes. Put its URL or numeric id in `lotUrls`. |
| Can I get every lot in one auction? | Yes. Put the auction URL or id in `auctionIds`. That path has no 10,000-row ceiling. |
| How many rows per run? | Free plan: 100. Paid: bounded by your filters, the 10,000 search cap, and the run timeout. A whole-auction walk returned 10,227 rows. |
| How fast is it? | 10,000 plain lot rows in about 3 minutes. Full enrichment is four requests per lot, so budget accordingly. |
| Can I avoid the extra charges entirely? | Yes. Every optional block is off by default. A run left alone bills `result-item`, `search-page` and the actor start, nothing else. |
| Why is it pricier than the other HiBid scrapers? | 47 fields on the base row against roughly a dozen, plus a bid ledger, hammer prices, auction terms and contact details that none of them return at any price. |
| Is this an official HiBid product? | No. It is unofficial and reads only publicly available HiBid data. |

### Related actors

- [Bring a Trailer Auctions Scraper](https://apify.com/parseforge/bringatrailer-auctions-scraper?fpr=vmoqkp): collector-car auctions with sold prices and comments.
- [GovDeals Auction Results Scraper](https://apify.com/parseforge/govdeals-scraper?fpr=vmoqkp): government surplus auction results.
- [Ritchie Bros Auctioneers Scraper](https://apify.com/parseforge/ritchie-bros-auctioneers-scraper?fpr=vmoqkp): heavy equipment auction listings and results.
- [LiveAuctioneers Scraper](https://apify.com/parseforge/liveauctioneers-scraper?fpr=vmoqkp): fine art and antiques lots with estimates.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by HiBid, Auction Flex, or their owners. It collects only publicly available HiBid data — auction listings, lot catalogues and the auction-house directory that HiBid publishes openly. Bidder handles are collected only as HiBid itself publishes them, already masked in most cases. You are responsible for using the data in compliance with HiBid's terms and applicable laws. Do not use this data to identify, profile, or target individual bidders.

# Actor input Schema

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

Lots returns one row per item. Auctions returns one row per sale event. Auction houses returns HiBid's company directory with contact details.

## `searchText` (type: `string`):

Keyword matched by HiBid against lot titles and descriptions, for example "john deere" or "rolex". Leave empty to take everything the other filters allow.

## `archive` (type: `boolean`):

Off searches live auctions. On searches HiBid's archive of closed lots, which is where realized prices live. The date window below only applies when this is on.

## `status` (type: `string`):

Leave empty and it follows the archive switch: open lots on a live search, closed lots in the archive. OPEN is currently biddable, CLOSING is ending soon, CLOSED is finished. HOT, TOP and FEATURED are HiBid's own promoted sets. Setting OPEN together with the archive returns almost nothing, because the two contradict each other.

## `lotType` (type: `string`):

ONLINE is internet-only bidding, WEBCAST is a live-streamed sale, ABSENTEE takes bids ahead of a floor auction, LISTING is catalogue-only with no online bidding.

## `category` (type: `string`):

A HiBid category name or numeric id, for example "Coins & Currency", "Men's Watches" or 40265. Matched against HiBid's live category tree (18 top-level categories, hundreds of subcategories) and rejected if unknown, because HiBid silently ignores an unknown id and returns everything.

## `lotUrls` (type: `array`):

Fetch these lots and skip discovery entirely. Accepts a full https://hibid.com/lot/<id> URL or a bare numeric lot id.

## `auctionIds` (type: `array`):

Walk every lot in these auctions. Accepts a https://hibid.com/auction/<id> URL or a bare id. This is the only way past HiBid's 10,000-result ceiling on an open search.

## `auctioneerName` (type: `string`):

Only used in Auction houses mode. Partial names match.

## `state` (type: `string`):

Two-letter code, for example TX, CA or ON. Matched against the auction's location, not the bidder's.

## `countryName` (type: `string`):

Full country name as HiBid writes it: "United States" or "Canada".

## `zip` (type: `string`):

US ZIP or Canadian postal code to measure distance from. Pair it with the radius below.

## `miles` (type: `integer`):

How far from the ZIP code to search. Only works together with a ZIP code. To get the distance back as a field, sort by "Nearest first" — HiBid only computes it for that sort.

## `shippingOffered` (type: `boolean`):

Keeps only lots whose auction offers shipping, dropping pickup-only sales.

## `closedAfter` (type: `string`):

ISO date, for example 2026-01-01. Archive only — HiBid ignores this on a live search.

## `closedBefore` (type: `string`):

ISO date, for example 2026-08-01. Archive only — HiBid ignores this on a live search.

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

Keeps lots at or above this amount. Compares the realized price when the lot has sold, otherwise the current high bid.

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

Keeps lots at or below this amount, using the same price as the minimum.

## `minBidCount` (type: `integer`):

Keeps only lots that already attracted at least this many bids.

## `onlyWithBids` (type: `boolean`):

Drops lots nobody has bid on yet.

## `onlyWithRealizedPrice` (type: `boolean`):

Keeps only lots whose hammer price the auctioneer uploaded. Use with the archive for a clean sold-price comp set.

## `onlyWithImages` (type: `boolean`):

Drops lots that carry no picture.

## `onlyReserveMet` (type: `boolean`):

Keeps lots that will actually sell at the current bid.

## `excludeKeywords` (type: `array`):

Drops a lot when its title or description contains any of these, for example "replica", "parts only", "damaged".

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

The seller's description text for the lot. Comes back with the search, so it costs no extra request.

## `includeCategory` (type: `boolean`):

Category id, name, full path, category URL and the root-to-leaf breadcrumb. Costs one extra request per lot.

## `includeAllImages` (type: `boolean`):

The complete list of photo URLs instead of just the lead image already in the base row. Costs one extra request per lot, shared with the category block.

## `includeBidHistory` (type: `boolean`):

HiBid's public bid ledger: every bid amount and timestamp, plus unique bidders and first and last bid times. Costs one extra request per lot.

## `includeRealizedPrice` (type: `boolean`):

The hammer price an archived lot sold for, with quantity sold and price per each. Comes back with the search, so it costs no extra request. Around half of archived lots carry one.

## `includeAuctionTerms` (type: `boolean`):

Terms and conditions, payment info, shipping and pickup info, the bid increment table, accepted cards and the registration type. Costs one extra request per auction, cached across every lot in it.

## `includeAuctioneerContact` (type: `boolean`):

The auction house phone, email, postal address and website. Costs one extra request per auction, shared with the auction terms block.

## `sortBy` (type: `string`):

How HiBid orders results before the Actor takes them. NO\_ORDER is fastest. In Auctions mode only NO\_ORDER and DISTANCE\_NEAREST apply.

## `sortDirection` (type: `string`):

Descending or ascending, applied to the sort order above. For "Nearest first" use ascending to get the closest lots.

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

Ceiling on rows written. Not a target: a narrow filter returns fewer. Free Apify plans are capped at 100.

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

Off by default. HiBid answers plain anonymous requests, so a proxy costs money without adding anything. Turn it on only if your runs start getting rate-limited.

## Actor input object example

```json
{
  "mode": "lots",
  "searchText": "rolex",
  "archive": false,
  "lotType": "ALL",
  "shippingOffered": false,
  "onlyWithBids": false,
  "onlyWithRealizedPrice": false,
  "onlyWithImages": false,
  "onlyReserveMet": false,
  "includeDescription": false,
  "includeCategory": false,
  "includeAllImages": false,
  "includeBidHistory": false,
  "includeRealizedPrice": false,
  "includeAuctionTerms": false,
  "includeAuctioneerContact": false,
  "sortBy": "NO_ORDER",
  "sortDirection": "DESC",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `lots` (type: `string`):

Every row this run saved.

# 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": "lots",
    "searchText": "rolex",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hibid-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": "lots",
    "searchText": "rolex",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hibid-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": "lots",
  "searchText": "rolex",
  "maxItems": 100
}' |
apify call parseforge/hibid-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/hibid-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/KKPcD4wwAvwPBvWuQ/builds/ljMCjkZY5oUeCipy8/openapi.json