# Zalando Product Scraper (`datascrapers/zalando-scraper`) Actor

Zalando product dataset from category pages, search queries, or product URLs, including prices, brands, and optional listing details.

- **URL**: https://apify.com/datascrapers/zalando-scraper.md
- **Developed by:** [Farhan Ali](https://apify.com/datascrapers) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 listings

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

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

## What's an Apify Actor?

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 Product Scraper** creates a structured dataset of products collected from [Zalando](https://en.zalando.de). Each dataset item represents one Zalando product and can include identifiers, brand, listing title, current and original prices, discount amount, currency, promotion flags, silhouette, images, sizes, and optional product-page details such as description, variants, availability, and GTIN. Query the source with category, search, or product `.html` URLs (`startUrls`) and/or search terms (`searchQueries`) resolved against `baseUrl`. Control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, XML, or another supported format.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | Zalando shop domains (default `en.zalando.de`) |
| Record unit | One Zalando product |
| Input methods | Category, search, or product `.html` URLs (`startUrls`) and/or `searchQueries` |
| Main identifiers | `sku` (recommended), product `url` |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $1 / 1,000 listings; +$2 / 1,000 listing details; Actor start $0.00005 |

### Coverage and available records

The Actor collects public Zalando product records from one or both entry points. When both are set, the seeds are combined.

- **URL-based**: Pass Zalando category, search, or product page URLs in `startUrls`. Category and search pages paginate. Product URLs ending in `.html` produce a single product record.
- **Search-based**: Pass free-text terms in `searchQueries` (for example `nike trainers`). Queries resolve against `baseUrl` (default `https://en.zalando.de`).

Record types and limits:

- **Listing-level records** are always collected when a product is returned: `id`, `sku`, `name`, `brand`, `url`, `price`, `originalPrice`, `discountAmount`, `currency`, `flags`, `silhouette`, `imageUrl`, `images`, `sizes`, `color`, `sourceUrl`, `sourceQuery`, and `detailsScraped`.
- **Product detail fields** are conditional: `description`, `variants` (including GTIN and availability on each variant) are returned only when `listingDetails` is enabled and the product page is collected successfully.
- **Result cap**: `maxItems` limits products across all seeds (`0` means unlimited). The default is `50`.

Known exclusions: login-only Zalando content is not collected; each run captures page state at run time (no historical snapshots); coverage is limited to the shop domains you query via `startUrls` or `baseUrl`.

### Data dictionary

Field names below match dataset record JSON properties exactly. Fields marked *conditional* appear only when `listingDetails` is enabled and the product page is collected. Values come from Zalando; the Actor does not calculate catalog prices.

#### Product listing fields

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `id` | string | Yes | Zalando product identifier | `ern:product::RE015O0NC-A12` |
| `sku` | string | No | Config SKU; best stable deduplication key | `RE015O0NC-A12` |
| `name` | string | Yes | Product title | `Nike Air Force 1 '07` |
| `brand` | string | Yes | Brand name | `Nike` |
| `url` | string | No | Product page URL; secondary deduplication key | `https://en.zalando.de/nike-air-force-1-07-re015o0nc-a12.html` |
| `price` | number | Yes | Current selling price in `currency` | `99.99` |
| `originalPrice` | number | Yes | Original / pre-discount price in `currency` | `149.99` |
| `discountAmount` | number | Yes | Discount amount in `currency` | `50.0` |
| `currency` | string | Yes | ISO currency code for price fields | `EUR` |
| `flags` | string\[] | Yes | Promotion flags as shown on Zalando | `["Sale"]` |
| `silhouette` | string | Yes | Product type / silhouette | `Sneakers` |
| `imageUrl` | string | Yes | Primary product image URL | — |
| `images` | string\[] | Yes | Product image URLs | — |
| `sizes` | string\[] | Yes | Available size labels | — |
| `color` | string | Yes | Color as shown on Zalando; typically present after listing details | — |
| `sourceUrl` | string | Yes | Seed URL that produced the record | `https://en.zalando.de/outlet-mens-shoes/` |
| `sourceQuery` | string | Yes | Search term when the record came from a search seed | `nike trainers` |
| `detailsScraped` | boolean | Yes | `true` when listing details were collected for this record | `true` |

#### Product detail fields (conditional — `listingDetails`)

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `description` | string | Yes | Product description from the product page | — |
| `variants` | object\[] | Yes | Size / config variants with identifiers, price, GTIN, and availability | See variant table |

Each `variants[]` object can include:

| Field | Type | Nullable | Description |
|---|---|---:|---|
| `sku` | string | Yes | Variant SKU |
| `size` | string | Yes | Size label |
| `gtin` | string | Yes | GTIN when Zalando publishes one |
| `price` | number | Yes | Variant price |
| `currency` | string | Yes | ISO currency code |
| `availability` | string | Yes | Availability label from the product page |

### Example dataset record

Representative listing record for SKU `RE015O0NC-A12`. Image URLs, sizes, color, description, and `variants` are omitted here; they appear on the record when Zalando returns them and, for description / variants, when `listingDetails` succeeds.

```json
{
  "id": "ern:product::RE015O0NC-A12",
  "sku": "RE015O0NC-A12",
  "name": "Nike Air Force 1 '07",
  "brand": "Nike",
  "url": "https://en.zalando.de/nike-air-force-1-07-re015o0nc-a12.html",
  "price": 99.99,
  "originalPrice": 149.99,
  "discountAmount": 50.0,
  "currency": "EUR",
  "flags": ["Sale"],
  "silhouette": "Sneakers",
  "sourceUrl": "https://en.zalando.de/nike-air-force-1-07-re015o0nc-a12.html",
  "sourceQuery": null,
  "detailsScraped": false
}
```

The record above matches this input:

```json
{
  "startUrls": [
    { "url": "https://en.zalando.de/nike-air-force-1-07-re015o0nc-a12.html" }
  ],
  "maxItems": 1,
  "listingDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---:|---|---|---|
| `startUrls` | array (requestListSources) | No\* | — | Zalando category, search, or product `.html` URLs | URL-based entry point. Combined with `searchQueries` when both are set |
| `searchQueries` | array | No\* | — | Free-text terms (e.g. `nike trainers`) | Search terms resolved against `baseUrl` |
| `baseUrl` | string | No | `https://en.zalando.de` | Zalando shop origin (e.g. `https://en.zalando.de`, `https://www.zalando.co.uk`) | Shop domain used when resolving `searchQueries` |
| `maxItems` | integer | No | `50` | `0` or any positive integer | Maximum products across all seeds; `0` = unlimited |
| `listingDetails` | boolean | No | `false` | `true` / `false` | Collect description, variants, availability, and GTIN (charged as `listing-details`) |
| `detailConcurrency` | integer | No | `10` | `1`–`50` | Parallel product-page fetches when `listingDetails` is enabled |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` group | Apify proxy groups or custom proxies | Residential proxies are recommended |

\* Provide at least one of `startUrls` or `searchQueries`.

Minimal request:

```json
{ "startUrls": [{ "url": "https://en.zalando.de/outlet-mens-shoes/" }] }
```

Advanced request (combined seeds with listing details):

```json
{
  "startUrls": [{ "url": "https://en.zalando.de/outlet-mens-shoes/" }],
  "searchQueries": ["nike trainers"],
  "baseUrl": "https://en.zalando.de",
  "maxItems": 200,
  "listingDetails": true,
  "detailConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Retrieve the data through the API

The Actor runs on the Apify platform. This is the Apify Actor API, not an official Zalando API.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "startUrls": [{"url": "https://en.zalando.de/outlet-mens-shoes/"}],
    "maxItems": 10,
    "listingDetails": True,
}

run = client.actor("datascrapers/zalando-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["sku"], item["name"], item["price"])
```

Apify generates ready-to-run Python, JavaScript, and cURL examples on the Actor's [API tab](https://apify.com/datascrapers/zalando-scraper/api). Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: `description`, `variants`, GTIN, and availability appear only when `listingDetails` is enabled and the product page is collected. Listing-only runs return a leaner record.
- **Source changes**: Zalando values can change; unreadable fields are omitted or returned as null rather than fabricated.
- **Deduplication**: within a run, products are de-duplicated by `sku`. Across runs, records are appended. Use `sku` as the stable external key, or `url` as a secondary key.
- **Partial enrichment**: a failed details fetch does not drop the listing record.
- **Charges**: the Actor stops when a spending limit is reached (see run log). Price, discount, currency, and flag values are read from Zalando and stored as the types in the data dictionary.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store SKUs, prices, and discount amounts alongside catalog records |
| Google Sheets | Apify Google Sheets integration | Share shortlists for price and assortment checks |
| PIM / catalog systems | Dataset API or completion webhook | Refresh fashion product feeds |
| S3 / cloud storage | Scheduled export via Apify scheduler + integration | Archival of market snapshots |

### Pricing and cost examples

The Actor uses pay-per-event pricing. Event rates are tiered by Apify plan. Listed amounts are the base rates:

| Event | Trigger | Rate |
|---|---|---|
| Actor start | Once per run | $0.00005 |
| `dataset-item` | Every product record pushed to the dataset | $0.001 per listing ($1.00 per 1,000) |
| `listing-details` | `listingDetails` enabled and details collected | $0.002 per listing ($2.00 per 1,000) |

Example costs (Actor start omitted; it is $0.00005):

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 | Listing only | $1.00 |
| 10,000 | Listing only | $10.00 |
| 1,000 | Listing + listing details | $3.00 |
| 10,000 | Listing + listing details | $30.00 |

Apify paid plans reduce event rates. Compute units and proxy usage are billed by your Apify plan. Estimates depend on the verified pricing model and the options selected for the run.

### Limitations and responsible data use

- The Actor collects publicly accessible data from Zalando pages only.
- Field availability depends on what Zalando renders at run time; some values can be null or missing, and site changes can alter fields.
- The Actor does not provide historical snapshots unless you store them yourself. Assortment, currency, and prices differ by shop domain.
- Residential proxies are recommended; coverage may degrade without them.
- You are responsible for compliance with Zalando's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One Zalando product. Size and config variants nest in `variants` when `listingDetails` is enabled, so a product with several sizes still produces a single dataset item.

#### Which field should I use as a unique identifier?

`sku` is the recommended deduplication key. `url` is a reasonable secondary key.

#### Are fields nullable or conditional?

Yes. `description`, `variants`, GTIN, and availability exist only when `listingDetails` is enabled and the product page is collected. Fields Zalando does not render are returned as null or omitted.

#### Can I retrieve the records as CSV or JSON?

Yes. Export JSON, CSV, Excel, XML, or HTML from the Apify Console, or query the Dataset API.

#### How do I query by category, search term, or product URL?

Pass category or search page URLs, or a product `.html` URL, in `startUrls`. For keyword search without a URL, set `searchQueries` and optionally `baseUrl`. Both inputs can be combined; `maxItems` applies across them.

#### Does the Actor return historical data?

No. Each run captures page state at run time. Schedule repeated runs and store outputs to track price or assortment changes.

#### What counts as a billable result?

Actor start once per run ($0.00005); `dataset-item` for every product ($0.001); and `listing-details` when details are collected ($0.002 per product). A listing-only run incurs Actor start plus `dataset-item` only.

### Related datasets from Data Scrapers

- **[IKEA Product Scraper](https://apify.com/datascrapers/ikea-scraper)** — Home and furniture products for cross-retailer catalog and price comparison with Zalando home and lifestyle items.
- **[Flipkart Product Scraper](https://apify.com/datascrapers/flipkart-scraper)** — Marketplace apparel and footwear records joinable by brand or title for multi-market pricing.
- **[Amazon Search Scraper](https://apify.com/datascrapers/amazon-scraper)** — Marketplace product records for competitive benchmarking against Zalando listings.
- **[Etsy Scraper](https://apify.com/datascrapers/etsy-scraper)** — Independent fashion and accessories listings for adjacent assortment research.
- **[Best Buy Product Scraper](https://apify.com/datascrapers/best-buy-scraper)** — Electronics listings for the same price-monitoring pipelines when comparing non-apparel categories.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

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

Zalando category, search, or product page URLs (e.g. https://en.zalando.de/outlet-mens-shoes/). Category and search pages are paginated; product pages (.html) are scraped as single items.

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

Search terms to look up on Zalando (e.g. nike trainers, adidas hoodie). Combined with Start URLs when both are set.

## `baseUrl` (type: `string`):

Zalando shop domain used when resolving search queries (e.g. https://en.zalando.de, https://www.zalando.co.uk).

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

Maximum number of products to scrape (0 = unlimited).

## `listingDetails` (type: `boolean`):

When enabled, open each product page for richer details (description, color, size variants, availability, GTIN). Charged as a separate listing-details event in addition to dataset-item.

## `detailConcurrency` (type: `integer`):

Maximum number of product detail pages fetched in parallel when Scrape Listing Details is enabled. Each request uses a freshly rotated proxy.

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

Apify Proxy settings. Residential proxies are recommended for reliable access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://en.zalando.de/outlet-mens-shoes/"
    }
  ],
  "searchQueries": [
    "nike trainers"
  ],
  "baseUrl": "https://en.zalando.de",
  "maxItems": 50,
  "listingDetails": false,
  "detailConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped Zalando products

## `runStats` (type: `string`):

Aggregate scrape statistics for this run

# 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/outlet-mens-shoes/"
        }
    ],
    "searchQueries": [
        "nike trainers"
    ],
    "baseUrl": "https://en.zalando.de",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/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 = {
    "startUrls": [{ "url": "https://en.zalando.de/outlet-mens-shoes/" }],
    "searchQueries": ["nike trainers"],
    "baseUrl": "https://en.zalando.de",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/zalando-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 '{
  "startUrls": [
    {
      "url": "https://en.zalando.de/outlet-mens-shoes/"
    }
  ],
  "searchQueries": [
    "nike trainers"
  ],
  "baseUrl": "https://en.zalando.de",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/zalando-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascrapers/zalando-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/rhxFLz4NwvKI9qtNz/builds/wyCVmFoYNggn3A4bg/openapi.json