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

Extracts product listings and detailed product data from Zalando category pages and search results across supported regions.

- **URL**: https://apify.com/scraptivo/zalando-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Categories:** E-commerce, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.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** collects product listings from [Zalando](https://www.zalando.com) category pages and search results and turns them into structured data for competitive pricing, catalog building, and trend monitoring. Provide a category URL or a search term such as "nike trainers", run the Actor, and export product name, brand, price, discount, sizes, images, and more to JSON, CSV, Excel, or your preferred integration. Optionally enrich each product with its full detail page. From just **$1 per 1,000 listings** ($2 per 1,000 listing details).

### What can you automate with Zalando Product Scraper?

- **Build product catalogs** — export name, brand, SKU, color, and images at scale.
- **Monitor competitor pricing** — track current and original prices plus discount amounts.
- **Track size availability** — capture available sizes and variants per product.
- **Follow fashion trends** — aggregate new arrivals across categories and brands.
- **Schedule recurring collection** — refresh pricing and stock daily or weekly.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| E-commerce analysts | Track competitor prices and promotions. |
| Marketplace sellers | Benchmark their own catalog against Zalando. |
| Fashion brands | Monitor distribution, pricing, and stock of their products. |
| Data providers | Build structured product feeds for downstream tools. |

### What data can you collect from Zalando?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `id`, `sku`, `name`, `brand`, `url` | Identify and link each product. |
| Pricing | `price`, `originalPrice`, `discountAmount`, `currency` | Compare price and promotions. |
| Catalog info | `color`, `sizes`, `silhouette`, `condition`, `supplierName` | Understand product attributes. |
| Media | `imageUrl`, `images` | Feed visual product data to your tools. |
| Enrichment | `description`, `variants`, `detailsScraped` | Optional detail-page data when enabled. |

### How to use Zalando Product Scraper

1. Open the Actor and go to the **Input** tab.
2. Paste a category or search **Start URL**, or enter a **Search Query**.
3. Set the **Base URL** to your target shop domain.
4. Choose a **Max Items** limit and toggle **Listing Details** if needed.
5. Run the Actor, then export the dataset as JSON, CSV, or Excel.

```json
{
  "searchQueries": ["nike trainers"],
  "baseUrl": "https://en.zalando.de",
  "maxItems": 50,
  "listingDetails": true
}
```

### Example workflow

#### Weekly monitoring of a brand's trainer catalog

1. Run a `nike trainers` search for your region every week.
2. Keep only products within your target price band.
3. Send new and changed records to a spreadsheet or pricing tool.
4. Deduplicate using the stable product `id` or `sku`.

### Automate and integrate your results

Schedule the Actor from the Apify Console or via API to run daily or weekly. After a successful run, trigger a webhook to push results to Google Sheets, Make, Zapier, Slack, or a database. Use the stable product `id` or `sku` as your deduplication key.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|---|
| `startUrls` | array | No | `[{"url": "https://en.zalando.de/outlet-mens-shoes/"}]` | Category, search, or product URLs. |
| `searchQueries` | array | No | `["nike trainers"]` | Search terms (combined with Start URLs when both set). |
| `baseUrl` | string | No | `https://en.zalando.de` | Shop domain used to resolve search queries. |
| `maxItems` | integer | No | — | Max products to return (0 = unlimited). |
| `listingDetails` | boolean | No | `false` | Add full product-page details (description, variants, GTIN). |
| `detailConcurrency` | integer | No | — | Parallel detail-page fetches when listing details are on. |

### Output example

```json
{
  "id": "N111A0A0A",
  "sku": "N111A0A0A-Q11",
  "name": "Nike Court Vision Low",
  "brand": "Nike",
  "url": "https://en.zalando.de/nike-court-vision-low.html",
  "price": 64.95,
  "originalPrice": 79.95,
  "discountAmount": 15.0,
  "currency": "EUR",
  "color": "White",
  "imageUrl": "https://img01.ztat.net/article/example.jpg",
  "sizes": ["40", "41", "42", "43", "44"],
  "description": "Leather low-top trainers with padded collar.",
  "detailsScraped": true
}
```

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

Billing is pay-per-event. You are charged **$1 per 1,000 listings** for search and category records (`dataset-item`). Enabling listing details adds **$2 per 1,000 detail pages** (`listing-details`). A one-time `Actor Start` fee of $0.00005 applies per run. Apify plan discounts reduce these prices further.

### Reliability and responsible use

Residential proxies are enabled by default and recommended for reliable access. Search-level fields such as `price` and `sizes` are available from listing cards, while `description` and `variants` appear only when listing details are enabled. Prices reflect the selected `baseUrl` region. Use the Actor only for lawful purposes and respect Zalando's terms of service.

### Frequently asked questions

#### Can I scrape products from multiple Zalando regions?

Yes. Set `baseUrl` to the target shop domain, e.g. `https://en.zalando.de` or `https://www.zalando.co.uk`, and the Actor resolves searches there.

#### Can I schedule Zalando Product Scraper to run automatically?

Yes. Use the Apify Scheduler to run daily or weekly and keep pricing and stock current.

#### What counts as one result?

One result is one product added to the dataset (`dataset-item`). Each enriched detail page is a separate `listing-details` event.

#### Why are some fields empty?

Detail-only fields such as `description` and `variants` are returned only when `listingDetails` is enabled. Some products may omit optional attributes.

#### How do I avoid duplicate records?

Deduplicate on the stable product `id` or `sku`.

#### Do I need a proxy?

Residential proxies are enabled by default and recommended for reliable access.

### Related Scraptivo automations

- [Amazon Scraper](https://apify.com/scraptivo/amazon-scraper) — marketplace product listings and pricing.
- [Best Buy Scraper](https://apify.com/scraptivo/best-buy-scraper) — consumer electronics listings.
- [Target Scraper](https://apify.com/scraptivo/target-scraper) — retail product data and availability.
- [IKEA Scraper](https://apify.com/scraptivo/ikea-scraper) — furniture and home product data.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, a sample category URL or search term, required fields, and expected volume so we can assess the request.

# 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("scraptivo/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("scraptivo/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 scraptivo/zalando-scraper --silent --output-dataset

```

## MCP server setup

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