# RitchieSpecs Catalog Scraper (`rastriq/ritchiespecs-catalog-scraper`) Actor

New actor improved.
Extract categories, model lists, and full machine specifications from the public RitchieSpecs API.

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

## Pricing

from $1.90 / 1,000 results

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## RitchieSpecs Scraper - Heavy Equipment Specifications at Scale

Extract complete machine specifications, model inventories, and equipment categories from RitchieSpecs. Get detailed specs for excavators, wheel loaders, forklifts, cranes, and 70+ equipment types - export to JSON, CSV, or Excel and integrate with any workflow.

> ?? **Try it free** - no credit card required.


### ?? What is RitchieSpecs Scraper?

**RitchieSpecs Scraper** is a ready-to-use data extraction tool that delivers structured machine specifications from the complete RitchieSpecs catalog. It covers 7 industry sectors, 55 equipment types, and thousands of models from all major manufacturers - Caterpillar, Komatsu, John Deere, Volvo, Liebherr, JCB, Hitachi, and many more.

Use RitchieSpecs Scraper to:

- ?? **Build equipment reference databases** - get complete specs for thousands of heavy machinery models in one run
- ?? **Power market intelligence platforms** - feed model data into competitive analysis and pricing benchmarks
- ??? **Enrich listing data** - match marketplace listings (Mascus, IronPlanet, Ritchie Bros) with manufacturer specifications
- ?? **Automate recurring inventory scans** - schedule runs to track new models added to the RitchieSpecs catalog

The Apify platform gives RitchieSpecs Scraper superpowers: **scheduling**, **monitoring**, **programmatic access**, and **integrations** with Make, Zapier, Google Sheets, and more - all out of the box.


### ?? What data does RitchieSpecs Scraper extract?

RitchieSpecs Scraper returns structured data with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `manufacturer` | string | Brand name (Caterpillar, Komatsu, Volvo, etc.) |
| `modelName` | string | Full model name including manufacturer |
| `modelNumber` | string | Short model number or code |
| `categoryGroup` | string | Top-level group (Construction, Mining, Agriculture) |
| `categoryName` | string | Equipment type (Wheel Loader, Mini Excavator, etc.) |
| `modelParams` | array | Key parameters with imperial + metric values |
| `specifications` | array | Full spec groups: Engine, Operational, Hydraulic, etc. |
| `dimensions` | array | Physical dimensions (length, width, height, clearance) |
| `drawings` | array | Technical drawing image URLs |
| `urls` | object | Cross-reference links to IronPlanet, Mascus, Ritchie Bros |
| `similarModels` | array | Comparable models suggested by RitchieSpecs |
| `detailUrl` | string | Direct link to the spec page on RitchieSpecs |
| `scrapedAt` | string | Extraction timestamp |

> ?? Specification fields (`modelParams`, `specifications`, `dimensions`, `drawings`) are only populated when **Include full specs** is enabled.


### ?? How to use RitchieSpecs Scraper

Extracting heavy equipment specifications takes under two minutes:

1. **Create a free Apify account** at [apify.com](https://apify.com)
2. **Open RitchieSpecs Scraper** in Apify Console or click **Try for free** on this page
3. **Pick equipment types** - select one or more from the dropdown (e.g. ??? Wheel Loader, ?? Combine) or select entire **Category groups** to include all equipment in a sector
4. **Filter by manufacturer** (optional) - enter brand slugs like `caterpillar`, `komatsu`, `john-deere` to narrow results
5. **Click Start** and wait - the scraper discovers models and retrieves full specs automatically
6. **Download your results** in JSON, CSV, Excel, or XML

**Example input for a quick test run:**

```json
{
  "equipmentTypes": ["wheel-loader", "hydraulic-excavator"],
  "manufacturerFilter": ["caterpillar"],
  "maxModelsPerCategory": 10,
  "includeDetails": true
}
````

### ?? Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `equipmentTypes` | array | ? | `[]` | Equipment types to extract - pick from 55 categories with visual chips |
| `categoryGroups` | array | ? | `[]` | Select entire sectors (Agriculture, Construction, Forestry, etc.) |
| `manufacturerFilter` | array | ? | `[]` | Filter results to specific brands (e.g. `caterpillar`, `komatsu`) |
| `maxModelsPerCategory` | integer | ? | `25` | Max models to process per equipment type |
| `includeDetails` | boolean | ? | `true` | Retrieve full specs (engine, dimensions, drawings) per model |
| `locale` | string | ? | `"en_us"` | Locale for language and measurement units |
| `maxConcurrency` | integer | ? | `8` | Parallel detail requests per category (1-32) |
| `requestDelayMs` | integer | ? | `0` | Delay in ms between requests for gentle crawling |

### ?? Output example

Each result is a structured JSON object. Here's a sample from a real run:

```json
{
  "locale": "en_us",
  "categoryGroup": "Construction",
  "categoryName": "Wheel Loader",
  "categorySlug": "wheel-loader",
  "manufacturer": "Yanmar",
  "modelName": "Yanmar V8",
  "modelNumber": "V8",
  "modelSlug": "yanmar-v8-wheel-loader",
  "detailUrl": "https://www.ritchiespecs.com/model/yanmar-v8-wheel-loader",
  "modelParams": [
    {
      "name": "Bucket Capacity - Heaped",
      "unit1": "yd3", "value1": 1.05,
      "unit2": "m3", "value2": 0.81
    },
    {
      "name": "Operating Weight",
      "unit1": "lb", "value1": 10802.66,
      "unit2": "kg", "value2": 4900
    }
  ],
  "specifications": [
    {
      "topparam": "Engine",
      "subparam": [
        { "subparam": "Engine Make", "value1": "Deutz", "value2": "Deutz" },
        { "subparam": "Net Power", "unit1": "hp", "value1": 60, "unit2": "kw", "value2": 44.8 }
      ]
    }
  ],
  "scrapedAt": "2026-07-04T22:12:58.927Z"
}
```

Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or access them programmatically from the integrations tab.

### ?? Related Rastriq Actors

Explore the full [Rastriq intelligence portfolio](https://apify.com/rastriq) on Apify Store:

| Actor | Description |
|-------|-------------|
| [Mascus Scraper](https://apify.com/rastriq/mascus-scraper) | Extract used heavy machinery listings with prices, hours, and seller info |
| [MachineryTrader Scraper](https://apify.com/rastriq/machinerytrader-scraper) | Extract equipment listings from MachineryTrader marketplace |
| [Machineseeker Scraper](https://apify.com/rastriq/machineseeker-scraper) | Extract industrial machinery listings from Machineseeker.com |

### ? Frequently Asked Questions

#### Is extracting data from RitchieSpecs legal?

RitchieSpecs Scraper only accesses **publicly available data** - the same specification information visible to any visitor without logging in. The scraper applies reasonable rate limiting to avoid overloading the source servers.

As with any data collection activity, you are responsible for ensuring your use case complies with applicable laws (GDPR, CCPA) and RitchieSpecs' Terms of Service. For guidance, see [Apify's blog on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Does RitchieSpecs Scraper require an account or credentials?

No. RitchieSpecs Scraper works entirely with **publicly available data**. No RitchieSpecs account, login, or credentials of any kind are required.

#### How many models can I extract?

RitchieSpecs Scraper can extract the full RitchieSpecs catalog - currently **10,000+ models across 55 equipment types in 7 industry sectors**. Use the equipment type and category group selectors to control scope.

#### How does the manufacturer filter work?

Enter manufacturer slugs (e.g. `caterpillar`, `john-deere`, `komatsu`) to limit results to specific brands. The filter matches against model slug prefixes. Run once without the filter to discover all available manufacturer slugs in the output.

#### Do I need to configure proxies?

No. The scraper works **without proxies** from most locations. If you experience any issues, try increasing `requestDelayMs` before enabling proxy rotation.

#### I found a bug or my run failed. Where do I report it?

Please open an issue in the **Issues tab** on this page. Include your input configuration and the run ID so we can investigate quickly.

# Actor input Schema

## `data_freshness` (type: `string`):

Choose how to get data:<br><br><b>📦 Preloaded</b> — downloads from our pre-scraped monthly snapshot. Instant results, lower cost. Updated on the 1st of each month.<br><br><b>🔄 Live</b> — scrapes RitchieSpecs in real time. Fresh data but slower and more expensive (one API call per model).<br><br>Both modes return the <b>same output schema</b> with a <code>\_data\_freshness</code> field so you know the source.

## `equipmentTypes` (type: `array`):

Select one or more equipment types to extract. Each chip is a specific machine category.<br><br>Leave empty and use <b>Category groups</b> below to select entire sectors at once.<br><br>💡 <b>Tip:</b> Leave both fields empty to get <b>all equipment types</b> — perfect for bulk exports.

## `categoryGroups` (type: `array`):

Select entire equipment sectors instead of individual types. All equipment within each selected group will be included.<br><br>Combine with <b>🏗️ Equipment types</b> above — results are merged automatically.

## `manufacturerFilter` (type: `array`):

Filter results to specific brands. Enter manufacturer slugs exactly as they appear on RitchieSpecs.<br><br>Examples:<br>• <code>caterpillar</code><br>• <code>komatsu</code><br>• <code>john-deere</code><br>• <code>volvo</code><br>• <code>liebherr</code><br><br>Leave empty to include <b>all manufacturers</b>.<br><br>💡 <b>Tip:</b> Run once without this filter, then check the <code>manufacturerSlug</code> field in the output to see all available slugs.

## `maxModelsPerCategory` (type: `integer`):

Safety cap on how many models to return per equipment type.<br><br>Recommended values:<br>• <b>10–25</b> — quick test run<br>• <b>100–500</b> — category deep-dive<br>• <b>0 or empty</b> — return ALL models (bulk export)<br><br>💡 <b>Tip:</b> In <b>Preloaded</b> mode, leaving this at 0 is fast and cheap — you're reading from a pre-built database.

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

When enabled, each model includes full specification data: engine, dimensions, drawings, similar models, and marketplace URLs.<br><br>In <b>📦 Preloaded</b> mode: full specs are always available at no extra cost (the snapshot already contains them).<br><br>In <b>🔄 Live</b> mode: ⚠️ <b>adds one extra API request per model</b>. Disable for a fast inventory-only crawl.

## `locale` (type: `string`):

Controls the language and measurement units in the specification data.<br><br>Known values:<br>• <code>en\_us</code> — English (imperial + metric)

## `maxConcurrency` (type: `integer`):

Number of parallel requests within each category. Only applies to <b>🔄 Live</b> mode.<br><br>Recommended values:<br>• <b>3–5</b> — conservative<br>• <b>8–12</b> — balanced (default)<br>• <b>15–32</b> — aggressive, use with <b>⏱️ Request delay</b> enabled

## `requestDelayMs` (type: `integer`):

Milliseconds to wait before each API request. Only applies to <b>🔄 Live</b> mode.<br><br>Recommended values:<br>• <b>0 ms</b> — fastest (default)<br>• <b>200–500 ms</b> — polite crawling<br>• <b>1000–2000 ms</b> — if experiencing rate limits

## Actor input object example

```json
{
  "data_freshness": "preloaded",
  "equipmentTypes": [
    "wheel-loader"
  ],
  "categoryGroups": [],
  "manufacturerFilter": [],
  "maxModelsPerCategory": 5,
  "includeDetails": true,
  "locale": "en_us",
  "maxConcurrency": 8,
  "requestDelayMs": 0
}
```

# Actor output Schema

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

Dataset containing one item per equipment model with category classification, manufacturer info, full specifications, dimensions, drawings, similar models, and marketplace URLs (IronPlanet, Mascus, Ritchie Bros).

# 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 = {
    "equipmentTypes": [
        "wheel-loader"
    ],
    "maxModelsPerCategory": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/ritchiespecs-catalog-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 = {
    "equipmentTypes": ["wheel-loader"],
    "maxModelsPerCategory": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/ritchiespecs-catalog-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 '{
  "equipmentTypes": [
    "wheel-loader"
  ],
  "maxModelsPerCategory": 5
}' |
apify call rastriq/ritchiespecs-catalog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RitchieSpecs Catalog Scraper",
        "description": "New actor improved.\nExtract categories, model lists, and full machine specifications from the public RitchieSpecs API.",
        "version": "0.3",
        "x-build-id": "NmhqB0D0Lbhb5e15M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rastriq~ritchiespecs-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rastriq-ritchiespecs-catalog-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/rastriq~ritchiespecs-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rastriq-ritchiespecs-catalog-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/rastriq~ritchiespecs-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rastriq-ritchiespecs-catalog-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",
                "properties": {
                    "data_freshness": {
                        "title": "📦 Data source",
                        "enum": [
                            "preloaded",
                            "live"
                        ],
                        "type": "string",
                        "description": "Choose how to get data:<br><br><b>📦 Preloaded</b> — downloads from our pre-scraped monthly snapshot. Instant results, lower cost. Updated on the 1st of each month.<br><br><b>🔄 Live</b> — scrapes RitchieSpecs in real time. Fresh data but slower and more expensive (one API call per model).<br><br>Both modes return the <b>same output schema</b> with a <code>_data_freshness</code> field so you know the source.",
                        "default": "preloaded"
                    },
                    "equipmentTypes": {
                        "title": "🏗️ Equipment types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more equipment types to extract. Each chip is a specific machine category.<br><br>Leave empty and use <b>Category groups</b> below to select entire sectors at once.<br><br>💡 <b>Tip:</b> Leave both fields empty to get <b>all equipment types</b> — perfect for bulk exports.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "2wd-tractor",
                                "4wd-tractor",
                                "air-drill",
                                "baler",
                                "combine",
                                "cultivator",
                                "disc",
                                "harrow",
                                "mfwd-tractor",
                                "sprayer",
                                "swather",
                                "utility-tractor",
                                "asphalt-paver",
                                "cold-planer",
                                "pneumatic-roller",
                                "static-smooth-drum-roller",
                                "vibratory-compactor",
                                "vibratory-smooth-drum-roller",
                                "articulated-dump-truck",
                                "compactor",
                                "crawler-loader",
                                "crawler-pipe-layer",
                                "crawler-tractor",
                                "elevating-motor-scraper",
                                "hydraulic-excavator",
                                "integrated-tool-carrier",
                                "loader-backhoe",
                                "midi-excavator",
                                "mini-excavator",
                                "mobile-excavator",
                                "motor-grader",
                                "motor-scraper",
                                "multi-terrain-loader",
                                "rock-truck",
                                "shovel",
                                "skid-steer-loader",
                                "wheel-dozer",
                                "wheel-loader",
                                "feller-buncher",
                                "forwarder",
                                "harvester",
                                "log-loader",
                                "skidder",
                                "all-terrain-crane",
                                "boom-lift",
                                "crawler-crane",
                                "forklift",
                                "hydraulic-truck-crane",
                                "material-handler",
                                "rough-terrain-crane",
                                "scissor-lift",
                                "telescopic-forklift",
                                "cab-and-chassis",
                                "dump-truck",
                                "truck-tractor"
                            ],
                            "enumTitles": [
                                "🌾 2WD Tractor",
                                "🌾 4WD Tractor",
                                "🌾 Air Drill",
                                "🌾 Baler",
                                "🌾 Combine",
                                "🌾 Cultivator",
                                "🌾 Disc",
                                "🌾 Harrow",
                                "🌾 MFWD Tractor",
                                "🌾 Sprayer",
                                "🌾 Swather",
                                "🌾 Utility Tractor",
                                "🛣️ Asphalt Paver",
                                "🛣️ Cold Planer",
                                "🛣️ Pneumatic Roller",
                                "🛣️ Static Smooth Drum Roller",
                                "🛣️ Vibratory Compactor",
                                "🛣️ Vibratory Smooth Drum Roller",
                                "🏗️ Articulated Dump Truck",
                                "🏗️ Compactor",
                                "🏗️ Crawler Loader",
                                "🏗️ Crawler Pipe Layer",
                                "🏗️ Crawler Tractor",
                                "🏗️ Elevating Motor Scraper",
                                "🏗️ Hydraulic Excavator",
                                "🏗️ Integrated Tool Carrier",
                                "🏗️ Loader Backhoe",
                                "🏗️ Midi Excavator",
                                "🏗️ Mini Excavator",
                                "🏗️ Mobile Excavator",
                                "🏗️ Motor Grader",
                                "🏗️ Motor Scraper",
                                "🏗️ Multi Terrain Loader",
                                "🏗️ Rock Truck",
                                "🏗️ Shovel",
                                "🏗️ Skid Steer Loader",
                                "🏗️ Wheel Dozer",
                                "🏗️ Wheel Loader",
                                "🌲 Feller Buncher",
                                "🌲 Forwarder",
                                "🌲 Harvester",
                                "🌲 Log Loader",
                                "🌲 Skidder",
                                "🏗️ All Terrain Crane",
                                "🏗️ Boom Lift",
                                "🏗️ Crawler Crane",
                                "🏗️ Forklift",
                                "🏗️ Hydraulic Truck Crane",
                                "🏗️ Material Handler",
                                "🏗️ Rough Terrain Crane",
                                "🏗️ Scissor Lift",
                                "🏗️ Telescopic Forklift",
                                "🚛 Cab and Chassis",
                                "🚛 Dump Truck",
                                "🚛 Truck Tractor"
                            ]
                        },
                        "default": []
                    },
                    "categoryGroups": {
                        "title": "📂 Category groups",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select entire equipment sectors instead of individual types. All equipment within each selected group will be included.<br><br>Combine with <b>🏗️ Equipment types</b> above — results are merged automatically.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "agriculture",
                                "asphalt-aggregate-concrete",
                                "construction",
                                "forestry",
                                "lifting-material-handling",
                                "transportation"
                            ],
                            "enumTitles": [
                                "🌾 Agriculture",
                                "🛣️ Asphalt / Aggregate / Concrete",
                                "🏗️ Construction & Mining",
                                "🌲 Forestry",
                                "🏗️ Lifting & Material Handling",
                                "🚛 Transportation"
                            ]
                        },
                        "default": []
                    },
                    "manufacturerFilter": {
                        "title": "🏭 Manufacturer filter",
                        "type": "array",
                        "description": "Filter results to specific brands. Enter manufacturer slugs exactly as they appear on RitchieSpecs.<br><br>Examples:<br>• <code>caterpillar</code><br>• <code>komatsu</code><br>• <code>john-deere</code><br>• <code>volvo</code><br>• <code>liebherr</code><br><br>Leave empty to include <b>all manufacturers</b>.<br><br>💡 <b>Tip:</b> Run once without this filter, then check the <code>manufacturerSlug</code> field in the output to see all available slugs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxModelsPerCategory": {
                        "title": "🔢 Max models per category",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap on how many models to return per equipment type.<br><br>Recommended values:<br>• <b>10–25</b> — quick test run<br>• <b>100–500</b> — category deep-dive<br>• <b>0 or empty</b> — return ALL models (bulk export)<br><br>💡 <b>Tip:</b> In <b>Preloaded</b> mode, leaving this at 0 is fast and cheap — you're reading from a pre-built database.",
                        "default": 25
                    },
                    "includeDetails": {
                        "title": "📊 Include full specs",
                        "type": "boolean",
                        "description": "When enabled, each model includes full specification data: engine, dimensions, drawings, similar models, and marketplace URLs.<br><br>In <b>📦 Preloaded</b> mode: full specs are always available at no extra cost (the snapshot already contains them).<br><br>In <b>🔄 Live</b> mode: ⚠️ <b>adds one extra API request per model</b>. Disable for a fast inventory-only crawl.",
                        "default": true
                    },
                    "locale": {
                        "title": "🌐 Locale",
                        "type": "string",
                        "description": "Controls the language and measurement units in the specification data.<br><br>Known values:<br>• <code>en_us</code> — English (imperial + metric)",
                        "default": "en_us"
                    },
                    "maxConcurrency": {
                        "title": "⚡ Max concurrency",
                        "minimum": 1,
                        "maximum": 32,
                        "type": "integer",
                        "description": "Number of parallel requests within each category. Only applies to <b>🔄 Live</b> mode.<br><br>Recommended values:<br>• <b>3–5</b> — conservative<br>• <b>8–12</b> — balanced (default)<br>• <b>15–32</b> — aggressive, use with <b>⏱️ Request delay</b> enabled",
                        "default": 8
                    },
                    "requestDelayMs": {
                        "title": "⏱️ Request delay",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Milliseconds to wait before each API request. Only applies to <b>🔄 Live</b> mode.<br><br>Recommended values:<br>• <b>0 ms</b> — fastest (default)<br>• <b>200–500 ms</b> — polite crawling<br>• <b>1000–2000 ms</b> — if experiencing rate limits",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
