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

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

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.

```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
```

![Il tempo di crawling di un negozio Shopify con 25.000 prodotti su 833 pagine: la paginazione sequenziale ha richiesto circa 120 secondi, una ricerca binaria dell'ultima pagina circa 12 alla prima esecuzione e circa 5 con l'ultima pagina in cache; la scheda mostra l'accelerazione di 25 volte e il limite rigido di 250 prodotti per pagina.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335164/blog/generated/qp-b9-027-diag1.png)
*L'endpoint è limitato a 250 prodotti per pagina — la velocità deriva dal trovare rapidamente l'ultima pagina, non da richieste più grandi.*

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

```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
```

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.

```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
```

Questo è il pilastro del [monitoraggio dei prezzi dei concorrenti](https://quantumproxies.io/blog/competitor-price-monitoring-with-proxies) e della [ricerca per dropshipping](https://quantumproxies.io/blog/proxies-for-dropshipping-research) — entrambi si basano sullo stesso schema di snapshot e differenza su molti negozi contemporaneamente.

[Ottieni proxy datacenter veloci per lo scraping di Shopify](https://quantumproxies.io/datacenter-proxies)

![Una pipeline di monitoraggio Shopify in quattro passaggi: scaricare products.json una volta per scoprire il catalogo, distribuire i download programmati su IP datacenter rotanti, indicizzare ogni variante per id con prezzo, SKU e disponibilità, poi confrontare oggi con ieri; la scheda elenca gli avvisi: variazioni di prezzo, nuovi prodotti e riassortimenti.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335164/blog/generated/qp-b9-027-diag2.png)
*Scatta un'istantanea su un programma, differenzia le varianti, e avrai avvisi di prezzo e riassortimento in tempo reale su ogni negozio che tracci.*

## 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](https://quantumproxies.io/datacenter-proxies) 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](https://quantumproxies.io/scraper-api) che rende e ruota per te è la soluzione più pulita. La nostra [guida su quando i proxy datacenter vincono](https://quantumproxies.io/blog/datacenter-proxies-when-to-use) 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](https://quantumproxies.io/datacenter-proxies)