Scraping Shopify products.json: L'Endpoint che Ogni Negozio Espone

Dimentica il parsing HTML. Ogni negozio Shopify ti offre un JSON pulito su /products.json — catalogo completo, prezzi, varianti, stock. Ecco i limiti di paginazione, i trucchi di velocità e come trasformarlo in monitoraggio della concorrenza.

Chiunque abbia fatto scraping di e-commerce conosce il dolore: selettori CSS fragili, div wrapper annidati, layout che cambiano e rompono tutto da un giorno all'altro. Shopify ti offre una via d'uscita. Quasi ogni negozio costruito su Shopify espone un endpoint pubblico /products.json che restituisce l'intero catalogo come JSON pulito e strutturato — titoli, handle, fornitori, tag, varianti, prezzi, flag di stock e immagini. Nessun parsing HTML, nessun browser headless. Questa guida copre come funziona l'endpoint, i suoi veri limiti di paginazione, un trucco che rende lo scraping di grandi negozi drasticamente più veloce e come trasformare il tutto in monitoraggio dei prezzi e delle scorte dei concorrenti.

L'endpoint su ogni negozio Shopify

Aggiungi /products.json al dominio radice di qualsiasi negozio Shopify e ottieni un elenco JSON di prodotti. Sono gli stessi dati che utilizza il negozio, esposti per design per l'Ajax API. Ogni prodotto porta un id numerico stabile, un handle, vendor, product_type, tags, un array di variants (ognuno con il proprio prezzo, SKU e booleano available), e immagini. È tutto ciò che normalmente faresti scraping da una pagina prodotto, consegnato in una richiesta.

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"])

Due avvertenze in anticipo. Shopify limita l'endpoint pubblico a 250 prodotti per pagina — un limite che non puoi superare indipendentemente da ciò che passi, quindi ignora i consigli di impostare limit=1000000 e prendere tutto in una chiamata. E una minoranza di negozi disabilita l'endpoint (le build personalizzate a volte lo spengono), quindi verifica una risposta valida prima di costruire un pipeline intorno ad esso.

Paginate fino alla fine

A causa del limite di 250, un catalogo completo significa percorrere le pagine fino a quando non ne trovi una vuota. Il ciclo ingenuo incrementa page e si ferma quando una pagina torna vuota. È corretto ed è adatto per negozi piccoli — un negozio con poche centinaia di prodotti richiede un paio di richieste.

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

Il trucco 25x: trova prima l'ultima pagina

Il paging sequenziale è lento nei grandi negozi perché non puoi parallelizzare — non sai quando fermarti, quindi ogni pagina aspetta quella precedente. La soluzione è una ricerca binaria: sonda i numeri di pagina per trovare l'ultima pagina non vuota, quindi lancia tutte le richieste di pagina contemporaneamente. In un benchmark pubblico contro un negozio con 25.000 prodotti su 833 pagine, questo ha ridotto uno scraping da circa 120 secondi a circa 12 alla prima esecuzione e circa 5 una volta memorizzato in cache il numero dell'ultima pagina — un'accelerazione di 25 volte. Instrada le sonde attraverso IP rotanti in modo che l'esplosione di richieste simultanee non attivi il throttling.

PROXY = "http://USER:PASS@gate.quantumproxies.io:8000"
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

Come ha detto Rob Pike, gli algoritmi sofisticati sono lenti quando n è piccolo — per un negozio con 200 prodotti, salta la ricerca binaria e fai semplicemente il loop. Si ripaga sui cataloghi di migliaia di prodotti, dove il paging sequenziale rallenta.

Restringi il tiro: collezioni e singoli prodotti

Non sempre vuoi l'intero catalogo. Shopify espone lo stesso JSON a livello di collezione: /collections/<handle>/products.json restituisce solo i prodotti in quella collezione, paginati allo stesso modo. Questo è il percorso efficiente quando tracci solo una categoria — sneakers, profumi, un singolo marchio — piuttosto che un intero negozio. E per ispezionare un prodotto, aggiungi .json al suo URL: /products/<handle>.json fornisce il record completo di quel prodotto, inclusa ogni variante e il suo flag di inventario, utile per un monitoraggio stretto del riassortimento su uno specifico SKU senza riscrivere il catalogo.

Combinare i due mantiene basso il volume delle richieste — e la larghezza di banda. Scopri il catalogo una volta con l'endpoint completo, memorizza gli handle che ti interessano, quindi controlla singoli prodotti o collezioni su un programma serrato. Questo schema è la differenza tra un monitor che si scala a centinaia di negozi e uno che brucia silenziosamente il tuo budget proxy riscaricando cataloghi che non sono cambiati.

Trasformalo in monitoraggio della concorrenza

Il vero valore non è un dump di catalogo una tantum — è la differenza nel tempo. Scatta un'istantanea del products.json di un concorrente su un programma, chiave per id variante, e confronta le esecuzioni per catturare cambiamenti di prezzo, nuovi prodotti e riassortimenti nel momento in cui accadono. Poiché available e price vivono su ogni variante, ottieni segnali di stock e prezzi senza toccare una pagina prodotto.

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

Questo è il pilastro del monitoraggio dei prezzi dei concorrenti e della ricerca per dropshipping — entrambi si basano sullo stesso schema di snapshot e differenza su molti negozi contemporaneamente.

Ottieni proxy datacenter veloci per lo scraping di Shopify

Quali proxy ti servono effettivamente

L'endpoint products.json è JSON pubblico, non un flusso di checkout protetto, quindi è indulgente — ma fai scraping di centinaia di negozi o martella uno su un programma e incontrerai limiti di velocità per IP. La risposta economica sono i proxy datacenter veloci con rotazione: economici, rapidi e sufficienti per distribuire le richieste tra gli IP in modo che nessuno venga limitato. Riserva gli IP residenziali per i negozi che bloccano le gamme dei datacenter. Se un negozio ha disabilitato products.json e nasconde il suo catalogo dietro pagine renderizzate o protezione bot, un Scraper API che rende e ruota per te è la soluzione più pulita. La nostra guida su quando i proxy datacenter vincono copre la decisione.

Domande frequenti

Come posso ottenere tutti i prodotti da un negozio Shopify come JSON?

Richiedi /products.json sul dominio del negozio con ?limit=250&page=N e incrementa page fino a quando una pagina restituisce un array di prodotti vuoto. Ogni risposta contiene fino a 250 prodotti con le loro varianti, prezzi, SKU e flag di stock. Per cataloghi grandi, cerca binariamente l'ultima pagina e recupera le pagine in parallelo.

Qual è il limite su Shopify products.json?

L'endpoint pubblico è limitato a 250 prodotti per pagina — il valore più alto che limit accetta. Passare un numero maggiore non restituirà di più; devi comunque paginare attraverso il catalogo. Questo è un limite rigido di Shopify, quindi pianifica la paginazione piuttosto che cercare di ottenere tutto in una richiesta.

È legale fare scraping di Shopify products.json?

L'endpoint serve dati di prodotto pubblicamente disponibili senza login, e i tribunali statunitensi hanno generalmente sostenuto lo scraping di dati pubblici. Detto ciò, rispetta i termini di servizio del negozio, evita i dati personali e non sovraccaricare il server. Queste sono informazioni generali, non consigli legali — verifica i dettagli per il tuo caso d'uso e giurisdizione.

Perché products.json restituisce un 404 o una risposta vuota?

O il negozio non è su Shopify, o il commerciante ha disabilitato l'endpoint su una build personalizzata. Alcuni negozi limitano anche le richieste ripetute da un IP, che può sembrare un errore. Conferma che il negozio è Shopify, ruota il tuo IP e aggiungi un ritardo tra le richieste prima di presumere che l'endpoint sia sparito.

L'endpoint products.json trasforma lo scraping di Shopify da un compito di gestione dei selettori in un'estrazione JSON pulita: catalogo completo, prezzi e stock in un URL, 250 per pagina, veloce da navigare con una ricerca binaria, e banale da differenziare per il monitoraggio della concorrenza. Scopri una volta, controlla le collezioni e i prodotti che contano, distribuisci le richieste tra IP datacenter rotanti, e puoi tracciare centinaia di negozi su un programma senza una singola esecuzione bloccata — nessun parser HTML, nessun browser headless, nessun selettore fragile da gestire.

Inizia a fare scraping di Shopify con QuantumProxies