Python e scraping di Pinterest: "Pin, board e infinite scroll"

Qualche mese fa, uno dei nostri ingegneri mi ha mostrato uno script Python che aveva scritto nel weekend. Doveva estrarre immagini di ispirazione prodotto da Pinterest per un progetto di analisi di mercato. Lo ha eseguito e il risultato è stato… 16 pin. Su una board da oltre 2.000. Mi ha fissato lo schermo, poi ha guardato me e ha detto: "Credo che Pinterest si stia prendendo gioco di me".

Non è il solo. È, senza dubbio, la frustrazione più comune che vedo tra gli sviluppatori che cercano di fare scraping di Pinterest con Python. Avvii requests e BeautifulSoup, apri un URL di Pinterest e ottieni solo pochi elementi oppure una shell HTML vuota. Il motivo? Pinterest è una single-page app renderizzata interamente in JavaScript: la semplice richiesta HTTP non vede mai i contenuti reali. In questa guida ti spiegherò perché succede, quali approcci funzionano davvero (Playwright, intercettazione dell’API interna e strumenti no-code come ) e ti fornirò codice passo passo per estrarre pin, board, profili utente, infinite scroll e immagini in alta risoluzione. Se vuoi costruire uno scraper pronto per la produzione o semplicemente ottenere i dati in fretta, qui trovi tutto quello che ti serve.

Cos’è lo scraping di Pinterest?

Lo scraping di Pinterest è il processo di estrazione automatica di dati da Pinterest — ad esempio immagini dei pin, titoli, descrizioni, nomi delle board, conteggi dei follower e URL. Invece di navigare manualmente e salvare i pin uno a uno, usi codice (o uno strumento) per raccogliere dati strutturati da risultati di ricerca, board o profili utente su larga scala.

Con sulla piattaforma e alla fine del 2025, Pinterest è una delle fonti di dati visivi più ricche del web. Per le aziende, questi dati valgono oro — sia che tu stia monitorando trend di prodotto, confrontando i contenuti dei concorrenti o creando liste per attività di influencer outreach.

Perché fare scraping di Pinterest con Python?

Pinterest non è più solo una bacheca d’ispirazione per chi organizza matrimoni. È una vera piattaforma di business intelligence — ha acquistato qualcosa partendo dai Pin di un brand, e , il che significa che gli utenti arrivano con un intento preciso ma senza fedeltà a un marchio. È un’enorme opportunità di scoperta — e spiega perché tanti team vogliono dati strutturati da Pinterest.

Ecco come si traduce per ciascun team:

E c’è un altro punto chiave: l’API ufficiale di Pinterest è limitata. Richiede un account business, un’approvazione (inclusa una demo video della tua app) e consente l’accesso solo ai dati del tuo account. Se vuoi esplorare board pubbliche, risultati di ricerca o profili dei concorrenti, lo scraping è l’alternativa pratica. È per questo che tanti team si affidano a Python — oppure a strumenti no-code come Thunderbit quando vogliono risultati senza configurazioni complesse.

Perché BeautifulSoup da solo non funziona su Pinterest (e cosa funziona davvero)

Se hai già provato a fare scraping di Pinterest con requests + BeautifulSoup e hai ottenuto 16 elementi o una pagina vuota, non te lo stai immaginando. Pinterest è costruito con React e renderizza il 100% dei contenuti via JavaScript. Quando richiami un URL di Pinterest con una semplice richiesta HTTP, il server ti restituisce solo uno scheletro HTML minimale — pochi tag <link> e <script>, più un <div> vuoto dove React monta l’app. Tutte le schede dei pin, le immagini e le griglie vengono inserite solo dopo l’esecuzione del JavaScript nel browser.

Niente esecuzione JavaScript = niente pin.

Quindi cosa funziona? Ecco il confronto tra i principali approcci:

Per questo tutorial, ti consiglio Playwright come soluzione Python. Renderizza JavaScript, supporta la simulazione dello scroll, è ben mantenuto (, con una crescita del nelle offerte di lavoro), ed è nei benchmark. Se preferisci la strada no-code, la vedremo comunque.

API ufficiale di Pinterest, scraping con Python o no-code: quale scegliere?

Prima di iniziare a scrivere codice, vale la pena chiederselo: ti serve davvero? Ecco una griglia decisionale:

Se sei un marketer, un professionista eCommerce o semplicemente vuoi i dati di Pinterest in un foglio di calcolo senza scrivere o mantenere script Python, è la corsia veloce. Apri una qualsiasi pagina Pinterest, clicchi su "AI Suggest Fields", premi "Scrape" ed esporti direttamente in Google Sheets, Excel, Airtable o Notion. La funzione di scraping delle sottopagine può persino seguire i singoli link dei pin per arricchire automaticamente i dati. Ho visto persone che non avevano mai scritto una riga di codice importare oltre 500 pin in un Google Sheet in meno di tre minuti.

Per chi invece vuole pieno controllo, vuole integrare lo scraping in una pipeline Python o semplicemente ama costruire cose, continua a leggere.

Configurare l’ambiente Python per lo scraping di Pinterest

• Difficoltà: Intermedia
• Tempo richiesto: ~30–60 minuti (inclusi sviluppo e test)
• Cosa ti serve: Python 3.9+, browser Chrome (per i test), accesso a terminale/command line

Installare Playwright e le dipendenze

Per prima cosa, crea una cartella progetto e configura un ambiente virtuale:

1mkdir pinterest-scraper
2cd pinterest-scraper
3python -m venv venv
4source venv/bin/activate  # Su Windows: venv\Scripts\activate

Installa Playwright e scarica il binario del browser Chromium:

1pip install playwright
2playwright install chromium

Userai anche i moduli integrati di Python json, os e csv per l’esportazione dei dati. Per questi non servono installazioni aggiuntive.

Struttura della cartella del progetto

Ti consiglio di tenere tutto ordinato fin dall’inizio:

1pinterest-scraper/
2├── scraper.py
3├── config.py
4├── output/
5│   ├── pins.json
6│   └── pins.csv
7└── images/
8    ├── board-name-1/
9    └── board-name-2/

In config.py, imposta la stringa user agent. Pinterest blocca spesso le firme tipiche dei browser headless, quindi usa un user agent realistico:

1USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"

Passo 1: costruire l’URL di ricerca di Pinterest

Costruisci l’URL di ricerca inserendo la query nel template:

1query = "mid century modern furniture"
2url = f"https://www.pinterest.com/search/pins/?q={query.replace(' ', '%20')}&rs=typed"

Puoi parametrizzarlo per qualsiasi termine di ricerca. Il parametro rs=typed dice a Pinterest che la query è stata digitata e non suggerita, e questo a volte influisce sulla pertinenza dei risultati.

Passo 2: avviare un browser headless e caricare la pagina

Ecco la configurazione base di Playwright. Nota l’user agent personalizzato — senza di esso, Pinterest probabilmente ti bloccherà o ti mostrerà una schermata di login.

1import asyncio
2from playwright.async_api import async_playwright
3from config import USER_AGENT
4async def scrape_search(query, max_pins=100):
5    url = f"https://www.pinterest.com/search/pins/?q={query.replace(' ', '%20')}&rs=typed"
6    async with async_playwright() as p:
7        browser = await p.chromium.launch(headless=True)
8        page = await browser.new_page(
9            user_agent=USER_AGENT,
10            viewport={"width": 1920, "height": 1080}
11        )
12        await page.goto(url)
13        await asyncio.sleep(3)  # Attendi il rendering iniziale dei pin via JS

Dopo l’esecuzione, la pagina dovrebbe aver caricato il primo blocco di pin — in genere 25–50.

Passo 3: estrarre i dati dei pin dalla pagina

Pinterest racchiude ogni pin in un div con data-test-id='pinWrapper'. Al suo interno trovi un link (<a>) con l’URL del pin e il titolo (tramite aria-label), oltre a un <img> con l’URL della miniatura.

1        results = []
2        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
3        for pin in pins:
4            link = await pin.query_selector("a")
5            if not link:
6                continue
7            title = await link.get_attribute("aria-label") or ""
8            href = await link.get_attribute("href") or ""
9            img = await link.query_selector("img")
10            src = await img.get_attribute("src") if img else ""
11            results.append({
12                "title": title,
13                "url": f"https://www.pinterest.com\{href\}" if href.startswith("/") else href,
14                "image_url": src
15            })

A questo punto, results contiene i pin visibili nel viewport iniziale. Per ottenere altro contenuto devi scorrere — ed è qui che entra in gioco la parte più importante.

Passo 4: salvare i risultati in JSON o CSV

Dopo l’estrazione, salva i dati in file facilmente riutilizzabili:

1import json
2import csv
3def save_json(data, filepath="output/pins.json"):
4    with open(filepath, "w", encoding="utf-8") as f:
5        json.dump(data, f, ensure_ascii=False, indent=2)
6def save_csv(data, filepath="output/pins.csv"):
7    if not data:
8        return
9    with open(filepath, "w", newline="", encoding="utf-8-sig") as f:
10        writer = csv.DictWriter(f, fieldnames=data[0].keys())
11        writer.writeheader()
12        writer.writerows(data)

Usa la codifica utf-8-sig per il CSV se prevedi di aprirlo in Excel — evita problemi con i caratteri speciali.

Fare scraping di intere board Pinterest e profili utente

Questa è una grossa lacuna nei tutorial esistenti. Non sono riuscito a trovare una guida concorrente che spieghi in modo approfondito lo scraping di board o profili — eppure è una delle funzioni più richieste nei forum. Gli utenti vogliono scaricare tutti i pin di una board, organizzare le immagini in cartelle separate per board ed estrarre dati a livello di profilo come follower e lista delle board.

Estrarre tutti i pin da un URL di board

Gli URL delle board seguono il pattern https://www.pinterest.com/\{username\}/{board-name}/. La struttura DOM è simile ai risultati di ricerca — i pin sono racchiusi in div[data-test-id='pinWrapper'] — ma devi scorrere per caricarli tutti.

1async def scrape_board(board_url, max_pins=500):
2    async with async_playwright() as p:
3        browser = await p.chromium.launch(headless=True)
4        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
5        await page.goto(board_url)
6        await asyncio.sleep(3)
7        seen_ids = set()
8        all_pins = []
9        for scroll_round in range(100):  # Limite di sicurezza
10            pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
11            new_count = 0
12            for pin in pins:
13                link = await pin.query_selector("a")
14                if not link:
15                    continue
16                href = await link.get_attribute("href") or ""
17                if href in seen_ids:
18                    continue
19                seen_ids.add(href)
20                new_count += 1
21                title = await link.get_attribute("aria-label") or ""
22                img = await link.query_selector("img")
23                src = await img.get_attribute("src") if img else ""
24                all_pins.append({
25                    "title": title,
26                    "url": f"https://www.pinterest.com\{href\}" if href.startswith("/") else href,
27                    "image_url": src
28                })
29            print(f"Scroll {scroll_round + 1}: {len(all_pins)} pin unici raccolti")
30            if new_count == 0 or len(all_pins) >= max_pins:
31                break
32            prev_height = await page.evaluate("document.body.scrollHeight")
33            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
34            await asyncio.sleep(2.5)
35            curr_height = await page.evaluate("document.body.scrollHeight")
36            if curr_height == prev_height:
37                break  # Nessun altro contenuto
38        await browser.close()
39        return all_pins

Una cosa da tenere d’occhio: nelle board, Pinterest a volte inserisce una scheda "More Ideas" che separa i pin salvati dai contenuti consigliati dall’algoritmo. Se vuoi solo i pin effettivamente salvati dall’utente, smetti di scorrere quando incontri quel divisore.

Fare scraping di un profilo utente: board, follower e pin

Gli URL dei profili hanno la forma https://www.pinterest.com/\{username\}/. Da una pagina profilo puoi estrarre:

• Follower/following: cerca div[data-test-id='follower-count']
• Elenco delle board: ogni board è una scheda che porta a /\{username\}/{board-name}/
• Numero totale di pin: a volte è mostrato nell’intestazione del profilo

1async def scrape_profile(username):
2    url = f"https://www.pinterest.com/\{username\}/"
3    async with async_playwright() as p:
4        browser = await p.chromium.launch(headless=True)
5        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
6        await page.goto(url)
7        await asyncio.sleep(3)
8        # Estrai il numero di follower
9        follower_el = await page.query_selector("div[data-test-id='follower-count']")
10        followers = await follower_el.inner_text() if follower_el else "N/A"
11        # Estrai i link alle board
12        board_links = await page.query_selector_all("a[href*='/" + username + "/']")
13        boards = []
14        for bl in board_links:
15            href = await bl.get_attribute("href") or ""
16            name = await bl.get_attribute("aria-label") or href.split("/")[-2]
17            if href.count("/") >= 3 and href != f"/\{username\}/":
18                boards.append({"name": name, "url": f"https://www.pinterest.com\{href\}"})
19        await browser.close()
20        return {"username": username, "followers": followers, "boards": boards}

Per estrarre tutti i pin di ogni board del profilo, cicla sulla lista delle board e richiama scrape_board() per ciascuna. Puoi anche organizzare automaticamente le immagini scaricate in cartelle separate per board.

Costruire un gestore di infinite scroll pronto per la produzione

Questa è la parte che distingue uno scraper dimostrativo da uno davvero usabile. Il problema numero uno — e l’ho visto in almeno una dozzina di thread nei forum — è che gli scraper restituiscono solo 16–25 elementi perché non scorrono abbastanza, oppure usano un numero fisso di scroll come for i in range(5): scroll() e sperano nel meglio.

Quell’approccio non è affidabile. Pinterest carica nuovi contenuti a blocchi di circa 25 pin, attivati dagli eventi di scroll. Se fai cinque scroll, potresti ottenere 125 pin — oppure 75 se la rete è lenta, o 150 se i blocchi sono più piccoli. Serve un pattern più intelligente.

Il pattern “scroll finché non arrivano più contenuti”

Ecco una funzione di scroll robusta che traccia gli ID unici dei pin, usa un timeout configurabile, include logica di retry e stampa l’avanzamento:

1import time
2import random
3async def scroll_and_collect(page, max_pins=1000, max_scrolls=200, scroll_pause=2.5):
4    seen_ids = set()
5    all_pins = []
6    no_new_count = 0
7    for i in range(max_scrolls):
8        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
9        new_this_round = 0
10        for pin in pins:
11            link = await pin.query_selector("a")
12            if not link:
13                continue
14            href = await link.get_attribute("href") or ""
15            if href in seen_ids:
16                continue
17            seen_ids.add(href)
18            new_this_round += 1
19            title = await link.get_attribute("aria-label") or ""
20            img = await link.query_selector("img")
21            src = await img.get_attribute("src") if img else ""
22            all_pins.append({
23                "title": title,
24                "url": f"https://www.pinterest.com\{href\}" if href.startswith("/") else href,
25                "image_url": src
26            })
27        print(f"  Scroll {i+1}: \{new_this_round\} nuovi pin | {len(all_pins)} pin unici totali")
28        if len(all_pins) >= max_pins:
29            print(f"  Raggiunto il limite max_pins (\{max_pins\}). Interruzione.")
30            break
31        if new_this_round == 0:
32            no_new_count += 1
33            if no_new_count >= 3:
34                print("  Nessun nuovo pin per 3 scroll consecutivi. Fine del contenuto.")
35                break
36        else:
37            no_new_count = 0
38        prev_height = await page.evaluate("document.body.scrollHeight")
39        await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
40        await asyncio.sleep(scroll_pause + random.uniform(0.5, 1.5))
41        curr_height = await page.evaluate("document.body.scrollHeight")
42        if curr_height == prev_height and new_this_round == 0:
43            print("  Altezza della pagina invariata e nessun nuovo pin. Probabile fine del feed.")
44            break
45    return all_pins

Perché questo design funziona:

• Deduplicazione tramite href: l’URL di ogni pin è univoco, quindi lo usiamo come ID. Così eviti di contare due volte lo stesso pin quando il DOM viene renderizzato di nuovo durante lo scroll.
• Regola dei tre tentativi: se tre scroll consecutivi non producono nuovi pin, ci fermiamo. Questo gestisce il caso in cui la pagina stia ancora caricando ma non ci siano davvero nuovi contenuti.
• Jitter casuale nella pausa: aggiungere un ritardo casuale di 0,5–1,5 secondi tra gli scroll rende il comportamento più umano e riduce il rischio di attivare meccanismi anti-bot.
• Limite massimo di scroll: evita loop infiniti se qualcosa va storto.

Gestire i casi limite

• Interruzione per "More Ideas": nelle board, Pinterest a volte inserisce una sezione "More Ideas". Se vuoi solo i pin effettivamente della board, puoi intercettare questo elemento e fermarti quando compare.
• Rate limiting durante sessioni lunghe: se stai scorrendo una board con migliaia di pin, Pinterest può iniziare a rallentare le risposte. Se noti scroll che producono zero nuovi pin in modo intermittente (ma non per tre volte consecutive), aumenta la pausa a 5+ secondi.

Ottenere immagini Pinterest in alta risoluzione (non miniature)

Questo manda fuori di testa molte persone. Fai scraping di tanti pin, scarichi le immagini e sono tutte miniature minuscole da 236px. Nei forum la descrivono come "qualità pessima, troppo piccole". La soluzione è capire la struttura degli URL delle immagini di Pinterest.

Capire i percorsi URL delle immagini di Pinterest

Tutte le immagini di Pinterest sono servite da https://i.pinimg.com/\{size\}/\{hash\}.jpg. Il segmento \{size\} controlla la risoluzione:

Funzione utile: portare qualsiasi URL immagine Pinterest alla massima risoluzione

Ecco una funzione che riscrive qualsiasi URL immagine di Pinterest alla massima qualità disponibile, con logica di fallback:

1import requests as req
2def upgrade_image_url(url, preferred_size="originals"):
3    """Riscrive un URL immagine di Pinterest alla massima risoluzione disponibile."""
4    sizes = ["originals", "736x", "474x", "236x"]
5    if preferred_size not in sizes:
6        preferred_size = "originals"
7    for size in sizes[sizes.index(preferred_size):]:
8        upgraded = url
9        for s in sizes:
10            upgraded = upgraded.replace(f"/\{s\}/", f"/\{size\}/")
11        try:
12            resp = req.head(upgraded, timeout=5, allow_redirects=True)
13            if resp.status_code == 200:
14                return upgraded
15        except Exception:
16            continue
17    return url  # Ritorna l’originale se tutto fallisce

Nota importante (aggiornata al 2025): il percorso /originals/ restituisce sempre più spesso errori HTTP 403 Forbidden. Un conferma questo comportamento a metà 2025. Il massimo affidabile è /736x/. La mia funzione prova prima /originals/ e poi torna automaticamente a /736x/.

Scaricare le immagini in cartelle organizzate

1import os
2import time
3def download_images(pins, folder="images/default", delay=1.5):
4    os.makedirs(folder, exist_ok=True)
5    for i, pin in enumerate(pins):
6        img_url = upgrade_image_url(pin.get("image_url", ""), preferred_size="736x")
7        if not img_url:
8            continue
9        filename = f"pin_{i+1}.jpg"
10        filepath = os.path.join(folder, filename)
11        try:
12            resp = req.get(img_url, timeout=15)
13            if resp.status_code == 200:
14                with open(filepath, "wb") as f:
15                    f.write(resp.content)
16                print(f"  Scaricato \{filename\} ({len(resp.content) // 1024} KB)")
17            else:
18                print(f"  Download fallito \{filename\}: HTTP \{resp.status_code\}")
19        except Exception as e:
20            print(f"  Errore nel download di \{filename\}: \{e\}")
21        time.sleep(delay + random.uniform(0.3, 0.8))

Aggiungi un ritardo tra un download e l’altro. Io uso 1,5–2,3 secondi con una piccola variabilità casuale. Senza, Pinterest potrebbe bloccare il tuo IP dopo qualche centinaio di richieste.

Esportare i dati Pinterest estratti

Esportare in CSV o JSON

Abbiamo già visto le basi prima. Per dataset grandi (oltre 10.000 pin), considera il formato JSON Lines — un oggetto JSON per riga — più facile da trasmettere ed elaborare:

1def save_jsonl(data, filepath="output/pins.jsonl"):
2    with open(filepath, "w", encoding="utf-8") as f:
3        for item in data:
4            f.write(json.dumps(item, ensure_ascii=False) + "\n")

Esportare in Google Sheets, Airtable o Notion

Se vuoi inviare i dati direttamente da Python a Google Sheets, ti serve la libreria gspread e un service account di Google Cloud. Per Airtable, usa pyairtable. Per Notion, notion-client. Ogni opzione richiede la configurazione di una chiave API e aggiunge complessità reale alla pipeline.

Oppure — e qui sono un po’ di parte, ma è davvero la via più veloce — puoi usare per fare scraping di Pinterest ed esportare in una di queste destinazioni con un solo clic. Niente chiavi API, niente service account, niente codice extra. L’ gestisce l’esportazione in modo nativo.

Consigli per evitare blocchi durante lo scraping di Pinterest

Il sistema anti-bot di Pinterest ha una difficoltà di bypass valutata da ScrapeOps — non banale, ma nemmeno il bersaglio più difficile. Usa fingerprinting del browser, analisi comportamentale e rate limiting basato sull’IP. Ecco cosa funziona:

• Ruota gli user agent: usa un pool di stringhe user agent reali di Chrome e scegli una in modo casuale per ogni sessione.
• Aggiungi ritardi casuali: 2–5 secondi tra scroll e richieste, con jitter. Se non usi proxy, aumenta a 10–15 secondi.
• Usa una viewport realistica: imposta viewport={"width": 1920, "height": 1080} — evita dimensioni piccole o strane.
• Valuta i proxy se devi scalare: se stai estraendo migliaia di pin, usa proxy residenziali. Senza, aspettati blocchi IP dopo qualche centinaio di richieste.
• Rispetta robots.txt: il robots.txt di Pinterest blocca la maggior parte dei crawler automatici e contiene . Tienilo presente per la conformità.
• Evita lo scraping da utente loggato: resta sui contenuti visibili pubblicamente mentre sei disconnesso. Fare scraping dietro login aumenta i rischi sia legali sia tecnici.

Thunderbit gestisce automaticamente anti-bot e CAPTCHA tramite il suo motore AI — una cosa in meno da mantenere se scegli la strada no-code.

Considerazioni legali ed etiche sullo scraping di Pinterest

Sarò breve perché non è il focus dell’articolo, ma è importante.

I Termini di Servizio di Pinterest (Sezione 2a) indicano che accetti di non "scrape, collect, search, copy or otherwise access data or content from Pinterest in unauthorized ways, such as by using automated means (without our express prior permission)." Detto questo, i tribunali hanno generalmente stabilito che lo scraping di dati pubblicamente accessibili non viola il Computer Fraud and Abuse Act — vedi e Meta v. Bright Data (gennaio 2024), dove il tribunale ha stabilito che fare scraping di dati visibili pubblicamente mentre si è disconnessi è legale.

Alcune regole di base:

• fai scraping solo di contenuti pubblici mentre sei disconnesso
• non usare i dati estratti per spam o per impersonare gli utenti
• rispetta il copyright delle immagini — estrai i metadati quando possibile ed evita di ridistribuire commercialmente immagini protette senza permesso
• se intendi usare i dati estratti per fini commerciali, consulta un legale

Per un approfondimento sul quadro normativo, vedi la nostra .

Conclusione: cosa hai imparato e dove andare ora

Ora sai perché lo scraping statico fallisce su Pinterest (è una SPA React — senza JavaScript, niente dati), come usare Playwright per estrarre risultati di ricerca, board e profili utente, come costruire un gestore di infinite scroll pronto per la produzione che non si fermi dopo 16 pin, e come ottenere immagini in alta risoluzione invece di miniature minuscole.

Riassunto rapido di ciò che conta:

• requests + BeautifulSoup non funzionano su Pinterest. Non perdere tempo.
• Playwright è il miglior strumento Python per questo compito — veloce, ben supportato e capace di gestire nativamente il rendering JS.
• L’infinite scroll richiede un ciclo di scroll basato sulla deduplicazione, non un conteggio fisso.
• Le immagini in alta risoluzione richiedono la riscrittura del percorso URL — punta a /736x/ (dato che /originals/ spesso restituisce 403).
• Lo scraping di board e profili è poco trattato nei tutorial esistenti, ma con i selettori giusti è piuttosto diretto.
• Per chi non programma o per i team che vogliono velocità, ti permette di fare scraping di Pinterest in 2 clic ed esportare su Google Sheets, Excel, Airtable o Notion — senza bisogno di Python. Provalo gratis tramite la .

Se stai costruendo una pipeline Python, il codice di questa guida ti offre una base solida. Se ti servono solo i dati, Thunderbit è la scorciatoia. In entrambi i casi, non resti più bloccato con 16 pin e uno sguardo perplesso.

Per altri contenuti su scraping ed estrazione dati, consulta le nostre guide su , e . Puoi anche esplorare i o guardare i tutorial sul .

FAQ

1. Si può fare scraping di Pinterest con BeautifulSoup?

Non in modo efficace da solo. Pinterest rende tutti i contenuti via JavaScript, quindi requests + BeautifulSoup vedono solo uno scheletro HTML vuoto. Serve un browser headless come Playwright o Selenium per renderizzare la pagina prima, oppure puoi usare uno strumento no-code come Thunderbit che gestisce automaticamente il rendering JS.

2. Quanti pin si possono estrarre da Pinterest in una sessione?

Dipende dalla logica di scroll e dalla gestione anti-bot. Con il gestore di infinite scroll pronto per la produzione presente in questa guida (deduplicazione, timeout, retry), puoi estrarre in modo affidabile centinaia o migliaia di pin per board o query di ricerca. Per board molto grandi, considera alcuni minuti di scrolling e raccolta.

3. Perché le immagini Pinterest estratte risultano minuscole?

Per impostazione predefinita, Pinterest mostra miniature /236x/ nella vista a griglia. Per ottenere una risoluzione più alta, riscrivi il percorso dell’immagine in /736x/ o /originals/. Tieni presente che dal 2025 /originals/ restituisce sempre più spesso errori 403, quindi /736x/ è il massimo affidabile.

4. È legale fare scraping di Pinterest?

Lo scraping di dati pubblicamente disponibili è in genere accettato alla luce di recenti sentenze (ad esempio hiQ v. LinkedIn, Meta v. Bright Data), ma i Termini di Servizio di Pinterest vietano l’accesso automatizzato non autorizzato. Limìtati ai contenuti pubblici, non usare i dati estratti per spam, rispetta il copyright e consulta un legale per utilizzi commerciali.

5. Qual è la migliore alternativa no-code per fare scraping di Pinterest?

può estrarre dati dai pin di Pinterest — titoli, immagini, URL, descrizioni — in 2 clic, con export integrato verso Google Sheets, Excel, Airtable o Notion. Gestisce automaticamente rendering JavaScript, infinite scroll e sfide anti-bot, quindi non devi scrivere o mantenere alcun codice.

Scopri di più