So scrapst du Zalando 2026 (API & Python)

Der schnellste Weg, Zalando 2026 zu scrapen, ist eine strukturierte API aufzurufen, die normalisiertes JSON zurückgibt — Keyword-Suche, Kategorie- und Marken-Browsing, Produktdetails und Autocomplete aus der Suchleiste — statt Zalandos HTML selbst zu parsen. Du kannst dir einen DIY-Scraper in Python bauen, aber Zalandos länderspezifische Storefronts, GraphQL-hydrierte Seiten und Anti-Bot-Abwehr machen es teuer, ihn am Laufen zu halten.

Zalando bietet keine öffentliche, selbstbedienbare API zum Auslesen seines Produktkatalogs an. Es gibt zwar ein Partner Program (zDirect) für Marken und Händler, die bereits auf Zalando verkaufen, mit dem sie Listings, Preise und Bestellungen verwalten können — aber das ist ein Onboarding-gated Merchant-Tool, kein Weg für externe Teams, den Storefront zu durchsuchen oder zu erforschen. Eine strukturierte Scraping-API ist der praktische Weg für Preisbeobachtung, Sortimentsrecherche und marktübergreifende Vergleiche.

Warum Zalando-Daten scrapen?

• Preisbeobachtung — verfolgen, wie sich Preis, Rabatt und Verfügbarkeit einer bestimmten SKU über die Zeit auf einem Storefront entwickeln.
• Marktübergreifender Preisvergleich — dasselbe Produkt kann auf Zalandos 25 Länderdomains unterschiedlich bepreist sein; vergleiche de vs. fr vs. gb für dieselbe Marke.
• Kategorie- und Trendrecherche — beobachten, welche Marken, Silhouetten und Kategorien an Listing-Volumen oder Rabatttiefe gewinnen.
• Wettbewerbs- und Sortiments-Tracking — sehen, welche Marken ein Wettbewerber in einer Kategorie führt und wie sich sein Katalog über eine Saison verändert.
• KI- und Datenpipelines — normalisierte Fashion-Retail-Listings in Pricing-Modelle, Sortiments-Tools oder Retail-Intelligence-Dashboards einspeisen.

Ist es legal, Zalando zu scrapen?

Zalandos allgemeine Geschäftsbedingungen behalten sich vor, eine Bestellung abzulehnen oder zu stornieren, die „durch den Einsatz von Software, Robots, Crawlern, Spidern oder anderen automatisierten Systemen oder skriptgesteuertem Verhalten" aufgegeben wurde — diese Klausel zielt auf automatisierten Checkout (Bots, die limitierte Drops kaufen), nicht auf ein pauschales Verbot des Browsens oder Lesens öffentlicher Seiten. Zalandos robots.txt sperrt eine bestimmte Reihe von Pfaden — /api/*, /cart/*, /wardrobe/*, /myaccount/*, /reco-catalog/, /assistant, /opinions* —, enthält aber kein pauschales Disallow für Katalog-, Such- oder Produktseiten und keine KI-Crawler-spezifischen Regeln. In den USA haben Gerichte wiederholt entschieden, dass das Scrapen öffentlich zugänglicher Seiten nicht gegen den Computer Fraud and Abuse Act verstößt, selbst wenn die Nutzungsbedingungen einer Seite das einschränken (siehe hiQ Labs v. LinkedIn, unten zitiert) — ein Verstoß gegen die Nutzungsbedingungen kann aber trotzdem zu einer Konto- oder IP-Sperre führen, und EU-Nutzer unterliegen zusätzlich der DSGVO, sobald personenbezogene Daten im Spiel sind.

Praktisch bedeutet das:

• Sammle nur öffentliche Such-, Kategorie-, Produkt- und Autocomplete-Daten — keine login-geschützten Seiten wie Warenkorb, Wardrobe oder Konto.
• Halte dich an robots.txt und Rate-Limits; bombardiere nicht den Storefront eines Markts mit gleichzeitigen Requests.
• Zalando-Preise und -Bestände variieren nach Länderdomain und Währung — behandle jeden Market als eigenen Datensatz, statt anzunehmen, dass ein Preis überall gilt.
• Verwende Produktfotos oder Marketingtexte nicht über das hinaus, was dein Use Case und das Urheberrecht erlauben; Preis, Marke, SKU und Größenverfügbarkeit sind Fakten, aber Bilder und Beschreibungen sind Content von Zalando oder der Marke.

Option 1: DIY in Python (und warum es scheitert)

Der naive Ansatz ruft eine Suchergebnisseite ab und parst die Produktkarten:

import csv, requests
from bs4 import BeautifulSoup

resp = requests.get(
    "https://en.zalando.de/catalogue/",
    params={"q": "running shoes"},
    headers={"User-Agent": "Mozilla/5.0", "Accept-Language": "en-US,en;q=0.9"},
)
soup = BeautifulSoup(resp.text, "html.parser")

rows = []
for card in soup.select("article[data-testid='catalog-article']"):
    name = card.select_one("h3")
    price = card.select_one("[data-testid='price-formatted']")
    rows.append({"name": name.get_text(strip=True) if name else None,
                 "price": price.get_text(strip=True) if price else None})

with open("zalando.csv", "w", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["name", "price"]); w.writeheader(); w.writerows(rows)
# ...then keep these selectors alive, handle GraphQL-hydrated content, and pick the right market domain

Es funktioniert einmal, dann fängt die Wartung an:

• Client-seitiges, GraphQL-hydriertes Rendering. Such- und Suggest-Ergebnisse hängen an einer internen GraphQL-API (/api/graphql/), sodass ein einfacher requests.get() oft nur eine leere Hülle zurückgibt — du brauchst einen Headless-Browser oder das exakte GraphQL-Payload, um an echte Produktdaten zu kommen.
• 25 separate Länder-Storefronts. en.zalando.de, www.zalando.fr, www.zalando.co.uk, www.zalando.it und 21 weitere laufen jeweils auf eigener Domain, eigener Währung und — bei vielen Kategorien — mit eigenem lokalsprachigen URL-Slug für dieselbe Kategorie.
• Anti-Bot-Abwehr. Datacenter-IPs werden gedrosselt oder blockiert, du brauchst also rotierende Residential-Proxys und realistische Header.
• Varianten für mehrere Größen. Eine einzelne Produktseite deckt mehrere Größen ab, jede mit eigener SKU, GTIN, eigenem Preis und Lagerstatus — „den Preis" zu parsen bedeutet, die richtige Variante für deinen Use Case herauszupicken.
• Selektor-Verschleiß. Zalando gestaltet sein Grid und seine Produktseiten regelmäßig neu und bricht dabei handgeschriebene CSS-Selektoren ohne Vorwarnung.

Option 2: No-Code- / Fertig-Tools

Browser-Extensions und Click-and-Go-Scraper können eine Seite Suchergebnisse exportieren, aber Preisbeobachtung und marktübergreifender Vergleich bedeuten, dieselbe Abfrage nach Zeitplan über mehrere Länderdomains hinweg erneut laufen zu lassen und den Verlauf zu speichern. Das ist ein wiederkehrender Pipeline-Job, für den eine API, die du aus einem Skript oder Cron-Job aufrufst, besser geeignet ist als ein manuelles Export-Tool.

Option 3: Eine strukturierte Zalando-API

Crawloras Zalando-API kapselt Request-Handling, Rendering und Parsing hinter dokumentierten Endpunkten für Suche, Kategorie- und Marken-Browsing, Produktdetails, Autocomplete und die Liste der unterstützten Märkte. Jeder Katalog-Endpunkt erfordert einen expliziten market.

Starte mit der Marktliste, denn sie ist die Referenz für jeden weiteren Call:

curl "https://api.crawlora.net/api/v1/zalando/markets" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{"code":200,"msg":"OK","data":{"count":25,"markets":[
  {"code":"de","domain":"en.zalando.de"},
  {"code":"fr","domain":"www.zalando.fr"},
  {"code":"gb","domain":"www.zalando.co.uk"},
  {"code":"it","domain":"www.zalando.it"}
]}}

Durchsuche dann einen bestimmten Market per Keyword:

import requests

BASE = "https://api.crawlora.net/api/v1/zalando"
headers = {"x-api-key": "YOUR_API_KEY"}

resp = requests.get(f"{BASE}/search", headers=headers, params={"q": "running shoes", "market": "de"})
for p in resp.json()["data"]["products"]:
    print(p["sku"], p["brand"], p["name"], p["price"], p["currency"])

Eine Response ist normalisiertes JSON (die genauen Felder findest du in den Docs):

{
  "code": 200,
  "msg": "OK",
  "data": {
    "query": "running shoes",
    "market": "de",
    "count": 24,
    "total_count": 4911,
    "source_url": "https://en.zalando.de/catalogue/?q=running+shoes",
    "fetched_at": "2026-07-01T12:00:00Z",
    "products": [
      {
        "sku": "N1241A1HR-I11",
        "name": "PEGASUS 42 SE - Road running shoes",
        "brand": "Nike Performance",
        "url": "https://en.zalando.de/nike-performance-pegasus-42-se-road-running-shoes-n1241a1hr-i11.html",
        "image": "https://img01.ztat.net/article/spp-media-p1/example.jpg?imwidth=400",
        "silhouette": "LOW_SHOE",
        "price": 97.95,
        "original_price": 149.95,
        "discount_percent": 52,
        "currency": "EUR"
      }
    ]
  }
}

Aus einem Such- oder Kategorieergebnis übergibst du dieselbe sku und denselben market an product, um alle Details inklusive Größenvarianten zu bekommen:

product = requests.get(f"{BASE}/product", headers=headers, params={"sku": "N1241A1HR-I11", "market": "de"}).json()["data"]["product"]
for v in product["variants"]:
    print(v["size"], v["sku"], v["price"], v["availability"])

{"sku":"ONM11A03W-A12","name":"CLOUD 6 - Trainers - white   white","brand":"On","color":"white   white/white",
 "price":160,"currency":"EUR",
 "variants":[{"size":"36","sku":"ONM11A03W-A120005000","gtin":"7615537206202","price":160,"currency":"EUR","availability":"InStock"}]}

Durchstöbere eine Kategorie oder einen Marken-Slug (die Slugs sind marktspezifisch — shoes auf de/gb, chaussures auf fr, scarpe auf it) und lass dir zu einer Teilanfrage Autocomplete-Vorschläge geben:

category = requests.get(f"{BASE}/category", headers=headers, params={"category": "shoes", "market": "de"}).json()["data"]
suggest = requests.get(f"{BASE}/suggest", headers=headers, params={"q": "running sho", "market": "de"}).json()["data"]["suggestions"]
# suggest -> ["running shoes", "running shoes nike", "running shoes adidas", ...]

search und category geben beide total_count zurück, die vollständige Trefferzahl des Upstreams, zusammen mit der ersten Ergebnisseite — tiefere Pagination ist noch nicht verfügbar, behandle total_count also eher als Trendsignal denn als etwas, durch das du dich vollständig durchblättern kannst.

Was du sammeln kannst

• Suchergebnisse: SKU, Name, Marke, Preis, Originalpreis, Rabattprozent, Silhouette und Bild, jeweils auf einen Market bezogen
• Kategorie- und Marken-Listings, plus der Upstream-total_count für diese Kategorie
• Produktdetails: Marke, Farbe, Beschreibung, alle Bilder und Größenvarianten (SKU, GTIN, Preis, Währung, Verfügbarkeit)
• Autocomplete-Vervollständigungen aus der Suchleiste für eine Teilanfrage
• Die vollständige Liste der 25 unterstützten Märkte mit ihren Domains

Grenzen

• Keine öffentliche Katalog-API. Zalandos Shop Public API wurde archiviert, ohne je öffentlich zu starten; ihre zDirect-Partner-API ist Händlern vorbehalten, vollständiger externer Katalogzugriff bedeutet also weiterhin Scraping.
• Marktfragmentierung. Preis, Währung und sogar Kategorie-Slugs sind länderspezifisch; Märkte zu vergleichen bedeutet, jeden einzeln abzufragen und die Währung selbst zu normalisieren.
• Nur die erste Ergebnisseite. Such- und Kategorie-Calls liefern die erste Seite, die Zalando rendert, plus total_count — tiefere Pagination wird noch nicht unterstützt.
• Anti-Bot- und GraphQL-hydriertes Rendering. Reine HTTP-Requests gegen Zalandos Storefront sind unzuverlässig; eine strukturierte API übernimmt Header, Rendering und Retries hinter einem einzigen Key.
• Medien sind urheberrechtlich geschützt. Preise, Marken, SKUs und Lagerstatus sind Fakten, die du sammeln kannst; Produktfotos und Marketingtexte unterliegen dem Urheberrecht — veröffentliche sie nicht über das hinaus, was dein Use Case und das Gesetz erlauben.

Wo das eingesetzt wird

• Preis- und Rabattbeobachtung für eine bestimmte Marke oder Kategorie auf einem oder mehreren Storefronts
• Marktübergreifende Fashion-Preisvergleiche und Arbitrage-Recherche
• Sortiments- und Trend-Tracking, aufgeschlüsselt nach Marke, Kategorie oder Silhouette
• Enrichment-Pipelines, die normalisierte Bekleidungs- und Schuhdaten in Pricing- oder Retail-Intelligence-Tools einspeisen

Sources

Leg los mit dem Sammeln

Probier es zuerst kostenlos aus: jage eine beliebige öffentliche URL durch den Free Web Scraper oder prüfe mit dem Anti-Bot Checker, ob eine Seite Bots blockiert — ohne Anmeldung.

Zalando-Daten passen gut zu anderen Fashion-Marketplace-APIs für plattformübergreifende Recherche — sieh dir how to scrape Vinted für Secondhand-Fashion-Preise an, how to scrape Etsy für handgemachte und Vintage-Waren, oder how to scrape Target für einen Vergleich mit einem US-General-Merchandise-Händler. Leg los, indem du den Endpunkt im Playground testest, das Request- und Response-Schema in den API-Docs liest und die Kreditkosten auf der Pricing-Seite prüfst. Du bist dir nicht sicher, ob das für deinen Use Case legal ist? Lies zuerst Is web scraping legal in 2026?.