# Scraping Shopify products.json: Der Endpoint, den jeder Store offenlegt

Vergessen Sie das Parsen von HTML. Jeder Shopify-Store liefert Ihnen sauberes JSON unter /products.json — vollständiger Katalog, Preise, Varianten, Lagerbestand. Hier sind die Paginierungsgrenzen, die Geschwindigkeitstricks und wie Sie es in Wettbewerbsüberwachung verwandeln können.

Jeder, der E-Commerce gescrapt hat, kennt den Schmerz: brüchige CSS-Selektoren, verschachtelte Wrapper-Divs, Layouts, die sich ändern und über Nacht alles zerstören. Shopify bietet Ihnen einen Ausweg. Fast jeder auf Shopify erstellte Store legt einen öffentlichen `/products.json` Endpoint offen, der den gesamten Katalog als sauberes, strukturiertes JSON zurückgibt — Titel, Handles, Anbieter, Tags, Varianten, Preise, Lagerbestandskennzeichen und Bilder. Kein HTML-Parsing, kein Headless-Browser. Dieser Leitfaden behandelt, wie der Endpoint funktioniert, seine tatsächlichen Paginierungsgrenzen, einen Trick, der das Crawlen großer Stores dramatisch beschleunigt, und wie man das Ganze in Wettbewerberpreis- und Lagerüberwachung verwandelt.

## Der Endpoint in jedem Shopify-Store

Fügen Sie `/products.json` zur Root-Domain eines Shopify-Stores hinzu und Sie erhalten eine JSON-Liste von Produkten. Es sind dieselben Daten, die das Schaufenster verwendet, absichtlich für die Ajax-API offengelegt. Jedes Produkt trägt eine stabile numerische `id`, ein `handle`, `vendor`, `product_type`, `tags`, ein Array von `variants` (jede mit eigenem Preis, SKU und `available` Boolean) und Bilder. Das ist alles, was Sie normalerweise von einer Produktseite scrapen würden, in einer Anfrage geliefert.

```python
import requests

url = "https://store.example.com/products.json"
r = requests.get(url, params={"limit": 250, "page": 1}, timeout=15)
products = r.json()["products"]

print(len(products), products[0]["title"])
for v in products[0]["variants"]:
    print(v["sku"], v["price"], v["available"])
```

Zwei Vorbehalte vorweg. Shopify begrenzt den öffentlichen Endpoint auf **250 Produkte pro Seite** — ein Limit, das Sie nicht überschreiten können, egal was Sie übergeben, also ignorieren Sie Ratschläge, `limit=1000000` zu setzen und alles in einem Aufruf zu holen. Und eine Minderheit der Stores deaktiviert den Endpoint (benutzerdefinierte Builds schalten ihn manchmal aus), also prüfen Sie auf eine gültige Antwort, bevor Sie eine Pipeline darum aufbauen.

## Bis zum Ende paginieren

Wegen des 250er-Limits bedeutet ein vollständiger Katalog, Seiten durchzugehen, bis Sie auf eine leere stoßen. Die naive Schleife erhöht `page` und stoppt, wenn eine Seite leer zurückkommt. Es ist korrekt und in Ordnung für kleine Stores — ein Shop mit ein paar hundert Produkten ist ein paar Anfragen.

```python
def all_products(base):
    page, out = 1, []
    while True:
        r = requests.get(f"{base}/products.json",
                         params={"limit": 250, "page": page}, timeout=15)
        batch = r.json()["products"]
        if not batch:
            break
        out.extend(batch)
        page += 1
    return out
```

![Crawl-Zeit für einen Shopify-Shop mit 25.000 Produkten auf 833 Seiten: Sequenzielles Blättern dauerte etwa 120 Sekunden, eine Binärsuche nach der letzten Seite etwa 12 beim ersten Lauf und etwa 5 mit zwischengespeicherter letzter Seite; die Karte zeigt die 25-fache Beschleunigung und die harte Grenze von 250 Produkten pro Seite.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335164/blog/generated/qp-b9-027-diag1.png)
*Der Endpoint ist auf 250 Produkte pro Seite begrenzt — die Geschwindigkeit kommt davon, die letzte Seite schnell zu finden, nicht von größeren Anfragen.*

## Der 25x-Trick: Finde zuerst die letzte Seite

Sequentielles Paging ist bei großen Stores langsam, weil Sie nicht parallelisieren können — Sie wissen nicht, wann Sie aufhören sollen, also wartet jede Seite auf die vorherige. Die Lösung ist eine Binärsuche: Untersuchen Sie Seitennummern, um die letzte nicht-leere Seite zu finden, und senden Sie dann alle Seitenanfragen gleichzeitig. In einem öffentlichen Benchmark gegen einen Store mit 25.000 Produkten über 833 Seiten verkürzte dies ein Crawl von etwa 120 Sekunden auf etwa 12 beim ersten Durchlauf und etwa 5, sobald die letzte Seitennummer zwischengespeichert war — eine 25-fache Beschleunigung. Leiten Sie die Sonden durch rotierende IPs, damit der Ansturm gleichzeitiger Anfragen keine Drosselung auslöst.

```python
PROXY = "http://USER:PASS@residentialpremium.quantumproxies.io:8080"
proxies = {"http": PROXY, "https": PROXY}

def last_page(base, hi=1000):
    lo, last = 1, 1
    while lo <= hi:
        mid = (lo + hi) // 2
        r = requests.get(f"{base}/products.json",
                         params={"limit": 250, "page": mid},
                         proxies=proxies, timeout=15)
        if r.json()["products"]:
            last, lo = mid, mid + 1   # go higher
        else:
            hi = mid - 1              # go lower
    return last
# then request pages 1..last_page concurrently
```

Wie Rob Pike es ausdrückte, sind ausgefallene Algorithmen langsam, wenn n klein ist — bei einem Store mit 200 Produkten überspringen Sie die Binärsuche und schleifen einfach. Es lohnt sich bei Katalogen in den Tausenden, wo sequentielles Paging sich hinzieht.

## Ziehen Sie die Abfrage ein: Kollektionen und einzelne Produkte

Sie wollen nicht immer den gesamten Katalog. Shopify legt dasselbe JSON auf Kollektionsniveau offen: `/collections/<handle>/products.json` gibt nur die Produkte in dieser Kollektion zurück, auf die gleiche Weise paginiert. Das ist der effiziente Weg, wenn Sie nur eine Kategorie verfolgen — Sneaker, Düfte, eine einzelne Marke — statt eines gesamten Stores. Und um ein Produkt zu inspizieren, fügen Sie `.json` zu seiner URL hinzu: `/products/<handle>.json` gibt den vollständigen Datensatz dieses Produkts, einschließlich jeder Variante und ihres Lagerbestandskennzeichens, was praktisch für enge Nachbestellungspollings bei einer bestimmten SKU ist, ohne den Katalog neu zu crawlen.

Die Kombination der beiden hält das Anfragevolumen — und die Bandbreite — niedrig. Entdecken Sie den Katalog einmal mit dem vollständigen Endpoint, speichern Sie die Handles, die Sie interessieren, und pollen Sie dann einzelne Produkte oder Kollektionen in einem engen Zeitplan. Dieses Muster ist der Unterschied zwischen einem Monitor, der auf Hunderte von Stores skaliert, und einem, der leise Ihr Proxy-Budget verbrennt, indem er Kataloge erneut herunterlädt, die sich nicht geändert haben.

## Verwandeln Sie es in Wettbewerbsüberwachung

Der wahre Wert ist nicht ein einmaliger Katalog-Dump — es ist die Differenz über die Zeit. Erfassen Sie einen Wettbewerber's `products.json` nach einem Zeitplan, ordnen Sie nach Varianten-`id` und vergleichen Sie Läufe, um Preisänderungen, neue Produkte und Nachbestellungen im Moment ihres Auftretens zu erfassen. Da `available` und `price` auf jeder Variante leben, erhalten Sie Lager- und Preissignale, ohne eine Produktseite zu berühren.

```python
def snapshot(base):
    rows = {}
    for p in all_products(base):
        for v in p["variants"]:
            rows[v["id"]] = {
                "product": p["title"],
                "sku": v["sku"],
                "price": v["price"],
                "available": v["available"],
            }
    return rows

# diff today's snapshot against yesterday's to flag price + stock moves
def changes(old, new):
    for vid, cur in new.items():
        prev = old.get(vid)
        if prev and (prev["price"] != cur["price"] or prev["available"] != cur["available"]):
            yield cur["sku"], prev, cur
```

Dies ist das Rückgrat von [Wettbewerberpreisüberwachung](https://quantumproxies.io/blog/competitor-price-monitoring-with-proxies) und [Dropshipping-Forschung](https://quantumproxies.io/blog/proxies-for-dropshipping-research) — beide stützen sich auf dasselbe Snapshot-und-Diff-Muster über viele Stores gleichzeitig.

[Holen Sie sich schnelle Rechenzentrums-Proxies für Shopify-Scraping](https://quantumproxies.io/datacenter-proxies)

![Eine Shopify-Monitoring-Pipeline in vier Schritten: products.json einmal abrufen, um den Katalog zu erfassen, geplante Abrufe über rotierende Rechenzentrums-IPs verteilen, jede Variante über ihre id mit Preis, SKU und Verfügbarkeit erfassen, dann heute mit gestern vergleichen; die Karte listet die Alarme auf: Preisänderungen, neue Produkte und wieder verfügbare Artikel.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335164/blog/generated/qp-b9-027-diag2.png)
*Erfassen Sie nach einem Zeitplan, differenzieren Sie die Varianten, und Sie haben Live-Preis- und Nachbestellungswarnungen über jeden Store, den Sie verfolgen.*

## Welche Proxies Sie tatsächlich benötigen

Der `products.json` Endpoint ist öffentliches JSON, kein gehärteter Checkout-Prozess, also ist er nachsichtig — aber wenn Sie Hunderte von Stores scrapen oder einen nach einem Zeitplan hämmern, stoßen Sie auf per-IP-Ratenlimits. Die wirtschaftliche Antwort sind schnelle [Rechenzentrums-Proxies](https://quantumproxies.io/datacenter-proxies) mit Rotation: günstig, schnell und genug, um Anfragen über IPs zu verteilen, damit keine einzelne gedrosselt wird. Reservieren Sie Wohn-IP-Adressen für Stores, die Rechenzentrumsbereiche vollständig blockieren. Wenn ein Store `products.json` deaktiviert hat und seinen Katalog hinter gerenderten Seiten oder Bot-Schutz verbirgt, ist eine [Scraper-API](https://quantumproxies.io/scraper-api), die für Sie rendert und rotiert, die sauberere Rückfalloption. Unser [Leitfaden, wann Rechenzentrums-Proxies gewinnen](https://quantumproxies.io/blog/datacenter-proxies-when-to-use), behandelt die Entscheidung.

## Häufig gestellte Fragen

### Wie bekomme ich alle Produkte eines Shopify-Stores als JSON?

Fordern Sie `/products.json` auf der Domain des Stores mit `?limit=250&page=N` an und erhöhen Sie `page`, bis eine Seite ein leeres Produktarray zurückgibt. Jede Antwort enthält bis zu 250 Produkte mit ihren Varianten, Preisen, SKUs und Lagerbestandskennzeichen. Für große Kataloge suchen Sie die letzte Seite per Binärsuche und holen Sie Seiten gleichzeitig ab.

### Was ist das Limit bei Shopify products.json?

Der öffentliche Endpoint ist auf 250 Produkte pro Seite begrenzt — der höchste Wert, den `limit` akzeptiert. Eine größere Zahl zu übergeben, wird nicht mehr zurückgeben; Sie paginieren weiterhin durch den Katalog. Dies ist ein festes Shopify-Limit, planen Sie also für Paginierung, anstatt zu versuchen, alles in einer Anfrage zu ziehen.

### Ist das Scraping von Shopify products.json legal?

Der Endpoint liefert öffentlich verfügbare Produktdaten ohne Login, und US-Gerichte haben im Allgemeinen das Scraping öffentlicher Daten unterstützt. Das gesagt, respektieren Sie die Nutzungsbedingungen des Stores, vermeiden Sie persönliche Daten und überlasten Sie den Server nicht. Dies ist allgemeine Information, keine Rechtsberatung — prüfen Sie die Einzelheiten für Ihren Anwendungsfall und Ihre Gerichtsbarkeit.

### Warum gibt products.json eine 404 oder leere Antwort zurück?

Entweder ist der Store nicht auf Shopify, oder der Händler hat den Endpoint bei einem benutzerdefinierten Build deaktiviert. Einige Stores drosseln auch wiederholte Anfragen von einer IP, was wie ein Fehler aussehen kann. Bestätigen Sie, dass der Store Shopify ist, rotieren Sie Ihre IP und fügen Sie eine Verzögerung zwischen Anfragen hinzu, bevor Sie annehmen, dass der Endpoint verschwunden ist.

Der `products.json` Endpoint verwandelt das Scraping von Shopify von einer Selector-Wrangling-Aufgabe in einen sauberen JSON-Abruf: vollständiger Katalog, Preise und Lagerbestand in einer URL, 250 pro Seite, schnell zu crawlen mit einer Binärsuche und trivial zu differenzieren in Wettbewerbsüberwachung. Entdecken Sie einmal, pollen Sie die Kollektionen und Produkte, die wichtig sind, verteilen Sie Anfragen über rotierende Rechenzentrums-IPs, und Sie können Hunderte von Stores nach einem Zeitplan verfolgen, ohne einen einzigen blockierten Lauf — kein HTML-Parser, kein Headless-Browser, keine brüchigen Selektoren, die betreut werden müssen.

[Starten Sie das Scraping von Shopify mit QuantumProxies](https://quantumproxies.io/datacenter-proxies)