Scraping Pinterest avec Python : « Pins, boards et défilement infini »

Il y a quelques mois, un de nos ingénieurs m’a montré un script Python qu’il avait bricolé pendant le week-end. Il devait aller chercher des images d’inspiration produit sur Pinterest pour un projet d’étude de marché. Il l’a lancé, et le résultat a été… 16 pins. Sur un board qui en comptait plus de 2 000. Il a regardé l’écran, puis moi, et il m’a dit : « Je crois que Pinterest se fout de moi. »

Il n’est pas le seul. C’est de loin la galère que je vois le plus souvent chez les développeurs qui essaient de scraper Pinterest avec Python. Tu lances requests et BeautifulSoup, tu vises une URL Pinterest, et tu te retrouves avec seulement quelques éléments, ou carrément une page HTML vide. Pourquoi ? Parce que Pinterest est une application monopage entièrement rendue en JavaScript — ta requête HTTP statique ne voit jamais le vrai contenu. Dans ce guide, je vais t’expliquer pourquoi ça arrive, quelles approches marchent vraiment (Playwright, interception de l’API interne et outils no-code comme ), et te donner du code pas à pas pour scraper les pins, les boards, les profils utilisateurs, le défilement infini et les images en haute résolution. Que tu veuilles construire un scraper de niveau production ou simplement récupérer des données vite fait, cet article est pour toi.

Qu’est-ce que le scraping Pinterest ?

Le scraping Pinterest, c’est extraire automatiquement des données depuis Pinterest — comme les images des pins, les titres, les descriptions, les noms de boards, le nombre d’abonnés et les URL. Au lieu de parcourir et d’enregistrer les pins un par un à la main, tu utilises du code (ou un outil) pour collecter des données structurées à grande échelle depuis les résultats de recherche, les boards ou les profils utilisateurs.

Avec sur la plateforme et fin 2025, Pinterest est l’une des plus grosses mines de données visuelles du web. Pour les entreprises, ces données valent de l’or — que tu suives les tendances produit, analyses le contenu des concurrents ou construises des listes de prospection d’influenceurs.

Pourquoi scraper Pinterest avec Python ?

Pinterest, ce n’est plus juste un tableau d’inspiration pour les mariages. C’est devenu une vraie plateforme de business intelligence — ont acheté quelque chose à partir de Pins de marque, et , ce qui veut dire que les gens arrivent avec une intention, mais sans fidélité à une marque. C’est une énorme opportunité de découverte — et c’est pour ça que tant d’équipes veulent des données Pinterest bien structurées.

Voilà à quoi ça ressemble selon les équipes :

Et voilà le point crucial : l’API officielle de Pinterest est limitée. Il faut un compte professionnel, une validation (y compris une démo vidéo de ton application), et l’accès ne porte que sur les données de ton propre compte. Si tu veux parcourir des boards publics, des résultats de recherche ou des profils concurrents, le scraping reste l’option la plus pratique. C’est pour ça que beaucoup d’équipes se tournent vers Python — ou vers des outils no-code comme Thunderbit quand elles veulent des résultats sans passer par la case configuration.

Pourquoi BeautifulSoup seul échoue sur Pinterest (et ce qui marche vraiment)

Si tu as déjà tenté de scraper Pinterest avec requests + BeautifulSoup et obtenu 16 éléments ou une page vide, tu n’as rien inventé. Pinterest est construit avec React et affiche 100 % de son contenu via JavaScript. Quand tu récupères une URL Pinterest avec une simple requête HTTP, le serveur renvoie une structure HTML minimale — quelques balises <link> et <script>, plus un <div> vide où React vient monter l’application. Toutes les cartes de pins, les images, les titres et les grilles sont injectés après l’exécution du JavaScript dans le navigateur.

Pas d’exécution JavaScript = pas de pins.

Alors, qu’est-ce qui fonctionne ? Voici un comparatif des principales approches :

Pour ce tutoriel, je recommande Playwright comme solution Python. Il rend le JavaScript, gère la simulation de défilement, est bien maintenu (, croissance de dans les offres d’emploi), et il est dans les benchmarks. Si tu préfères une approche sans code, je vais aussi l’aborder.

API officielle Pinterest vs scraping Python vs no-code : quelle option choisir ?

Avant d’écrire du code, ça vaut le coup de se demander : est-ce que tu en as vraiment besoin ? Voici une grille pour t’aider à décider :

Si tu es marketeur, responsable e-commerce, ou juste quelqu’un qui veut des données Pinterest dans un tableur sans écrire ni maintenir de scripts Python, est la voie rapide. Ouvre n’importe quelle page Pinterest, clique sur « AI Suggest Fields », lance l’extraction, puis exporte directement vers Google Sheets, Excel, Airtable ou Notion. Sa fonction d’extraction des sous-pages peut même suivre les liens de chaque pin pour enrichir automatiquement les données. J’ai vu des membres d’équipe qui n’avaient jamais écrit une seule ligne de code récupérer plus de 500 pins dans Google Sheets en moins de trois minutes.

Pour ceux qui veulent garder la main, intégrer le scraping dans un pipeline Python, ou simplement tout construire eux-mêmes, continue la lecture.

Préparer ton environnement Python pour scraper Pinterest

• Difficulté : Intermédiaire
• Temps nécessaire : environ 30 à 60 minutes (code et tests compris)
• Ce qu’il te faut : Python 3.9+, navigateur Chrome (pour les tests), accès au terminal / ligne de commande

Installer Playwright et les dépendances

Commence par créer un dossier projet et configurer un environnement virtuel :

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

Installe Playwright et télécharge le binaire du navigateur Chromium :

1pip install playwright
2playwright install chromium

Tu utiliseras aussi les modules intégrés de Python json, os et csv pour exporter les données. Pas besoin d’installer autre chose pour ceux-là.

Structure du dossier projet

Je te conseille de structurer le projet dès le départ :

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/

Dans config.py, définis ta chaîne user agent. Pinterest bloque souvent les signatures par défaut des navigateurs headless, donc utilise une chaîne réaliste :

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"

Étape 1 : construire l’URL de recherche Pinterest

Construis l’URL de recherche en insérant ta requête dans le modèle :

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

Tu peux adapter ça à n’importe quel mot-clé. Le paramètre rs=typed indique à Pinterest que la requête a été saisie manuellement (et non suggérée), ce qui peut parfois influencer la pertinence des résultats.

Étape 2 : lancer un navigateur headless et charger la page

Voici la configuration Playwright de base. Note bien le user agent personnalisé — sans lui, Pinterest risque fortement de te bloquer ou d’afficher une page de connexion.

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)  # Laisser le temps au JavaScript de charger les premiers pins

Une fois ça lancé, la page devrait afficher le premier lot de pins — généralement entre 25 et 50.

Étape 3 : extraire les données des pins depuis la page

Pinterest enveloppe chaque pin dans un div avec data-test-id='pinWrapper'. À l’intérieur, tu trouveras un lien (<a>) avec l’URL du pin et son titre (via aria-label), ainsi qu’une balise <img> avec l’URL de la miniature.

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 pin.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            })

À ce stade, results contient les pins visibles dans la zone initiale. Pour en récupérer plus, il faut faire défiler la page — et c’est ce qu’on va voir maintenant.

Étape 4 : enregistrer les résultats en JSON ou CSV

Après l’extraction, écris tes données dans des fichiers pour pouvoir les réutiliser facilement :

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)

Utilise l’encodage utf-8-sig pour le CSV si tu comptes l’ouvrir dans Excel — ça évite les caractères illisibles.

Scraper des boards Pinterest entiers et des profils utilisateurs

C’est un gros manque dans la plupart des tutoriels existants. Je n’ai trouvé aucun guide concurrent qui couvre vraiment le scraping des boards ou des profils — pourtant, c’est l’une des fonctionnalités les plus demandées sur les forums. Les gens veulent télécharger tous les pins d’un board, organiser les images dans des dossiers par board et récupérer des données de profil comme le nombre d’abonnés et la liste des boards.

Scraper tous les pins d’une URL de board

Les URL de board suivent ce format : https://www.pinterest.com/{username}/{board-name}/. La structure du DOM ressemble à celle des résultats de recherche — les pins sont toujours dans des div[data-test-id='pinWrapper'] — mais il faut faire défiler la page pour tout charger.

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 de sécurité
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"Défilement {scroll_round + 1} : {len(all_pins)} pins uniques collectés")
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  # Plus de contenu
38        await browser.close()
39        return all_pins

À surveiller : les pages de board affichent parfois un onglet « Plus d’idées » qui sépare les pins enregistrés des recommandations algorithmiques. Si tu ne veux que les pins réellement enregistrés par l’utilisateur, arrête le défilement quand ce séparateur apparaît.

Scraper un profil utilisateur : boards, nombre d’abonnés et pins

Les URL de profil ressemblent à https://www.pinterest.com/{username}/. Depuis une page de profil, tu peux extraire :

• Nombre d’abonnés / d’abonnements : cherche div[data-test-id='follower-count']
• Liste des boards : chaque board est une carte menant à /{username}/{board-name}/
• Nombre total de pins : parfois affiché dans l’en-tête du profil

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        # Extraire le nombre d'abonnés
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        # Extraire les liens des boards
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}

Pour scraper tous les pins de chaque board d’un profil, parcours la liste des boards et appelle scrape_board() pour chacun. Tu peux ensuite organiser automatiquement les images téléchargées dans des dossiers séparés par board.

Construire un gestionnaire de défilement infini prêt pour la production

C’est là que la différence se fait entre un scraper de démo et un vrai outil exploitable. Le problème numéro 1 — et je l’ai vu dans au moins une douzaine de fils de discussion — c’est que les scrapers ne renvoient que 16 à 25 éléments parce qu’ils ne font pas assez défiler, ou parce qu’ils utilisent un nombre de scrolls fixe du type for i in range(5): scroll() en espérant que ça suffise.

Cette approche n’est pas fiable. Pinterest charge de nouveaux contenus par lots d’environ 25 pins, déclenchés par les événements de scroll. Si tu fais défiler cinq fois, tu obtiens peut-être 125 pins — ou seulement 75 si le réseau est lent, ou 150 si les lots sont plus petits. Il faut une logique plus intelligente.

Le pattern « défiler jusqu’à ce qu’il n’y ait plus rien de nouveau »

Voici une fonction de défilement robuste qui suit les identifiants uniques des pins, utilise un délai configurable, ajoute une logique de reprise et affiche la progression :

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"  Défilement {i+1} : {new_this_round} nouveaux pins | {len(all_pins)} pins uniques au total")
28        if len(all_pins) >= max_pins:
29            print(f"  Limite max_pins atteinte ({max_pins}). Arrêt.")
30            break
31        if new_this_round == 0:
32            no_new_count += 1
33            if no_new_count >= 3:
34                print("  Aucun nouveau pin après 3 défilements consécutifs. Fin du contenu.")
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("  Hauteur de page inchangée et aucun nouveau pin. Fin probable du flux.")
44            break
45    return all_pins

Pourquoi ce design fonctionne :

• Déduplication par href : l’URL de chaque pin est unique, donc on l’utilise comme identifiant. Ça évite de compter deux fois le même pin quand le DOM se reconstruit pendant le défilement.
• Règle des trois échecs : si trois défilements consécutifs ne renvoient aucun nouveau pin, on s’arrête. Ça couvre les cas où la page charge encore, mais sans nouveau contenu.
• Aléa dans les pauses : ajouter un délai aléatoire de 0,5 à 1,5 seconde entre les scrolls donne un comportement plus humain et réduit le risque de déclencher les protections anti-bot.
• Limite de sécurité sur les scrolls : ça évite les boucles infinies en cas de souci.

Gérer les cas particuliers

• Blocage par « Plus d’idées » : sur les pages de board, Pinterest insère parfois une section « Plus d’idées ». Si tu ne veux que les pins du board, tu peux détecter cet élément et arrêter le défilement quand il apparaît.
• Rate limiting lors de longues sessions : si tu fais défiler un board de plusieurs milliers de pins, Pinterest peut commencer à ralentir les réponses. Si tu vois que certains scrolls ne produisent aucun nouveau pin de temps en temps (mais pas trois fois d’affilée), augmente le délai de scroll à 5 secondes ou plus.

Obtenir des images Pinterest en pleine résolution (pas des miniatures)

C’est un sujet qui rend les gens fous. Tu scrapés un lot de pins, tu télécharges les images, et elles font toutes 236 px et sont minuscules. Sur les forums, les gens décrivent ça comme une « qualité poubelle, vraiment trop petite ». La solution, c’est de comprendre la structure des URL d’images Pinterest.

Comprendre les chemins d’URL des images Pinterest

Toutes les images Pinterest sont servies depuis https://i.pinimg.com/{size}/{hash}.jpg. La partie {size} détermine la résolution :

Fonction utilitaire : convertir n’importe quelle URL Pinterest en pleine résolution

Voici une fonction qui réécrit n’importe quelle URL d’image Pinterest vers la meilleure qualité disponible, avec une logique de repli :

1import requests as req
2def upgrade_image_url(url, preferred_size="originals"):
3    """Réécrit une URL d'image Pinterest vers la meilleure résolution disponible."""
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  # Retourne l'URL d'origine si tout échoue

Note importante (en 2025) : le chemin /originals/ renvoie de plus en plus souvent des erreurs HTTP 403 Forbidden. Un confirme ce comportement à la mi-2025. Le maximum fiable est /736x/. Ma fonction essaie d’abord /originals/, puis bascule automatiquement vers /736x/.

Télécharger les images dans des dossiers organisés

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"  Téléchargé {filename} ({len(resp.content) // 1024} KB)")
17            else:
18                print(f"  Échec {filename} : HTTP {resp.status_code}")
19        except Exception as e:
20            print(f"  Erreur lors du téléchargement de {filename} : {e}")
21        time.sleep(delay + random.uniform(0.3, 0.8))

Ajoute un délai entre les téléchargements. J’utilise 1,5 à 2,3 secondes avec une variation aléatoire. Sans ça, Pinterest bloquera ton IP après quelques centaines de requêtes.

Exporter tes données Pinterest scrapées

Exporter en CSV ou JSON

On a déjà vu l’essentiel plus haut. Pour les jeux de données plus volumineux (plus de 10 000 pins), pense au format JSON Lines — un objet JSON par ligne — plus simple à traiter en flux :

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

Exporter vers Google Sheets, Airtable ou Notion

Si tu veux pousser les données directement depuis Python vers Google Sheets, il te faudra la bibliothèque gspread et un compte de service Google Cloud. Pour Airtable, utilise pyairtable. Pour Notion, notion-client. Chaque option demande une configuration de clé API et ajoute une vraie couche de complexité à ton pipeline.

Ou alors — et je suis un peu biaisé ici, mais c’est franchement la voie la plus rapide — tu peux utiliser pour scraper Pinterest et exporter en un clic vers l’une de ces destinations. Pas de clés API, pas de comptes de service, pas de code en plus. L’ gère l’export nativement.

Conseils pour éviter d’être bloqué lors du scraping de Pinterest

Le système anti-bot de Pinterest est évalué à par ScrapeOps — pas simple, mais pas le plus costaud non plus. Il utilise l’empreinte navigateur, l’analyse comportementale et la limitation par IP. Voici ce qui marche :

• Faire tourner les user agents : utilise un pool de vraies chaînes user agent Chrome et choisis-en une aléatoirement à chaque session.
• Ajouter des délais aléatoires : 2 à 5 secondes entre les scrolls et les requêtes, avec variation. Sans proxy, monte à 10 à 15 secondes.
• Utiliser une fenêtre réaliste : définis viewport={"width": 1920, "height": 1080} — évite les tailles petites ou bizarres.
• Prévoir des proxies à grande échelle : si tu scrapes des milliers de pins, fais tourner des proxies résidentiels. Sans eux, attends-toi à des blocages IP après quelques centaines de requêtes.
• Respecter robots.txt : le robots.txt de Pinterest bloque la plupart des crawlers automatisés et contient . Garde ça en tête côté conformité.
• Éviter le scraping connecté : limite-toi au contenu public, en étant déconnecté. Scraper derrière un login augmente les risques juridiques et techniques.

Thunderbit gère automatiquement les protections anti-bot et les CAPTCHA via son moteur IA — une contrainte de moins à maintenir si tu choisis le no-code.

Considérations légales et éthiques pour le scraping de Pinterest

Je vais faire court, parce que ce n’est pas le cœur de l’article, mais c’est important.

Les conditions d’utilisation de Pinterest (section 2a) précisent que tu acceptes de ne pas « scraper, collecter, rechercher, copier ou accéder autrement aux données ou contenus de Pinterest par des moyens non autorisés, par exemple à l’aide de moyens automatisés (sans notre autorisation écrite préalable) ». Cela dit, les tribunaux ont généralement considéré que le scraping de données publiquement accessibles ne viole pas le Computer Fraud and Abuse Act — voir et Meta v. Bright Data (janvier 2024), où le tribunal a jugé que le scraping de données visibles publiquement en étant déconnecté est légal.

Quelques règles de base :

• Ne scrape que du contenu public, en étant déconnecté
• N’utilise pas les données scrapées pour du spam ou pour usurper des utilisateurs
• Respecte les droits d’auteur sur les images — extrais les métadonnées quand c’est possible, et évite de redistribuer commercialement des images protégées sans autorisation
• Si tu comptes utiliser les données scrapées à des fins commerciales, consulte un avocat

Pour aller plus loin sur le cadre juridique, consulte notre .

Conclusion : ce que tu as appris et la suite

Tu sais maintenant pourquoi le scraping statique échoue sur Pinterest (c’est une SPA React — pas de JavaScript, pas de données), comment utiliser Playwright pour scraper les résultats de recherche, les boards et les profils utilisateurs, comment construire un gestionnaire de défilement infini prêt pour la production qui ne s’arrête pas après 16 pins, et comment obtenir des images en pleine résolution au lieu de minuscules miniatures.

Récapitulatif rapide de l’essentiel :

• requests + BeautifulSoup ne fonctionnera pas sur Pinterest. Ne perds pas ton temps là-dessus.
• Playwright est le meilleur outil Python pour cette tâche — rapide, bien maintenu et capable de gérer le rendu JavaScript nativement.
• Le défilement infini demande une boucle basée sur la déduplication, pas un nombre fixe de scrolls.
• Les images en haute résolution nécessitent une réécriture de l’URL — vise /736x/ (car /originals/ renvoie souvent des 403).
• Le scraping des boards et profils est peu couvert dans les tutoriels existants, mais reste simple avec les bons sélecteurs.
• Pour les non-développeurs ou les équipes qui veulent aller vite, permet de scraper Pinterest en 2 clics et d’exporter vers Google Sheets, Excel, Airtable ou Notion — sans Python. Essaie gratuitement via l’.

Si tu construis un pipeline Python, le code de ce guide te donne une base solide. Si tu as juste besoin des données, Thunderbit est le raccourci. Dans tous les cas, tu n’es plus bloqué avec 16 pins et une tête dépitée.

Pour aller plus loin sur le scraping et l’extraction de données, consulte nos guides sur , et . Tu peux aussi découvrir ou regarder des tutoriels sur la .

FAQ

1. Peut-on scraper Pinterest avec BeautifulSoup ?

Pas efficacement tout seul. Pinterest rend tout son contenu via JavaScript, donc requests + BeautifulSoup ne voit qu’une coquille HTML vide. Tu as besoin d’un navigateur headless comme Playwright ou Selenium pour rendre la page, ou alors d’un outil no-code comme Thunderbit qui gère automatiquement le rendu JS.

2. Combien de pins peut-on scraper sur Pinterest en une session ?

Ça dépend de ta logique de scroll et de ta gestion anti-bot. Avec le gestionnaire de défilement infini prêt pour la production présenté dans ce guide (déduplication, timeout, logique de reprise), tu peux scraper de façon fiable des centaines à des milliers de pins par board ou par requête. Pour les très grands boards, compte plusieurs minutes de défilement et de collecte.

3. Pourquoi mes images Pinterest scrapées sont-elles minuscules ?

Par défaut, Pinterest sert des miniatures /236x/ dans la vue grille. Pour obtenir une meilleure résolution, réécris le chemin de l’URL de l’image vers /736x/ ou /originals/. Note que /originals/ renvoie de plus en plus souvent des erreurs 403 en 2025, donc /736x/ est la limite fiable.

4. Est-il légal de scraper Pinterest ?

Le scraping de données publiquement accessibles est généralement accepté par les décisions de justice récentes (par exemple hiQ v. LinkedIn, Meta v. Bright Data), mais les Conditions d’utilisation de Pinterest interdisent l’accès automatisé non autorisé. Limite-toi au contenu public, n’utilise pas les données pour spammer, respecte les droits d’auteur et demande un avis juridique pour les usages commerciaux.

5. Quelle est la meilleure alternative no-code pour scraper Pinterest ?

peut extraire les données des pins Pinterest — titres, images, URL, descriptions — en 2 clics, avec export intégré vers Google Sheets, Excel, Airtable ou Notion. Il gère automatiquement le rendu JavaScript, le défilement infini et les défis anti-bot, sans que tu aies à écrire ou maintenir du code.

En savoir plus