Python Pinterest-skraping: "Pins, tavler og uendelig scrolling"

For noen måneder siden viste en av utviklerne våre meg et Python-skript han hadde laget i helgen. Det skulle hente produktinspirasjonsbilder fra Pinterest til et markedsundersøkelsesprosjekt. Han kjørte det, og resultatet var … 16 pins. Fra en tavle med over 2 000. Han stirret på skjermen, så på meg, og sa: «Jeg tror Pinterest gjør narr av meg.»

Han er langt fra alene. Dette er uten tvil den vanligste frustrasjonen jeg ser hos utviklere som prøver å skrape Pinterest med Python. Du fyrer opp requests og BeautifulSoup, går til en Pinterest-URL, og får enten bare noen få elementer eller et tomt HTML-skall tilbake. Hvorfor? Pinterest er en fullverdig JavaScript-renderet single-page app — en statisk HTTP-forespørsel ser aldri det ekte innholdet. I denne guiden forklarer jeg hvorfor det skjer, hvilke metoder som faktisk fungerer (Playwright, intercept av intern API og no-code-verktøy som Thunderbit), og gir deg trinn-for-trinn-kode for å skrape pins, tavler, brukerprofiler, uendelig scrolling og bilder i full oppløsning. Enten du vil bygge en produksjonsklar scraper eller bare trenger data raskt, har denne artikkelen det du trenger.

Hva er Pinterest-skraping?

Pinterest-skraping er prosessen med å hente data fra Pinterest programmatisk — for eksempel pin-bilder, titler, beskrivelser, tavlenavn, følgertall og URL-er. I stedet for å bla manuelt og lagre én og én pin, bruker du kode (eller et verktøy) til å samle strukturert data fra søkeresultater, tavler eller brukerprofiler i stor skala.

Med over 240 milliarder Pins på plattformen og 619 millioner månedlige aktive brukere per slutten av 2025, er Pinterest en av de rikeste visuelle datakildene på nettet. For bedrifter er den typen data gull verdt — enten du følger produkttrender, sammenligner konkurrentinnhold eller bygger lister for influencer-oppfølging.

Hvorfor skrape Pinterest med Python?

Pinterest er ikke lenger bare en inspirasjonstavle for bryllupsplanleggere. Det er en seriøs plattform for forretningsinnsikt — 85% av ukentlige Pinners har kjøpt noe basert på merkevare-Pins, og 96–97% av de mest populære søkene er uten merkevare, noe som betyr at brukerne kommer med en intensjon, men uten lojalitet til et bestemt merke. Det gir en enorm mulighet til å bli oppdaget — og forklarer hvorfor så mange team ønsker strukturert Pinterest-data.

Slik ser det ut for ulike team:

Team	Data som trengs	Forretningsverdi
E-handel / drift	Produktbilder, priser, trendestetikk	Konkurransedyktig prissetting, lagerstyring basert på trender
Markedsføring	Tavleytelse, pin-engasjement, konkurrentinnhold	Innholdsstrategi, kampanjebenchmarking
Salg / lead-generering	Skaperprofiler, følgertall, kontaktinformasjon	Influencer-arbeid, partnerutvelgelse
Eiendom	Pins for styling av hjem, interiørtrender, romoppsett	Foto til boligannonser, stylingveiledning
Innholdsskapere	Trendende temaer, populære formater, sesongtemaer	Innholdskalender, research på visuell stil

Og her er den store forskjellen: Pinterest sitt offisielle API er begrenset. Det krever bedriftskonto, godkjenning (inkludert en videodemonstrasjon av appen din), og gir deg kun tilgang til data fra din egen konto. Hvis du vil se offentlige tavler, søkeresultater eller konkurrentprofiler, er skraping det praktiske alternativet. Derfor velger så mange Python — eller no-code-verktøy som Thunderbit når de vil ha resultater uten oppsett.

Hvorfor BeautifulSoup alene feiler på Pinterest (og hva som faktisk fungerer)

Hvis du har prøvd å skrape Pinterest med requests + BeautifulSoup og fått 16 elementer eller en tom side, innbiller du deg ikke ting. Pinterest er bygget med React og renderer 100% av innholdet via JavaScript. Når du henter en Pinterest-URL med en vanlig HTTP-forespørsel, sender serveren bare et minimalt HTML-skall — noen få <link>- og <script>-tags, og en tom <div> der React monterer appen. Alle pin-kort, bilder, titler og rutenett legges inn først etter at JavaScript har kjørt i nettleseren.

Ingen JavaScript-kjøring = ingen pins.

Så hva fungerer? Slik sammenlignes de viktigste metodene:

Tilnærming	Håndterer JS?	Får med all data?	Kompleksitet	Best for
`requests` + BeautifulSoup	Nei	~0–16 elementer	Lav	Ikke egnet for Pinterest
Selenium / Playwright	Ja	Ja, med scroll-logikk	Middels	Full kontroll, Python-pipelines
Intercept av intern Pinterest-API	Ja	Ja, paginert JSON	Høy	Maksimal datamengde, uten nettleser
Tredjeparts Scraper API	Ja	Varierer	Lav	Skalering uten infrastruktur
No-code-verktøy (Thunderbit)	Ja	AI-strukturert	Svært lav	Ikke-tekniske brukere, raske resultater

I denne guiden anbefaler jeg Playwright som Python-løsning. Den renderer JavaScript, støtter simulering av scrolling, vedlikeholdes godt (78 600+ GitHub-stjerner, med 180% vekst år over år i stillingsannonser), og er 35–45% raskere enn Selenium i benchmark-tester. Hvis du vil ha no-code-veien, tar jeg det også med.

Pinterest offisielle API vs. Python-skraping vs. no-code: hvilken vei bør du velge?

Før du begynner å skrive kode, er det verdt å spørre: trenger du egentlig det? Her er en enkel beslutningsmodell:

Kriterium	Pinterest API	Python-skraping	Thunderbit (no-code)
Godkjenning kreves	Bedriftskonto + videodemonstrasjon	Nei	Nei
Tilgang til offentlige pins/tavler	Begrenset (kun egne data)	Full	Full
Nedlasting av bilder i full oppløsning	Varierer	Ja, med parsing av URL	Ja, via bildeframskaffing
Håndterer uendelig scrolling	N/A	Ja, med kode	Automatisk
Vedlikehold nødvendig	Lavt	Høyt (selektorer kan slutte å virke)	Ingen (AI tilpasser seg)
Eksport til Sheets/Airtable	Manuelt	Egendefinert kode	Innebygd
Oppsettstid	Timer–dager	30–60 min	2 minutter

Hvis du er markedsfører, jobber med e-handel, eller bare vil ha Pinterest-data inn i et regneark uten å skrive eller vedlikeholde Python-skript, er Thunderbit's AI Web Scraper den raskeste veien. Du åpner en hvilken som helst Pinterest-side, klikker «AI Suggest Fields», trykker «Scrape», og eksporterer direkte til Google Sheets, Excel, Airtable eller Notion. Funksjonen for skraping av undersider kan til og med følge individuelle pin-lenker for å berike data automatisk. Jeg har sett teammedlemmer som aldri har skrevet en linje kode, hente 500+ pins inn i et Google Sheet på under tre minutter.

For lesere som vil ha full kontroll, vil integrere skraping i en Python-pipeline, eller bare liker å bygge ting selv — fortsett å lese.

Slik setter du opp Python-miljøet for Pinterest-skraping

Vanskelighetsgrad: Middels
Tidsbruk: Ca. 30–60 minutter (inkludert koding og testing)
Du trenger: Python 3.9+, Chrome-nettleser (for testing), tilgang til terminal/kommandolinje

Installer Playwright og avhengigheter

Først lager du en prosjektmappe og setter opp et virtuelt miljø:

mkdir pinterest-scraper
cd pinterest-scraper
python -m venv venv
source venv/bin/activate  # På Windows: venv\Scripts\activate

Installer Playwright og last ned Chromium-nettleseren:

pip install playwright
playwright install chromium

Du bruker også Python sine innebygde moduler json, os og csv for eksport av data. Ingen ekstra installasjon trengs for dem.

Struktur for prosjektmappen

Jeg anbefaler å holde det ryddig fra starten:

pinterest-scraper/
├── scraper.py
├── config.py
├── output/
│   ├── pins.json
│   └── pins.csv
└── images/
    ├── board-name-1/
    └── board-name-2/

I config.py setter du user agent-strengen din. Pinterest blokkerer standard signaturer fra headless-nettlesere, så bruk en realistisk en:

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

Steg 1: Bygg Pinterest-søke-URL-en

Konstruer søke-URL-en ved å sette inn søket ditt i malen:

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

Du kan gjøre dette parametrisk for hvilket som helst søk. Parameteren rs=typed forteller Pinterest at spørsmålet ble skrevet inn manuelt (ikke foreslått), noe som av og til påvirker relevansen i resultatene.

Steg 2: Start en headless nettleser og last inn siden

Her er kjernen i Playwright-oppsettet. Legg merke til den tilpassede user agent-en — uten den vil Pinterest sannsynligvis blokkere deg eller vise en innloggingsmur.

import asyncio
from playwright.async_api import async_playwright
from config import USER_AGENT

async def scrape_search(query, max_pins=100):
    url = f"https://www.pinterest.com/search/pins/?q={query.replace(' ', '%20')}&rs=typed"
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(
            user_agent=USER_AGENT,
            viewport={"width": 1920, "height": 1080}
        )
        await page.goto(url)
        await asyncio.sleep(3)  # Vent til JS har rendret de første pinnene

Etter at dette kjører, bør siden ha den første batchen med pins lastet inn — vanligvis 25–50.

Steg 3: Trekk ut pin-data fra siden

Pinterest pakker hver pin inn i en div med data-test-id='pinWrapper'. Inni finner du en lenke (<a>) med pin-URL og tittel (via aria-label), samt et <img>-element med miniatyrbildets URL.

        results = []
        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
        for pin in pins:
            link = await pin.query_selector("a")
            if not link:
                continue
            title = await link.get_attribute("aria-label") or ""
            href = await link.get_attribute("href") or ""
            img = await pin.query_selector("img")
            src = await img.get_attribute("src") if img else ""
            results.append({
                "title": title,
                "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
                "image_url": src
            })

På dette punktet inneholder results pinnene som er synlige i første visning. For å hente flere må du scrolle — og det er her den viktigste delen kommer.

Steg 4: Lagre resultatene til JSON eller CSV

Etter uthenting skriver du dataene til filer for enkel bruk:

import json
import csv

def save_json(data, filepath="output/pins.json"):
    with open(filepath, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

def save_csv(data, filepath="output/pins.csv"):
    if not data:
        return
    with open(filepath, "w", newline="", encoding="utf-8-sig") as f:
        writer = csv.DictWriter(f, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)

Bruk utf-8-sig for CSV hvis du planlegger å åpne filen i Excel — det hindrer rare tegn i å bli ødelagt.

Slik skraper du hele Pinterest-tavler og brukerprofiler

Dette er et stort hull i mange eksisterende guider. Jeg klarte ikke å finne én eneste konkurrerende guide som går grundig gjennom skraping av tavler eller profiler — likevel er dette blant de mest etterspurte funksjonene i forumene. Brukere vil laste ned alle pins fra en tavle, organisere bilder i mapper per tavle og hente profildata som følgertall og tavlelister.

Skrap alle pins fra en tavle-URL

Tavle-URL-er følger mønsteret https://www.pinterest.com/{username}/{board-name}/. DOM-strukturen ligner søkeresultatene — pins ligger i div[data-test-id='pinWrapper'] — men du må scrolle for å laste inn alt.

async def scrape_board(board_url, max_pins=500):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
        await page.goto(board_url)
        await asyncio.sleep(3)

        seen_ids = set()
        all_pins = []

        for scroll_round in range(100):  # Sikkerhetsgrense
            pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
            new_count = 0
            for pin in pins:
                link = await pin.query_selector("a")
                if not link:
                    continue
                href = await link.get_attribute("href") or ""
                if href in seen_ids:
                    continue
                seen_ids.add(href)
                new_count += 1
                title = await link.get_attribute("aria-label") or ""
                img = await link.query_selector("img")
                src = await img.get_attribute("src") if img else ""
                all_pins.append({
                    "title": title,
                    "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
                    "image_url": src
                })

            print(f"Scroll {scroll_round + 1}: {len(all_pins)} unike pins samlet")
            if new_count == 0 or len(all_pins) >= max_pins:
                break

            prev_height = await page.evaluate("document.body.scrollHeight")
            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
            await asyncio.sleep(2.5)
            curr_height = await page.evaluate("document.body.scrollHeight")
            if curr_height == prev_height:
                break  # Ingen mer innhold

        await browser.close()
        return all_pins

Én ting å passe på: Tavlesider har noen ganger en «More Ideas»-fane som skiller lagrede pins fra algoritmiske anbefalinger. Hvis du bare vil ha brukerens faktiske lagrede pins, bør du stoppe scrollingen når du møter den skiljelinjen.

Skrap en brukerprofil: tavler, følgertall og pins

Profil-URL-er ser ut som https://www.pinterest.com/{username}/. Fra en profilside kan du hente ut:

Følger-/følgertall: Se etter div[data-test-id='follower-count']
Liste over tavler: Hver tavle er et kort som lenker til /{username}/{board-name}/
Totalt antall pins: Vises noen ganger i profilhodet

async def scrape_profile(username):
    url = f"https://www.pinterest.com/{username}/"
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
        await page.goto(url)
        await asyncio.sleep(3)

        # Hent følgertall
        follower_el = await page.query_selector("div[data-test-id='follower-count']")
        followers = await follower_el.inner_text() if follower_el else "N/A"

        # Hent lenker til tavler
        board_links = await page.query_selector_all("a[href*='/" + username + "/']")
        boards = []
        for bl in board_links:
            href = await bl.get_attribute("href") or ""
            name = await bl.get_attribute("aria-label") or href.split("/")[-2]
            if href.count("/") >= 3 and href != f"/{username}/":
                boards.append({"name": name, "url": f"https://www.pinterest.com{href}"})

        await browser.close()
        return {"username": username, "followers": followers, "boards": boards}

For å skrape alle pins på tvers av alle tavler på en profil, går du gjennom tavlelisten og kaller scrape_board() for hver enkelt. Du kan organisere nedlastede bilder automatisk i mapper per tavle.

Bygg en robust løsning for uendelig scrolling

Dette er delen som skiller en enkel test-scraper fra en skikkelig løsning. Det største problemet — og jeg har sett det i minst et dusin forumtråder — er at skriptene bare returnerer 16–25 elementer fordi de ikke scroller langt nok, eller fordi de bruker et fast antall scrolls som for i in range(5): scroll() og håper på det beste.

Det er upålitelig. Pinterest laster nytt innhold i batcher på omtrent 25 pins, trigget av scroll-hendelser. Hvis du scroller fem ganger, kan du få 125 pins — eller 75 hvis nettverket er tregt, eller 150 hvis batchene er små. Du trenger et smartere mønster.

Mønsteret «scroll til ingen nytt innhold»

Her er en robust scroll-funksjon som sporer unike pin-ID-er, bruker en konfigurerbar timeout, inkluderer retry-logikk og skriver fremdrift underveis:

import time
import random

async def scroll_and_collect(page, max_pins=1000, max_scrolls=200, scroll_pause=2.5):
    seen_ids = set()
    all_pins = []
    no_new_count = 0

    for i in range(max_scrolls):
        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
        new_this_round = 0

        for pin in pins:
            link = await pin.query_selector("a")
            if not link:
                continue
            href = await link.get_attribute("href") or ""
            if href in seen_ids:
                continue
            seen_ids.add(href)
            new_this_round += 1
            title = await link.get_attribute("aria-label") or ""
            img = await link.query_selector("img")
            src = await img.get_attribute("src") if img else ""
            all_pins.append({
                "title": title,
                "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
                "image_url": src
            })

        print(f"  Scroll {i+1}: {new_this_round} nye pins | {len(all_pins)} totale unike pins")

        if len(all_pins) >= max_pins:
            print(f"  Nådde grensen for max_pins ({max_pins}). Stopper.")
            break

        if new_this_round == 0:
            no_new_count += 1
            if no_new_count >= 3:
                print("  Ingen nye pins etter 3 påfølgende scrolls. Slutt på innhold.")
                break
        else:
            no_new_count = 0

        prev_height = await page.evaluate("document.body.scrollHeight")
        await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
        await asyncio.sleep(scroll_pause + random.uniform(0.5, 1.5))
        curr_height = await page.evaluate("document.body.scrollHeight")

        if curr_height == prev_height and new_this_round == 0:
            print("  Siden har samme høyde og ingen nye pins. Trolig slutt på feeden.")
            break

    return all_pins

Hvorfor denne løsningen fungerer:

Deduplisering via href: Hver pins URL er unik, så vi bruker den som ID. Det hindrer at samme pin telles to ganger når DOM-en rendres på nytt under scrolling.
Trefeil-regel: Hvis tre scrolls på rad ikke gir noen nye pins, stopper vi. Dette håndterer situasjoner der siden fortsatt laster, men det ikke finnes mer innhold.
Tilfeldig variasjon i pausen: Å legge inn 0,5–1,5 sekunder tilfeldig forsinkelse mellom scrolls gjør oppførselen mer menneskelig og reduserer sjansen for å trigge anti-bot-mekanismer.
Sikkerhetsgrense for maks antall scrolls: Hindrer uendelige løkker hvis noe går galt.

Håndtering av edge cases

Brudd ved «More Ideas»: På tavlesider legger Pinterest noen ganger inn en «More Ideas»-seksjon. Hvis du bare vil ha tavlens faktiske pins, kan du sjekke etter dette elementet og stoppe scrollingen når det vises.
Rate limiting ved lange økter: Hvis du scroller gjennom en tavle med tusenvis av pins, kan Pinterest begynne å strupe responsene. Hvis du ser at scrolls av og til gir null nye pins (men ikke tre på rad), øk pausen til 5+ sekunder.

Slik får du Pinterest-bilder i full oppløsning (ikke miniatyrbilder)

Dette driver mange til vanvidd. Du skraper mange pins, laster ned bildene, og de er alle små 236px-miniatyrer. Brukere på forum beskriver det som «dårlig kvalitet, for liten størrelse». Løsningen er å forstå Pinterest sin bilde-URL-struktur.

Forstå banene i Pinterest sine bilde-URL-er

Alle Pinterest-bilder leveres fra https://i.pinimg.com/{size}/{hash}.jpg. Segmentet {size} styrer oppløsningen:

Stistørrelse	Dimensjoner	Bruk
`/236x/`	236px bred	Standard rutenettvisning (det du får som standard)
`/474x/`	474px bred	Middels oppløsning
`/736x/`	736px bred	Pin-detalj / utvidet visning
`/originals/`	Originale opplastingsdimensjoner	Full oppløsning

Hjelpefunksjon: oppgrader en Pinterest-bilde-URL til full oppløsning

Her er en funksjon som omskriver en hvilken som helst Pinterest-bilde-URL til høyest tilgjengelig kvalitet, med fallback-logikk:

import requests as req

def upgrade_image_url(url, preferred_size="originals"):
    """Omskriv en Pinterest-bilde-URL til høyest tilgjengelige oppløsning."""
    sizes = ["originals", "736x", "474x", "236x"]
    if preferred_size not in sizes:
        preferred_size = "originals"

    for size in sizes[sizes.index(preferred_size):]:
        upgraded = url
        for s in sizes:
            upgraded = upgraded.replace(f"/{s}/", f"/{size}/")
        try:
            resp = req.head(upgraded, timeout=5, allow_redirects=True)
            if resp.status_code == 200:
                return upgraded
        except Exception:
            continue
    return url  # Returner originalen hvis alt feiler

Viktig merknad (per 2025): Banen /originals/ gir i økende grad HTTP 403 Forbidden-feil. En dokumentert feil i gallery-dl bekrefter denne oppførselen per midten av 2025. Den pålitelige maksverdien er /736x/. Funksjonen min prøver /originals/ først, og faller automatisk tilbake til /736x/.

Last ned bilder til organiserte mapper

import os
import time

def download_images(pins, folder="images/default", delay=1.5):
    os.makedirs(folder, exist_ok=True)
    for i, pin in enumerate(pins):
        img_url = upgrade_image_url(pin.get("image_url", ""), preferred_size="736x")
        if not img_url:
            continue
        filename = f"pin_{i+1}.jpg"
        filepath = os.path.join(folder, filename)
        try:
            resp = req.get(img_url, timeout=15)
            if resp.status_code == 200:
                with open(filepath, "wb") as f:
                    f.write(resp.content)
                print(f"  Lastet ned {filename} ({len(resp.content) // 1024} KB)")
            else:
                print(f"  Feilet {filename}: HTTP {resp.status_code}")
        except Exception as e:
            print(f"  Feil ved nedlasting av {filename}: {e}")
        time.sleep(delay + random.uniform(0.3, 0.8))

Legg inn en forsinkelse mellom nedlastinger. Jeg bruker 1,5–2,3 sekunder med litt variasjon. Uten det vil Pinterest blokkere IP-en din etter noen hundre forespørsler.

Eksporter Pinterest-dataene dine

Eksporter til CSV eller JSON

Vi dekket grunnlaget tidligere. For større datasett (10 000+ pins) bør du vurdere JSON Lines-format — ett JSON-objekt per linje — som er enklere å strømme og prosessere:

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

Eksporter til Google Sheets, Airtable eller Notion

Hvis du vil sende data direkte fra Python til Google Sheets, trenger du biblioteket gspread og en Google Cloud service-konto. For Airtable bruker du pyairtable. For Notion bruker du notion-client. Hver av disse krever oppsett av API-nøkler og gjør pipelinen din mer kompleks.

Eller — og her er jeg litt partisk, men dette er faktisk den raskeste veien — du kan bruke Thunderbit til å skrape Pinterest og eksportere til ett av disse målene med ett klikk. Ingen API-nøkler, ingen servicekontoer, ingen ekstra kode. Thunderbit Chrome-utvidelsen håndterer eksporten direkte.

Tips for å unngå blokkering når du skraper Pinterest

Pinterest sitt anti-bot-system har fått 6/10 i vanskelighetsgrad for omgåelse av ScrapeOps — ikke trivielt, men heller ikke det vanskeligste målet. Det bruker nettleser-fingeravtrykk, atferdsanalyse og IP-basert rate limiting. Dette fungerer:

Roter user agents: Bruk en pool med ekte Chrome user agent-strenger og velg en tilfeldig per sesjon.
Legg inn tilfeldige pauser: 2–5 sekunder mellom scrolls og forespørsler, med litt variasjon. Uten proxyer bør du øke til 10–15 sekunder.
Bruk realistisk skjermstørrelse: Sett viewport={"width": 1920, "height": 1080} — ikke bruk små eller rare dimensjoner.
Vurder proxyer for skala: Hvis du skraper tusenvis av pins, roter boligproxyer. Uten dem må du regne med IP-blokkering etter noen hundre forespørsler.
Respekter robots.txt: Pinterest sitt robots.txt blokkerer de fleste automatiserte crawlere og har omtrent 180 disallow-regler. Ha dette i bakhodet for etterlevelse.
Unngå innlogget skraping: Hold deg til offentlig synlig innhold mens du er utlogget. Skraping bak innlogging øker både juridisk og teknisk risiko.

Thunderbit håndterer anti-bot og CAPTCHA-utfordringer automatisk via AI-motoren sin — én ting mindre å vedlikeholde hvis du velger no-code.

Juridiske og etiske hensyn ved Pinterest-skraping

Jeg holder dette kort, siden det ikke er hovedfokuset i artikkelen, men det er viktig.

Pinterest sine bruksvilkår (seksjon 2a) sier at du ikke skal «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).» Samtidig har domstoler generelt slått fast at skraping av offentlig tilgjengelige data ikke bryter Computer Fraud and Abuse Act — se hiQ v. LinkedIn og Meta v. Bright Data (jan. 2024), der retten slo fast at skraping av offentlig synlig data mens man er utlogget er lovlig.

Noen grunnregler:

Skrap bare offentlig synlig innhold mens du er utlogget
Ikke bruk skrapte data til spam eller til å utgi deg for å være andre
Respekter opphavsretten til bilder — hent metadata der det er mulig, og unngå å videredistribuere opphavsrettsbeskyttede bilder kommersielt uten tillatelse
Hvis du planlegger å bruke skrapte data kommersielt, snakk med en advokat

For en grundigere gjennomgang av det juridiske landskapet, se vår guide til juridiske konsekvenser av webskraping.

Oppsummering: hva du har lært og hva du kan gjøre videre

Nå vet du hvorfor statisk skraping feiler på Pinterest (det er en React SPA — ingen JavaScript, ingen data), hvordan du bruker Playwright til å skrape søkeresultater, tavler og brukerprofiler, hvordan du bygger en produksjonsklar løsning for uendelig scrolling som ikke gir opp etter 16 pins, og hvordan du får bilder i full oppløsning i stedet for små miniatyrer.

Kort oppsummert, dette er det viktigste:

requests + BeautifulSoup fungerer ikke på Pinterest. Ikke kast bort tiden din.
Playwright er det beste Python-verktøyet for jobben — raskt, godt støttet og håndterer JavaScript-rendering naturlig.
Uendelig scrolling krever en dedupliseringsbasert scroll-løkke, ikke et fast antall.
Bilder i full oppløsning krever omskriving av URL-stien — bruk /736x/ (siden /originals/ ofte gir 403).
Skraping av tavler og profiler er dårlig dekket i eksisterende guider, men ganske rett frem med riktige selektorer.
For ikke-utviklere eller team som vil ha fart, lar Thunderbit deg skrape Pinterest på 2 klikk og eksportere til Google Sheets, Excel, Airtable eller Notion — uten Python. Prøv gratis via Chrome-utvidelsen.

Hvis du bygger en Python-pipeline, gir koden i denne guiden deg et solid utgangspunkt. Hvis du bare trenger dataene, er Thunderbit snarveien. Uansett sitter du ikke lenger fast med 16 pins og et tomt blikk.

For mer om skraping og datauthenting, se guidene våre om hvordan webskrape med Python, beste automatiserte webskrapingsverktøy og skraping av data fra nettside til Excel. Du kan også utforske Thunderbit-priser eller se veiledninger på Thunderbit YouTube-kanal.

Vanlige spørsmål

1. Kan du skrape Pinterest med BeautifulSoup?

Ikke effektivt alene. Pinterest renderer alt innhold via JavaScript, så requests + BeautifulSoup ser bare et tomt HTML-skall. Du trenger en headless nettleser som Playwright eller Selenium for å rendre siden først, eller du kan bruke et no-code-verktøy som Thunderbit som håndterer JavaScript-rendering automatisk.

2. Hvor mange pins kan du skrape fra Pinterest i én økt?

Det avhenger av scroll-logikken din og hvordan du håndterer anti-bot. Med den produksjonsklare scroll-løsningen i denne guiden (deduplisering, timeout, retry-logikk) kan du pålitelig skrape hundrevis til tusenvis av pins per tavle eller søk. For svært store tavler må du regne med flere minutter med scrolling og uthenting.

3. Hvorfor blir de skrapede Pinterest-bildene mine så små?

Som standard serverer Pinterest /236x/-miniatyrer i rutenettvisningen. For høyere oppløsning må du omskrive bilde-URL-en til /736x/ eller /originals/. Merk at /originals/ i økende grad returnerer 403-feil fra og med 2025, så /736x/ er den pålitelige maksverdien.

4. Er det lovlig å skrape Pinterest?

Skraping av offentlig tilgjengelige data er generelt akseptert under nyere rettsavgjørelser (for eksempel hiQ v. LinkedIn, Meta v. Bright Data), men Pinterest sine bruksvilkår forbyr uautorisert automatisert tilgang. Hold deg til offentlig innhold, ikke bruk skrapte data til spam, respekter opphavsrett og snakk med juridisk rådgiver ved kommersiell bruk.

5. Hva er det beste no-code-alternativet for å skrape Pinterest?

Thunderbit's AI Web Scraper kan hente ut Pinterest-data — titler, bilder, URL-er, beskrivelser — med 2 klikk, og har innebygd eksport til Google Sheets, Excel, Airtable eller Notion. Den håndterer JavaScript-rendering, uendelig scrolling og anti-bot-utfordringer automatisk, så du slipper å skrive eller vedlikeholde kode.

Les mer