# Zalando Scraper (`automation-lab/zalando-products-scraper`) Actor

Extract public Zalando products, prices, size availability, images, and optional reviews across supported European storefronts.

- **URL**: https://apify.com/automation-lab/zalando-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 42.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Zalando Scraper

Extract public Zalando product search results, product details, current prices, size availability, and optional customer reviews from supported European storefronts.

Use this Zalando scraper for recurring assortment checks, price monitoring, SKU availability snapshots, fashion catalog research, or structured exports to your analytics stack. It accepts keyword searches, search/category URLs, and individual product URLs.

### What does the Zalando Scraper do?

The Actor turns public Zalando pages into one normalized dataset row per product.

It can:

- search supported Zalando storefronts by keyword and audience;
- crawl public search or category URLs;
- extract individual product URLs;
- capture product IDs, SKUs, brands, names, colors, and images;
- capture current price and currency;
- capture size-level price and stock availability;
- optionally open the public review panel and extract review records;
- deduplicate products by their canonical URL;
- stop at your requested product limit.

The Actor uses a locale-matched residential browser session because Zalando's public storefronts reject ordinary server requests. You do not need to configure the proxy yourself.

### Who is this Zalando data extractor for?

- **Retail analysts** comparing public assortment and prices by country.
- **Merchandising teams** checking whether tracked SKUs and sizes remain available.
- **Fashion researchers** building structured brand or category samples.
- **Marketplace teams** enriching internal catalogs with current public product fields.
- **Data engineers** scheduling a Zalando API-style export to a warehouse.
- **Review analysts** collecting public ratings and review text for selected products.

### Why use this Actor?

Zalando serves different catalogs, currencies, availability, and language variants across European country domains. A plain HTTP request commonly returns an error shell instead of useful product data.

This Actor keeps the browser fingerprint, cookies, storefront locale, proxy country, and residential identity together. It validates the returned page before saving data and fails loudly on a challenge page instead of returning a misleading empty dataset.

It also reads structured product metadata and the browser's review response rather than relying only on fragile visual card selectors.

### What Zalando data can you extract?

| Field | Meaning |
| --- | --- |
| `productId` | Stable Zalando product-group identifier |
| `sku` | Product-group SKU |
| `url` | Canonical product URL |
| `sourceDomain` | Country storefront, such as `zalando.at` |
| `sourcePage` | Search, category, or product URL that produced the row |
| `brand` | Published brand |
| `name` | Product name and color label |
| `color` | Published color |
| `description` | Structured product description |
| `images` | Public product image URLs |
| `price` | Current price of the first published variant |
| `currency` | ISO currency code |
| `availability` | Current structured stock status |
| `sizes` | Variant SKU, size, availability, price, and currency |
| `rating` | Average rating when exposed by the storefront |
| `reviewCount` | Total public review count when exposed |
| `reviews` | Public review IDs, ratings, titles, text, dates, and verified status |
| `scrapedAt` | UTC extraction timestamp |

Fields that Zalando does not expose for a product are returned as `null` or an empty array.

### Getting started

1. Open the Actor input page.
2. Enter a `query`, or add one or more Zalando `startUrls`.
3. For keyword searches, select a country `domain` and `audience`.
4. Set `maxItems` to the maximum number of product rows required.
5. Enable `includeReviews` only when review records are needed.
6. Click **Start**.
7. Open the default dataset to preview or export JSON, CSV, Excel, XML, or RSS.

A small first run with one to five products is recommended before scheduling a larger monitor.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | — | Product, brand, or keyword search |
| `domain` | string | `zalando.co.uk` | Country storefront for keyword searches |
| `audience` | string | `men` | `women`, `men`, or `kids` section for keyword searches |
| `startUrls` | array | — | Public Zalando search, category, or product URLs |
| `maxItems` | integer | `10` | Product limit from 1 to 100 |
| `includeReviews` | boolean | `false` | Open and capture the public review panel |
| `maxReviewsPerProduct` | integer | `20` | Review limit per product from 0 to 100 |

Provide at least one query or start URL. All explicit URLs in one run must use the same country storefront so the browser locale and proxy country remain coherent.

Keyword construction is supported for Austria, Germany, Switzerland, the United Kingdom, France, and Italy. For another supported storefront, paste its public search or category URL in `startUrls`.

### Example: search Zalando products

```json
{
  "query": "cap",
  "domain": "zalando.at",
  "audience": "men",
  "maxItems": 5,
  "includeReviews": false
}
```

This searches the Austrian men's section and then opens product pages to return current variant prices and availability.

### Example: track one product's availability

```json
{
  "startUrls": [
    {
      "url": "https://www.zalando.at/pme-legend-mit-gesticktem-logo-cap-salute-pg352b00a-k11.html"
    }
  ],
  "maxItems": 1,
  "includeReviews": false
}
```

Schedule this input to create timestamped availability snapshots for the same public SKU.

### Example: extract product reviews

```json
{
  "startUrls": [
    {
      "url": "https://www.zalando.co.uk/nike-sportswear-club-unisex-cap-off-white-ni154b02i-a11.html"
    }
  ],
  "maxItems": 1,
  "includeReviews": true,
  "maxReviewsPerProduct": 20
}
```

Review extraction is optional because it requires an additional page interaction. Some products or storefronts do not expose a public review panel; those records return an empty `reviews` array.

### Example output

```json
{
  "productId": "PG352B00A-K11",
  "sku": "PG352B00A-K11",
  "url": "https://www.zalando.at/pme-legend-mit-gesticktem-logo-cap-salute-pg352b00a-k11.html",
  "sourceDomain": "zalando.at",
  "sourcePage": "https://www.zalando.at/herren/?q=cap",
  "brand": "PME Legend",
  "name": "EMBROIDED LOGO - Cap - salute",
  "color": "salute/blau",
  "price": 39.99,
  "currency": "EUR",
  "availability": "InStock",
  "sizes": [
    {
      "sku": "PG352B00A-K110ONE000",
      "size": "One Size",
      "availability": "InStock",
      "price": 39.99,
      "currency": "EUR"
    }
  ],
  "rating": null,
  "reviewCount": null,
  "reviews": [],
  "scrapedAt": "2026-07-29T04:07:50.766Z"
}
```

The live record also includes the public description and image URL array.

### How much does it cost to scrape Zalando products?

This Actor uses pay-per-event pricing:

- a one-time **Start** event of **$0.005** per run;
- one **Item processed** event for each validated product saved;
- when `includeReviews` is enabled, one additional **Review enrichment** event per saved product because the storefront requires extra browser and residential-proxy work;
- no separate event for individual sizes or review records inside the product row.

Current per-product tiers are:

| Plan tier | Item processed | Review enrichment when enabled |
| --- | ---: | ---: |
| Free | $0.006348 | $0.15092 |
| Bronze | $0.00552 | $0.13124 |
| Silver | $0.0043056 | $0.10236 |
| Gold | $0.003312 | $0.078742 |
| Platinum | $0.002208 | $0.052494 |
| Diamond | $0.0015456 | $0.036746 |

At the Bronze tier, 10 products without reviews cost about **$0.0602** and 100 cost about **$0.557**, including the start event. One review-enriched product costs about **$0.14176** at Bronze: the $0.005 start, $0.00552 item, and $0.13124 review-enrichment events. Apify may also apply normal platform usage according to your plan.

Enable reviews only when the review fields are needed. The enrichment event covers the extra processing for each saved product even when that product has no public review panel or no reviews. The result limit remains 100 products per run to keep browser work bounded.

### Scheduling price and availability monitoring

Create an Apify Schedule with a stable product, search, or category input. Each run writes a fresh dataset with `scrapedAt`, making it straightforward to compare:

- current price against the previous run;
- `InStock` and `OutOfStock` transitions;
- size additions or removals;
- new products found for the same query;
- review-count changes for selected products.

For alerts, connect the dataset to a webhook, Make, Zapier, n8n, or your own comparison service.

### Export and integration options

The default dataset supports:

- JSON for application integrations;
- CSV or Excel for analysts;
- XML and RSS for legacy workflows;
- the Apify API for scheduled pipelines;
- webhooks after successful or failed runs;
- direct integrations with cloud storage and automation tools.

Nested `sizes` and `reviews` are easiest to consume in JSON. Flatten those arrays downstream when a tabular warehouse model requires one row per size or review.

### Use through the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~zalando-products-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"cap","domain":"zalando.at","audience":"men","maxItems":5}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zalando-products-scraper').call({
  query: 'cap',
  domain: 'zalando.at',
  audience: 'men',
  maxItems: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/zalando-products-scraper').call(run_input={
    'query': 'cap',
    'domain': 'zalando.at',
    'audience': 'men',
    'maxItems': 5,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/zalando-products-scraper"
```

#### Claude Desktop

Add this server to Claude Desktop's MCP configuration.

#### Cursor

Use the same HTTP MCP URL in Cursor's MCP server settings.

#### VS Code

Use the same HTTP MCP URL with an MCP-capable VS Code extension.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/zalando-products-scraper"
    }
  }
}
```

Example prompts:

- “Search Zalando Austria for five men's caps and summarize current prices.”
- “Extract this Zalando product URL and list every available size.”
- “Collect public reviews for this Zalando UK product and group ratings.”

### Is it legal to scrape Zalando?

Scraping public product information can be lawful in many contexts, but rules differ by jurisdiction and use case. You are responsible for having a lawful purpose, respecting Zalando's terms, avoiding excessive load, and complying with copyright, database-right, privacy, and data-protection requirements. Public reviews may contain personal expression, so collect and retain only what your legitimate workflow requires. This guidance is not legal advice.

### Limits and responsible usage

- Only public, anonymous Zalando pages are supported.
- Login, checkout, wish lists, carts, and customer accounts are not supported.
- The Actor does not bypass paywalls or collect private customer data.
- Availability is a point-in-time storefront observation, not a stock guarantee.
- Results depend on the selected country storefront and may differ between markets.
- Review panels are not available for every product or locale.
- A run supports one storefront so geography and cookies remain consistent.
- The maximum is 100 products and 100 reviews per product per run.
- Zalando may change its pages or public response shapes.

Use the data in accordance with applicable law, Zalando's terms, and data-protection requirements. Avoid collecting more review content than is necessary for a legitimate purpose.

### Troubleshooting

#### Why did the run fail instead of returning zero products?

The Actor distinguishes a valid no-result search from an anti-bot or error shell. If Zalando rejects all three fresh locale-matched sessions, the run fails so monitoring systems do not interpret a block as an empty catalog.

#### Why are reviews empty?

Confirm that `includeReviews` is enabled and the selected storefront displays an **All reviews** panel for that product. Some products have no reviews, and some country storefronts do not expose the review panel.

#### Why was my start URL rejected?

Use an HTTPS URL on a supported country-specific Zalando domain. Do not mix domains such as `zalando.at` and `zalando.co.uk` in one run.

#### Why can keyword search be rejected for a domain?

The Actor builds locale-specific audience paths only for markets whose search paths have been validated. For another market, paste a working public search or category URL instead.

### FAQ

#### Is this an official Zalando API?

No. It is an independent Actor that converts public storefront pages and browser responses into an API-style dataset.

#### Can I monitor prices every day?

Yes. Save the input as an Apify Task, schedule it, and compare product rows by `sku` and `scrapedAt`.

#### Can I request only one product?

Yes. Supply its product URL and set `maxItems` to `1`.

#### Are unavailable sizes included?

The Actor returns the variants Zalando publishes in structured product data, including each exposed availability value.

#### Are reviews charged separately?

Optional review processing emits one **Review enrichment** event per saved product when `includeReviews` is enabled. Individual reviews are not charged separately.

### Related Actors from automation-lab

- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) for cross-retailer shopping result research.
- [Musinsa Fashion Rankings Scraper](https://apify.com/automation-lab/musinsa-fashion-rankings-scraper) for fashion ranking and assortment signals.

Use related Actors only when their source and data model match the comparison you intend to make.

# Actor input Schema

## `query` (type: `string`):

Product, brand, or keyword to search on Zalando Austria, Germany, Switzerland, the UK, France, or Italy. For other storefronts, supply a search/category URL.

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

European storefront used for query searches. Explicit start URLs determine their own storefront.

## `audience` (type: `string`):

Audience section used for keyword searches. It does not affect explicit URLs.

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

Optional public Zalando URLs. All URLs in one run must belong to the same country storefront.

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

Maximum number of product records to save after deduplication.

## `includeReviews` (type: `boolean`):

Open the review panel when available and include public review records. This adds browser work per product.

## `maxReviewsPerProduct` (type: `integer`):

Maximum public reviews retained for each product when review extraction is enabled.

## Actor input object example

```json
{
  "query": "running shoes",
  "domain": "zalando.co.uk",
  "audience": "men",
  "startUrls": [
    {
      "url": "https://www.zalando.co.uk/men/?q=running+shoes"
    }
  ],
  "maxItems": 10,
  "includeReviews": false,
  "maxReviewsPerProduct": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset records shown in the product overview view.

# 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 = {
    "query": "running shoes",
    "domain": "zalando.co.uk",
    "audience": "men",
    "startUrls": [
        {
            "url": "https://www.zalando.co.uk/men/?q=running+shoes"
        }
    ],
    "maxItems": 10,
    "includeReviews": false,
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zalando-products-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 = {
    "query": "running shoes",
    "domain": "zalando.co.uk",
    "audience": "men",
    "startUrls": [{ "url": "https://www.zalando.co.uk/men/?q=running+shoes" }],
    "maxItems": 10,
    "includeReviews": False,
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zalando-products-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 '{
  "query": "running shoes",
  "domain": "zalando.co.uk",
  "audience": "men",
  "startUrls": [
    {
      "url": "https://www.zalando.co.uk/men/?q=running+shoes"
    }
  ],
  "maxItems": 10,
  "includeReviews": false,
  "maxReviewsPerProduct": 20
}' |
apify call automation-lab/zalando-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ZS9fuHBirCleUnRu8/builds/JZsIRuKgyzb1K79Dg/openapi.json