# BigIron Auction Scraper - Live Lots & Sold Price Comps (`scrapersdelight/bigiron-lot-scraper`) Actor

From $4.50 per 1,000 rows, no start fee. Every BigIron and Sullivan lot: make, model, year, serial, current bid or the realized hammer price, bid count, winning bidder's state, sale date, plus the consignor's name, town, state and ZIP. 5,161 live lots and 799,266 sold lots, counted.

- **URL**: https://apify.com/scrapersdelight/bigiron-lot-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** E-commerce, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.50 / 1,000 per row returneds

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

## 🚜 BigIron Auction Scraper — Live Lots & Sold Price Comps

**Every lot on BigIron and Sullivan Auctioneers, live or already sold.** 5,161 lots are taking bids
right now; 799,266 have already sold and still carry the price they made. Each row gives you make,
model, year, category, the money, the sale it belongs to, and the consignor's name, town, state and
ZIP. No login, no API key. Export to CSV, JSON, Excel or XML.

Every number on this page was measured on 2026-09-18 by reading BigIron's own result counter through
an Apify datacenter proxy. Nothing here is an estimate.

| Who uses it | What they pull from BigIron |
|---|---|
| **Ag & construction dealers** | What is coming up in their territory this week, and what the same machine made last time it sold |
| **Ag lenders, insurers, appraisers** | Realized auction values by make, model, year and state — collateral marked to an actual sale, not a book |
| **Equipment-valuation SaaS** | 799,266 hammer prices with bid depth, sale date and location, the raw material for a price index |
| **Flippers and resellers** | Live bids against buy-it-now and minimum-offer prices, to spot lots still trading under market |
| **Parts recyclers & livestock traders** | Whole categories BigIron sells weekly — headers, tyres, shop equipment, pairs and bred cows |
| **Market analysts** | Regional supply, seller mix and where the winning bidders are coming from |

### What makes this one different

The one other BigIron scraper on the Apify Store reads the **open** feed only. This one reads both,
and the sold half is the product ag lenders and valuation tools actually pay for:

| | Here | The other BigIron actor |
|---|---|---|
| Live open lots | ✅ 5,161 | ✅ |
| **Sold lots with the realized hammer price** | ✅ **799,266** | ❌ |
| **Sale date and bid count on a sold lot** | ✅ | ❌ |
| **State the winning bidder bid from** | ✅ | ✅ (open lots only) |
| Consignor name, town, state, ZIP | ✅ | ✅ |
| BigIron's territory rep: name, direct phone, email | ✅ | ✅ |
| Full sale calendar back to 2014 | ✅ 1,942 sales | Upcoming only |
| Walks past BigIron's 100,000-row query ceiling | ✅ automatic, with the split proved exhaustive | ❌ |
| **Price** | **$4.50 per 1,000 rows, flat — every block included** | $5.04 per 1,000 rows base, rising to $13.84 with every block on, plus a run-start fee |
| Empty fields written as | `null` | the string `Not Disclosed` |

### 📦 What one row is

One row = one lot. It carries:

- 🚜 **Machine identity** — title, make, model, year, category and category slug, quantity and
  units, BigIron's lot id, tracking number and group id.
- 💰 **The money** — on a sold lot, `soldPriceUsd`, the price it actually made, plus `bids`,
  `leadingBidderState` and `soldAt`. On a live lot, `currentBidUsd`, `nextBidUsd`,
  `minimumOfferUsd`, `buyItNowUsd` and `secondsRemaining`. Plus the buyer's premium that applies.
- ⏱️ **Timing** — the exact closing time in UTC, seconds remaining, seconds until the lot opens.
- 🏷️ **The sale** — auction id, slug, URL and printed date, the sale-event label, the auctioneer and
  which brand is listing it (BigIron or Sullivan).
- 📍 **Where the machine is** — the consignor's name, and the town, state, state code and ZIP of the
  yard it sells from. Equipment sells where it stands and has to be inspected there, so BigIron
  publishes the location on every lot.
- 🖼️ **Optional blocks** — the full written description, the specification table with the serial
  number, every full-size photo, BigIron's own territory representative, the loading terms and the
  breadcrumb category path.

Two more row types are available through `outputs`: **auctions** (1,942 sales back to 2014, with
item counts, and closing times on the upcoming ones) and **filter values** (every string the filters
accept, with its live lot count).

#### A real sold row — lot LR2024, exactly as the verified run returned it

```json
{
  "rowType": "lot",
  "lotId": "691bcb3fa0174bd0ae87d6aef1a22d0a",
  "lotUrl": "https://www.bigiron.com/Lots/2023-john-deere-630f-hydraflex-platform-header",
  "trackingNumber": "LR2024",
  "title": "2023 John Deere 630F HydraFlex Platform Header",
  "make": "John Deere",
  "model": "630F HydraFlex",
  "year": "2023",
  "categoryName": "Combine-Headers-Platform-Head",
  "saleStatus": "Sold",
  "soldPriceUsd": 26250,
  "currentBidUsd": null,
  "bids": 28,
  "leadingBidderNumber": 58293,
  "leadingBidderState": "Texas",
  "buyersPremium": "10%, Max: $2,500",
  "soldAt": "2026-09-18T16:22:24.000Z",
  "auctionSlug": "Sep_18_2026_10A",
  "auctionDateText": "Sep 18, 2026",
  "auctioneer": "BigIron",
  "listingProvider": "BigIron",
  "sellerName": "Western Equipment LLC",
  "locationCity": "Guymon",
  "locationState": "Oklahoma",
  "locationStateCode": "OK",
  "locationZip": "73942-4557",
  "serialNumber": "1CQ0630AAN0145513",
  "repName": "Brian Reyes",
  "repTerritory": "Texas",
  "repPhone": "806-662-3528",
  "repEmail": "brian.reyes@bigiron.com",
  "consignorContactPublished": false
}
```

### 📊 Measured field fill — what is actually populated

Not a sample and not an estimate: these are two real runs on 2026-09-18, counted over every row
they delivered. BigIron does not fill every field on every lot, and a field it leaves empty is
written `null` — never a zero, never a placeholder string.

**Run A — the whole live catalogue, 5,000 rows**, no filters, no optional blocks. 200 requests,
44.8 MB, 5,000 rows delivered and 5,000 charged, zero duplicate lot ids across 100 pages.

| Field | Fill | Note |
|---|---|---|
| `lotId`, `title`, `lotUrl`, `lotSlug`, `trackingNumber` | 5,000/5,000 (100%) | |
| `sellerName` (the consignor) | 5,000/5,000 (100%) | a name; BigIron publishes no consignor phone or email |
| `locationCity`, `locationState`, `locationStateCode`, `locationZip` | 5,000/5,000 (100%) | the yard the machine sells from |
| `categoryName`, `auctionId`, `auctionSlug`, `auctioneer`, `closesAt`, `bids`, `sellingMode` | 5,000/5,000 (100%) | |
| `auctionDateText` | 4,970/5,000 (99%) | |
| `buyersPremium` | 4,953/5,000 (99%) | real-estate and some livestock lots carry none |
| `leadingBidderState` | 2,475/5,000 (50%) | a live lot only has one once bidding starts |
| `currentBidUsd` | 2,473/5,000 (49%) | ditto |
| `make` | 3,612/5,000 (72%) | livestock, pallet and mixed shop lots have no manufacturer |
| `model` | 2,451/5,000 (49%) | |
| `year` | 1,385/5,000 (28%) | |
| `buyItNowUsd` | 30/5,000 (1%) | only on make-an-offer lots |
| `minimumOfferUsd` | 22/5,000 (0.4%) | BigIron's reserve on make-an-offer lots |
| `soldPriceUsd` | 2/5,000 | two lots closed mid-run; on the sold feed it is 100% |

**Run B — sold comps with the specification block**: 2WD tractors sold in Nebraska, 200 rows.

| Field | Fill | Note |
|---|---|---|
| `soldPriceUsd` — the realized hammer price | **200/200 (100%)** | |
| `soldAt`, `bids`, `leadingBidderState` | 200/200 (100%) | sale date, bid depth, where the buyer bid from |
| `sellerName`, `locationCity`, `locationState`, `locationStateCode`, `locationZip` | 200/200 (100%) | |
| `make`, `description`, `photoUrls`, `industry` | 200/200 (100%) | |
| `model` | 199/200 (100%) | |
| `specifications` | 186/200 (93%) | the spec table, as a key/value object |
| `serialNumber` | 175/200 (88%) | |
| `year` | 173/200 (87%) | |
| `assetNumber` | 4/200 (2%) | BigIron rarely publishes the consignor's own asset number |

**The contact block**, measured on the two lot pages captured: one BigIron representative on a live
lot, two on a closed one, each with a name, a territory, a direct phone and a decoded
`@bigiron.com` email. On both, BigIron's Owner panel says the *consignor's* contact is not
available.

### ⚙️ Configure the run

Leave everything empty and it walks the open catalogue, closing-soonest first, and stops at
`maxItems`. Every filter below is one **BigIron applies on its own servers**, so rows your filters
exclude are never fetched and never billed. Values must match BigIron exactly — a near-miss returns
an empty page rather than an error, which is why the filter-value directory exists.

Every John Deere and Case IH lot open in Nebraska and Kansas:

```json
{ "saleStatus": "open", "makes": ["John Deere", "Case IH"], "states": ["NE", "KS"], "maxItems": 500 }
```

What 2WD tractors have actually been making in Nebraska — a comps table:

```json
{ "saleStatus": "sold", "categories": ["Tractors : Tractors 2WD"], "states": ["NE"],
  "years": ["2000 - 2004", "2005"], "maxItems": 2000 }
```

One complete sale's results, the cleanest way to pull a whole auction:

```json
{ "saleStatus": "sold", "auctions": ["Dec 07, 2022 - Equipment Auction"], "maxItems": 0 }
```

Combines within 150 miles of a yard, with the description, photos and BigIron's rep:

```json
{ "searchTerm": "combine", "zipCode": "68008", "distanceMiles": 150,
  "includeDescription": true, "includePhotos": true, "includeContact": true, "maxItems": 200 }
```

Get the exact strings the filters accept. A whole directory for one category runs to roughly 1,350
values across 14 panels, and each value is a billed row, so set `maxItems` to cover it:

```json
{ "outputs": ["facets"], "saleStatus": "sold", "categories": ["Tractors : Tractors 2WD"], "maxItems": 1400 }
```

| Input | What it does |
|---|---|
| `saleStatus` | `open` (5,161 live lots) or `sold` (799,266 completed sales with hammer prices) |
| `outputs` | `lots`, `auctions`, `facets` — pick any combination; `maxItems` is split evenly |
| `maxItems` | Row cap, which is also your spend cap. `0` = everything the filters match |
| `searchTerm`, `searchMode` | Free text over title and description, matched on all words / any word / exact phrase |
| `industries` | Agriculture, Construction, Transportation, Industrial, Livestock, RealEstate, CollectorCars, Other |
| `categories` | `"Parent : Child"`, e.g. `"Tractors : Tractors 2WD"` |
| `makes`, `models` | Manufacturer and model, exactly as BigIron writes them |
| `years` | Model-year **bands**: `"1990 - 1999"`, `"2006"`, `"< 1930"` |
| `engineHours`, `horsepowers`, `sizes` | BigIron's spec bands, e.g. `"500 - 999"`, `"100 - 149"` |
| `priceBuckets` | Price bands with the dollar signs: `"$10,000 - $19,999"`. Hammer price on the sold feed, current bid on the open one |
| `auctions` | Named sales: `"Dec 07, 2022 - Equipment Auction"` |
| `sellers` | Consignor names |
| `states`, `counties` | Two-letter codes or full names; counties without the word "County" |
| `zipCode` / `city` + `state` + `distanceMiles` | Radius search. A ZIP or city on its own does **not** filter — the radius is what makes it bite |
| `providers` | `BigIron`, `Sullivan`, or leave empty for both |
| `includeDescription`, `includeSpecifications`, `includePhotos` | One extra ~30 KB request per lot |
| `includeContact`, `includeTerms`, `includeCategoryPath` | Opens the full 250–280 KB lot page, which also fills everything above |
| `sortBy` | BigIron's own four orders: closing soonest/latest, state A–Z/Z–A |
| `concurrency`, `detailConcurrency`, `proxyConfiguration` | Plumbing |

### 💵 Pricing

Pay-per-event: **$0.0045 per row — $4.50 per 1,000 rows.** That is the whole bill. No run-start fee,
no per-page fee, no extra charge for the description, specification, photo or contact blocks. You
pay for rows written to your dataset and nothing else, so a run that matches nothing costs nothing.

| Rows | You pay |
|---|---|
| 100 | $0.45 |
| 1,000 | $4.50 |
| 10,000 | $45.00 |
| 100,000 | $450.00 |

The only other BigIron scraper on the Store charges $5.04 per 1,000 rows for a base row and $13.84
with every block on, plus a run-start fee. Flat, with everything included, this is **10.7% cheaper
on a base row and 67.5% cheaper** once you want the description, specifications, photos or the
contact block — and it is the only one that reads the sold feed at all.

New Apify accounts start with free credit. Free-plan runs return a preview; a paid plan lifts the
per-run row limit.

### 🔎 Honest limits

These are the things worth knowing before you run it, stated plainly.

**BigIron does not publish the consignor's phone or email.** The lot page says so in as many words:
*"Owner Contact information is not available. Click here to request details."* What a row carries is
the consignor's **name**, and the **town, state and ZIP** of the yard the machine sells from —
BigIron publishes those on every lot by marketplace convention, because equipment sells where it
stands and buyers have to inspect and collect it there. That is a convention, not a statutory
disclosure, and BigIron could change it. The only phone numbers on a lot belong to **BigIron**: its
corporate line (800-937-3558) and the named territory representative for that sale, which the
`repName` / `repPhone` / `repEmail` fields carry and label as exactly that. There is no field on
this row pretending to be a consignor phone, and `consignorContactPublished` is written on every
enriched row so you can see the answer rather than infer it from a null.

**No single query can page past 100,000 rows.** Measured: `page=2000` of the sold feed returns
"99,951 to 100,000 of 799,266", and page 2001 returns an empty pager. When your scope is larger than
that, the actor splits it by state and then by price band — but only after checking that the split's
own counts add up to the query total, which is what proves nothing is being dropped. If no
exhaustive split exists, it says so in `RUN_SUMMARY.windowCapped` with the exact number of lots left
out of reach, rather than quietly shipping a partial answer. To get the full 799,266 you walk it
sale by sale.

**A filter panel prints at most 200 values.** Makes, models, auctions, sizes, consignors and
counties each come back as a top-200 list, not a complete one — the facet rows say so in
`listTruncated`. States (43), price bands (17), year bands, engine-hour bands and horsepower bands
are complete.

**`make`, `model` and `year` are not universal.** Measured over the whole live catalogue: 72%, 49%
and 28% of 5,000 rows. Livestock lots, pallet lots and mixed shop-equipment lots genuinely have no
manufacturer, and that is written `null`. On a machine category the rates are far higher — 100%,
100% and 87% on the 200 2WD tractors in run B.

**Live figures are read at fetch time.** The bid, bid count and seconds remaining come from
BigIron's own live bidding endpoint at the moment the row is built. A lot that closes mid-run is
reported `Sold`, with its price on `soldPriceUsd` rather than `currentBidUsd` — the live feed wins.

**The optional blocks cost requests.** Description, specifications, serial number and photos add one
\~30 KB request per lot. The BigIron contact, loading terms and category path need the full lot page,
about ten times the bytes and roughly ten times slower per row. Leave them off unless you need them;
they do not change the price.

### ❓ FAQ

| Question | Answer |
|---|---|
| Do I need a BigIron account or API key? | No. It reads public pages and the same endpoints BigIron's own front end calls. |
| Does it include sold lots and their prices? | Yes — that is the point of it. 799,266 sold lots, each with the realized hammer price, the bid count, the sale date and the winning bidder's state. |
| Where does the sold price come from? | BigIron fills the price client-side, so it is read from the same live bidding endpoint the site's own page calls, batched 50 lots to a request. |
| Does it cover Sullivan Auctioneers? | Yes. BigIron hosts Sullivan sales on the same platform; every row records which brand is listing. |
| Is the consignor's phone number included? | No. BigIron does not publish it. You get the consignor's name, town, state and ZIP, and BigIron's own territory rep with a direct phone and email. |
| How do I know what to put in a filter? | Run once with `"outputs": ["facets"]`. It returns every valid value with its live lot count and the input field it belongs to. |
| Can I combine filters? | Yes. Different fields are ANDed; several values in one field are ORed. Measured: `makes: ["John Deere","Case IH"]` returned 108,388 sold lots, exactly 91,386 + 17,002. |
| Why did my run return nothing? | A filter value has to match BigIron exactly and it answers a near-miss with an empty page rather than an error. `"John Deere"` works; `"john deere"` and `"JohnDeere"` do not. |
| Can I search near a location? | Yes — ZIP code or city plus a radius in miles, or by state and county. The radius is required; a ZIP alone does not filter. |
| How many rows can I get in one run? | Up to 100,000 per query, which is BigIron's own paging ceiling. Beyond that the actor splits the scope automatically, or tells you exactly what it could not reach. |
| How fresh are the prices? | Read at the moment of the fetch, straight from BigIron's live bidding record. |
| What happens if a lot has gone? | Its page answers a redirect; that lot is listed in `RUN_SUMMARY.notFound` and is not charged. |
| Is this an official BigIron product? | No. It is unofficial and reads only public BigIron data. |

### ⚖️ Source and legal

Source: [bigiron.com](https://www.bigiron.com), a public online auction marketplace. This Actor is
unofficial and is not affiliated with, endorsed by, or sponsored by Big Iron Auction Company, LLC or
Sullivan Auctioneers.

`https://www.bigiron.com/robots.txt` allows the site root with a crawl delay and reserves several
paths. The two that are relevant here, quoted verbatim:

```
User-agent: *
Allow: /
Crawl-delay: 5

Disallow: /*?filter=Sold
Disallow: /Past/
```

`saleStatus: "sold"` reads the completed-sale feed, which the first of those lines reserves. That is
a deliberate, disclosed choice by the operator of this Actor, not an oversight, and it is recorded
in `RUN_SUMMARY.robots` on every run so it is visible in your own logs. `saleStatus: "open"` — the
default — touches only paths robots.txt allows. The account-gated `/Past/` area is never read: it
answers a redirect to a sign-in page, and this Actor follows no such redirect.

The rows are auction-listing data: machines, prices, sale dates and the business or individual
consigning them. Consignor names can be personal names, and the location is the yard the machine
sells from. You are responsible for using the data in compliance with BigIron's terms and applicable
law, including GDPR, CCPA and PIPL. Do not use it to profile or target individuals.

🆘 **Something stopped filling?** BigIron changed its page. Send the run id and what you expected.

# Actor input Schema

## `saleStatus` (type: `string`):

OPEN (default) reads the live lot feed: current bid, next increment, minimum offer, buy-it-now, closing time. SOLD reads the completed-sale feed: the hammer price the lot actually made, the bid count and the winning bidder's state. Note that BigIron's robots.txt reserves the sold feed ("Disallow: /\*?filter=Sold"); see the Source and legal section of the README before you run it.

## `outputs` (type: `array`):

Which row types to write. LOTS (default) is one row per machine. AUCTIONS is BigIron's whole sale calendar, upcoming sales with their closing time and every past sale back to 2014 with its item count. FILTER VALUES is the directory you need to use the filters below: one row per valid make, model, category, year band, engine-hour band, horsepower band, size, state, price band, auction, seller and county, each with the number of lots behind it. Rows are billed at the same per-row rate whichever type they are, and Max rows is split evenly between the types you pick.

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

Stop after this many rows, across all selected outputs. You are charged per row delivered, so this is also your spend cap. 0 means everything the filters match, bounded by BigIron's 100,000-row-per-query paging ceiling (the actor splits a larger scope by state and price band automatically; see the README).

## `searchTerm` (type: `string`):

Free-text search across the lot title and description, e.g. "combine" or "skid steer". Measured: "tractor" matched 77,264 sold lots.

## `searchMode` (type: `string`):

How the search term is matched. Only used when Search term is set.

## `industries` (type: `array`):

BigIron's top-level industries: Agriculture, Construction, Transportation, Industrial, Livestock, RealEstate, CollectorCars, Other. Several entries are ORed. Measured: Agriculture = 531,234 sold lots.

## `categories` (type: `array`):

Category values in BigIron's own "Parent : Child" form, e.g. "Tractors : Tractors 2WD" or "Harvest Equipment : Combine Headers". Several entries are ORed. Run with Outputs = Filter values for the exact strings.

## `makes` (type: `array`):

Manufacturer names exactly as BigIron writes them: "John Deere", "Case IH", "Massey Ferguson". "john deere" and "JohnDeere" match nothing. Several entries are ORed.

## `models` (type: `array`):

Model designations as BigIron writes them, e.g. "4020", "4430". Several entries are ORed. Most useful together with a category, since model strings repeat across makes.

## `years` (type: `array`):

BigIron buckets model years rather than taking a single year: "1990 - 1999", "2000 - 2004", "2006", "< 1930". A bare "2020" matches nothing. Several entries are ORed.

## `engineHours` (type: `array`):

Engine-hour buckets as BigIron writes them: "< 100", "500 - 999", "4,000 - 4,999". Several entries are ORed. Only populated on machines that report hours.

## `horsepowers` (type: `array`):

Horsepower buckets as BigIron writes them: "< 10", "100 - 149", "> 500". Several entries are ORed.

## `sizes` (type: `array`):

BigIron's size facet, which is category-specific (tyre sizes on tractors, widths on headers), e.g. "18.4-38 Rear Tires". Several entries are ORed. Use Filter values to see what a category offers.

## `priceBuckets` (type: `array`):

Price bands exactly as BigIron writes them, including the dollar signs and commas: "< $100", "$1,000 - $1,999", "$10,000 - $19,999". On the sold feed this is the realized hammer price; on the open feed it is the current bid. Several entries are ORed — measured: the $10k-$19,999 and $20k-$29,999 bands together returned 59,650, exactly 41,592 + 18,058.

## `auctions` (type: `array`):

Named sales, as BigIron writes them: "Dec 07, 2022 - Equipment Auction". Several entries are ORed. This is the cleanest way to pull one complete sale's results — measured: that sale holds 3,642 lots.

## `sellers` (type: `array`):

Consignor names exactly as BigIron writes them, e.g. "Behlen Manufacturing". Several entries are ORed. Use Filter values to get the top 200 consignors with their lot counts.

## `states` (type: `array`):

Two-letter codes ("NE", "KS") or full state names. Several entries are ORed. The lot's state is where the machine stands — the consignor's yard — because it has to be inspected and collected there.

## `counties` (type: `array`):

County names without the word "County", e.g. "Platte". Several entries are ORed. County names repeat across states, so pair this with States.

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

Centre of a radius search. Only filters when Radius is set as well — a ZIP on its own returned 594,551 of 799,266 sold lots, i.e. everything inside the default 500-mile radius.

## `city` (type: `string`):

Centre of a radius search by town name instead of ZIP. Pair it with State and Radius; a city name on its own does not filter at all.

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

Two-letter state code that disambiguates the City above, e.g. "OK". Ignored unless City or ZIP code is set. This is NOT the state filter — use States for that.

## `distanceMiles` (type: `integer`):

Radius around the ZIP code or city. BigIron's own default is 500. Measured: ZIP 73942 at 50 miles returned 4,779 sold lots.

## `providers` (type: `array`):

BigIron hosts Sullivan Auctioneers sales on the same platform. Leave empty for both; set \["BigIron"] or \["Sullivan"] to pick one. Every row records which brand is selling.

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

The full written description BigIron publishes for the lot, plus the date it was last updated. Adds one ~30 KB request per lot.

## `includeSpecifications` (type: `boolean`):

BigIron's specification table as a key/value object (year, make, model, serial number, seller asset number, width, hours, horsepower and whatever else the category carries), plus serialNumber lifted out as its own field. Same request as the description.

## `includePhotos` (type: `boolean`):

Every full-size photo URL for the lot, in page order. Measured 24 and 39 photos on the two lots captured. Same request as the description.

## `includeContact` (type: `boolean`):

The named BigIron representative for the lot: name, territory, direct phone and email. THIS IS BIGIRON'S OWN REP, NOT THE CONSIGNOR — BigIron does not publish a consignor phone or email anywhere on a lot (the page says "Owner Contact information is not available"). Opens the full 250-280 KB lot page, which also fills description, specifications, serial number and photos.

## `includeTerms` (type: `boolean`):

Whether the yard has a loading dock and the loading-assistance note the consignor published. Opens the full lot page, same as the contact block.

## `includeCategoryPath` (type: `boolean`):

The lot's breadcrumb as an array, e.g. \["Farm Equipment", "John Deere Farm Equipment"]. Opens the full lot page, same as the contact block.

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

BigIron's own four sort options. The default is the natural one for the feed you picked: open lots come back closing-soonest, sold lots most-recent-first.

## `concurrency` (type: `integer`):

How many 50-lot search pages to fetch at once. Each one runs on its own pinned proxy session. 4 is a good balance against BigIron's "Crawl-delay: 5"; raise it only if you accept a higher chance of being rate-limited.

## `detailConcurrency` (type: `integer`):

How many per-lot detail requests to run at once, when any of the extra blocks above is on.

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

Apify Proxy on the shared datacenter pool is the default and was measured sufficient for every surface this actor touches: the open feed, the sold feed, the price endpoint, the lot page and the facet page all returned 200 through it. Cloudflare sits in front of the site but serves no challenge to a session that carries the cookies from a normal page load, which this actor always does. Switch to RESIDENTIAL only if your own account's datacenter pool is treated differently.

## Actor input object example

```json
{
  "saleStatus": "open",
  "outputs": [
    "lots"
  ],
  "maxItems": 25,
  "searchMode": "All",
  "industries": [],
  "categories": [],
  "makes": [],
  "models": [],
  "years": [],
  "engineHours": [],
  "horsepowers": [],
  "sizes": [],
  "priceBuckets": [],
  "auctions": [],
  "sellers": [],
  "states": [],
  "counties": [],
  "distanceMiles": 500,
  "providers": [],
  "includeDescription": false,
  "includeSpecifications": false,
  "includePhotos": false,
  "includeContact": false,
  "includeTerms": false,
  "includeCategoryPath": false,
  "sortBy": "closing-soonest",
  "concurrency": 4,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per BigIron lot. Live lots carry the current bid, next increment, minimum offer, buy-it-now and the exact UTC closing time; sold lots carry the realized hammer price, the bid count, the sale date and the state the winning bidder bid from. Every row also carries make, model, year, category, quantity, buyer's premium, the auction it belongs to, and the consignor's name, town, state and ZIP. Optional blocks add the description, the specification table with the serial number, every full-size photo, and BigIron's own territory representative.

## `runSummary` (type: `string`):

RUN\_SUMMARY: the filters actually sent, how many lots BigIron said match, how the scope was sliced to stay under its 100,000-row paging ceiling, rows delivered (which equals rows charged), per-field fill measured on this run's own rows, and four separate lists — lots whose page is no longer published, cards that carried no readable record, surfaces that could not be reached after retries, and optional blocks that failed while the base row succeeded. None of those four is charged.

# 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 = {
    "saleStatus": "open",
    "maxItems": 25,
    "searchTerm": "",
    "zipCode": "",
    "city": "",
    "state": "",
    "sortBy": "closing-soonest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/bigiron-lot-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 = {
    "saleStatus": "open",
    "maxItems": 25,
    "searchTerm": "",
    "zipCode": "",
    "city": "",
    "state": "",
    "sortBy": "closing-soonest",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/bigiron-lot-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 '{
  "saleStatus": "open",
  "maxItems": 25,
  "searchTerm": "",
  "zipCode": "",
  "city": "",
  "state": "",
  "sortBy": "closing-soonest"
}' |
apify call scrapersdelight/bigiron-lot-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/bigiron-lot-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/7m8UO3q9ylVKSdxfK/builds/oTcn3reCkaWxmcZZj/openapi.json