# Zalando Scraper | European Fashion & E-commerce Product Data (`longanimous_bracken/zalando-scraper`) Actor

Scrape product listings from Zalando across 11+ European markets (fi, se, de, uk, fr, es, it, nl, pl, at, ch). Extracts title, price, brand, category, images, availability, and product URL. Multi-country, price/brand filtering, detail pages, CSV/JSON/webhook output.

- **URL**: https://apify.com/longanimous\_bracken/zalando-scraper.md
- **Developed by:** [petteri mähönen](https://apify.com/longanimous_bracken) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 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/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

## Zalando Scraper — European Fashion Marketplace Data

Extract product listings from **Zalando** across 11+ European markets. Europe's largest fashion and lifestyle marketplace (100M+ users, 5000+ brands) — no competitor on the Apify Store.

---

### ✨ Features

- **Multi-country** — scrape fi, se, de, uk, fr, es, it, nl, pl, at, ch (and more)
- **Search + Category browsing** — keyword search or direct category URL slugs
- **Price filtering** — min/max price in local currency
- **Brand filtering** — filter by specific brand names (case-insensitive)
- **Outlet / Sale items** — extract only discounted products
- **Detail pages** — full descriptions, images, sizes, materials, care instructions
- **Anti-detection** — UA rotation, request delays, jittered timing
- **Multiple output formats** — Dataset, CSV, JSON, webhook delivery
- **Cheapest on Store** — $1.00/1K results

---

### 📥 Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | string | Search term (e.g. `'sneakers'`, `'dress'`) | `''` |
| `categories` | string[] | Category slugs (e.g. `'women/sneakers'`) — overrides searchQuery | `[]` |
| `country` | string | Country code: fi, se, de, uk, fr, es, it, nl, pl, at, ch | `'fi'` |
| `maxPages` | integer | Pages per query (~84 listings/page) | `1` |
| `priceMin` | number | Minimum price in local currency | `null` |
| `priceMax` | number | Maximum price in local currency | `null` |
| `brands` | string[] | Filter by brand names | `[]` |
| `outletOnly` | boolean | Only extract sale/discounted items | `false` |
| `fetchDetails` | boolean | Visit detail pages for full product data | `false` |
| `detailDelaySecs` | integer | Delay between detail page visits (seconds) | `2` |
| `outputFormat` | string | `dataset`, `csv`, `json`, or `all` | `'dataset'` |
| `webhookUrl` | string | POST results to HTTPS URL on completion | `null` |

---

### 📤 Output

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Product name |
| `name` | string | Product name (alias) |
| `brand` | string | Brand name |
| `price` | string | Displayed price (e.g. `'€89.99'`) |
| `price_numeric` | number | Price as number for sorting/filtering |
| `url` | string | Full product URL |
| `image_url` | string | Product thumbnail image URL |
| `badge` | string | Sale badge (Diili, Uusi, Designer, etc.) |
| `search_query` | string | Query that produced this result |
| `page_number` | integer | Result page number |
| `country` | string | Country code (fi, se, de, etc.) |
| `scraped_at` | string | ISO 8601 timestamp |
| `description` | string | *Detail page only* — full product description |
| `images` | string[] | *Detail page only* — all product images |
| `sizes` | string[] | *Detail page only* — available sizes |
| `colors` | string[] | *Detail page only* — available colors |
| `material` | string | *Detail page only* — material info |
| `care` | string | *Detail page only* — care instructions |
| `availability` | string | *Detail page only* — stock status |

---

### 🚀 Quick Start

```bash
## Search sneakers on Zalando Finland
apify call cgWoCj83jWTFIH5OD -i '{"searchQuery":"sneakers","country":"fi"}' -b latest -m 4096 -o -t 120

## Browse category with price filter
apify call cgWoCj83jWTFIH5OD -i '{"categories":["women/sneakers"],"country":"de","priceMin":30,"priceMax":120}' -b latest -m 4096 -o -t 120

## Multi-country search with detail pages
apify call cgWoCj83jWTFIH5OD -i '{"searchQuery":"leather jacket","country":"uk","fetchDetails":true,"maxPages":2}' -b latest -m 4096 -o -t 300
````

***

### 💡 Use Cases

- **Dropshipping** — track fashion product availability and pricing across European markets
- **Competitor monitoring** — benchmark your prices against Zalando sellers
- **Price tracking** — historical price analysis with cron jobs
- **Resale market research** — identify trending brands and styles
- **Affiliate marketing** — build fashion recommendation engines
- **Market intelligence** — seasonal trend analysis, category demand tracking

***

### 🔧 Example Input

```json
{
  "searchQuery": "sneakers",
  "country": "fi",
  "maxPages": 2,
  "priceMin": 25,
  "priceMax": 200,
  "brands": ["Nike", "Adidas"],
  "fetchDetails": true,
  "detailDelaySecs": 2,
  "outputFormat": "all"
}
```

***

### ⚠️ Limitations

- **Rate limits** — Zalando may throttle heavy scraping. Use delays and moderate page counts.
- **Anti-detection** — built-in, but not guaranteed. For high-volume use, consider Apify proxy.
- **CSS selectors** — Zalando uses Web Components with hashed class names; selectors are pattern-based and may need updates after site redesigns.
- **Detail pages** — `fetchDetails` adds ~2-5s per listing and increases memory usage.

***

### 📋 Changelog

| Version | Date | Changes |
|---------|------|---------|
| 0.1 | 2026-07-17 | Initial release — search + category extraction, multi-country (11+), price/brand/outlet filters, detail page extraction, CSV/JSON/webhook output |

***

### 🤖 Copy to AI Assistant

```
Scrape Zalando fashion listings from the Apify Store.
Actor: https://apify.com/longanimous_bracken/zalando-scraper

Example: search for "sneakers" on Zalando Finland, 2 pages,
filter brands Nike/Adidas, price 25-200 EUR, fetch detail pages.

Input:
{
  "searchQuery": "sneakers",
  "country": "fi",
  "maxPages": 2,
  "priceMin": 25,
  "priceMax": 200,
  "brands": ["Nike", "Adidas"],
  "fetchDetails": true
}
```

# Actor input Schema

## `searchQuery` (type: `string`):

Search term — any product keyword (e.g. 'sneakers', 'dress', 'jacket'). Leave empty to browse categories.

## `categories` (type: `array`):

Category slugs to scrape (e.g. 'women/sneakers', 'men/jackets'). Overrides searchQuery if provided.

## `country` (type: `string`):

Zalando country subdomain: fi, se, de, uk, fr, es, it, nl, pl, at, ch, be, cz, hu, pt, ro, sk, si, hr, lt, lv, ee, bg, gr, cy, mt, lu.

## `maxPages` (type: `integer`):

Number of result pages per query/category (~84 listings per page). Default: 1.

## `priceMin` (type: `number`):

Minimum price in local currency. Applied post-extraction.

## `priceMax` (type: `number`):

Maximum price in local currency. Applied post-extraction.

## `brands` (type: `array`):

Filter by brand names (case-insensitive). Leave empty for all brands.

## `outletOnly` (type: `boolean`):

If true, only extract items with sale badges (Diili, Uusi, Designer, etc.).

## `fetchDetails` (type: `boolean`):

Visit each product's detail page to extract full description, all images, available sizes, colors, materials, and care instructions. Adds ~2-5s per listing.

## `detailDelaySecs` (type: `integer`):

Delay between detail page visits. Jitter added automatically. Only relevant when fetchDetails is true.

## `outputFormat` (type: `string`):

Output format: dataset, csv, json, or all.

## `webhookUrl` (type: `string`):

HTTPS URL to POST all listings to on completion.

## Actor input object example

```json
{
  "categories": [],
  "country": "fi",
  "maxPages": 1,
  "brands": [],
  "outletOnly": false,
  "fetchDetails": false,
  "detailDelaySecs": 2,
  "outputFormat": "dataset"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("longanimous_bracken/zalando-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("longanimous_bracken/zalando-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 '{}' |
apify call longanimous_bracken/zalando-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zalando Scraper | European Fashion & E-commerce Product Data",
        "description": "Scrape product listings from Zalando across 11+ European markets (fi, se, de, uk, fr, es, it, nl, pl, at, ch). Extracts title, price, brand, category, images, availability, and product URL. Multi-country, price/brand filtering, detail pages, CSV/JSON/webhook output.",
        "version": "0.0",
        "x-build-id": "6mTqwTHWgdb4rNpE9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/longanimous_bracken~zalando-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-longanimous_bracken-zalando-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/longanimous_bracken~zalando-scraper/runs": {
            "post": {
                "operationId": "runs-sync-longanimous_bracken-zalando-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/longanimous_bracken~zalando-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-longanimous_bracken-zalando-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term — any product keyword (e.g. 'sneakers', 'dress', 'jacket'). Leave empty to browse categories."
                    },
                    "categories": {
                        "title": "Category URL Slugs",
                        "type": "array",
                        "description": "Category slugs to scrape (e.g. 'women/sneakers', 'men/jackets'). Overrides searchQuery if provided.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Zalando country subdomain: fi, se, de, uk, fr, es, it, nl, pl, at, ch, be, cz, hu, pt, ro, sk, si, hr, lt, lv, ee, bg, gr, cy, mt, lu.",
                        "default": "fi"
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "type": "integer",
                        "description": "Number of result pages per query/category (~84 listings per page). Default: 1.",
                        "default": 1
                    },
                    "priceMin": {
                        "title": "Minimum Price",
                        "type": "number",
                        "description": "Minimum price in local currency. Applied post-extraction."
                    },
                    "priceMax": {
                        "title": "Maximum Price",
                        "type": "number",
                        "description": "Maximum price in local currency. Applied post-extraction."
                    },
                    "brands": {
                        "title": "Brands",
                        "type": "array",
                        "description": "Filter by brand names (case-insensitive). Leave empty for all brands.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "outletOnly": {
                        "title": "Outlet / Sale Items Only",
                        "type": "boolean",
                        "description": "If true, only extract items with sale badges (Diili, Uusi, Designer, etc.).",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch Detail Pages",
                        "type": "boolean",
                        "description": "Visit each product's detail page to extract full description, all images, available sizes, colors, materials, and care instructions. Adds ~2-5s per listing.",
                        "default": false
                    },
                    "detailDelaySecs": {
                        "title": "Detail Page Delay (seconds)",
                        "type": "integer",
                        "description": "Delay between detail page visits. Jitter added automatically. Only relevant when fetchDetails is true.",
                        "default": 2
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "type": "string",
                        "description": "Output format: dataset, csv, json, or all.",
                        "default": "dataset"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "HTTPS URL to POST all listings to on completion."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
