# BigIron Auction Scraper - Farm Equipment & Sullivan Lots (`parseforge/bigiron-auctions-scraper`) Actor

Reads every open lot on BigIron.com and Sullivan Auctioneers: 6,500+ live farm, construction, transportation and livestock lots with make, model, year, current bid, closing time and location.

- **URL**: https://apify.com/parseforge/bigiron-auctions-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 $4.45 / 1,000 auction lots

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)

### BigIron Auction Scraper - Farm Equipment & Sullivan Lots

**Scrape every open lot on BigIron.com and Sullivan Auctioneers, all 6,500 of them, in one run of about five minutes.** Each row carries 44 fields: make, model, year, category, current bid, next bid increment, bid count, minimum offer, buy-it-now price, closing time, seller, auction, city, state and ZIP. No login, no API key. Export to CSV, JSON, Excel or XML.

BigIron has no public API and its search is a paged web app that shows 50 lots at a time behind a sidebar of filter panels. This reads the same feed its own front end reads, applies your filters server side so you only pay for lots you want, and hands back one flat row per lot.

| Who uses it | What they scrape BigIron for |
|---|---|
| Equipment dealers | What is coming up for sale this week in their territory, before the auction closes |
| Flippers and resellers | Live bids against buy-it-now prices to spot lots still trading under market |
| Ag lenders and insurers | Current asking and bid levels on collateral by make, model and year |
| Fleet and farm buyers | Every combine, planter or skid steer within a radius of their ZIP code |
| Market analysts | Bid depth, seller mix and regional supply across six industries |

### What it does

This Actor reads BigIron's open lot search and returns each lot as a flat row. Every lot carries:

- 🚜 **Machine identity:** title, make, model, year, category, category path, tracking number and BigIron's internal lot ID.
- 💰 **Live bidding:** current bid, next bid increment, bid count, minimum offer on make-an-offer lots, buy-it-now price, selling mode and whether bidding was extended.
- ⏱️ **Timing:** exact closing time in UTC, seconds remaining, seconds until the lot opens, and the auction it belongs to.
- 📍 **Location:** city, state, state code and ZIP, plus the seller and the buyer's premium that applies.
- 🖼️ **Optional blocks:** the seller's full description, the specification table, every full size photo, the equipment contact, attachments, loading terms and the raw BigIron record.
- 🗓️ **Two more outputs:** the upcoming auction calendar, and a directory of every valid filter value with its live lot count. Pick them with `outputs`.

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

### What you can do with BigIron auction data

**🔎 Watch a make and model across every sale.**

Filter to John Deere combines or Case IH planters and get every open lot in the country with its current bid and closing time, refreshed on a schedule.

**📊 Build price comps from live bidding.**

Pull current bid, bid count and buy-it-now for a category, and track where bidding actually lands against the asking price.

**📍 Source inventory near a yard.**

Set a ZIP code and a radius, or pick states and counties, and get everything closing inside that footprint.

**🧭 Map supply and sellers.**

Run with `"outputs": ["facets"]` to see how many open lots sit behind each make, category, county, seller and auction, then drill into the ones that matter.

### Why choose this scraper

| | What you get |
|---|---|
| **Every BigIron filter** | 16 server side filters: free text search with three match modes, industry, state, listing provider, make, model, category, model year, engine hours, horsepower, size, current bid range, auction, seller, county and a ZIP code radius. Each one was measured against the site's own result count before it went in. |
| **Filter values included** | A second output with one row per valid make, model, category, county, seller and bucket, and its live lot count. No guessing at spelling. |
| **Fields no rival carries** | `minimumOfferUsd`, BigIron's reserve on make-an-offer lots, and `leadingBidderState`, the state the current high bidder is bidding from. |
| **Sullivan Auctioneers included** | BigIron hosts Sullivan sales on the same platform. Both are read, and every row says which. |
| **Optional blocks, billed only when they return** | Description, specifications, photos, contact, attachments and terms are each a checkbox. Untouched blocks are neither fetched nor billed. |
| **Open lots only** | BigIron's robots file reserves its sold and past listings. This reads the open feed it allows, and nothing else. |

### How it compares

There is no other BigIron scraper on Apify. The closest actors cover neighbouring marketplaces: Ritchie Bros, IronPlanet, AuctionTime, Proxibid. Against those, the difference is depth per lot and the fact that every filter here is one the site actually honours, so the filtering happens on BigIron's servers rather than after you have paid for rows you discard.

| Feature | ParseForge BigIron | lulzasaur/ironplanet | muhammadafzal/auctiontime | rastriq/rbauction |
|---|---|---|---|---|
| Covers BigIron and Sullivan | Yes | No | No | No |
| Server side filters | 16, each measured | Search only | Search only | Search only |
| Live bid, next increment, bid count | Yes | Partial | Partial | Partial |
| Minimum offer and leading bidder state | Yes | No | No | No |
| Filter value directory | Yes | No | No | No |
| Price per row | $0.005 | $0.02 | $0.05 | $0.0019 |

### What a BigIron lot looks like

```json
{
 "rowType": "lot",
 "lotId": "9fca7b36-4b97-f111-85cd-0022488cdb71",
 "title": "2021 Case IH 2130 16 Row Strip Till Planter",
 "lotUrl": "https://www.bigiron.com/Lots/2021-case-ih-2130-16-row-strip-till-planter",
 "lotSlug": "2021-case-ih-2130-16-row-strip-till-planter",
 "trackingNumber": "15485622",
 "make": "Case IH",
 "model": "2130",
 "year": "2021",
 "categoryName": "Planters",
 "categorySlug": "planters",
 "parentCategorySlug": "planters",
 "quantity": 1,
 "quantityUnits": "ea",
 "biddingPerUnit": "No",
 "saleStatus": "Active",
 "sellingMode": "MakeAnOffer",
 "currentBidUsd": 27500,
 "nextBidUsd": 27501,
 "minimumOfferUsd": 60000,
 "buyItNowUsd": 75000,
 "bids": 1,
 "leadingBidderNumber": 22274,
 "leadingBidderState": "Mississippi",
 "bidExtended": "No",
 "closesAt": "2026-10-05T04:59:00.000Z",
 "secondsRemaining": 2906175,
 "secondsUntilOpen": 0,
 "auctionId": "bfd42ea86da5f111aad1000d3a600915",
 "auctionSlug": "Sep_01_2026_12A",
 "auctionUrl": "https://www.bigiron.com/Auctions/Sep_01_2026_12A",
 "auctionName": "Sep 01, 2026 - 12:00 AM",
 "saleEventLabel": "IronExchange - Sep 2026",
 "auctioneer": "BigIron",
 "listingProvider": "BigIron",
 "seller": "Equipment Online",
 "locationCity": "Las Vegas",
 "locationState": "Nevada",
 "locationStateCode": "NV",
 "locationZip": "89165",
 "buyersPremium": "10%, Max: $1,000",
 "thumbnailUrl": "https://bigiron.blob.core.windows.net:443/thumbnail/items/9fca7b364b97f11185cd0022488cdb71/2021-case-ih-2130-16-row-strip-till-planter_5af4d3e4ed1b4a6aa5848ca46592c1d7.jpg",
 "groupId": "3929101d4b97f11185cd0022488cdb71",
 "scrapedAt": "2026-09-01T13:42:44.804Z"
}
```

Add `"outputs": ["lots", "auctions"]` and you also get one row per upcoming sale:

```json
{
 "rowType": "auction",
 "auctionId": "02b95ef3-b165-f111-9b48-7ced8d2b8992",
 "title": "Sep 02, 2026 - Equipment Auction",
 "auctionSlug": "Sep_02_2026_9A",
 "auctionUrl": "https://www.bigiron.com/Auctions/Sep_02_2026_9A",
 "categoriesUrl": "https://www.bigiron.com/Industries?auction=Sep_02_2026_9A",
 "itemCount": 1086,
 "closesAtText": "Sep 2 9:00 AM CDT.",
 "auctioneerBrand": "BigIron",
 "hostedOnBigIron": "Yes",
 "summary": "1,086 Items - Items Begin Closing at Sep 2 9:00 AM CDT. View Categories",
 "scrapedAt": "2026-09-01T13:36:35.498Z"
}
```

Add `"facets"` and you get one row per valid filter value, with its live lot count:

```json
{
 "rowType": "facet",
 "facet": "makes",
 "facetTitle": "Make",
 "facetValue": "John Deere",
 "title": "John Deere",
 "openLots": 771,
 "inputField": "makes",
 "seenOn": "all",
 "scrapedAt": "2026-09-01T13:41:05.799Z"
}
```

### Configure the run

Leave everything empty and the Actor walks the whole open catalogue, earliest closing sale first, which is the order BigIron itself shows. Add filters and BigIron applies them before it sends the page, so only matching lots are written and billed. Filter values must match the site exactly; run once with `"outputs": ["facets"]` to get the list.

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

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

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

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

Tractors between 100 and 149 horsepower built in the 1990s, with the specification table:

```json
{ "categories": ["Tractors : Tractors 2WD"], "horsepowers": ["100 - 149"], "years": ["1990 - 1999"], "includeSpecifications": true, "maxItems": 100 }
```

### Pricing

Pay-per-event: **$0.005 per lot**, dropping to $0.00445 at higher volume, plus $0.002 per search page of 50 and a $0.002 run-start fee. You pay only for lots written to your dataset.

| Lots collected | Base row | Every block on |
|---|---|---|
| 100 | $0.51 | $1.39 |
| 1,000 | $5.04 | $13.84 |
| 10,000 | $50.40 | $138.40 |

Each optional block is billed separately and only when it actually returned something: opening the lot page $0.002, description $0.001, specifications $0.001, photos $0.001, contact $0.0012, attachments $0.0008, terms $0.0008, category path $0.0006, raw record $0.0004. Auction events are $0.004 each and filter values $0.001 each. New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 rows as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 rows per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [BigIron Auction Scraper](https://apify.com/parseforge/bigiron-auctions-scraper?fpr=vmoqkp).
3. Set any filters you want, set `maxItems`, and click **Start**.
4. Export the results as CSV, Excel, JSON or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to BigIron through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/bigiron-auctions-scraper"
```

Then prompt it in plain language:

- *"List every John Deere combine open on BigIron in Iowa and Nebraska with its current bid and closing time."*
- *"Find skid steers within 200 miles of ZIP 68008 closing this week and sort them by bid count."*
- *"Show me which BigIron sellers have the most open lots right now."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/bigiron-auctions-scraper" to collect open BigIron auction lots. Input: { "makes": ["<make>"], "states": ["<XX>"], "categories": ["<Parent : Child>"], "maxItems": <n> }. It returns title, make, model, year, categoryName, currentBidUsd, buyItNowUsd, bids, closesAt, seller, locationCity, locationState and lotUrl per lot. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

A filter value has to match BigIron exactly, and a value the site does not know returns an empty page rather than an error. `"John Deere"` works, `"john deere"` and `"JohnDeere"` do not. Run once with `"outputs": ["facets"]` to get the exact strings, then copy them in.

**Why fewer lots than I asked for?**

Your filters matched fewer open lots than `maxItems`. The log prints the true total the moment the first page comes back: `6,486 open lot(s) match`. If you asked for more than one output, `maxItems` is split evenly between them and what one does not use rolls into the next.

**Why is a field empty?**

BigIron does not fill every field on every lot. Measured over 702 live lots: make on 599, model on 551, year on 444, minimum offer on 187. Real estate and livestock lots carry no buyer's premium, and only IronExchange lots carry a written sale label. An empty field is the lot's real state, written as `Not Disclosed`.

**Why is the run slow?**

Two reasons. Deep pagination gets slower the further in you go: the whole 6,548 lot catalogue takes about 5 and a half minutes at the default memory, which is about 20 rows a second. And every extra data block opens the lot's own page, one request per lot, which runs at about 1.7 lots a second, roughly twelve times slower per row than the search feed. Leave the blocks off unless you need them.

**A field stopped filling.**

BigIron changed its page. Email us with your run ID so we can update the parser.

### FAQ

| Question | Answer |
|---|---|
| Do I need a BigIron account or API key? | No. It reads the public lot search, the same feed the site's own front end uses. |
| Does it include sold and past lots? | No. BigIron's robots file reserves its sold and past listings, so this reads the open feed only. |
| Does it cover Sullivan Auctioneers? | Yes. BigIron hosts Sullivan sales on the same platform, and every row records which brand is selling. |
| How do I know what to put in a filter? | Set `"outputs": ["facets"]`. It returns every valid make, model, category, county, seller, auction and bucket with its live lot count and the input field it belongs to. |
| Can I combine filters? | Yes, and each accepts several values at once. Filters are ANDed across fields and ORed inside one field. |
| Can I search near a location? | Yes, by state, county, or a ZIP code plus a radius in miles. |
| How current are the bids? | The bid, bid count and seconds remaining are read at the moment the page is fetched, straight from BigIron's own lot record. |
| How many lots per run? | Free plan: 10. Paid: up to 1,000,000, bounded by the roughly 6,500 lots open at any time. |
| Is this an official BigIron product? | No. It is unofficial and reads only public BigIron data. |

### Related actors

- [AuctionTime Equipment Scraper](https://apify.com/parseforge/auctiontime-scraper?fpr=vmoqkp): heavy equipment auction listings across the AuctionTime network.
- [Ritchie Bros Auctioneers Scraper](https://apify.com/parseforge/ritchie-bros-auctioneers-scraper?fpr=vmoqkp): lots and results from the largest industrial auctioneer.
- [Machinery Trader Scraper](https://apify.com/parseforge/machinerytrader-scraper?fpr=vmoqkp): dealer listings for construction and farm equipment.
- [EquipmentWatch Scraper](https://apify.com/parseforge/equipmentwatch-scraper?fpr=vmoqkp): equipment valuation and cost data.
- [Auction.com Property Scraper](https://apify.com/parseforge/auction-com-property-scraper?fpr=vmoqkp): foreclosure and bank owned property auctions.

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 Big Iron Auction Company, LLC or Sullivan Auctioneers. It collects only publicly available lot data from the open auction feed, and it does not read the sold, past or account areas that BigIron's robots file reserves. You are responsible for using the data in compliance with BigIron's terms and applicable laws, including GDPR, CCPA and PIPL. Do not use it to identify, profile, or target individuals.

# Actor input Schema

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

Free text searched across lot titles and descriptions, for example 'grain cart' or 'John Deere combine'. Leave empty to take every open lot that matches the filters below.

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

How the search term is matched. All: the lot must contain every word. Phrase: the lot must contain the exact phrase. Any: the lot may contain any of the words.

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

BigIron's top level industry buckets. Leave empty for every industry. Verified open lot counts on 2026-08-31: Agriculture 4,361, Construction 1,347, Transportation 887, Other 647, Livestock 406, Collector Cars 15.

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

Two letter state codes, taken from BigIron's own state picker. Leave empty for the whole country.

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

BigIron runs its own sales and Sullivan Auctioneers sales on the same platform. Leave empty for both.

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

Free users: limited to 10 items (preview). Paid users: up to 1,000,000.

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

What the run collects. Lots is the auction inventory. Auctions is the upcoming sale calendar, about 131 rows. Filter values is a directory of every valid value for the filters above with its live lot count, about 900 rows, which is how you learn the exact strings the filters expect. Pick more than one and maxItems is split evenly between them, with whatever one does not use rolling into the next.

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

Exact manufacturer names as BigIron spells them, for example 'John Deere', 'Case IH', 'Allis-Chalmers'. Turn on the facet directory below to pull the live list with counts.

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

Exact model designations, for example '4020' or '8R 410'. Most useful combined with a make.

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

BigIron category paths in the form 'Parent : Child', for example 'Tractors : Tractors 2WD' or 'Miscellaneous : Tires/Rims'.

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

A single year such as '2015', or one of BigIron's decade buckets such as '1970 - 1979'. Arbitrary ranges are not supported by the site and return nothing.

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

BigIron's own hour buckets, spelled exactly: '< 100', '100 - 499', '500 - 999', '5,000 - 5,999'.

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

BigIron's own horsepower buckets, spelled exactly: '10 - 29', '30 - 49', '50 - 99', '100 - 149', '150 - 199', '200 - 249'.

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

Tyre and dimension buckets as the site spells them, for example '6.00-16 Front Tires'.

## `currentBidBuckets` (type: `array`):

Current bid ranges as the site spells them: '< $100', '$100 - $499', '$500 - $999', '$1,000 - $1,999', '$10,000 - $19,999' and so on.

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

Full auction event names as BigIron writes them, for example 'Sep 16, 2026 - Equipment Auction'.

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

Consignment names, for example 'Mark Kepler Retirement' or 'Larson Family Farms Retirement'.

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

County names without the word County, for example 'Platte' or 'Buffalo'.

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

Anchor ZIP for a radius search. Needs the radius below to do anything.

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

Miles around the ZIP code above. BigIron's own picker defaults to 500.

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

The site's own sort options. Sale time earliest first is what the site itself shows.

## `skipClosedLots` (type: `boolean`):

BigIron's open list carries a small number of lots whose closing time has already passed and that read as Sold. Leave this on to drop them. Measured on 2026-08-31: 1 stale lot in the first 50 of 6,486.

## `startUrls` (type: `array`):

Optional. Paste BigIron lot URLs (https://www.bigiron.com/Lots/...) to scrape those exact lots instead of running a search. Ignored when empty.

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

Opens each lot page and adds the full seller description plus the date the listing was last updated. One extra request per lot.

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

Adds the lot's specification rows: serial number, engine hours, horsepower, tyre sizes and every other attribute the seller filled in.

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

Adds every full resolution photo URL from the lot gallery, plus the photo count.

## `includeContacts` (type: `boolean`):

Adds the BigIron representative named on the lot: name, territory, phone and email. Email is decoded from the page's obfuscation.

## `includeAttachments` (type: `boolean`):

Adds the additional resources on the lot page: spec sheets, manuals, title documents and other PDFs.

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

Adds the buyer's premium, loading dock availability, loading assistance notes and the lot's disclaimer text.

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

Adds the breadcrumb category hierarchy from the lot page, which is deeper than the single category on the listing row.

## `includeRawLot` (type: `boolean`):

Adds BigIron's own untouched lot object exactly as the page embeds it. Costs nothing extra to fetch; useful when you want a field we did not map.

## Actor input object example

```json
{
  "searchMode": "All",
  "maxItems": 10,
  "outputs": [
    "lots"
  ],
  "sortBy": "Start-Ascending",
  "skipClosedLots": true,
  "includeDescription": false,
  "includeSpecifications": false,
  "includePhotos": false,
  "includeContacts": false,
  "includeAttachments": false,
  "includeTerms": false,
  "includeCategoryPath": false,
  "includeRawLot": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `csv` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerm": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bigiron-auctions-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 = {
    "searchTerm": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bigiron-auctions-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 '{
  "searchTerm": "",
  "maxItems": 10
}' |
apify call parseforge/bigiron-auctions-scraper --silent --output-dataset

```

## MCP server setup

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