# John Deere Spain — Products & Specs Scraper (`rastriq/john-deere-es-scraper`) Actor

Extracts product listings and technical specifications from the John Deere Spain website (deere.es). Supports filtering by series and leveling configuration.

- **URL**: https://apify.com/rastriq/john-deere-es-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## John Deere Spain — Products & Specs Scraper

Extracts product listings and detailed technical specifications from the [John Deere Spain website](https://www.deere.es) (`deere.es`). Outputs a clean, structured dataset ready for market intelligence, catalog analysis, and competitive research.

### What it scrapes

Each run produces one dataset item per equipment model, containing:

- **Identity** — `baseCode` (internal John Deere ID), commercial `headline`, and `subHeadline`
- **Product URL** — direct link to the product detail page
- **Image** — highest-resolution image URL available
- **Price** — `priceAmount` and `priceCurrencyCode` (most B2B models return `null`)
- **Technical specifications** — full spec sheet as a flat key-value map, e.g.:
  ```json
  {
    "Especificaciones clave > Capacidad de carga a la máxima altura": "1372.0 kg",
    "Especificaciones clave > Altura máxima de elevación (A)": "3680.0 mm",
    "Cargadora > Configuración de nivelación": "Nivelación automática mecánica (MSL)"
  }
  ```
- **`scrapedAt`** — UTC timestamp of extraction

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | String | `front-end-loaders` | Product category to scrape. See below for available categories. |
| `maxResults` | Integer | — | Max products to extract. Leave empty for all (recommended for first test: `10`). |
| `shopByFilter` | Array | `[]` | Filter by equipment series. Multiselect. Leave empty for all series. |
| `levelingFilter` | Array | `[]` | Filter by loader leveling system type. Multiselect. Leave empty for all. |
| `includeSpecifications` | Boolean | `true` | Enrich each product with its full technical spec sheet. Disabling this roughly halves run time. |
| `proxyConfiguration` | Object | — | Proxy settings. Not required for standard runs — the site does not aggressively block scrapers. |
| `debugMode` | Boolean | `false` | Enable verbose DEBUG logging. For troubleshooting only. |

#### Available categories

| Key | Description | Known models |
|-----|-------------|-------------|
| `front-end-loaders` | Palas cargadoras frontales | 18 models |

More categories will be added as they are mapped.

#### shopByFilter values (front-end loaders)

| Value | Approx. count |
|-------|-------------|
| `Serie R` | 8 models (543R, 603R, 623R, 643R…) |
| `Serie M` | 4 models (543M, 603M, 623M, 643M) |
| `Serie E` | 1 model (300E) |
| `Serie H` | 1 model |
| `Tractores compactos` | Compact tractors |

#### levelingFilter values

| Value | Description |
|-------|-------------|
| `Nivelación automática mecánica (MSL)` | Mechanical Self-Leveling — 6 models |
| `Nivelación automática mecánica` | Mechanical auto-leveling — 4 models |
| `Sin nivelación automática (NSL)` | No Self-Leveling — 3 models |
| `685R con nivelación automática mecánica` | 685R with mechanical auto-leveling — 1 model |

### Example inputs

**Scrape all front-end loaders with full specs:**

```json
{
  "category": "front-end-loaders",
  "includeSpecifications": true
}
```

**Quick test — first 5 Serie R models:**

```json
{
  "category": "front-end-loaders",
  "shopByFilter": ["Serie R"],
  "maxResults": 5,
  "includeSpecifications": true
}
```

**All MSL models, no specs (fast):**

```json
{
  "category": "front-end-loaders",
  "levelingFilter": ["Nivelación automática mecánica (MSL)"],
  "includeSpecifications": false
}
```

### Output format

Each dataset item follows this schema:

```json
{
  "baseCode": "543R",
  "headline": "543R",
  "subHeadline": "Palas cargadoras frontales",
  "productUrl": "https://www.deere.es/es-es/productos-soluciones/cargadoras/palas-cargadoras-frontales/543r-...",
  "image": "https://www.deere.es/content/dam/deere-dtac/products/...",
  "priceAmount": null,
  "priceCurrencyCode": "",
  "specifications": {
    "Especificaciones clave > Capacidad de carga a la máxima altura": "1372.0 kg",
    "Especificaciones clave > Altura máxima de elevación (A)": "3680.0 mm",
    "Cargadora > Configuración de nivelación": "Nivelación automática mecánica (MSL)",
    "Tractor compatible > Potencia neta del motor": "85 CV"
  },
  "scrapedAt": "2026-08-22T21:45:00.000000+00:00"
}
```

The Apify Console **Output** tab shows two views:

- **Products** — table with code, model, category, price, URL, image, and scrape timestamp
- **Specifications** — table with code, model, and the full `specifications` object

### Technical notes

#### API used

The actor uses John Deere Spain's internal REST API — the same calls the website makes from the browser:

| Endpoint | Description |
|----------|-------------|
| `GET /service/productSearch/{categoryPath}/products` | Product listing with pagination (`?page=N`, 12 items/page) |
| `GET /service/productSearch/{categoryPath}/filter` | Filter metadata (ranges, checkbox options, shopBy tiles) |
| `GET /service/data/specifications/{baseCode}/432824` | Technical spec sheet per product |

Filters are passed as query params:

- **shopBy**: `?shopBy=Serie+R`
- **Checkbox**: `?wgSpecifications-es_ES-hydraulicSystem-levelingConfiguration--Nivelación+automática+mecánica+(MSL)=true`

The `specSchemaId` `432824` is fixed for the Spanish market and has been validated against all 18 front-end loader models without a single failure.

#### Rate limiting

The actor uses a 1.5-second delay between API calls by default. This is conservative enough to avoid any rate limiting on the current 18-model catalog. The site does not use aggressive bot detection.

#### Proxy

Proxy is not required for standard runs. The `proxyConfiguration` input is provided for cases where you experience blocking (unlikely) or need to rotate IPs for large-scale monitoring.

### Compliance

This actor accesses only publicly available product information from `www.deere.es`. It:

- Respects the site's natural request cadence (1.5s delay between calls)
- Does not extract personally identifiable information (PII)
- Uses the same API endpoints the website calls from a standard browser session
- Is intended for legitimate market intelligence and catalog analysis purposes

### Changelog

#### v0.1

- Initial release: front-end loaders category
- Filters: shopBy (series), leveling configuration (checkbox)
- Full spec sheet extraction via `/specifications` endpoint
- Two Console views: Products table and Specifications table

# Actor input Schema

## `market` (type: `string`):

John Deere website to scrape. Each market uses its own domain and returns data in its local language — product titles, specs labels, and filter values are all localized. The underlying product catalog is global (same models, same counts across all 13 markets).

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

Categoría a extraer. Todas confirmadas en ES; disponibles en los 16 mercados con la misma estructura de API.

## `maxResults` (type: `integer`):

Maximum number of products to extract. Default is 20 — use the prefilled value of 5 for a quick first test.<br><br>Leave empty to use the default (20), or increase it to extract more products from the category.

## `shopBySeries` (type: `array`):

Filtra por serie de tractores/cargadores. El actor busca automáticamente la etiqueta correcta en el idioma del mercado seleccionado — no necesitas saber cómo se llama en alemán, francés, etc.<br><br>Deja vacío para extraer todas las series.

## `levelingType` (type: `array`):

Filtra por sistema de nivelación del cargador frontal. El actor localiza el valor exacto en el idioma del mercado vía la API.<br><br>Deja vacío para incluir todos los tipos.

## `includeSpecifications` (type: `boolean`):

If enabled, each product is enriched with its full technical spec sheet.<br><br>Disabling this roughly halves the run time and number of API calls.

## `minLiftHeight` (type: `integer`):

Minimum loader maximum lift height at max tilt cylinder (AMTC). Leave empty for no lower bound.

## `maxLiftHeight` (type: `integer`):

Maximum loader maximum lift height at max tilt cylinder (AMTC). Leave empty for no upper bound.

## `minLiftCapacity` (type: `integer`):

Minimum loader lift capacity at maximum height. Leave empty for no lower bound.<br><br>⚠️ Only models that have this field indexed as a filterable facet will be filtered at API level — others may still appear in results.

## `maxLiftCapacity` (type: `integer`):

Maximum loader lift capacity at maximum height. Leave empty for no upper bound.

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

Select proxies for the scraping run. Apify Proxy recommended if you encounter blocking.

## `shopByFilterRaw` (type: `array`):

Override avanzado: introduce los valores de serie <b>exactamente</b> como los devuelve la API del mercado (p.ej. <code>Serie R</code> en ES, <code>R-Serie</code> en DE). Usa <i>Discover filters</i> para obtener los valores. Si está relleno, tiene prioridad sobre «Series de equipo».

## `levelingFilterRaw` (type: `array`):

Override avanzado: valores exactos del checkbox de nivelación tal y como los devuelve la API. Tiene prioridad sobre «Tipo de nivelación» si está relleno.

## `discoverFilters` (type: `boolean`):

When enabled, the actor outputs the available filter values for the selected market and category <b>instead of scraping products</b>. Use this to find out which series names, leveling options, and slider ranges exist in your target language before running a full scrape.

## `specSchemaId` (type: `string`):

<b>432824</b> confirmed for Spain; used as default for all markets. Only change if technical specifications are not loading — inspect the network requests on the product page of your target market to find the correct value.

## `debugMode` (type: `boolean`):

Enable verbose logging for troubleshooting.

## Actor input object example

```json
{
  "market": "es",
  "category": "front-end-loaders",
  "maxResults": 5,
  "shopBySeries": [],
  "levelingType": [],
  "includeSpecifications": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "shopByFilterRaw": [],
  "levelingFilterRaw": [],
  "discoverFilters": false,
  "specSchemaId": "432824",
  "debugMode": false
}
```

# Actor output Schema

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

All scraped product listings with their technical specifications.

# 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 = {
    "maxResults": 5,
    "shopBySeries": [],
    "levelingType": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "shopByFilterRaw": [],
    "levelingFilterRaw": [],
    "specSchemaId": "432824"
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/john-deere-es-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 = {
    "maxResults": 5,
    "shopBySeries": [],
    "levelingType": [],
    "proxyConfiguration": { "useApifyProxy": False },
    "shopByFilterRaw": [],
    "levelingFilterRaw": [],
    "specSchemaId": "432824",
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/john-deere-es-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 '{
  "maxResults": 5,
  "shopBySeries": [],
  "levelingType": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "shopByFilterRaw": [],
  "levelingFilterRaw": [],
  "specSchemaId": "432824"
}' |
apify call rastriq/john-deere-es-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/john-deere-es-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/XR2URM352Hjj62X5c/builds/RlZc3J6dqRpDtC6gV/openapi.json