# MachineryPete Equipment Price Scraper (`crawlerbros/machinerypete-equipment-price-scraper`) Actor

Scrape used ag and construction equipment listings from MachineryPete.com - tractors, combines, planters, tillage, hay & forage, construction equipment, trucks & trailers, and more. Get title, make, model, year, price, condition, hours, seller location, and images for equipment price benchmarking.

- **URL**: https://apify.com/crawlerbros/machinerypete-equipment-price-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (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 $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## MachineryPete Equipment Price Scraper

Scrape used ag and construction equipment listings from [MachineryPete.com](https://www.machinerypete.com) — tractors, combines, planters, tillage tools, hay & forage equipment, construction machinery, trucks & trailers, livestock equipment, and more. Get title, make, model, year, price, condition, hours of use, seller/location, images, and full technical specs for equipment price benchmarking, market research, and inventory tracking. No login, no cookies, no paid proxy required.

### What this actor does

- **Browse by category and subcategory** — 14 top-level categories (Tractors, Harvesting, Planting, Tillage, Hay & Forage, Applicators, Grain Handling, Loaders & Lifts, Construction, Trucks & Trailers, Livestock Equipment, Specialty Crops, Lawn & Garden, Other) and 147 equipment-type subcategories (Combines, Excavators, Balers, Skid Steers, Dump Trucks, etc.)
- **Filter by make** — curated dropdown of 38 common ag/construction/truck manufacturers (John Deere, Case IH, New Holland, Caterpillar, Kubota, Kenworth, and more), plus a free-text override for any manufacturer
- **Filter by model, year range, price range, and seller type** (dealer / private seller / auction)
- **Full listing detail enrichment** — optionally fetches each listing's detail page for exact location (city/state), hours of use, condition, serial number, and detailed technical specs (drive, transmission, cab options, tire type, and more)
- **Empty fields are omitted** — every record only contains fields the source actually provided

### Output per listing

- `listingId`, `title`, `make`, `model`, `year`
- `price`, `currency` (omitted for "call for price" listings)
- `category`, `subcategory`, `categorySlug`, `subcategorySlug`
- `condition` (from detail page), `hoursOfUse`, `serialNumber`, `specs` (technical spec key/value map)
- `sellerType` (Dealer / Private Seller / Auction), `sellerName`, `sellerProfileUrl`, `auctionName`
- `location`, `street`, `city`, `state`, `postalCode`, `country`, `fullAddress`
- `imageUrl`, `description` (from detail page), `offers` (financing/shipping/tires/warranty availability)
- `listingDetailUrl`, `sourceUrl`, `postedDate`
- `recordType: "equipmentListing"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `category` | string (select) | `tractors` | Top-level equipment category |
| `subcategory` | string (select) | `tractors/175-299-hp` | Equipment type within the category |
| `customSubcategory` | string | – | Raw `category/subcategory-slug` override, for subcategories not in the dropdown |
| `make` | string (select) | – | Filter to a specific manufacturer |
| `customMake` | string | – | Manufacturer slug override, for makes not in the dropdown |
| `model` | string | – | Only keep listings whose model/title contains this text |
| `yearMin` / `yearMax` | integer | – | Manufacture year range |
| `priceMin` / `priceMax` | integer | – | Price range in USD (listings without a public price always pass through) |
| `sellerType` | string (select) | `any` | `any` / `dealer` / `privateSeller` / `auction` |
| `includeDetails` | boolean | `true` | Fetch each listing's detail page for location, hours, condition, and specs (capped at 200 listings/run) |
| `maxItems` | integer | `30` | Hard cap on emitted records (1–2000) |

#### Example: Case IH tractors, 175-299 HP, under $150k

```json
{
  "category": "tractors",
  "subcategory": "tractors/175-299-hp",
  "make": "case-ih",
  "priceMax": 150000,
  "maxItems": 50
}
````

#### Example: John Deere combines built since 2015

```json
{
  "category": "harvesting",
  "subcategory": "harvesting/combines",
  "make": "john-deere",
  "yearMin": 2015,
  "maxItems": 100
}
```

#### Example: Caterpillar excavators from dealers only

```json
{
  "category": "construction",
  "subcategory": "construction/excavators",
  "make": "caterpillar",
  "sellerType": "dealer"
}
```

### Use cases

- **Equipment price benchmarking** — track resale values for a make/model across time and region
- **Dealer inventory monitoring** — watch what a category of equipment is listing for nationally
- **Market research** — analyze pricing trends by HP class, equipment type, or manufacturer
- **Lead generation** — surface private-seller ("by owner") listings for a specific make/model
- **Auction tracking** — find equipment listed through linked auction promotions

### FAQ

**What's MachineryPete?** A marketplace and price-benchmarking service for used agricultural and construction equipment, aggregating dealer, private-seller, and auction listings across North America.

**Why do I need both `category` and `subcategory`?** MachineryPete's listing pages are organized by category → equipment type (e.g. Harvesting → Combines) or, for tractors, category → horsepower band (e.g. Tractors → 175-299 HP). Both segments are required to reach a real listings page.

**Why is `price` sometimes missing?** Some listings — especially dealer "Request a Quote" equipment — don't publish a price. The actor never fabricates a price; it omits the field instead.

**What if my make isn't in the dropdown?** Use `customMake` with the manufacturer's URL slug (lowercase, hyphenated — e.g. `versatile`, `bourgault`, `mahindra`). Most manufacturer names map directly to their lowercase-hyphenated form.

**Does the actor use MachineryPete's keyword search?** No — the free-text `custom-search` page is protected by a bot-detection JS challenge that requires a real browser to solve. The actor instead uses the fully public category/subcategory/make browse pages, which return complete listing data with no restrictions, and applies `model`, price, and year filters client-side for equivalent precision.

**Can I sort results (e.g. by price or year)?** Not currently. MachineryPete's browse pages have a visible "Sort" dropdown (Relevance / Nearest / Most Photos / Price / Year / Most Recently Added), but the sort order is set through a stateful POST to an internal endpoint guarded by the same bot-detection challenge as keyword search — it can't be driven reliably via a plain URL parameter. Sort was evaluated for this actor and excluded rather than shipped as an unreliable feature; `yearMin`/`yearMax` and `priceMin`/`priceMax` cover most filtering needs in the meantime.

**What happens if I set `category` but leave `subcategory` blank?** The actor falls back to the first subcategory belonging to your chosen category (rather than defaulting to Tractors) so your category choice is always respected. For precise results, pick both from the dropdowns or use `customSubcategory`.

**How fresh is the data?** Listings are scraped live on every run — MachineryPete's dealer and private-seller inventory updates continuously.

**Can I browse a specific dealer's full inventory?** Not as a dedicated mode in this version. MachineryPete does have public per-dealer store pages (`machinerypete.com/store/{dealer-slug}`) that list a dealer's current inventory in the same underlying data format the category/subcategory browse pages use, but they aren't exposed as an actor mode yet — this actor is category/subcategory-first. Considered a reliable, valuable future addition (no auth/bot-detection barrier observed), but out of scope for this finalization pass since it would require a new lookup mode rather than a small tweak.

# Actor input Schema

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

Top-level equipment category to browse.

## `subcategory` (type: `string`):

Equipment type within the category (e.g. Combines, Excavators, HP range for tractors). Must belong to the selected category.

## `customSubcategory` (type: `string`):

Override `subcategory` with a raw `category/subcategory-slug` pair not in the dropdown (e.g. a newly added MachineryPete subcategory). Takes precedence over `subcategory` when set.

## `make` (type: `string`):

Filter listings to a specific equipment make. Leave blank to include all makes in the category/subcategory.

## `customMake` (type: `string`):

Override `make` with any manufacturer slug not in the dropdown (lowercase, hyphenated, e.g. `versatile`, `hesston`, `bourgault`). Takes precedence over `make` when set.

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

Only keep listings whose model/title contains this text (case-insensitive, e.g. `8320` or `Magnum`).

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

Drop listings manufactured before this year.

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

Drop listings manufactured after this year.

## `priceMin` (type: `integer`):

Drop listings priced below this amount. Listings without a public price (e.g. "Call for price") always pass through.

## `priceMax` (type: `integer`):

Drop listings priced above this amount. Listings without a public price (e.g. "Call for price") always pass through.

## `sellerType` (type: `string`):

Filter by who's selling the equipment.

## `includeDetails` (type: `boolean`):

Fetch each listing's detail page for location, hours of use, condition, serial number, and full specs. Adds one extra request per listing (capped at 200 listings per run for runtime).

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "category": "tractors",
  "subcategory": "tractors/175-299-hp",
  "sellerType": "any",
  "includeDetails": true,
  "maxItems": 30
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped equipment listings.

# 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": "tractors",
    "subcategory": "tractors/175-299-hp",
    "sellerType": "any",
    "includeDetails": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/machinerypete-equipment-price-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 = {
    "category": "tractors",
    "subcategory": "tractors/175-299-hp",
    "sellerType": "any",
    "includeDetails": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/machinerypete-equipment-price-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "tractors",
  "subcategory": "tractors/175-299-hp",
  "sellerType": "any",
  "includeDetails": false,
  "maxItems": 30
}' |
apify call crawlerbros/machinerypete-equipment-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/machinerypete-equipment-price-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MachineryPete Equipment Price Scraper",
        "description": "Scrape used ag and construction equipment listings from MachineryPete.com - tractors, combines, planters, tillage, hay & forage, construction equipment, trucks & trailers, and more. Get title, make, model, year, price, condition, hours, seller location, and images for equipment price benchmarking.",
        "version": "1.0",
        "x-build-id": "DxMWrtrcZII49TQlq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~machinerypete-equipment-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-machinerypete-equipment-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~machinerypete-equipment-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-machinerypete-equipment-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~machinerypete-equipment-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-machinerypete-equipment-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "category",
                    "subcategory"
                ],
                "properties": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "applicators",
                            "construction",
                            "grain-handling",
                            "harvesting",
                            "hay-and-forage",
                            "lawn-and-garden",
                            "livestock-equipment",
                            "loaders-and-lifts",
                            "other",
                            "planting",
                            "specialty-crops",
                            "tillage",
                            "tractors",
                            "trucks-and-trailers"
                        ],
                        "type": "string",
                        "description": "Top-level equipment category to browse.",
                        "default": "tractors"
                    },
                    "subcategory": {
                        "title": "Subcategory",
                        "enum": [
                            "applicators/fertilizer-spreaders",
                            "applicators/manure-pumps",
                            "applicators/manure-spreaders",
                            "applicators/pull-type-fertilizer-spreaders",
                            "applicators/pull-type-sprayers",
                            "applicators/self-propelled-fertilizer-spreaders",
                            "applicators/self-propelled-sprayers",
                            "applicators/sprayers",
                            "applicators/toolbars",
                            "construction/backhoe-and-excavator-attachments",
                            "construction/backhoes",
                            "construction/compacting-and-paving",
                            "construction/cranes",
                            "construction/crawlers",
                            "construction/dozers",
                            "construction/excavators",
                            "construction/mini-excavators",
                            "construction/scissor-boom-lifts",
                            "construction/scrapers",
                            "construction/trenchers",
                            "grain-handling/augers-and-conveyors",
                            "grain-handling/grain-bag-unloaders",
                            "grain-handling/grain-baggers",
                            "grain-handling/grain-bins",
                            "grain-handling/grain-carts",
                            "grain-handling/grain-cleaners",
                            "grain-handling/grain-dryers",
                            "grain-handling/grain-trailers",
                            "grain-handling/grain-vacs",
                            "grain-handling/gravity-wagons",
                            "harvesting/combines",
                            "harvesting/corn-heads",
                            "harvesting/corn-pickers",
                            "harvesting/forage-harvester-heads",
                            "harvesting/forage-harvesters",
                            "harvesting/harvesting-attachments",
                            "harvesting/headers",
                            "harvesting/platforms",
                            "harvesting/pull-type-forage-harvesters",
                            "harvesting/self-propelled-forage-harvesters",
                            "hay-and-forage/bale-processors",
                            "hay-and-forage/bale-wagons-and-trailers",
                            "hay-and-forage/bale-wrappers",
                            "hay-and-forage/balers",
                            "hay-and-forage/batwing-mowers",
                            "hay-and-forage/big-square-balers",
                            "hay-and-forage/disk-mowers",
                            "hay-and-forage/forage-baggers",
                            "hay-and-forage/forage-blowers",
                            "hay-and-forage/forage-wagons",
                            "hay-and-forage/hay-racks",
                            "hay-and-forage/hay-stacking-equipment",
                            "hay-and-forage/hay-tools",
                            "hay-and-forage/inverters",
                            "hay-and-forage/mergers",
                            "hay-and-forage/mower-conditioners",
                            "hay-and-forage/mowers",
                            "hay-and-forage/pull-type-windrowers-and-swathers",
                            "hay-and-forage/rakes",
                            "hay-and-forage/rotary-cutters",
                            "hay-and-forage/round-balers",
                            "hay-and-forage/self-propelled-windrowers-and-swathers",
                            "hay-and-forage/sickle-mowers",
                            "hay-and-forage/small-square-balers",
                            "hay-and-forage/tedders",
                            "hay-and-forage/windrowers-and-swathers",
                            "lawn-and-garden/accessories-and-attachments",
                            "lawn-and-garden/lawn-mowers",
                            "livestock-equipment/cattle-equipment",
                            "livestock-equipment/feed-bins",
                            "livestock-equipment/feed-wagons",
                            "livestock-equipment/grinders-and-mixers",
                            "livestock-equipment/hog-equipment",
                            "livestock-equipment/horse-equipment",
                            "livestock-equipment/livestock-trailers",
                            "livestock-equipment/milking-equipment",
                            "livestock-equipment/roller-mills",
                            "loaders-and-lifts/forklifts",
                            "loaders-and-lifts/front-end-loaders",
                            "loaders-and-lifts/loader-and-skid-steer-attachments",
                            "loaders-and-lifts/skid-steers",
                            "loaders-and-lifts/telehandlers",
                            "loaders-and-lifts/wheel-loaders",
                            "other/agricultural-drones",
                            "other/atvs-and-utility-vehicles",
                            "other/blades",
                            "other/cars",
                            "other/field-drainage-equipment",
                            "other/forestry-and-mining",
                            "other/generators",
                            "other/irrigation",
                            "other/miscellaneous",
                            "other/post-hole-diggers",
                            "other/precision-ag",
                            "other/rock-pickers",
                            "other/snow-blowers",
                            "other/tanks",
                            "other/wheels-tires-tracks",
                            "planting/air-seeders",
                            "planting/drill-fills",
                            "planting/drills",
                            "planting/planter-and-drill-attachments",
                            "planting/planters",
                            "planting/seed-tenders",
                            "specialty-crops/bean-bars",
                            "specialty-crops/beets",
                            "specialty-crops/cotton",
                            "specialty-crops/orchard-vineyard",
                            "specialty-crops/peanuts",
                            "specialty-crops/potato",
                            "specialty-crops/sugar-cane",
                            "specialty-crops/tobacco",
                            "specialty-crops/vegetables",
                            "tillage/chisel-plows",
                            "tillage/cultivators",
                            "tillage/disk-chisels",
                            "tillage/disks",
                            "tillage/field-cultivators",
                            "tillage/flail-choppers-stalk-choppers",
                            "tillage/harrows",
                            "tillage/in-line-rippers",
                            "tillage/land-rollers",
                            "tillage/mulchers-cultipackers",
                            "tillage/plows",
                            "tillage/rotary-hoes",
                            "tillage/soil-finishers",
                            "tillage/strip-till",
                            "tillage/v-rippers",
                            "tillage/vertical-tillage",
                            "tractors/100-174-hp",
                            "tractors/175-299-hp",
                            "tractors/300-hp",
                            "tractors/40-99-hp",
                            "tractors/under-40-hp",
                            "trucks-and-trailers/belt-trailers",
                            "trucks-and-trailers/box-trucks-trailers",
                            "trucks-and-trailers/bucket-service-trucks",
                            "trucks-and-trailers/construction-trucks-trailers",
                            "trucks-and-trailers/dump-trucks-trailers",
                            "trucks-and-trailers/flatbed-trucks-trailers",
                            "trucks-and-trailers/fuel-trucks-trailers",
                            "trucks-and-trailers/grain-trucks",
                            "trucks-and-trailers/header-trailers",
                            "trucks-and-trailers/implement-caddies",
                            "trucks-and-trailers/pickups",
                            "trucks-and-trailers/semi-trucks-trailers",
                            "trucks-and-trailers/truck-beds"
                        ],
                        "type": "string",
                        "description": "Equipment type within the category (e.g. Combines, Excavators, HP range for tractors). Must belong to the selected category.",
                        "default": "tractors/175-299-hp"
                    },
                    "customSubcategory": {
                        "title": "Custom subcategory override (advanced)",
                        "type": "string",
                        "description": "Override `subcategory` with a raw `category/subcategory-slug` pair not in the dropdown (e.g. a newly added MachineryPete subcategory). Takes precedence over `subcategory` when set."
                    },
                    "make": {
                        "title": "Make / manufacturer",
                        "enum": [
                            "john-deere",
                            "case-ih",
                            "new-holland",
                            "caterpillar",
                            "kubota",
                            "agco",
                            "claas",
                            "vermeer",
                            "bobcat",
                            "komatsu",
                            "massey-ferguson",
                            "kinze",
                            "krone",
                            "jcb",
                            "gehl",
                            "bush-hog",
                            "land-pride",
                            "great-plains",
                            "sunflower",
                            "fendt",
                            "challenger",
                            "ford",
                            "international",
                            "kenworth",
                            "peterbilt",
                            "freightliner",
                            "mack",
                            "volvo",
                            "hesston",
                            "gleaner",
                            "deutz-fahr",
                            "kverneland",
                            "mccormick",
                            "bourgault",
                            "salford",
                            "unverferth",
                            "mahindra",
                            "kioti",
                            "yanmar"
                        ],
                        "type": "string",
                        "description": "Filter listings to a specific equipment make. Leave blank to include all makes in the category/subcategory."
                    },
                    "customMake": {
                        "title": "Custom make override (advanced)",
                        "type": "string",
                        "description": "Override `make` with any manufacturer slug not in the dropdown (lowercase, hyphenated, e.g. `versatile`, `hesston`, `bourgault`). Takes precedence over `make` when set."
                    },
                    "model": {
                        "title": "Model contains",
                        "type": "string",
                        "description": "Only keep listings whose model/title contains this text (case-insensitive, e.g. `8320` or `Magnum`)."
                    },
                    "yearMin": {
                        "title": "Year (min)",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop listings manufactured before this year."
                    },
                    "yearMax": {
                        "title": "Year (max)",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop listings manufactured after this year."
                    },
                    "priceMin": {
                        "title": "Price (min, USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings priced below this amount. Listings without a public price (e.g. \"Call for price\") always pass through."
                    },
                    "priceMax": {
                        "title": "Price (max, USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop listings priced above this amount. Listings without a public price (e.g. \"Call for price\") always pass through."
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "any",
                            "dealer",
                            "privateSeller",
                            "auction"
                        ],
                        "type": "string",
                        "description": "Filter by who's selling the equipment.",
                        "default": "any"
                    },
                    "includeDetails": {
                        "title": "Fetch full listing details",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page for location, hours of use, condition, serial number, and full specs. Adds one extra request per listing (capped at 200 listings per run for runtime).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
