# HiBid Scraper (`crawlerbros/hibid-scraper`) Actor

Scrape HiBid.com - the #1 live/timed online auction aggregator for grassroots US & Canada farm, equipment, estate, and antiques auctions from thousands of independent auctioneers. Search or browse lots and auctions by category, state, status, and keyword.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## HiBid Scraper

Scrape [HiBid.com](https://hibid.com) — the leading live and timed online auction aggregator for grassroots farm, equipment, estate, and antiques auctions across the US and Canada. Thousands of independent auctioneers list lots on HiBid every day; this actor lets you search or browse those lots and auctions by keyword, category, state/province, status, and more — no login required.

### What this actor does

- **Five modes:** search/browse lots, search/browse auctions, look up specific lots or auctions by ID, and search auctioneers (auction houses)
- **Real HiBid taxonomy:** all 17 top-level categories (Antiques & Collectibles, Cars & Vehicles, Construction & Farm, Real Estate, etc.)
- **Location filters:** any US state/territory or Canadian province, plus optional ZIP + radius search
- **Status filters:** hot, top, closing soon, featured, open, closed
- **Auction-type filters:** online-only, biddable, absentee, webcast, listing-only
- **19 sort orders** for lot results — ending soonest, most bids, highest bid, newly added, and more
- **No login, no cookies, no paid proxy required** — HiBid's browse/search catalog is fully public; only placing a bid requires an account
- Empty fields are omitted from every record

### Output fields

#### Lots (`mode=lots` / `lotDetails`)

| Field | Description |
|---|---|
| `lotId`, `lotNumber` | Lot identifiers |
| `title`, `description` | Item title and full description |
| `category`, `topCategory`, `categoryPath` | Leaf category, top-level category, full breadcrumb |
| `currentBid`, `startingBid`, `bidCount` | Bidding status |
| `buyNowPrice` | Buy-it-now price, if offered |
| `status` | `OPEN`, `CLOSED`, `LIVE`, `SOLD`, etc. |
| `timeLeft`, `timeLeftSeconds` | Time remaining until close |
| `reserveSatisfied` | Whether the reserve price has been met |
| `quantity`, `pictureCount` | Item quantity and photo count |
| `shippingOffered` | Whether the auctioneer offers shipping |
| `imageUrl`, `thumbnailUrl`, `images[]` | Photo URLs |
| `auctionId`, `auctionTitle` | Parent auction |
| `auctioneerName`, `auctioneerId` | Auction house |
| `eventCity`, `eventState`, `eventZip`, `currency` | Location & currency |
| `distanceMiles` | Distance from the given ZIP, if a radius search was used |
| `sourceUrl` | Canonical `hibid.com/lot/...` page |
| `recordType: "lot"`, `scrapedAt` | |

#### Auctions (`mode=auctions` / `auctionDetails`)

| Field | Description |
|---|---|
| `auctionId`, `title`, `description` | Auction identifiers |
| `auctioneerName`, `auctioneerId` | Auction house |
| `eventAddress`, `eventCity`, `eventState`, `eventZip` | Location |
| `eventDateBegin`, `eventDateEnd`, `bidOpenDateTime`, `bidCloseDateTime` | Schedule |
| `lotCount`, `openLotCount`, `matchingLotCount` | Lot counts |
| `bidType`, `auctionStatus` | Bidding format and live status |
| `buyerPremium`, `currency` | Terms |
| `shippingOffered`, `shippingType`, `isWebcast`, `isBiddable` | Format flags |
| `imageUrl`, `thumbnailUrl` | Featured photo |
| `distanceMiles` | Distance from the given ZIP, if a radius search was used |
| `sourceUrl` | Canonical `hibid.com/auction/...` page |
| `recordType: "auction"`, `scrapedAt` | |

#### Auctioneers (`mode=auctioneers`)

| Field | Description |
|---|---|
| `auctioneerId`, `name` | Auction house identifier and name |
| `address`, `city`, `state`, `postalCode`, `country` | Location |
| `sourceUrl` | Canonical `hibid.com/auctioneer/...` page |
| `recordType: "auctioneer"`, `scrapedAt` | |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `lots` | `lots` / `auctions` / `lotDetails` / `auctionDetails` / `auctioneers` |
| `searchText` | string | `tractor` | Keyword search (mode=lots/auctions) |
| `category` | select | Any | One of the 17 HiBid top-level categories (mode=lots/auctions) |
| `state` | select | Any | US state/territory or Canadian province (mode=lots/auctions/auctioneers) |
| `status` | select | `ALL` | `ALL` / `HOT` / `TOP` / `CLOSING` / `FEATURED` / `OPEN` / `CLOSED` |
| `auctionType` | select | `ALL` | `ALL` / `ONLINE` / `BIDDABLE` / `ABSENTEE` / `WEBCAST` / `LISTING` |
| `sortOrder` | select | `LOT_NUMBER` | Sort order for lot results (mode=lots only) |
| `auctionIds` | array | – | Scope lot search to one auction (mode=lots), or look up auctions (mode=auctionDetails) |
| `lotIds` | array | – | Look up specific lots by ID (mode=lotDetails) |
| `auctioneerName` | string | – | Filter auctioneers by name (mode=auctioneers) |
| `zipCode` | string | – | Center point for a distance search |
| `milesRadius` | integer | `50` | Radius in miles (used with `zipCode`) |
| `shippingOfferedOnly` | boolean | `false` | Only include lots/auctions offering shipping |
| `includeEnded` | boolean | `false` | Include closed/ended auctions and lots |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–2000) |
| `proxyConfiguration` | proxy | AUTO | Optional; HiBid's catalog works without any proxy |

#### Example: browse open farm & construction equipment in Texas

```json
{
  "mode": "lots",
  "category": "700008",
  "state": "TX",
  "status": "OPEN",
  "sortOrder": "TIME_LEFT",
  "maxItems": 100
}
````

#### Example: search auctions closing soon near a ZIP code

```json
{
  "mode": "auctions",
  "searchText": "estate",
  "zipCode": "90210",
  "milesRadius": 100,
  "status": "CLOSING",
  "maxItems": 50
}
```

#### Example: look up specific lots by ID

```json
{
  "mode": "lotDetails",
  "lotIds": ["309402453", "309009599"]
}
```

### Use cases

- **Auction aggregation** — build a cross-auctioneer feed of open farm/equipment/estate lots
- **Price research** — track current bids and closing prices for a category over time
- **Regional market monitoring** — watch a specific state or ZIP radius for new listings
- **Auctioneer directory** — build a directory of auction houses by region
- **Deal alerts** — surface hot/closing-soon lots in a category you care about
- **Resale sourcing** — find equipment or antiques below market value across thousands of small auctioneers

### FAQ

**Do I need a HiBid account or cookies?** No. Browsing and searching auctions/lots is fully public. HiBid only requires an account to register and place bids — this actor does not place bids and does not require any credentials.

**Does this cover Canada too?** Yes — the `state` filter includes both US states/territories and Canadian provinces, matching HiBid's own coverage. A handful of lots also come from other countries, but the marketplace is overwhelmingly US/Canada.

**What are the 17 categories?** Antiques & Collectibles, Art, Cars & Vehicles, Coins & Currency, Business & Industrial, Construction & Farm, Computers & Electronics, Fashion, Furniture, Home Goods & Decor, Jewelry/Watches & Gemstones, Lawn & Garden, Real Estate, Sporting Goods, Boats & Aviation, Kid & Baby Essentials, Toys — the same categories shown on hibid.com.

**What does `status` mean?** `HOT`, `TOP`, `CLOSING`, and `FEATURED` are HiBid's own curated lists (most active, most bids/views, ending soonest, and staff-picked). `OPEN` and `CLOSED` filter by whether bidding is currently active. `ALL` applies no status filter.

**Why is `category` sometimes inconsistent with the item title?** Category tagging is set by each independent auctioneer at listing time; HiBid does not enforce or re-verify it. Occasionally an auctioneer mis-tags a lot (e.g. tagging an entire batch under one category). The actor reports HiBid's own category data as-is.

**Can I get lots for one specific auction?** Yes — set `mode=lots` and pass the auction's ID in `auctionIds` (first ID is used to scope the search), or use `mode=auctionDetails` to fetch the auction itself.

**Are there missing fields for lots that already sold?** Some real-time-only fields (like `timeLeft`) become historical/stale once a lot closes; the actor still returns whatever HiBid's API reports for closed lots. Set `includeEnded: true` to include them.

**How fresh is the data?** Live — every request hits HiBid's own search API directly, so results reflect current bids and listings at the moment the actor runs.

**Why did an unfiltered `status=CLOSED` + `includeEnded=true` search return no results?** HiBid's closed/ended archive spans over a million lots. A search with no `category`, `state`, or `searchText` to narrow it can occasionally time out on HiBid's own server. Add a category, state, or keyword to scope the query — narrowed archive searches (e.g. `searchText` + `status=CLOSED`) work reliably.

### Data Source / Limitations

- All data comes directly from HiBid's public browse/search API — no login, cookies, or paid proxy are required to view auctions, lots, or auctioneer listings.
- Placing a bid requires a HiBid account; this actor only reads public listing data and never bids.
- Very broad, unfiltered queries against the closed/ended archive (`includeEnded: true` with no category/state/keyword) can occasionally time out upstream given the archive's size — narrow with `category`, `state`, or `searchText` for reliable results.
- Category tagging reflects each auctioneer's own listing choices and is not independently verified by HiBid or this actor.

# Actor input Schema

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

What to fetch.

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

Free-text keyword search (mode=lots/auctions). Searches titles and descriptions.

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

Filter by top-level HiBid category (mode=lots/auctions).

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

Filter to auctions/lots located in a specific US state or Canadian province (mode=lots/auctions/auctioneers).

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

Filter by curated status (mode=lots/auctions).

## `auctionType` (type: `string`):

Filter by bidding format (mode=lots/auctions).

## `sortOrder` (type: `string`):

Sort order for lot results (mode=lots only).

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

Scope lot search to one auction (mode=lots, first ID used), or look up full auction details (mode=auctionDetails, all IDs used). Find IDs in HiBid auction URLs, e.g. `hibid.com/auction/755763/...` → `755763`.

## `lotIds` (type: `array`):

Look up specific lots by ID (mode=lotDetails). Find IDs in HiBid lot URLs, e.g. `hibid.com/lot/307654532/...` → `307654532`.

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

Filter auctioneers/auction houses by name (mode=auctioneers).

## `zipCode` (type: `string`):

Center point for a distance radius search (mode=lots/auctions). Use with `milesRadius`.

## `milesRadius` (type: `integer`):

Only include auctions/lots within this many miles of `zipCode`. Ignored if `zipCode` is empty.

## `shippingOfferedOnly` (type: `boolean`):

Only include lots/auctions where the auctioneer offers shipping (mode=lots/auctions).

## `includeEnded` (type: `boolean`):

Include closed/ended auctions and lots instead of only currently open ones (mode=lots/auctions).

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

Hard cap on emitted records.

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

HiBid's browse/search API works without any proxy from most datacenter IPs. Leave AUTO on for resilience; no paid proxy group is required.

## Actor input object example

```json
{
  "mode": "lots",
  "searchText": "tractor",
  "category": "",
  "state": "",
  "status": "ALL",
  "auctionType": "ALL",
  "sortOrder": "LOT_NUMBER",
  "auctionIds": [],
  "lotIds": [],
  "milesRadius": 50,
  "shippingOfferedOnly": false,
  "includeEnded": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped HiBid lots / auctions / auctioneers.

# 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": "tractor",
    "category": "",
    "state": "",
    "status": "ALL",
    "auctionType": "ALL",
    "sortOrder": "LOT_NUMBER",
    "auctionIds": [],
    "lotIds": [],
    "milesRadius": 50,
    "shippingOfferedOnly": false,
    "includeEnded": false,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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": "tractor",
    "category": "",
    "state": "",
    "status": "ALL",
    "auctionType": "ALL",
    "sortOrder": "LOT_NUMBER",
    "auctionIds": [],
    "lotIds": [],
    "milesRadius": 50,
    "shippingOfferedOnly": False,
    "includeEnded": False,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/hibid-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "tractor",
  "category": "",
  "state": "",
  "status": "ALL",
  "auctionType": "ALL",
  "sortOrder": "LOT_NUMBER",
  "auctionIds": [],
  "lotIds": [],
  "milesRadius": 50,
  "shippingOfferedOnly": false,
  "includeEnded": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/hibid-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/hibid-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HiBid Scraper",
        "description": "Scrape HiBid.com - the #1 live/timed online auction aggregator for grassroots US & Canada farm, equipment, estate, and antiques auctions from thousands of independent auctioneers. Search or browse lots and auctions by category, state, status, and keyword.",
        "version": "1.0",
        "x-build-id": "veYlcwjm0iyu2du3s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~hibid-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-hibid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~hibid-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-hibid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~hibid-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-hibid-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "lots",
                            "auctions",
                            "lotDetails",
                            "auctionDetails",
                            "auctioneers"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "lots"
                    },
                    "searchText": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword search (mode=lots/auctions). Searches titles and descriptions.",
                        "default": "tractor"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "700001",
                            "40089",
                            "700006",
                            "40118",
                            "700009",
                            "700008",
                            "40196",
                            "40111",
                            "40237",
                            "700004",
                            "40252",
                            "700003",
                            "40060",
                            "700002",
                            "700007",
                            "40391",
                            "40359"
                        ],
                        "type": "string",
                        "description": "Filter by top-level HiBid category (mode=lots/auctions).",
                        "default": ""
                    },
                    "state": {
                        "title": "State / Province",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AB",
                            "AS",
                            "AZ",
                            "AR",
                            "AA",
                            "AE",
                            "AP",
                            "BC",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "DC",
                            "FM",
                            "FL",
                            "GA",
                            "GU",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MB",
                            "MH",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NB",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NL",
                            "NC",
                            "ND",
                            "MP",
                            "NT",
                            "NS",
                            "NU",
                            "OH",
                            "OK",
                            "ON",
                            "OR",
                            "PW",
                            "PA",
                            "PE",
                            "PR",
                            "QC",
                            "RI",
                            "SK",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VI",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "YT"
                        ],
                        "type": "string",
                        "description": "Filter to auctions/lots located in a specific US state or Canadian province (mode=lots/auctions/auctioneers).",
                        "default": ""
                    },
                    "status": {
                        "title": "Auction/lot status",
                        "enum": [
                            "ALL",
                            "HOT",
                            "TOP",
                            "CLOSING",
                            "FEATURED",
                            "OPEN",
                            "CLOSED"
                        ],
                        "type": "string",
                        "description": "Filter by curated status (mode=lots/auctions).",
                        "default": "ALL"
                    },
                    "auctionType": {
                        "title": "Auction type",
                        "enum": [
                            "ALL",
                            "ONLINE",
                            "BIDDABLE",
                            "ABSENTEE",
                            "WEBCAST",
                            "LISTING"
                        ],
                        "type": "string",
                        "description": "Filter by bidding format (mode=lots/auctions).",
                        "default": "ALL"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "LOT_NUMBER",
                            "TIME_LEFT",
                            "NEWLY_ADDED",
                            "HOT_RANK",
                            "BID_COUNT_HIGH_TO_LOW",
                            "BID_COUNT_LOW_TO_HIGH",
                            "MAX_BID_HIGH_TO_LOW",
                            "MAX_BID_LOW_TO_HIGH",
                            "BID_AMOUNT_HIGH_TO_LOW",
                            "BID_AMOUNT_LOW_TO_HIGH",
                            "LAST_BID",
                            "PENDING_BIDS",
                            "SALE_ORDER",
                            "VIEW_COUNT_HIGH_TO_LOW",
                            "VIEW_COUNT_LOW_TO_HIGH",
                            "WATCH_COUNT_HIGH_TO_LOW",
                            "WATCH_COUNT_LOW_TO_HIGH",
                            "DISTANCE_NEAREST",
                            "NO_ORDER"
                        ],
                        "type": "string",
                        "description": "Sort order for lot results (mode=lots only).",
                        "default": "LOT_NUMBER"
                    },
                    "auctionIds": {
                        "title": "Auction IDs (mode=lots/auctionDetails)",
                        "type": "array",
                        "description": "Scope lot search to one auction (mode=lots, first ID used), or look up full auction details (mode=auctionDetails, all IDs used). Find IDs in HiBid auction URLs, e.g. `hibid.com/auction/755763/...` → `755763`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lotIds": {
                        "title": "Lot IDs (mode=lotDetails)",
                        "type": "array",
                        "description": "Look up specific lots by ID (mode=lotDetails). Find IDs in HiBid lot URLs, e.g. `hibid.com/lot/307654532/...` → `307654532`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "auctioneerName": {
                        "title": "Auctioneer name",
                        "type": "string",
                        "description": "Filter auctioneers/auction houses by name (mode=auctioneers)."
                    },
                    "zipCode": {
                        "title": "ZIP / postal code",
                        "type": "string",
                        "description": "Center point for a distance radius search (mode=lots/auctions). Use with `milesRadius`."
                    },
                    "milesRadius": {
                        "title": "Distance radius (miles)",
                        "minimum": 1,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "Only include auctions/lots within this many miles of `zipCode`. Ignored if `zipCode` is empty.",
                        "default": 50
                    },
                    "shippingOfferedOnly": {
                        "title": "Shipping offered only",
                        "type": "boolean",
                        "description": "Only include lots/auctions where the auctioneer offers shipping (mode=lots/auctions).",
                        "default": false
                    },
                    "includeEnded": {
                        "title": "Include ended (archived)",
                        "type": "boolean",
                        "description": "Include closed/ended auctions and lots instead of only currently open ones (mode=lots/auctions).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "HiBid's browse/search API works without any proxy from most datacenter IPs. Leave AUTO on for resilience; no paid proxy group is required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
