Python Pinterest-scraping: "Pins, borden & eindeloos scrollen"

Een paar maanden geleden liet een van onze engineers me een Python-script zien waar hij in het weekend aan had gewerkt. Het was bedoeld om inspirerende productafbeeldingen van Pinterest te halen voor een marktonderzoek. Hij draaide het script, en het resultaat was… 16 pins. Uit een bord met meer dan 2.000. Hij staarde naar zijn scherm, daarna naar mij, en zei: "Ik denk dat Pinterest me uitlacht."

Hij is niet de enige. Dit is zonder twijfel de meest voorkomende frustratie die ik zie bij developers die Pinterest met Python proberen te scrapen. Je start requests en BeautifulSoup, opent een Pinterest-URL, en krijgt vervolgens maar een handjevol items terug — of alleen een lege HTML-schaal. Waarom? Pinterest is een volledig via JavaScript gerenderde single-page app; je statische HTTP-verzoek ziet nooit de echte content. In deze gids leg ik uit waarom dat gebeurt, welke aanpakken echt werken (Playwright, het onderscheppen van de interne API en no-code tools zoals ), en geef ik je stap-voor-stap code om pins, borden, gebruikersprofielen, infinite scroll en afbeeldingen in volledige resolutie te scrapen. Of je nu een scraper van productieniveau wilt bouwen of gewoon snel data wilt ophalen, dit artikel helpt je op weg.

Wat is Pinterest-scraping?

Pinterest-scraping is het geautomatiseerd ophalen van data van Pinterest — denk aan pin-afbeeldingen, titels, beschrijvingen, bordnamen, volgersaantallen en URL’s. In plaats van handmatig door pins te bladeren en ze één voor één op te slaan, gebruik je code (of een tool) om gestructureerde data op schaal te verzamelen uit zoekresultaten, borden of gebruikersprofielen.

Met op het platform en eind 2025 is Pinterest een van de rijkste visuele databronnen op het web. Voor bedrijven is die data goud waard — of je nu producttrends volgt, content van concurrenten vergelijkt of lijsten opbouwt voor influencer outreach.

Waarom Pinterest scrapen met Python?

Pinterest is allang niet meer alleen een moodboard voor weddingplanners. Het is een serieus business-intelligenceplatform — heeft iets gekocht op basis van merkpins, en . Gebruikers komen dus met koopintentie, maar zonder sterke merkloyaliteit. Dat biedt enorme kansen voor discovery — en verklaart waarom zoveel teams gestructureerde Pinterest-data willen hebben.

Zo valt dat uiteen per team:

En hier zit de crux: Pinterest’s officiële API is beperkt. Je hebt een zakelijk account nodig, goedkeuring (inclusief een videodemo van je app), en je krijgt alleen toegang tot data van je eigen account. Wil je publieke borden, zoekresultaten of profielen van concurrenten bekijken, dan is scrapen de praktische optie. Daarom stappen zoveel teams over op Python — of op no-code tools zoals Thunderbit als ze resultaat willen zonder gedoe met setup.

Waarom BeautifulSoup alleen faalt op Pinterest (en wat wel werkt)

Als je Pinterest hebt proberen te scrapen met requests + BeautifulSoup en slechts 16 items of een lege pagina terugkreeg, beeld je het je niet in. Pinterest is gebouwd met React en rendert 100% van de content via JavaScript. Wanneer je een Pinterest-URL met een simpele HTTP-request ophaalt, krijg je van de server alleen een minimale HTML-skeletversie — een paar <link>- en <script>-tags, plus een lege <div> waarin React de app mount. Alle pin-kaarten, afbeeldingen, titels en rasterindelingen worden pas toegevoegd nadat JavaScript in de browser is uitgevoerd.

Geen JavaScript-uitvoering = geen pins.

Dus wat werkt dan wel? Dit is hoe de belangrijkste opties zich verhouden:

Voor deze tutorial raad ik Playwright aan als Python-aanpak. Het rendert JavaScript, ondersteunt scroll-simulatie, wordt goed onderhouden (, met een groei van in vacatures) en is in benchmarks . Wil je liever zonder code werken, dan behandel ik die route ook.

Pinterest officiële API vs. Python-scraping vs. no-code: welke route kies je?

Voordat je begint met coderen, is het de moeite waard om jezelf af te vragen: heb je dat eigenlijk wel nodig? Hier is een besliskader:

Ben je marketeer, werk je in e-commerce operations, of wil je gewoon Pinterest-data in een spreadsheet zonder Python-scripts te schrijven of te onderhouden? Dan is de snelle route. Je opent elke Pinterest-pagina, klikt op "AI Suggest Fields", drukt op "Scrape" en exporteert direct naar Google Sheets, Excel, Airtable of Notion. De subpagina-scrapingfunctie kan zelfs individuele pinlinks volgen om data automatisch aan te vullen. Ik heb teamleden die nog nooit één regel code hadden geschreven, in minder dan drie minuten meer dan 500 pins in een Google Sheet zien zetten.

Voor lezers die volledige controle willen, scraping willen integreren in een Python-pijplijn, of gewoon genieten van het bouwen: lees vooral verder.

Je Python-omgeving instellen voor Pinterest-scraping

• Moeilijkheidsgraad: Gemiddeld
• Benodigde tijd: ~30–60 minuten (inclusief coderen en testen)
• Wat je nodig hebt: Python 3.9+, Chrome-browser (voor testen), terminal-/commandline-toegang

Playwright en afhankelijkheden installeren

Maak eerst een projectmap aan en zet een virtuele omgeving op:

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

Installeer Playwright en download de Chromium-browserbinary:

1pip install playwright
2playwright install chromium

Je gebruikt daarnaast Python’s ingebouwde modules json, os en csv voor data-export. Voor die modules hoef je niets extra’s te installeren.

Structuur van de projectmap

Ik raad aan om vanaf het begin alles netjes te organiseren:

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/

Zet in config.py je user-agentstring. Pinterest blokkeert standaard headless browser-signatures, dus gebruik een realistische variant:

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"

Stap 1: Bouw de Pinterest-zoek-URL

Stel de zoek-URL samen door je zoekterm in het sjabloon te plaatsen:

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

Je kunt dit parametriseren voor elke zoekterm. De parameter rs=typed vertelt Pinterest dat de zoekterm is getypt (en niet voorgesteld), wat soms de relevantie van de resultaten beïnvloedt.

Stap 2: Start een headless browser en laad de pagina

Hier is de kernopzet met Playwright. Let op de aangepaste user-agent — zonder die instelling blokkeert Pinterest je waarschijnlijk of krijg je een login-scherm te zien.

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)  # Wacht tot JavaScript de eerste pins heeft gerenderd

Na dit stukje zou de pagina de eerste batch pins geladen moeten hebben — meestal 25–50.

Stap 3: Haal pin-data uit de pagina

Pinterest verpakt elke pin in een div met data-test-id='pinWrapper'. Daarbinnen vind je een link (<a>) met de pin-URL en titel (via aria-label), en een <img> met de thumbnail-URL.

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

Op dit punt bevat results de pins die in de initiële viewport zichtbaar zijn. Om meer te krijgen moet je scrollen — en dat is meteen het belangrijkste onderdeel.

Stap 4: Sla de resultaten op als JSON of CSV

Na het extraheren kun je je data wegschrijven naar bestanden voor later gebruik:

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)

Gebruik voor CSV utf-8-sig als je het bestand in Excel wilt openen — dat voorkomt rare tekens.

Hele Pinterest-borden en gebruikersprofielen scrapen

Dit is een grote inhoudelijke leemte in bestaande tutorials. Ik kon geen enkele concurrerende gids vinden die board- of profile-scraping echt diepgaand behandelt — terwijl dit juist een van de meest gevraagde functies is in forums. Gebruikers willen alle pins van een bord downloaden, afbeeldingen per bord in mappen ordenen en profieldata ophalen zoals volgersaantallen en lijsten met borden.

Alle pins van een bord-URL scrapen

Board-URL’s volgen meestal dit patroon: https://www.pinterest.com/{username}/{board-name}/. De DOM-structuur lijkt op zoekresultaten — pins zijn verpakt in div[data-test-id='pinWrapper'] — maar je moet wel scrollen om alles te laden.

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):  # Veiligheidslimiet
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)} unieke pins verzameld")
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  # Geen verdere content
38        await browser.close()
39        return all_pins

Let op één ding: op board-pagina’s plaatst Pinterest soms een sectie "More Ideas" die opgeslagen pins scheidt van algoritmische aanbevelingen. Wil je alleen de daadwerkelijk opgeslagen pins van de gebruiker, stop dan met scrollen zodra je die scheiding tegenkomt.

Een gebruikersprofiel scrapen: borden, volgersaantal en pins

Profiel-URL’s zien er zo uit: https://www.pinterest.com/{username}/. Vanuit een profielpagina kun je het volgende extraheren:

• Volgers-/volgingen-aantallen: Zoek naar div[data-test-id='follower-count']
• Bordenlijst: Elk bord is een kaart die linkt naar /{username}/{board-name}/
• Totaal aantal pins: Wordt soms getoond in de profielheader

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        # Volgersaantal ophalen
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        # Bordlinks ophalen
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}

Om alle pins van elk bord op een profiel te scrapen, loop je door de bordenlijst heen en roep je voor elk bord scrape_board() aan. Zo kun je gedownloade afbeeldingen automatisch in mappen per bord ordenen.

Een productieklare infinite-scroll-handler bouwen

Dit is het deel dat een speelgoed-scraper onderscheidt van een echte scraper. Het grootste pijnpunt — en ik heb het in zeker een dozijn forumberichten gezien — is dat scrapers maar 16–25 items teruggeven omdat ze niet ver genoeg scrollen, of omdat ze een vaste scrollteller gebruiken zoals for i in range(5): scroll() en dan maar hopen op het beste.

Die aanpak is onbetrouwbaar. Pinterest laadt nieuwe content in batches van ongeveer 25 pins, getriggerd door scroll-events. Als je vijf keer scrolt, krijg je misschien 125 pins — of 75 als het netwerk traag is, of 150 als de batches kleiner zijn. Je hebt een slimmer patroon nodig.

Het patroon: scrollen tot er geen nieuwe content meer komt

Hier is een robuuste scrollfunctie die unieke pin-ID’s bijhoudt, een instelbare timeout gebruikt, retry-logica bevat en voortgang print:

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} nieuwe pins | {len(all_pins)} unieke pins totaal")
28        if len(all_pins) >= max_pins:
29            print(f"  max_pins-limiet bereikt ({max_pins}). Stoppen.")
30            break
31        if new_this_round == 0:
32            no_new_count += 1
33            if no_new_count >= 3:
34                print("  Geen nieuwe pins na 3 opeenvolgende scrolls. Einde van de content.")
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("  Paginahoogte ongewijzigd en geen nieuwe pins. Waarschijnlijk einde van de feed.")
44            break
45    return all_pins

Waarom dit werkt:

• Deduplicatie op basis van href: De URL van elke pin is uniek, dus we gebruiken die als ID. Zo tel je dezelfde pin niet twee keer mee wanneer de DOM tijdens het scrollen opnieuw wordt opgebouwd.
• Regel van drie keer nul: Als drie opeenvolgende scrolls geen nieuwe pins opleveren, stoppen we. Dat vangt gevallen op waarin de pagina nog laadt maar er geen nieuwe content meer is.
• Willekeurige jitter in pauzes: Een random vertraging van 0,5–1,5 seconde tussen scrolls laat het gedrag menselijker lijken en verkleint de kans op anti-botmaatregelen.
• Veiligheidslimiet voor max_scrolls: Voorkomt oneindige loops als er iets misgaat.

Randgevallen afhandelen

• Onderbreking door "More Ideas": Op board-pagina’s voegt Pinterest soms een sectie "More Ideas" in. Wil je alleen de echte pins van het bord, dan kun je op dat element controleren en stoppen met scrollen zodra het verschijnt.
• Rate limiting bij lange sessies: Als je door een bord met duizenden pins scrolt, kan Pinterest beginnen met het afknijpen van responses. Merk je dat scrolls af en toe geen nieuwe pins opleveren (maar niet drie keer achter elkaar), verhoog dan je scrollpauze naar 5+ seconden.

Afbeeldingen in volledige resolutie ophalen van Pinterest

Dit frustreert mensen enorm. Je scrapt een hoop pins, downloadt de afbeeldingen en ze blijken allemaal kleine thumbnails van 236 px te zijn. Op forums wordt dat beschreven als "trash quality, like too small size". De oplossing is inzicht krijgen in de URL-structuur van Pinterest-afbeeldingen.

De Pinterest-afbeeldings-URL’s begrijpen

Alle Pinterest-afbeeldingen worden geleverd via https://i.pinimg.com/{size}/{hash}.jpg. Het gedeelte {size} bepaalt de resolutie:

Hulpfunctie: upgrade elke Pinterest-afbeeldings-URL naar volledige resolutie

Hier is een functie die elke Pinterest-afbeeldings-URL herschrijft naar de hoogst beschikbare kwaliteit, met fallback-logica:

1import requests as req
2def upgrade_image_url(url, preferred_size="originals"):
3    """Herschrijf een Pinterest-afbeeldings-URL naar de hoogste beschikbare resolutie."""
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  # Geef de originele URL terug als alles faalt

Belangrijke opmerking (per 2025): Het pad /originals/ geeft steeds vaker HTTP 403 Forbidden-fouten terug. Een bevestigt dit gedrag halverwege 2025. De betrouwbare bovengrens is /736x/. Mijn functie probeert eerst /originals/ en valt daarna automatisch terug op /736x/.

Afbeeldingen downloaden naar georganiseerde mappen

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"  {filename} gedownload ({len(resp.content) // 1024} KB)")
17            else:
18                print(f"  Mislukt {filename}: HTTP {resp.status_code}")
19        except Exception as e:
20            print(f"  Fout bij downloaden van {filename}: {e}")
21        time.sleep(delay + random.uniform(0.3, 0.8))

Voeg een pauze toe tussen downloads. Ik gebruik 1,5–2,3 seconden met jitter. Zonder die vertraging blokkeert Pinterest je IP na een paar honderd verzoeken.

Je Pinterest-data exporteren

Exporteren naar CSV of JSON

De basis hebben we al behandeld. Voor grotere datasets (10.000+ pins) kun je beter JSON Lines gebruiken — één JSON-object per regel — omdat dat makkelijker te streamen en verwerken is:

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

Exporteren naar Google Sheets, Airtable of Notion

Als je data rechtstreeks vanuit Python naar Google Sheets wilt sturen, heb je de gspread-bibliotheek en een Google Cloud service-account nodig. Voor Airtable gebruik je pyairtable. Voor Notion heb je notion-client nodig. Voor elk van deze opties moet je API-keys instellen en dat maakt je pipeline echt een stuk complexer.

Of — en ik ben hier misschien bevooroordeeld, maar dit is echt de snelste route — je gebruikt om Pinterest te scrapen en de data met één klik naar een van deze bestemmingen te exporteren. Geen API-keys, geen service-accounts, geen extra code. De regelt de export standaard.

Tips om geblokkeerd te worden tijdens Pinterest-scraping te vermijden

Pinterest’s anti-botsysteem krijgt van ScrapeOps een — niet triviaal, maar ook niet het moeilijkste doelwit. Het gebruikt browser fingerprinting, gedragsanalyse en IP-gebaseerde rate limiting. Dit werkt meestal:

• Roteer user agents: Gebruik een pool van echte Chrome user-agentstrings en kies er per sessie willekeurig één.
• Voeg willekeurige vertragingen toe: 2–5 seconden tussen scrolls en requests, met jitter. Zonder proxies kun je beter 10–15 seconden aanhouden.
• Gebruik een realistische viewport: Stel viewport={"width": 1920, "height": 1080} in — gebruik geen piepkleine of vreemde afmetingen.
• Overweeg proxies op schaal: Scrape je duizenden pins, roteer dan residential proxies. Zonder proxies kun je na een paar honderd verzoeken IP-blokkades verwachten.
• Respecteer robots.txt: Pinterest’s robots.txt blokkeert de meeste geautomatiseerde crawlers en bevat . Houd daar rekening mee voor compliance.
• Vermijd scraping terwijl je bent ingelogd: Blijf bij publiek zichtbare content terwijl je uitgelogd bent. Scrapen achter een login brengt zowel juridische als technische risico’s met zich mee.

Thunderbit handelt anti-bot- en CAPTCHA-uitdagingen automatisch af via zijn AI-engine — één zorg minder als je voor de no-code route kiest.

Juridische en ethische overwegingen bij Pinterest-scraping

Ik houd dit kort, omdat het niet de kern van het artikel is, maar het is wel belangrijk.

Pinterest’s Servicevoorwaarden (sectie 2a) stellen dat je ermee akkoord gaat om data of content van Pinterest niet te "scrapen, verzamelen, doorzoeken, kopiëren of anderszins te benaderen op onbevoegde manieren, bijvoorbeeld met geautomatiseerde middelen (zonder onze uitdrukkelijke voorafgaande toestemming)." Tegelijkertijd hebben rechtbanken in het algemeen geoordeeld dat het scrapen van publiek beschikbare data niet in strijd is met de Computer Fraud and Abuse Act — zie en Meta v. Bright Data (jan. 2024), waarin de rechter oordeelde dat het scrapen van publiek zichtbare data terwijl je bent uitgelogd legaal is.

Een paar basisregels:

• Scrape alleen publiek zichtbare content terwijl je bent uitgelogd
• Gebruik gescrapete data niet voor spam of om gebruikers te imiteren
• Respecteer auteursrecht op afbeeldingen — haal waar mogelijk metadata op en verspreid auteursrechtelijk beschermde afbeeldingen niet commercieel zonder toestemming
• Als je de data commercieel wilt gebruiken, overleg dan met een jurist

Voor een diepere blik op het juridische landschap, bekijk onze .

Afsluiting: wat je hebt geleerd en wat de volgende stap is

Je weet nu waarom statisch scrapen op Pinterest faalt (het is een React SPA — geen JavaScript, geen data), hoe je Playwright gebruikt om zoekresultaten, borden en gebruikersprofielen te scrapen, hoe je een productieklare infinite-scroll-handler bouwt die niet na 16 pins opgeeft, en hoe je afbeeldingen in volledige resolutie krijgt in plaats van piepkleine thumbnails.

Korte samenvatting van de belangrijkste punten:

• requests + BeautifulSoup werkt niet op Pinterest. Verspil er geen tijd aan.
• Playwright is de beste Python-tool voor deze klus — snel, goed ondersteund en rendert JavaScript native.
• Infinite scroll vereist een scroll-loop op basis van deduplicatie, niet een vast aantal herhalingen.
• Afbeeldingen in volledige resolutie vragen om herschrijven van de URL-structuur — kies /736x/ (aangezien /originals/ vaak 403 geeft).
• Scraping van borden en profielen wordt in bestaande tutorials vaak onderbelicht, maar is met de juiste selectors gewoon goed te doen.
• Voor niet-coders of teams die snelheid willen, laat je Pinterest in 2 klikken scrapen en exporteer naar Google Sheets, Excel, Airtable of Notion — Python is niet nodig. Probeer gratis via de .

Bouw je een Python-pijplijn, dan vormt de code in deze gids een stevige basis. Heb je alleen de data nodig, dan is Thunderbit de kortste weg. Hoe dan ook: je zit niet langer vast aan 16 pins en een lege blik.

Voor meer informatie over scraping en data-extractie, bekijk onze gidsen over , en . Je kunt ook bekijken of tutorials volgen op het .

FAQ’s

1. Kun je Pinterest scrapen met BeautifulSoup?

Niet echt effectief op zichzelf. Pinterest rendert alle content via JavaScript, dus requests + BeautifulSoup ziet alleen een lege HTML-schaal. Je hebt eerst een headless browser zoals Playwright of Selenium nodig om de pagina te renderen, of je gebruikt een no-code tool zoals Thunderbit die JS-rendering automatisch afhandelt.

2. Hoeveel pins kun je in één sessie van Pinterest scrapen?

Dat hangt af van je scroll-logica en anti-botafhandeling. Met de productieklare infinite-scroll-handler uit deze gids (deduplicatie, timeout, retry-logica) kun je betrouwbaar honderden tot duizenden pins per bord of zoekopdracht scrapen. Voor heel grote borden moet je rekening houden met enkele minuten scrollen en verzamelen.

3. Waarom zijn mijn gescrapete Pinterest-afbeeldingen zo klein?

Standaard levert Pinterest in de rasterweergave /236x/ thumbnails. Voor hogere resolutie herschrijf je het afbeeldingspad naar /736x/ of /originals/. Let op: /originals/ geeft in 2025 steeds vaker 403-fouten, dus /736x/ is de betrouwbare bovengrens.

4. Is het legaal om Pinterest te scrapen?

Het scrapen van publiek beschikbare data wordt in recente rechterlijke uitspraken doorgaans geaccepteerd (bijv. hiQ v. LinkedIn, Meta v. Bright Data), maar Pinterest’s Servicevoorwaarden verbieden onbevoegde geautomatiseerde toegang. Houd het bij openbare content, gebruik gescrapete data niet voor spam, respecteer auteursrechten en raadpleeg juridisch advies voor commerciële toepassingen.

5. Wat is het beste no-code alternatief om Pinterest te scrapen?

kan Pinterest-pin-data — titels, afbeeldingen, URL’s, beschrijvingen — in 2 klikken ophalen, met ingebouwde export naar Google Sheets, Excel, Airtable of Notion. Het verwerkt JavaScript-rendering, infinite scroll en anti-bot-uitdagingen automatisch, dus je hoeft geen code te schrijven of te onderhouden.

Meer lezen