# AuctionTime Scraper — Lots, Bids & Dates (`crawloop/auctiontime-scraper`) Actor

Scrape public AuctionTime equipment auctions for farm, construction, and truck lots. Returns the bid, auction date, year, make, model, hours, location, seller, and photos. No login.

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

## Pricing

from $23.99 / 1,000 auction lots

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/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

## AuctionTime Scraper — Lots, Bids & Dates

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by AuctionTime or Sandhills or their affiliates. Data is read from publicly accessible auction search and lot pages only. No login. You are responsible for complying with applicable law (including GDPR where a seller or contact name appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Scrape public AuctionTime equipment auctions for farm machinery, construction equipment, trucks, and trailers. Each row is one lot: title, year, make, model, current bid when published, auction date, hours, location, seller, and photos.

Dealers and appraisers use it to watch upcoming lots and to export auction-result metadata. Sold hammer prices are often hidden on the public card, so a row can have a date and specs with an empty price.

> **Crawloop Used Machinery Marketplace Suite** — equipment auctions and dealer inventory.

| IronPlanet | GovPlanet | Ritchie Bros | BidSpotter | NetBid | AuctionTime | Purple Wave |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| [IronPlanet Scraper](https://apify.com/crawloop/ironplanet-scraper) | [GovPlanet Scraper](https://apify.com/crawloop/govplanet-scraper) | [Ritchie Bros Auction Scraper](https://apify.com/crawloop/rbauction-scraper) | [BidSpotter Scraper](https://apify.com/crawloop/bidspotter-scraper) | [NetBid Scraper](https://apify.com/crawloop/netbid-scraper) | AuctionTime Scraper ◄── you are here | [Purple Wave Auctions Scraper](https://apify.com/crawloop/purplewave-scraper) |

| AuctionTime | TractorHouse | MachineryTrader | TruckPaper |
| :--- | :--- | :--- | :--- |
| AuctionTime Scraper ◄── you are here | [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) | [MachineryTrader Scraper](https://apify.com/crawloop/machinerytrader-scraper) | [TruckPaper Scraper](https://apify.com/crawloop/truckpaper-scraper) |

### When to use

Use this Actor when you need AuctionTime lots in a dataset: upcoming auctions, a keyword such as excavator, or a category URL you already have.

Use [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) next when you want retail asking prices for the same kind of farm equipment. Use [Ritchie Bros Auction Scraper](https://apify.com/crawloop/rbauction-scraper) when the lot is on Ritchie Bros instead of AuctionTime.

### Key features

- Search by manufacturer, category id, state, or a start URL. A keyword then keeps lots whose title, make, model, or description contains that word
- Upcoming auctions, auction results, or the for-sale catalog
- Lot number, auction date, current bid, hours, serial, seller, and images from the search card
- Optional detail pages for address enrichment
- Monitor mode: the first run stores fingerprints and writes no rows; later runs emit new lots and price changes
- Phone fields stay off unless you turn them on

### Input

| Field | Default | What it does |
| :--- | :--- | :--- |
| `searchQuery` | excavator | Extra text filter. A keyword alone does not search the catalog |
| `listingType` | Auction | Auction, Auction Results, or For Sale |
| `manufacturer` | empty | Brand filter |
| `category` | empty | Sandhills category id |
| `state` | empty | US state code |
| `startUrls` | empty | Search, category, or lot URLs |
| `runMode` | listings | `details` opens each lot page |
| `maxItems` | 50 | Maximum saved rows |
| `maxPagesPerUrl` | 3 | Search pages per URL |
| `pricedOnly` | false | Keep only rows with a numeric price or bid |
| `monitorMode` | false | New lots and price changes after a seed run |
| `includePhones` | false | Keep public phone fields |
| `proxyConfiguration` | US residential | Required for Cloudflare |

```json
{
  "searchQuery": "excavator",
  "listingType": "Auction",
  "manufacturer": "CATERPILLAR",
  "state": "TX",
  "maxItems": 50,
  "maxPagesPerUrl": 2,
  "runMode": "listings",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

A category page you already copied from the browser also works:

```json
{
  "startUrls": [
    { "url": "https://www.auctiontime.com/listings/construction-equipment/for-sale/list" }
  ],
  "maxItems": 40
}
```

### Output

| Field | Meaning |
| :--- | :--- |
| `title`, `make`, `model`, `year` | Lot identity |
| `currentBid`, `price`, `priceFormatted`, `currency` | Bid or published price. Empty when the card only says Auction |
| `auctionDate`, `lotNumber` | When and which lot |
| `hours`, `serialNumber`, `category` | Specs from the card |
| `location`, `city`, `state` | Where the machine sits |
| `dealerName` | Seller or auction company |
| `url`, `images` | Lot link and photos |
| `changeType` | `new` or `price_change` in monitor mode |

```json
{
  "id": "42",
  "title": "2018 CATERPILLAR 320",
  "make": "CATERPILLAR",
  "model": "320",
  "year": "2018",
  "currentBid": 12500,
  "price": null,
  "auctionDate": "Oct 22, 2026",
  "lotNumber": "14A",
  "hours": "4500",
  "state": "TX",
  "dealerName": "Example Auction Co",
  "url": "https://www.auctiontime.com/listing/auction/42"
}
```

### Use cases

- Watch upcoming construction and farm auctions for a make and model
- Export lot metadata before a sale for a bid sheet
- Compare AuctionTime lots with retail asking prices from TractorHouse
- Schedule a monitor so only new lots and bid changes land in the dataset

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("crawloop/auctiontime-scraper").call({
  searchQuery: "excavator",
  listingType: "Auction",
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="APIFY_TOKEN")
run = client.actor("crawloop/auctiontime-scraper").call(run_input={
    "searchQuery": "excavator",
    "listingType": "Auction",
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~auctiontime-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"excavator","listingType":"Auction","maxItems":50}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).
Connect your Apify account, then call this Actor by its Store name `crawloop/auctiontime-scraper`.

Example prompts:

- "Run AuctionTime Scraper for Caterpillar excavators in Texas and return the top 20 lots as JSON with bid, date, and hours."
- "Scrape upcoming AuctionTime farm equipment lots and summarize make, model, and auction date."
- "Chain AuctionTime Scraper then TractorHouse Scraper to compare auction lots with retail asking prices."

### Suite next step

After the auction export, run [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper) for retail asking prices on the same farm equipment, or [Ritchie Bros Auction Scraper](https://apify.com/crawloop/rbauction-scraper) for Ritchie Bros lots.

### FAQ

#### Does this log in or place bids?

No. It reads public search cards and, in details mode, public lot pages. It does not sign in, watch, or bid.

#### Why did a keyword return no rows?

AuctionTime's public search HTML applies manufacturer, category, and state. It does not apply a keyword by itself, and this Actor does not save that unfiltered catalog. Set a manufacturer or paste a filtered start URL, then use the keyword to keep matching rows.

#### Why is the price empty?

Auction result and some live cards publish the word Auction instead of a number. The hammer price is often behind a login. `pricedOnly` drops those rows.

#### What does monitor mode write on the first run?

Nothing to the dataset. It stores lot fingerprints. The next scheduled run writes new lots and price or bid changes.

# Actor input Schema

## `includePhones` (type: `boolean`):

Off by default. Include phone or WhatsApp fields already published on public pages only when you have a lawful basis.

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

AuctionTime search, category, or listing detail URLs. Leave empty to build a search from the filters below.

## `searchQuery` (type: `string`):

Kept only when the word appears in the title, make, model, or description. AuctionTime's public HTML ignores a keyword by itself, so also set a manufacturer, category, state, or paste a filtered start URL.

## `listingType` (type: `string`):

Used when building a search URL. Auction Results metadata is public; sold hammer prices are often hidden.

## `manufacturer` (type: `string`):

Brand filter for the built search URL, such as CATERPILLAR, JOHN DEERE, or KOMATSU.

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

Sandhills category id when you already know it (for example 4 for construction equipment).

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

US state code added to the built search URL, such as TX or IA.

## `sort` (type: `string`):

Optional sort key for built search URLs (9 = recently added).

## `baseUrl` (type: `string`):

Origin used when the Actor builds a search URL.

## `runMode` (type: `string`):

listings reads search cards. details also opens each lot page for address enrichment.

## `pricedOnly` (type: `boolean`):

Skip rows whose price is missing or zero. Auction results often hide the hammer price.

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

Maximum dataset rows. In a monitor seed run this is the maximum number of lots to fingerprint.

## `maxPagesPerUrl` (type: `integer`):

Maximum search pages per start URL.

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

US residential proxies. AuctionTime sits behind Cloudflare.

## `concurrencyLimit` (type: `integer`):

Parallel lot-page fetches in details mode.

## `monitorMode` (type: `boolean`):

First run stores lot fingerprints and writes no dataset rows. Later runs emit new lots and bid or price changes.

## `monitorStoreName` (type: `string`):

Named key-value store for fingerprints. Use a distinct name per watch.

## `telegramToken` (type: `string`):

Optional bot token for monitor alerts.

## `telegramChatId` (type: `string`):

Chat that receives monitor alerts.

## `resetMonitorState` (type: `boolean`):

Clear stored fingerprints before this run.

## Actor input object example

```json
{
  "includePhones": false,
  "searchQuery": "excavator",
  "listingType": "Auction",
  "baseUrl": "https://www.auctiontime.com",
  "runMode": "listings",
  "pricedOnly": false,
  "maxItems": 50,
  "maxPagesPerUrl": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "concurrencyLimit": 3,
  "monitorMode": false,
  "monitorStoreName": "auctiontime-monitor-state",
  "resetMonitorState": false
}
```

# Actor output Schema

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

Default dataset items.

# 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 = {
    "searchQuery": "excavator",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/auctiontime-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 = {
    "searchQuery": "excavator",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/auctiontime-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 '{
  "searchQuery": "excavator",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/auctiontime-scraper --silent --output-dataset

```

## MCP server setup

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