Come scrapeare pin e board di Pinterest nel 2026: guida per sviluppatori

Anti-bot: rate limit, bot scoring e perché servono proxy residenziali

Pinterest implementa difese anti-bot su più livelli:

1. Rate limit per IP: un singolo IP che effettua troppe richieste in breve tempo riceve 429 Too Many Requests o 403.
2. Bot scoring: Pinterest analizza pattern di traffico — cadenza delle richieste, header, TLS fingerprint, comportamento di navigazione — e assegna un punteggio di rischio. Punteggi alti portano a CAPTCHA o blocchi.
3. Geolocalizzazione: i risultati di ricerca e le raccomandazioni sono localizzati. Una ricerca da un IP tedesco restituisce risultati diversi rispetto a un IP statunitense.

Per questi motivi, l'uso di proxy residenziali rotanti è essenziale per chiunque voglia scrapeare Pinterest a scala. I proxy datacenter vengono bloccati più facilmente perché i loro range IP sono noti e associati a traffico automatizzato. I proxy residenziali, invece, usano IP di dispositivi reali assegnati da ISP, il che riduce drasticamente il rischio di rilevazione.

La geolocalizzazione è un fattore spesso sottovalutato. Se il tuo dataset deve rappresentare trend negli Stati Uniti, devi usare IP statunitensi, altrimenti i risultati di SearchResource rifletteranno il mercato del paese del proxy. ProxyHat permette di specificare il geo nel username: user-country-US:pass.

ProxyHat: configurazione del proxy residenziale

ProxyHat offre proxy residenziali rotanti accessibili tramite un gateway HTTP su gate.proxyhat.com:8080 o SOCKS5 su gate.proxyhat.com:1080. La rotazione IP e il geo-targeting si configurano direttamente nel username:

# HTTP — rotazione automatica, geo US
http://user-country-US:PASSWORD@gate.proxyhat.com:8080

# HTTP — sessione sticky (IP persistente), geo US
http://user-country-US-session-abc123:PASSWORD@gate.proxyhat.com:8080

# SOCKS5 — rotazione automatica, geo DE
socks5://user-country-DE:PASSWORD@gate.proxyhat.com:1080

Per lo scraping di Pinterest, la strategia consigliata è:

• Rotazione per richiesta per BoardFeedResource quando raccogli pin in bulk — ogni richiesta usa un IP diverso.
• Sessione sticky per sequenze che richiedono continuità del csrftoken — lo stesso IP per tutta la sessione di paginazione.
• Geo fisso per coerenza dei risultati di ricerca.

Puoi consultare la lista completa di location disponibili sulla pagina /it/locations e i dettagli di pricing su /it/pricing.

Esempio 1: Python — paginazione di BoardFeedResource

Vediamo un esempio completo in Python usando requests e il gateway ProxyHat. L'obiettivo è estrarre i pin da una board pubblica, paginando con i bookmark.

import requests
import json
from urllib.parse import quote

# ProxyHat residential proxy — geo US, sticky session per csrftoken continuity
PROXY = "http://user-country-US-session-pint01:PASSWORD@gate.proxyhat.com:8080"
PROXIES = {"http": PROXY, "https": PROXY}

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "X-Pinterest-PWS-Handler": "www/[username]/[slug].js",
    "X-APP-VERSION": "abc123def",  # aggiorna ispezionando la pagina
    "Accept": "application/json",
}

def scrape_board_pins(board_slug, max_pages=10):
    """Scrapea pin pubblici da una board usando BoardFeedResource."""
    base_url = "https://www.pinterest.com/resource/BoardFeedResource/get/"
    bookmarks = []
    all_pins = []

    for page in range(max_pages):
        data_param = json.dumps({
            "options": {
                "board_url": board_slug,
                "page_size": 25,
                "bookmarks": bookmarks,
            },
            "context": {},
        })

        params = {
            "source_url": f"/{board_slug}/",
            "data": data_param,
        }

        try:
            resp = requests.get(
                base_url,
                headers=HEADERS,
                params=params,
                proxies=PROXIES,
                timeout=30,
            )
            resp.raise_for_status()
            payload = resp.json()
        except Exception as e:
            print(f"Errore pagina {page}: {e}")
            break

        results = payload.get("resource_response", {}).get("data", [])
        if not results:
            print("Nessun altro risultato.")
            break

        for pin in results:
            pin_id = pin.get("id")
            title = pin.get("title") or pin.get("grid_title", "")
            image = pin.get("images", {}).get("orig", {}).get("url", "")
            link = pin.get("link", "")
            all_pins.append({
                "id": pin_id,
                "title": title,
                "image_url": image,
                "link": link,
            })

        # Aggiorna bookmarks per la pagina successiva
        bookmarks = payload.get("resource_response", {}).get("bookmark", [])
        if not bookmarks:
            break

        # Pacing: 2-3 secondi tra le richieste per ridurre il bot score
        import time
        time.sleep(2.5)

    return all_pins

# Esempio di utilizzo
pins = scrape_board_pins("username/board-name", max_pages=5)
print(f"Estratti {len(pins)} pin")
for p in pins[:3]:
    print(json.dumps(p, indent=2))

Questo snippet estrae per ogni pin l'id, il title, l'image_url (versione originale) e il link di origine. La sessione sticky (-session-pint01) mantiene lo stesso IP per tutta la paginazione, preservando la validità del csrftoken.

Esempio 2: Node.js — ricerca pubblica con SearchResource

Il secondo esempio usa Node.js con axios e il gateway HTTP ProxyHat sulla porta 8080 per estrarre risultati di ricerca pubblici.

const axios = require('axios');

const PROXY_URL = 'http://user-country-US-session-search01:PASSWORD@gate.proxyhat.com:8080';

const HEADERS = {
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
    + '(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
  'X-Pinterest-PWS-Handler': 'www/search/[query].js',
  'X-APP-VERSION': 'abc123def',
  'Accept': 'application/json',
};

async function scrapePinterestSearch(query, maxPages = 5) {
  const baseUrl = 'https://www.pinterest.com/resource/SearchResource/get/';
  let bookmarks = [];
  const allResults = [];

  for (let page = 0; page < maxPages; page++) {
    const dataParam = JSON.stringify({
      options: {
        query: query,
        scope: 'pins',
        page_size: 25,
        bookmarks: bookmarks,
      },
      context: {},
    });

    try {
      const resp = await axios.get(baseUrl, {
        params: {
          source_url: `/search/pins/?q=${encodeURIComponent(query)}`,
          data: dataParam,
        },
        headers: HEADERS,
        proxy: false,
        httpsAgent: new (require('https-proxy-agent').HttpsProxyAgent)(PROXY_URL),
        timeout: 30000,
      });

      const data = resp.data.resource_response?.data || [];
      if (data.length === 0) break;

      for (const pin of data) {
        allResults.push({
          id: pin.id,
          title: pin.title || pin.grid_title || '',
          image_url: pin.images?.orig?.url || '',
          link: pin.link || '',
        });
      }

      bookmarks = resp.data.resource_response?.bookmark || [];
      if (bookmarks.length === 0) break;

      await new Promise(r => setTimeout(r, 2500)); // pacing
    } catch (err) {
      console.error(`Errore pagina ${page}: ${err.message}`);
      break;
    }
  }

  return allResults;
}

// Esempio
scrapePinterestSearch('interior design ideas', 5)
  .then(r => console.log(`Estratti ${r.length} pin`));

Paginazione, sessioni sticky e fingerprint: best practice

Bookmark/cursor pagination

Pinterest usa un sistema di paginazione basato su bookmarks, non su offset numerici. Il server restituisce un array di cursori opachi che devi rimandare nella richiesta successiva. Non ci sono numeri di pagina: se salti un bookmark, perdi la sequenza. Conserva sempre i bookmark della risposta precedente e passali nel campo bookmarks del prossimo data param.

Sessioni sticky per continuità del csrftoken

Il token CSRF è legato alla sessione e all'IP. Se l'IP cambia a metà paginazione, il token può diventare invalido e le richieste successive ricevono 403. Usa una sessione sticky ProxyHat (es. -session-abc123) per mantenere lo stesso IP durante una sequenza di paginazione. Cambia sessione (e quindi IP) solo quando inizi una nuova board o una nuova query.

Pacing e rate limit

Il bot scoring di Pinterest penalizza traffico troppo regolare e troppo veloce. Linee guida pratiche:

• 2-3 secondi di pausa tra le richieste per sessione sticky.
• Non superare 50-100 richieste per IP per ora.
• Varia leggermente i tempi di pausa (jitter) per evitare pattern meccanici.
• Monitora la percentuale di 429/403: se supera il 5%, riduci la frequenza.

User-Agent e fingerprint hygiene

L'User-Agent deve essere realistico e coerente con altri header. Errori comuni:

• Usare un UA vecchio (Chrome 90) con header moderni.
• Non inviare header come Accept-Language e Sec-Fetch-Dest.
• Rotare troppi UA diversi dalla stessa sessione — innaturale.

Usa un singolo UA realistico per sessione e mantienilo coerente. Aggiungi header come Accept-Language: en-US,en;q=0.9 per completare il profilo del browser.

Scraping etico: quando usare l'API ufficiale invece

Lo scraping di dati pubblici è una pratica legittima per ricerca, analisi di mercato e costruzione di dataset, ma deve essere fatto in modo responsabile. Alcuni principi:

1. Rispetta robots.txt: controlla sempre https://www.pinterest.com/robots.txt prima di avviare un crawler. Se un percorso è disallowed, non scraperarlo.
2. Solo dati pubblici e non personali: non estrarre dati dietro login, profili privati o informazioni personali identificabili. Il GDPR considera i dati personali un'categoria speciale con obblighi rigorosi.
3. Limita il carico: lo scraping non deve degradare il servizio per altri utenti. Pacing ragionevole e proxy rotanti riducono l'impatto.
4. Preferisci l'API ufficiale per produzione: se devi interagire con Pinterest in modo continuativo (pubblicare pin, leggere analytics del tuo account), usa la Pinterest API v5. È più stabile, supportata e non rischia blocchi. Lo scraping ha senso per dati pubblici non coperti dall'API ufficiale.

Per approfondire pattern di scraping robusti, consulta la documentazione ProxyHat e la pagina sui casi d'uso di web scraping. Per progetti di monitoraggio SERP, vedi anche SERP tracking.

Punti chiave (Key Takeaways)

• Superfici pubbliche: pin, board e ricerca pubblica sono accessibili senza login. L'home feed personalizzato è login-walled e fuori limite.
• API Resource interna: Pinterest serve i dati via endpoint /resource/*/get/ con parametri source_url e data URL-encoded, più header specifici.
• Proxy residenziali rotanti: essenziali per evitare rate limit e bot scoring. Usa geo-targeting (-country-US) per coerenza dei risultati di ricerca.
• Sessioni sticky: mantengono lo stesso IP durante una sequenza di paginazione, preservando il csrftoken.
• Pacing e fingerprint: 2-3 secondi tra richieste, UA coerente, jitter nei tempi. Monitora la percentuale di errori 429/403.
• Etica: solo dati pubblici e non personali, rispetta robots.txt e ToS. Per produzione, preferisci l'API v5 ufficiale.

FAQ

Come scrapeare pin e board di Pinterest nel 2026?

Si scrapeano i pin e le board pubbliche di Pinterest replicando le chiamate all'API Resource interna (BoardFeedResource, SearchResource, PinResource) con gli header corretti (X-Pinterest-PWS-Handler, X-APP-VERSION, csrftoken) e usando proxy residenziali rotanti per evitare blocchi. La paginazione avviene tramite bookmark opachi restituiti dal server. È essenziale rispettare i Termini di Servizio e accedere solo a dati pubblici.

Perché serve un proxy per scrapeare Pinterest?

Pinterest applica rate limit per IP e bot scoring basato su pattern di traffico. Senza proxy, un singolo IP viene bloccato rapidamente dopo 50-100 richieste. I proxy residenziali rotanti distribuiscono le richieste su molti IP reali, riducendo il rischio di rilevazione. Il geo-targeting è importante perché i risultati di ricerca sono localizzati: un IP tedesco restituisce risultati diversi da un IP statunitense.

Quale tipo di proxy funziona meglio per Pinterest?

I proxy residenziali rotanti sono la scelta ottimale per scrapeare Pinterest, perché usano IP assegnati da ISP reali e sono meno rilevabili dei proxy datacenter. Le sessioni sticky permettono di mantenere lo stesso IP durante una sequenza di paginazione, preservando la validità del csrftoken. Il geo-targeting (es. country-US) garantisce coerenza nei risultati di ricerca localizzati.

Come evitare i blocchi quando si scrapea Pinterest?

Per evitare blocchi: usa proxy residenziali rotanti con geo-targeting, mantieni sessioni sticky per continuità del csrftoken, imposta pacing di 2-3 secondi tra le richieste con jitter, usa un User-Agent realistico e coerente, includi header completi (Accept-Language, Sec-Fetch-*), e monitora la percentuale di errori 429/403 riducendo la frequenza se supera il 5%. Rispetta sempre robots.txt e i Termini di Servizio.

È meglio usare l'API ufficiale v5 o lo scraping?

Dipende dal caso d'uso. L'API v5 ufficiale è consigliata per interazioni con il proprio account (pubblicare pin, leggere analytics), ma ha limiti significativi: richiede approvazione app, OAuth, e non copre ricerche pubbliche arbitrarie. Lo scraping di dati pubblici è legittimo per dataset di trend e analisi di mercato, ma deve rispettare ToS, robots.txt e normative come CFAA e GDPR. Per produzione stabile, valuta prima l'API ufficiale.