# Zalando Scraper | $1/1K · Prices, Sizes & Stock (`technicaldost/zalando-product-scraper-plus`) Actor

Scrape Zalando products from category, search and product URLs. Prices, discounts, images, sizes, stock and material attributes. $1 per 1,000 successful products, including detail enrichment; paid-plan discounts.

- **URL**: https://apify.com/technicaldost/zalando-product-scraper-plus.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 successful products

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Zalando Scraper — $1/1,000 products, prices, sizes and availability

Extract structured Zalando fashion products for price comparison, catalog research, stock analysis and ecommerce data pipelines. Paste category, search or direct-product URLs, or enter search keywords. No browser, login cookies or third-party API key required.

### Pricing

One successful unique product costs **$0.001 ($1 per 1,000)** on the Free plan. Detail enrichment is included in that same product event — no extra detail fee. Paid-plan rates per 1,000: Bronze **$0.95**, Silver **$0.90**, Gold/Platinum/Diamond **$0.85**. Actor start costs **$0.00005** per run at supported memory settings.

Failed product requests, invalid inputs, duplicates within a run and filtered-out products do not generate product events. The start event still applies to runs with no products. Set Apify's maximum-charge budget and `maxResults` to control spend. For example, 1,000 delivered products on Free cost $1.00005 including one start. Confirm current prices on the Pricing tab; your plan determines the applicable tier.

### Quick start

1. Keep the example UK clothing URL or paste your own Zalando URLs.
2. Choose the maximum products. The default is **10**, across all inputs combined.
3. Keep **Include product details** enabled for size availability, colors and published attributes. Turn it off for faster catalog-only extraction.
4. Run the Actor and export the Products dataset as JSON, CSV or Excel. Open **Run report** for request counts and failed URLs.

```json
{
  "startUrls": [{"url":"https://www.zalando.co.uk/womens-clothing/"}],
  "maxResults": 10,
  "maxPagesPerUrl": 3,
  "scrapeDetails": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {"useApifyProxy":true}
}
```

### What you get

| Field | Meaning |
| --- | --- |
| `sku`, `url`, `market` | Product identifier, canonical URL and country code |
| `name`, `brand` | Published product and brand names |
| `price`, `originalPrice`, `promotionalPrice` | Current, reference and discounted prices in local currency units |
| `currency`, `priceCurrency` | ISO currency code, such as GBP or EUR; compatible aliases |
| `discountPercent` | Discount relative to the original/reference price |
| `images` | Deduplicated image URLs; videos excluded |
| `variants` | Size-level SKU, size label, availability, price and GTIN when exposed |
| `availableSizes`, `inStock` | Confirmed availability; unknown stock is **null**, never assumed false |
| `color`, `description` | Published detail data when exposed |
| `attributes`, `material`, `category` | Published detail attributes, material subset and leading category |
| `rating`, `ratingCount` | Aggregate rating data when supplied; not a full reviews export |
| `colorVariants` | Related family/color products exposed by the page; not recursively crawled |
| `detailFetched`, `extractedAt` | Detail-fetch flag and UTC extraction timestamp |

Fields unavailable on the source page are null or empty arrays. Catalog-only mode generally has less detail and may not confirm stock. Product-level prices can differ from size-level offers. `originalPrice` is Zalando's reference price, not a verified historical price.

Illustrative output (values change with live inventory):

```json
{
  "sku":"EV421I0BV-C11",
  "name":"Jumper - mid grey melange",
  "brand":"Even&Odd by Zalando",
  "market":"GB",
  "price":22,
  "originalPrice":29.99,
  "promotionalPrice":22,
  "discountPercent":26.64,
  "currency":"GBP",
  "priceCurrency":"GBP",
  "color":"mid grey melange",
  "url":"https://www.zalando.co.uk/evenandodd-jumper-mid-grey-melange-ev421i0bv-c11.html",
  "detailFetched":true
}
```

### Category, search and product inputs

Category URLs follow the actual pagination exposed by Zalando, preserving search and filter parameters. Direct product URLs return only the requested product, excluding recommendation carousels. Duplicate products are returned once per market; the same SKU in two markets is retained twice because prices and inventory differ.

Keyword example:

```json
{
  "searchTerms":["nike shoes"],
  "market":"de",
  "maxResults":20,
  "maxPagesPerUrl":2,
  "scrapeDetails":true
}
```

Price and brand filter example:

```json
{
  "startUrls":["https://www.zalando.co.uk/mens-clothing/"],
  "maxResults":30,
  "minPrice":20,
  "maxPrice":80,
  "onSaleOnly":true,
  "brandIncludes":["Nike","adidas"]
}
```

Prices are filtered in each product's local currency without conversion. Strong filters or a small page limit may legitimately return zero products.

### Markets

Country-domain inputs are accepted for UK, Germany, France, Italy, Spain, Netherlands, Belgium, Poland, Austria, Switzerland, Ireland, Denmark, Sweden, Norway, Finland, Czechia, Slovakia, Hungary, Romania, Croatia, Slovenia, Estonia, Latvia, Lithuania and Luxembourg. They use the same structured-data parser, but not every market or product template is guaranteed. Keyword search has localized routes for UK, Germany, France, Italy, Spain and Netherlands; use explicit start URLs for other countries. Cross-market redirects are rejected to avoid silently mixing currencies. Legitimate language-subdomain redirects, such as `en.zalando.de`, retain their German market identity.

Release verification (4 October 2026): UK, Germany and France passed live Apify cloud detail runs. Italy, Spain and Netherlands passed local live keyword-catalog checks. A UK pagination test delivered 100 unique products, and a charge-limit test stopped correctly after one product. These are test samples, not a guaranteed success rate for every future request.

### Input reference

| Parameter | Default | Description |
| --- | --- | --- |
| `startUrls` | UK clothing example in the input form | String URLs or `{ "url": "..." }` objects |
| `searchTerms` | None | Keyword searches, optionally combined with URLs |
| `market` | `co.uk` | Domain suffix for keyword searches only |
| `maxResults` | `10` | Global successful-product limit, 1–10,000; `maxItems` accepted as a JSON alias |
| `maxPagesPerUrl` | `3` | Catalog page limit per input, 1–100 |
| `scrapeDetails` | `true` | Detail enrichment; direct-product URLs always include detail |
| `minPrice`, `maxPrice` | None | Inclusive price bounds, local currency |
| `onSaleOnly` | `false` | Require a current price lower than original price |
| `brandIncludes` | None | Case-insensitive partial brand names |
| `maxConcurrency` | `2` | Parallel detail requests, 1–4 |
| `maxRequestRetries` | `2` | Extra attempts per failed page, 0–5 |
| `proxyConfiguration` | Datacenter proxies | Optional Apify/custom proxy settings |

### Reliability and diagnostics

The Actor parses literal JSON from Zalando's server-rendered GraphQL hydration and JSON-LD. Remaining catalog cards are fetched in bounded batches through the public web GraphQL endpoint using the query definition exposed by the page, so pagination does not skip cards omitted from the initial HTML. It does not execute website scripts. HTTP requests use browser-like headers, bounded timeouts and rotated proxy sessions on retry. Successful product IDs and completed pages are checkpointed for run migration/restart. Failed URLs are stored in `ERRORS` and `REPORT`, not inserted as product rows.

`REPORT` contains products, failures, filtered records, duplicate skips, HTTP requests and whether the spending limit stopped the run. The Actor fails clearly when requests fail and no valid products can be delivered. Partial failures do not discard successful products. Zalando may block some IPs or change its page structure; retries cannot guarantee availability.

### API and integrations

Use Apify's API, schedules, webhooks, Make, Zapier or MCP clients. No integration-specific setup is bundled into this Actor. The output schema exposes both Products and Run report to clients.

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/technicaldost~zalando-product-scraper-plus/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":["https://www.zalando.co.uk/womens-clothing/"],"maxResults":10}'
```

For longer jobs use the asynchronous runs endpoint and retrieve the dataset after completion. Keep your API token private.

### FAQ

**Does this download product images?** No. It returns source image URLs only.

**Can it extract every review or exact stock quantity?** No. Aggregate ratings and available size offers are collected where exposed. Unknown values remain null.

**Why fewer products than requested?** The source may have fewer results, filters may exclude products, some URLs may fail, or the page/spending limit may be reached. Check REPORT.

**Can I use listing-only mode?** Yes. Set `scrapeDetails:false` for fewer HTTP requests and faster catalog extraction. Detail fields may be missing.

**Need help?** Open an issue on this Actor with the run ID and a non-sensitive example URL. Never share tokens or proxy passwords.

This is an independent tool, not affiliated with or endorsed by Zalando. Use responsibly for data you are authorized to access and comply with applicable terms and law.

# Actor input Schema

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

Paste Zalando HTTPS URLs. Strings or objects with url are accepted. Duplicate products are returned once per market.

## `searchTerms` (type: `array`):

Create search URLs using the selected market. Can be combined with start URLs.

## `market` (type: `string`):

Localized search route for searchTerms. startUrls retain their own market and accept additional country domains.

## `maxResults` (type: `integer`):

Global limit of unique successful products across all inputs. Compatible with maxItems in JSON input.

## `maxPagesPerUrl` (type: `integer`):

Follow real catalog pagination up to this limit. Product URLs use one page.

## `scrapeDetails` (type: `boolean`):

Fetch each detail page for size availability, color, attributes and ratings when exposed. Direct product URLs always include details. No extra detail event.

## `minPrice` (type: `number`):

Optional inclusive minimum, in each product's local currency.

## `maxPrice` (type: `number`):

Optional inclusive maximum, in each product's local currency.

## `onSaleOnly` (type: `boolean`):

Return products whose current price is lower than their original price.

## `brandIncludes` (type: `array`):

Case-insensitive partial brand matches. Empty means any brand.

## `maxConcurrency` (type: `integer`):

Bounded detail requests. Two is the recommended default.

## `maxRequestRetries` (type: `integer`):

Additional attempts with rotated proxy sessions after failure.

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

Datacenter proxies by default. Optional custom or residential proxy settings; residential increases developer operating costs. No login cookies or external API key needed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zalando.co.uk/womens-clothing/"
    }
  ],
  "market": "co.uk",
  "maxResults": 10,
  "maxPagesPerUrl": 3,
  "scrapeDetails": true,
  "onSaleOnly": false,
  "maxConcurrency": 2,
  "maxRequestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Unique successfully extracted products in JSON. Export this dataset as CSV or Excel from the console.

## `report` (type: `string`):

Product count, requests, filters, failures and spending-limit status.

## `errors` (type: `string`):

Failed URLs are saved here, never billed as product results.

# 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://www.zalando.co.uk/womens-clothing/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/zalando-product-scraper-plus").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://www.zalando.co.uk/womens-clothing/" }] }

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/zalando-product-scraper-plus").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://www.zalando.co.uk/womens-clothing/"
    }
  ]
}' |
apify call technicaldost/zalando-product-scraper-plus --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/zalando-product-scraper-plus"
        }
    }
}
```

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/P4HcW3EnElRgpBeOV/builds/dvDCrgBPLp59digAn/openapi.json