# Machinery Sold Prices — Equipment Auction Database (`rastriq/machinery-sold-prices`) Actor

Hammer prices of 750K+ heavy equipment & truck auctions (Ritchie Bros, IronPlanet, GovPlanet, 2024–2026). Make, model, year, hours, sale date. Filter by category, brand, model, country.

- **URL**: https://apify.com/rastriq/machinery-sold-prices.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Business
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 result rows

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

## Machinery Sold Prices — Heavy Equipment Auction Price Database

**Machinery Sold Prices** gives you the final **hammer prices of 750,000+ heavy equipment and truck auctions** sold on Ritchie Bros, IronPlanet, GovPlanet, TruckPlanet and Marketplace-E between 2024 and 2026. Every record is cleaned and ready for **used equipment valuation**: make, model, year of manufacture, hours/km, sale date, country and sold price.

No scraping wait and no blocked requests: Machinery Sold Prices serves a curated, monthly-updated database, so most runs finish in seconds.

### 🏗️ What is Machinery Sold Prices?

Pricing used machinery is hard: asking prices are inflated, dealer quotes are opaque, and auction results are scattered across thousands of event pages. Machinery Sold Prices collects the **actual sold prices** of completed Ritchie Bros auctions, removes duplicates and noise, and lets you pull exactly the comparables you need — by category, brand, model, sale date, year of manufacture and country.

It is built for appraisers, equipment dealers, lenders, lessors, insurers, fleet managers and market analysts who need **heavy equipment auction results** without building a scraper.

### 📊 What data does Machinery Sold Prices include?

| Field | Description |
|---|---|
| 💰 `price`, `currency` | Final hammer price in the auction's original currency (USD, CAD, EUR, AUD, GBP…) |
| 📅 `sold_at` | Date and time the lot was sold |
| 🏭 `make`, `model` | Brand and model (e.g. Caterpillar 320, Komatsu D65EX-17) |
| 🔎 `model_key`, `model_family` | Normalized model (`M2 106` = `M2106`) and model family (`D6T`, `D6N` → `d6`) for grouping comparables |
| 📆 `year` | Year of manufacture |
| ⏱️ `usage` | Hours or kilometers/miles at sale (`12684 h`, `627387 km`) |
| 🗂️ `industry`, `category`, `asset_type` | Construction › Excavators › Crawler Excavator |
| 📏 `spec_main` | Main size/capacity from the listing (`53 ft`, `4500 lb`, `20 kW`) |
| 🌍 `country`, `platform`, `sale_event` | Where and on which marketplace it sold |
| 🔨 `bid_count`, `buying_format` | Auction competitiveness and format |
| 📦 `lot_qty`, `price_per_unit` | Multi-unit lots ("Quantity of (12)…") with unit price |
| ✅ `unused`, `inoperable` | Condition flags |
| 🔗 `url`, `asset_description` | Original lot link and title |

#### Data quality applied to every record

- One record per auction lot (duplicates removed).
- Only lots with a usable **make and model** are kept.
- Loose parts, attachments, low-value unused imports and non-equipment lots are excluded.
- Make, model and year recovered from the lot title when the source field was empty — `make_source`, `model_source` and `year_source` tell you which values were inferred.
- 75% of lots have **10+ comparable sales** of the same make and model.

### 🚀 How to use Machinery Sold Prices to get equipment auction results

1. Open **Machinery Sold Prices** and pick at least one **category**, **industry** or **make**.
2. Optionally narrow by **model**, **sale month**, **year of manufacture**, **country** or exclude unused equipment.
3. Choose the output: **Dataset rows** (up to 200,000, most recent sales first) or **Single file** (all matches in one Parquet or CSV file — best for bulk analysis).
4. Click **Start**. Download results as JSON, CSV, Excel or via API, or connect them to Google Sheets, Make, Zapier or your BI tool.

### ⚙️ Input parameters

| Parameter | Type | Description |
|---|---|---|
| `category` | list | Equipment category, e.g. Excavators, Truck Tractors, Wheel Loaders |
| `industry` | list | Construction, Trucks & Trailers, Agriculture, Forklifts, Cranes… |
| `make` | list | Brands, case-insensitive (`Cat` = Caterpillar) |
| `model` | text | Model or family (`320`, `D6`, `Cascadia 125`) |
| `soldFrom` / `soldTo` | YYYY-MM | Auction month range |
| `yearMin` / `yearMax` | number | Year of manufacture range |
| `country` | list | ISO-2 country of the auction site (`US`, `CA`, `AU`, `NL`…) |
| `excludeUnused` | boolean | Keep only used equipment |
| `outputMode` | dataset / file | Rows in the dataset, or one bulk file |
| `maxItems` | number | Max rows in dataset mode (default 5,000) |

#### Example input

```json
{
  "category": ["Excavators"],
  "make": ["Caterpillar", "Komatsu"],
  "soldFrom": "2025-01",
  "yearMin": 2015,
  "maxItems": 5000
}
```

### 📤 Output example

```json
{
  "item_id": "757658CA-E6D3-47EA-8663-AAB06FE89C9A",
  "sold_at": "2026-07-15T16:10:50",
  "make": "Komatsu",
  "model": "D65EX-17",
  "model_family": "d65",
  "year": 2014,
  "usage": "12684 h",
  "price": 30000,
  "currency": "USD",
  "lot_qty": 1,
  "price_per_unit": 30000,
  "category": "Dozers",
  "asset_type": "Crawler Dozer",
  "country": "US",
  "platform": "Ritchie Bros. Auctioneers",
  "bid_count": 87,
  "_data_version": "2026-10"
}
```

### 💰 How much does it cost to get heavy equipment sold prices?

Machinery Sold Prices uses **pay-per-event** pricing — you only pay for the data you get:

| Event | Price |
|---|---|
| Actor start | $0.005 |
| Database query (once per run that returns data) | $0.03 |
| Result row (dataset mode) | $0.0025 |
| Exported row (file mode) | $0.001 |

Examples:

- **1,000 recent sales of one model** (dataset mode): ≈ $2.54
- **All 57,000+ excavator sales** as one Parquet file: ≈ $57.80
- With Apify's **$5 free credit** you can pull roughly **1,900 sold prices** to test the data.

> 💡 Use **file mode** for bulk downloads: it is 60% cheaper per row than dataset rows.

### 🔗 Related Actors

- [Ritchie Bros Scraper](https://apify.com/rastriq/rbauction-scraper) — live Ritchie Bros, IronPlanet and GovPlanet listings plus the latest month of sold auctions.
- [RitchieSpecs Catalog Scraper](https://apify.com/rastriq/ritchiespecs-catalog-scraper) — technical specifications for thousands of equipment models, to enrich your valuations.

### ❓ FAQ

**Where does the data come from?** From publicly visible completed auctions on Ritchie Bros Auctioneers and its marketplaces (IronPlanet, GovPlanet, TruckPlanet, Marketplace-E). Machinery Sold Prices does not access any login-protected data.

**How fresh is Machinery Sold Prices?** The database is rebuilt every month; `_data_version` shows the snapshot month. For auctions that closed in the last weeks or for live listings, use [Ritchie Bros Scraper](https://apify.com/rastriq/rbauction-scraper).

**Are prices converted to one currency?** No. Prices stay in the auction's original `currency`, so you can apply your own FX rates.

**Why can't I search without filters?** To keep runs fast and focused, choose at least a category, industry or make — or use file mode to export the full database.

**Can I use this data for valuations or credit models?** Yes, that is its main use. Always combine auction results with condition, hours and inspection data for individual appraisals.

**Something missing or wrong?** Open an issue on the Actor's Issues tab — we usually answer within one business day.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/machinery-sold-prices/changelog.md

# Actor input Schema

## `category` (type: `array`):

Equipment category (e.g. Excavators, Truck Tractors). Pick at least one category, industry or make.

## `industry` (type: `array`):

Broad industry. Use it to pull a whole sector.

## `make` (type: `array`):

Brands, e.g. Caterpillar, Komatsu, John Deere. Case-insensitive; 'Cat' = Caterpillar.

## `model` (type: `string`):

Model or model family, e.g. 320 or D6. Matches normalized model (spaces/hyphens ignored).

## `soldFrom` (type: `string`):

First auction month, YYYY-MM.

## `soldTo` (type: `string`):

Last auction month (inclusive), YYYY-MM.

## `yearMin` (type: `integer`):

Oldest year of manufacture to include.

## `yearMax` (type: `integer`):

Newest year of manufacture to include.

## `country` (type: `array`):

ISO-2 country codes of the auction site, e.g. US, CA, AU, NL.

## `excludeUnused` (type: `boolean`):

Keep only used equipment.

## `outputMode` (type: `string`):

<b>dataset</b>: results as rows in the run dataset. <b>file</b>: one Parquet/CSV file with all matches (cheaper per row, no row limit).

## `fileFormat` (type: `string`):

Format of the bulk file in file mode.

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

Most recent sales first.

## Actor input object example

```json
{
  "category": [
    "Excavators"
  ],
  "make": [
    "Caterpillar"
  ],
  "excludeUnused": false,
  "outputMode": "dataset",
  "fileFormat": "parquet",
  "maxItems": 5000
}
```

# Actor output Schema

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

No description

## `export` (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 = {
    "category": [
        "Excavators"
    ],
    "make": [
        "Caterpillar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/machinery-sold-prices").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 = {
    "category": ["Excavators"],
    "make": ["Caterpillar"],
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/machinery-sold-prices").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 '{
  "category": [
    "Excavators"
  ],
  "make": [
    "Caterpillar"
  ]
}' |
apify call rastriq/machinery-sold-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/machinery-sold-prices"
        }
    }
}
```

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/Mj5bkCStyJNIlpmmj/builds/WeoyrROECnPyEEwXR/openapi.json