# Zalando Listings Scraper (`piotrv1001/zalando-listings-scraper`) Actor

The Zalando Listings Scraper extracts product listings and detailed product pages from Zalando shops across 25 country domains, capturing name, brand, SKU, price, sizes, gender, image gallery, stock status, and attributes — ideal for price tracking, competitive analysis, and catalog mirroring.

- **URL**: https://apify.com/piotrv1001/zalando-listings-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 product listings

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 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

### 🛍️ Zalando Listings Scraper

Easily extract product data from **Zalando** across every country shop (DE, UK, FR, IT, ES, NL, PL, and 18 more). The **Zalando Listings Scraper** turns any category, search, or product page into clean structured JSON — ready for price tracking, competitive intelligence, catalog mirroring, or feeding into your downstream pipelines.

### ✨ Features

- 🌍 **25 country domains** — `zalando.de`, `zalando.co.uk`, `zalando.fr`, `zalando.pl`, … with optional English-locale (`en.zalando.*`) variants.
- 🏷️ **Rich product data** — name, brand, SKU, price, currency, sizes, gender, silhouette, full image gallery, packshot, model image, in-stock flag, and more.
- 📂 **Two scrape modes** — fast listing-only (cheap), or deep PDP scrape with attributes (material, fit, care instructions) and JSON-LD price/stock.
- 🔍 **Category, search, and PDP URLs** — paste any URL or send in-category search queries (`{ query: "nike air", categorySlug: "mens-clothing" }`).
- ⚡ **Pure HTTP + Cheerio** — no headless browser, no JS execution. Fast, lightweight, and proxy-friendly.
- 📑 **Pagination built-in** — automatically crawls listing pages until `maxItems` is reached.

### 🛠️ How It Works

1. **Enter URLs or search queries** — provide Zalando category URLs (`/mens-clothing/`), PDP URLs (`*.html`), or in-category search queries.
2. **Choose your depth** — toggle `includeProductDetails` for either lightweight listing data or full PDP enrichment.
3. **Run the scraper** — pagination, header rotation, and hydration parsing happen automatically.
4. **Get structured JSON** — every product is pushed to the dataset, ready to export as JSON / CSV / Excel.

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | `Array<{ url: string }>` | `[https://en.zalando.de/mens-clothing/]` | Zalando category, in-category search, or product detail (`.html`) URLs to scrape. |
| `searchQueries` | `Array<{ query: string, categorySlug?: string }>` | `[]` | Optional in-category search queries. `categorySlug` defaults to `mens-clothing`. |
| `domain` | `string` (enum) | `zalando.de` | Zalando country domain used for search queries (25 options). |
| `englishLocale` | `boolean` | `true` | Prefix the domain with `en.` for the English variant of each shop. |
| `maxItems` | `integer` | `50` | Hard cap on products pushed to the dataset. Set `0` for unlimited. |
| `includeProductDetails` | `boolean` | `false` | If true, every listing card enqueues its PDP for richer fields (attributes, stock, model image). See [Pricing](#-pricing). |
| `proxyConfiguration` | `object` | `{ useApifyProxy: false }` | Standard Apify proxy configuration. Use residential proxies with country matching when running at scale. |

#### Example input

```json
{
    "startUrls": [
        { "url": "https://en.zalando.de/mens-clothing/" }
    ],
    "searchQueries": [
        { "query": "nike air", "categorySlug": "mens-clothing" }
    ],
    "domain": "zalando.de",
    "englishLocale": true,
    "maxItems": 100,
    "includeProductDetails": false,
    "proxyConfiguration": { "useApifyProxy": false }
}
````

### 📊 Sample Output Data

The scraper produces structured JSON. Lightweight listing example:

```json
[
    {
        "id": "ern:product::BEJ22O1GP-G11",
        "sku": "BEJ22O1GP-G11",
        "url": "https://en.zalando.de/bershka-print-t-shirt-red-bej22o1gp-g11.html",
        "name": "SPIDERMAN  - Print T-shirt - red",
        "brandName": "Bershka",
        "supplierName": "SPIDERMAN",
        "gender": "MEN",
        "silhouette": "T_SHIRT_TOP",
        "price": 19.99,
        "promotionalPrice": null,
        "currency": "EUR",
        "priceDisplayMode": "BLACK_PRICE",
        "sizes": [
            { "size": "S", "sku": "BEJ22O1GP-G11000S000" },
            { "size": "M", "sku": "BEJ22O1GP-G11000M000" },
            { "size": "L", "sku": "BEJ22O1GP-G11000L000" }
        ],
        "inStock": null,
        "images": [
            "https://img01.ztat.net/article/spp-media-p1/.../...jpg?imwidth=780"
        ],
        "packshotImage": "https://img01.ztat.net/article/spp-media-p1/.../...jpg?imwidth=780&filter=packshot",
        "hoverImage": null,
        "modelImage": null,
        "domain": "en.zalando.de",
        "scrapedAt": "2026-05-16T08:23:19.766Z"
    }
]
```

When `includeProductDetails: true`, each record additionally contains `attributes` (material, fit, care instructions, …), `inStock`, `productFlags`, `benefits`, `releaseDate`, `visibility`, and the full image set sourced from the PDP's JSON-LD.

### 💰 Pricing

This Actor uses **Pay-Per-Event** pricing. You only pay for products that successfully land in your dataset — listing pages, retries, and pagination requests are free. The event charged depends on the `includeProductDetails` flag, so each scraped product fires **exactly one** event:

| Event | Triggered when | Price (USD) | Per 1,000 products |
|---|---|---|---|
| **Listing product** (`product-listing`) | `includeProductDetails: false` — product extracted directly from a category/search listing | **$0.0015** | **$1.50** |
| **Detailed product** (`item-detail`) | `includeProductDetails: true` — product extracted from its own PDP with full attributes and JSON-LD data | **$0.0030** | **$3.00** |

#### Cost examples

| Scenario | Items | Event | Estimated cost |
|---|---|---|---|
| Quick category sweep (default) | 50 | Listing product | **$0.075** |
| Mid-scale catalog mirror | 1,000 | Listing product | **$1.50** |
| Deep enrichment run | 1,000 | Detailed product | **$3.00** |
| Large monthly export | 10,000 | Listing product | **$15.00** |

Optimize your Zalando data pipeline with **Zalando Listings Scraper** today! 🚀

# Actor input Schema

## `startUrls` (type: `array`):

Zalando category, product detail (.html), or in-category search URLs to scrape.

## `searchQueries` (type: `array`):

Optional in-category search queries. Each item: { query: string, categorySlug?: string }. Defaults categorySlug to 'mens-clothing'.

## `domain` (type: `string`):

Zalando country domain used for search queries (e.g. zalando.de, zalando.co.uk, zalando.pl).

## `englishLocale` (type: `boolean`):

Prefix the domain with 'en.' (English variant) when building search URLs.

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

Hard cap on the number of products pushed to the dataset. Set 0 for unlimited.

## `includeProductDetails` (type: `boolean`):

If false, each product is pushed straight from the listing page and billed as 'Listing product'. If true, every product card enqueues its PDP and the richer record is billed as 'Detailed product' instead — exactly one charge per scraped product either way.

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

Proxy settings. Required on the Apify platform — Zalando's Akamai protection blocks raw datacenter IPs. Use residential proxy with country pinned to the target domain (e.g. DE for zalando.de) when running at scale.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://en.zalando.de/mens-clothing/"
    }
  ],
  "searchQueries": [],
  "domain": "zalando.de",
  "englishLocale": true,
  "maxItems": 50,
  "includeProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://en.zalando.de/mens-clothing/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/zalando-listings-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 = { "startUrls": [{ "url": "https://en.zalando.de/mens-clothing/" }] }

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/zalando-listings-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 '{
  "startUrls": [
    {
      "url": "https://en.zalando.de/mens-clothing/"
    }
  ]
}' |
apify call piotrv1001/zalando-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zalando Listings Scraper",
        "description": "The Zalando Listings Scraper extracts product listings and detailed product pages from Zalando shops across 25 country domains, capturing name, brand, SKU, price, sizes, gender, image gallery, stock status, and attributes — ideal for price tracking, competitive analysis, and catalog mirroring.",
        "version": "0.0",
        "x-build-id": "MImMumBYdaybU8Eyj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~zalando-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-zalando-listings-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/piotrv1001~zalando-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-zalando-listings-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/piotrv1001~zalando-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-zalando-listings-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Zalando category, product detail (.html), or in-category search URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional in-category search queries. Each item: { query: string, categorySlug?: string }. Defaults categorySlug to 'mens-clothing'.",
                        "default": []
                    },
                    "domain": {
                        "title": "Domain",
                        "enum": [
                            "zalando.de",
                            "zalando.co.uk",
                            "zalando.fr",
                            "zalando.it",
                            "zalando.es",
                            "zalando.nl",
                            "zalando.pl",
                            "zalando.com.tr",
                            "zalando.se",
                            "zalando.dk",
                            "zalando.fi",
                            "zalando.no",
                            "zalando.be",
                            "zalando.at",
                            "zalando.ch",
                            "zalando.cz",
                            "zalando.ie",
                            "zalando.lt",
                            "zalando.lv",
                            "zalando.ee",
                            "zalando.sk",
                            "zalando.hu",
                            "zalando.ro",
                            "zalando.hr",
                            "zalando.si"
                        ],
                        "type": "string",
                        "description": "Zalando country domain used for search queries (e.g. zalando.de, zalando.co.uk, zalando.pl).",
                        "default": "zalando.de"
                    },
                    "englishLocale": {
                        "title": "English locale",
                        "type": "boolean",
                        "description": "Prefix the domain with 'en.' (English variant) when building search URLs.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of products pushed to the dataset. Set 0 for unlimited.",
                        "default": 50
                    },
                    "includeProductDetails": {
                        "title": "Include product details",
                        "type": "boolean",
                        "description": "If false, each product is pushed straight from the listing page and billed as 'Listing product'. If true, every product card enqueues its PDP and the richer record is billed as 'Detailed product' instead — exactly one charge per scraped product either way.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Required on the Apify platform — Zalando's Akamai protection blocks raw datacenter IPs. Use residential proxy with country pinned to the target domain (e.g. DE for zalando.de) when running at scale.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
