# Farm Equipment Listings Scraper — Prices, Bids & Dealers (`crawloop/farm-equipment-listings-scraper`) Actor

Search used farm equipment on TractorHouse, MachineryTrader, and AuctionTime in one run. Machinery Pete and Fastline are optional sources on the same schema. Each row has year, make, model, asking price or bid, hours, location, and seller. No login.

- **URL**: https://apify.com/crawloop/farm-equipment-listings-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 $2.50 / 1,000 tractorhouse listings

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

## Farm Equipment Listings Scraper — Prices, Bids & Dealers

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Sandhills Global, TractorHouse, MachineryTrader, AuctionTime, Machinery Pete, Fastline, or their affiliates. Data is read from publicly accessible listing cards only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and each site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Search used farm equipment on **TractorHouse**, **MachineryTrader**, and **AuctionTime** in one run. **Machinery Pete** and **Fastline** are the same schema when you select them. Each row is a public listing card: year, make, model, asking price or current bid, hours, location, and seller. Built for dealers, appraisers, and brokers who want one dataset instead of a separate export per site.

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

| Machinery Pete | Fastline |
| :--- | :--- |
| [Machinery Pete Scraper](https://apify.com/crawloop/machinerypete-scraper) | [Fastline Scraper](https://apify.com/crawloop/fastline-scraper) |

### What this Actor does

This **farm equipment listings scraper** reads the search page on each selected marketplace and writes one shared schema. TractorHouse and MachineryTrader contribute retail asking prices. AuctionTime contributes upcoming auction cards (lot, bid, auction date) when those fields are public. Machinery Pete and Fastline stay off unless you add them to `sources`, so a scheduled watch of the three Sandhills sites does not open those extra pages.

It is a farm equipment API alternative for a cross-market pull in **Python**, **Node.js**, or **MCP**. For a single-site dump, dealer monitor, or lot-page enrichment, use the marketplace Actor named above.

**Sold hammers** on AuctionTime are often hidden on the public card. This Actor keeps the published bid and leaves the price empty when the site does.

### When to use

- Pull John Deere, Case IH, or Kubota cards from retail and auction sites in one dataset
- Compare asking prices and public bids for the same model
- Export a short list for a trade-in desk or a lender packet
- Hand the rows to an AI assistant through Apify MCP

**When a single site is enough:** a dealer inventory watch or a full catalog belongs on [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper), [MachineryTrader Scraper](https://apify.com/crawloop/machinerytrader-scraper), [AuctionTime Scraper](https://apify.com/crawloop/auctiontime-scraper), [Machinery Pete Scraper](https://apify.com/crawloop/machinerypete-scraper), or [Fastline Scraper](https://apify.com/crawloop/fastline-scraper).

### Key features

- **One schema** — `source` says which site the row came from. Pete and Fastline are optional
- **Retail price and auction bid** on the same table
- **Year, make, model, hours, location, seller**
- **Keyword tokens** kept only when every word appears on the card
- **Phone numbers off by default**
- **US residential proxy** on the shared Cloudflare path

### Input

| Field | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `sources` | String\[] | three Sandhills sites | Add `machinerypete` or `fastline` only when you want those cards |
| `manufacturer` | String | — | Brand filter the site applies (`JOHN DEERE`) |
| `searchQuery` | String | — | Extra words that must appear on the card (`8R 230`) |
| `category` | String | — | Sandhills category id (`1100`), or a name such as `Tractors` on Pete and Fastline |
| `state` | String | — | US state code (`IA`, `TX`) |
| `maxItemsPerSource` | Integer | `20` | Saved cards per marketplace (1–100) |
| `maxPagesPerSource` | Integer | `2` | Search pages per marketplace (1–5) |
| `includePhones` | Boolean | `false` | Keep a phone already printed on the card |
| `monitorMode` | Boolean | `false` | Watch the first recently-added page on each site |
| `monitorStoreName` | String | `farm-equipment-listings-monitor` | Named store for fingerprints. One name per saved search |
| `resetMonitorState` | Boolean | `false` | Clear fingerprints and start a new seed |

Set a manufacturer, category, state, or keywords. A manufacturer is the tightest AuctionTime filter.

#### John Deere across three sites

```json
{
  "sources": ["tractorhouse", "machinerytrader", "auctiontime"],
  "manufacturer": "JOHN DEERE",
  "searchQuery": "8R 230",
  "state": "IA",
  "maxItemsPerSource": 20,
  "maxPagesPerSource": 2
}
```

#### Machinery Pete and Fastline

```json
{
  "sources": ["machinerypete", "fastline"],
  "manufacturer": "JOHN DEERE",
  "maxItemsPerSource": 20,
  "maxPagesPerSource": 1
}
```

#### TractorHouse retail only

```json
{
  "sources": ["tractorhouse"],
  "manufacturer": "KUBOTA",
  "category": "1100",
  "maxItemsPerSource": 40,
  "maxPagesPerSource": 2
}
```

### Output

One dataset row is one listing card.

| Field | Description |
| :--- | :--- |
| `source` / `sourceName` | `tractorhouse`, `machinerytrader`, `auctiontime`, `machinerypete`, or `fastline` |
| `title`, `make`, `model`, `year` | Card identity |
| `price` | Asking price when the card prints a number |
| `currentBid` | Public bid on an auction card |
| `hours` | Meter hours |
| `state`, `location`, `dealerName` | Where it sits and who listed it |
| `auctionDate`, `lotNumber` | Auction card fields |
| `url` | Listing URL |
| `changeType` | Monitor only: `new` or `price_change` |
| `previousPrice` / `previousBid` | Value from the previous tick when the price or bid moved |

```json
{
  "source": "tractorhouse",
  "sourceName": "TractorHouse",
  "id": "257864499",
  "title": "2021 JOHN DEERE 8R 230",
  "make": "JOHN DEERE",
  "model": "8R 230",
  "year": "2021",
  "price": 249000,
  "currency": "USD",
  "hours": "1450",
  "state": "IA",
  "dealerName": "Example Dealer",
  "url": "https://www.tractorhouse.com/listing/for-sale/257864499"
}
```

### Monitor

Turn on `monitorMode` and schedule the same input. The Actor reads **one recently-added page** on each selected site (about 28 cards) and stores a fingerprint in the named key-value store.

- The **first run is a seed**. It caches the cards already on that page and writes **no dataset rows**.
- Later runs write a row only when a card is **new** or its **asking price or bid** changed. `changeType` is `new` or `price_change`.
- A quiet tick still opens those three pages, then stops. It does not open listing pages and it does not walk page 2.
- Give each saved search its own `monitorStoreName`. `resetMonitorState` starts the seed over.

```json
{
  "monitorMode": true,
  "monitorStoreName": "deere-8r-230-watch",
  "sources": ["tractorhouse", "machinerytrader", "auctiontime"],
  "manufacturer": "JOHN DEERE",
  "searchQuery": "8R 230",
  "maxPagesPerSource": 1
}
```

### Use cases

- A dealer desk prices a trade-in from live asking prices and public auction cards
- A lender pulls a one-page comp set for a model and a state
- An analyst tracks which marketplace is listing a model this week
- An integration stores `source` + `id` and refreshes the same search on a schedule

### 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/farm-equipment-listings-scraper").call({
  sources: ["tractorhouse", "machinerytrader", "auctiontime"],
  manufacturer: "JOHN DEERE",
  searchQuery: "8R 230",
  maxItemsPerSource: 20,
  maxPagesPerSource: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("crawloop/farm-equipment-listings-scraper").call(run_input={
    "sources": ["tractorhouse", "machinerytrader", "auctiontime"],
    "manufacturer": "JOHN DEERE",
    "searchQuery": "8R 230",
    "maxItemsPerSource": 20,
    "maxPagesPerSource": 1,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~farm-equipment-listings-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"manufacturer":"JOHN DEERE","searchQuery":"8R 230","maxItemsPerSource":10,"maxPagesPerSource":1}'
```

### 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/farm-equipment-listings-scraper`.

Example prompts:

- "Run Farm Equipment Listings Scraper for JOHN DEERE 8R 230 and return the rows as JSON grouped by marketplace"
- "Compare TractorHouse asking prices and AuctionTime bids for a used Kubota tractor in Iowa"
- "Chain Farm Equipment Listings Scraper, then open TractorHouse Scraper when I need the full dealer monitor for one yard"

### Suite next step

For a raw dump or a scheduled dealer watch on one site, run [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper). For construction iron only, run [MachineryTrader Scraper](https://apify.com/crawloop/machinerytrader-scraper). For auction lots and dates, run [AuctionTime Scraper](https://apify.com/crawloop/auctiontime-scraper). For ZIP and by-owner cards, run [Machinery Pete Scraper](https://apify.com/crawloop/machinerypete-scraper). For a Fastline dealer watch, run [Fastline Scraper](https://apify.com/crawloop/fastline-scraper).

### FAQ

**Which pages are read?** Public search cards. The default run is TractorHouse, MachineryTrader, and AuctionTime. Machinery Pete and Fastline run only when selected. Lot pages stay on the single-site Actors.

**Why are Pete and Fastline off by default?** A monitor tick reads one page per selected site. Leaving them out keeps the scheduled watch on the three Sandhills pages.

**Why set a manufacturer?** AuctionTime’s public HTML applies the brand, category, and state on the server. A keyword is applied to the cards this Actor already fetched, so a brand keeps the run short.

**Where are phone numbers?** Off unless `includePhones` is true. The number has to already be on the public card.

**What does a monitor run return?** The first run returns an empty dataset and stores fingerprints. The next runs return only new cards and price or bid changes. Schedule that same input; keep one `monitorStoreName` per search.

### Related Actors

- [TractorHouse Scraper](https://apify.com/crawloop/tractorhouse-scraper)
- [MachineryTrader Scraper](https://apify.com/crawloop/machinerytrader-scraper)
- [AuctionTime Scraper](https://apify.com/crawloop/auctiontime-scraper)
- [Machinery Pete Scraper](https://apify.com/crawloop/machinerypete-scraper)
- [Fastline Scraper](https://apify.com/crawloop/fastline-scraper)

# Actor input Schema

## `sources` (type: `array`):

Sites to search in this run. The default three are Sandhills retail and auction cards. Machinery Pete and Fastline are optional and stay out of a default monitor tick.

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

Brand filter applied by the site, such as JOHN DEERE, CASE IH, or KUBOTA. This is the tightest way to search AuctionTime.

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

Extra words that must appear in the title, make, model, or description, such as 8R 230. A keyword alone is a loose filter. Pair it with a manufacturer.

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

Sandhills category id (1100 is tractors on TractorHouse), or a category name such as Tractors for Machinery Pete and Fastline. A numeric id is ignored on those two sites.

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

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

## `maxItemsPerSource` (type: `integer`):

Maximum saved cards from each selected site.

## `maxPagesPerSource` (type: `integer`):

Maximum search pages to open on each site. One page is about 28 cards before the keyword filter.

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

First run stores fingerprints for the first page on each site and writes no dataset rows. Later runs write only new cards and price or bid changes. A tick always reads one recently-added page per marketplace.

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

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

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

Clear stored fingerprints before this run. The run becomes a new seed and writes no dataset rows.

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

Off by default. Include a phone already printed on the public card only when you have a lawful basis.

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

US residential proxies. The same path is used for every selected site.

## Actor input object example

```json
{
  "sources": [
    "tractorhouse",
    "machinerytrader",
    "auctiontime"
  ],
  "manufacturer": "JOHN DEERE",
  "category": "1100",
  "maxItemsPerSource": 20,
  "maxPagesPerSource": 2,
  "monitorMode": false,
  "monitorStoreName": "farm-equipment-listings-monitor",
  "resetMonitorState": false,
  "includePhones": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

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

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

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

```

## MCP server setup

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