# EquipmentWatch Scraper (`parseforge/equipmentwatch-scraper`) Actor

Scrapes heavy equipment valuation records from EquipmentWatch with filters for manufacturer, model, year, and category. Returns fair market value, forced liquidation value, and specs as flat rows.

- **URL**: https://apify.com/parseforge/equipmentwatch-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.99 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### EquipmentWatch Scraper

**Scrape heavy equipment valuations, specifications, and ownership costs from EquipmentWatch, filtered by manufacturer, model, year, and category.** Every record includes fair market value, forced liquidation value, and detailed specs. Export to CSV, JSON, Excel, or XML.

EquipmentWatch is the industry standard for heavy equipment values, but its web interface makes bulk lookups slow and manual. This Actor reads the public valuation data directly, letting you pull hundreds or thousands of records in one run. Filter by manufacturer like Caterpillar or Genie, model, year, classification, or numeric category ID, and get a clean dataset ready for analysis.

| Who uses it | What they scrape EquipmentWatch for |
|---|---|
| Equipment dealers | Price used inventory against current EquipmentWatch fair market and forced liquidation values. |
| Insurance adjusters | Pull replacement cost data for heavy equipment claims by make, model, and year. |
| Fleet managers | Benchmark fleet residual values and plan capital replacement cycles. |
| Market researchers | Track valuation trends across construction, agricultural, and lift equipment segments. |

### What it does

This Actor collects equipment valuation records from EquipmentWatch by manufacturer, model, year, and category filters, and returns each one as a flat row.

- 🔍 **Flexible filtering:** combine manufacturer name, model, year, classification ID, category ID, subtype ID, and size class ID to narrow results.
- 📊 **Valuation data:** fair market value, forced liquidation value, and estimated ownership costs where available.
- ⚙️ **Concurrency control:** set max parallel requests from 1 to 50 to balance speed against rate limits.
- 📋 **Flat row output:** every equipment record lands in your dataset as one row, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with EquipmentWatch data

**🚜 Price used construction equipment.**

A dealer runs the Actor filtered by manufacturer Caterpillar and model 320 to pull current fair market and forced liquidation values for every year available, then sets listing prices.

**📋 Audit an insured fleet.**

An insurance adjuster inputs a list of manufacturer and model pairs, collects replacement values by year, and validates coverage limits against EquipmentWatch data.

**📈 Track residual value curves.**

A fleet manager scrapes all years for a specific model across multiple size classes to plot how values decline with age and plan trade-in timing.

**🏗️ Compare segments.**

A market researcher pulls valuations across classification IDs 1, 2, and 3 to compare construction, agricultural, and lift equipment pricing trends in one dataset.

### Why choose this scraper

|  | What you get |
|---|---|
| **Bulk lookups** | Pull hundreds of valuations in one run instead of clicking through the web interface one at a time. |
| **Structured output** | Get a consistent schema with fair market value, forced liquidation value, specs, and ownership costs. |
| **No manual data entry** | Eliminate copy-paste errors when building equipment pricing spreadsheets. |

### How it compares

No other Store actor targets EquipmentWatch the same way, so the honest comparison is with the alternatives teams actually weigh.

| | EquipmentWatch Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When EquipmentWatch changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with manufacturer, model, year, and numeric category or classification IDs, alone or in combination, and filters run as each record is fetched so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "manufacturer": "Genie"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "manufacturer": "Genie"
}
```

### Pricing

Pay-per-result: **$0.01599 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.60 |
| 1,000 results | $15.99 |
| 10,000 results | $159.90 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [EquipmentWatch Scraper](https://apify.com/parseforge/equipmentwatch-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to EquipmentWatch through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/equipmentwatch-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your filter values match real EquipmentWatch data. Try running without filters first to confirm the Actor can reach the site. If you are using numeric IDs like categoryId or subtypeId, verify them against the EquipmentWatch taxonomy.

**Why are my requests failing with errors?**

You may be hitting rate limits. Lower the Max Concurrency setting to 10 or 5 and retry. Also check that your manufacturer name is spelled correctly, or switch to using the Manufacturer ID for exact matching.

**Why do I get fewer results than my Max Items setting?**

The Actor stops when it has collected your Max Items or when no more matching equipment exists for your filters. Broaden your filters or remove some to get more records.

**Why are some valuation fields empty in my output?**

EquipmentWatch may not publish every data point for every equipment record. Older or less common models sometimes have fewer valuation details available. This is normal and reflects the source data.

**How do I look up numeric IDs for categories and subtypes?**

Run the Actor once with broad filters and inspect the output dataset. The returned records will include category, subtype, and size class IDs that you can reuse in later targeted runs.

### FAQ

| Question | Answer |
|---|---|
| What data does this Actor return from EquipmentWatch? | It returns equipment valuations including fair market value, forced liquidation value, and estimated ownership costs, along with specifications like manufacturer, model, year, and category. The exact fields depend on what EquipmentWatch publishes for each equipment record. |
| Do I need an EquipmentWatch subscription or API key? | No. This Actor reads publicly available valuation data from the EquipmentWatch website. You do not need a login, subscription, or API key. |
| How do I filter by a specific manufacturer? | Use the Manufacturer input field with a name like Caterpillar or John Deere. For exact matching, use the Manufacturer ID field instead. Enable Partial Match if you want the filter to catch variations in spelling or naming. |
| What are the classification IDs? | Classification ID 1 is Construction equipment, 2 is Agricultural Equipment, and 3 is Lift and Access. Use these to narrow results to a broad equipment segment. |
| How do I find the right category, subtype, or size class ID? | These are numeric IDs used by EquipmentWatch. You can look them up by browsing the EquipmentWatch website taxonomy or by running a broad scrape first and noting the IDs that appear in your results. |
| Can I scrape all equipment without any filters? | Yes. Leave all filter fields blank and set a high Max Items value. The Actor will collect equipment records across all manufacturers and categories up to the limit you set. |
| What year should I use for valuations? | The Year field sets the model year for valuation lookups. If you leave it blank, the Actor defaults to the previous calendar year. You can set any year from 1960 to 2030. |
| How fast can I scrape? | You control the speed with Max Concurrency, from 1 to 50 parallel requests. Higher values are faster but may trigger rate limiting. Start with the default of 25 and reduce if you see errors. |
| What export formats are supported? | Your dataset can be exported to CSV, JSON, Excel, or XML directly from the Apify platform after the run completes. |
| Does this Actor handle pagination automatically? | Yes. The Actor navigates through EquipmentWatch search results and valuation pages automatically until it reaches your Max Items limit or runs out of matching records. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by EquipmentWatch. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many equipment records to collect per run.

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

Filter by manufacturer name (e.g. "Caterpillar", "John Deere").

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

Filter by model name (e.g. "320", "950").

## `year` (type: `integer`):

Model year for valuations (e.g. 2022). Defaults to previous year if not set.

## `classificationId` (type: `integer`):

Filter by classification ID: 1 = Construction, 2 = Agricultural Equipment, 3 = Lift & Access.

## `categoryId` (type: `integer`):

Filter by equipment category ID (numeric). Use taxonomy lookup to find IDs.

## `subtypeId` (type: `integer`):

Filter by equipment subtype ID (numeric).

## `manufacturerId` (type: `integer`):

Filter by manufacturer ID (numeric). Use instead of manufacturer name for exact matching.

## `sizeClassId` (type: `integer`):

Filter by size class ID (numeric).

## `partialMatch` (type: `boolean`):

Enable partial matching for manufacturer and model name filters.

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

Maximum number of parallel valuation requests (1-50).

## Actor input object example

```json
{
  "maxItems": 10,
  "manufacturer": "Genie",
  "partialMatch": false,
  "maxConcurrency": 25
}
```

# Actor output Schema

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

Dataset with all scraped items

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "manufacturer": "Genie"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/equipmentwatch-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 = {
    "maxItems": 10,
    "manufacturer": "Genie",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/equipmentwatch-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "manufacturer": "Genie"
}' |
apify call parseforge/equipmentwatch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/equipmentwatch-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Xz8XzY8foalsdY4vr/builds/4n0mpPyHmeUkItfO2/openapi.json