Python Pinterest-skrapning: "Pins, anslagstavlor och oändlig scroll"

Senast uppdaterad April 17, 2026
Python Pinterest-skrapning: "Pins, anslagstavlor och oändlig scroll"

För några månader sedan visade en av våra ingenjörer mig ett Python-skript han hade skrivit under helgen. Tanken var att hämta inspirationsbilder på produkter från Pinterest för ett marknadsundersökningsprojekt. Han körde det, och resultatet blev… 16 pins. Från en anslagstavla med över 2 000. Han stirrade på skärmen, sedan på mig, och sa: "Jag tror att Pinterest driver med mig."

Han är långt ifrån ensam. Det här är utan tvekan den vanligaste frustrationen jag ser bland utvecklare som försöker skrapa Pinterest med Python. Du öppnar requests och BeautifulSoup, skickar en Pinterest-URL, och får tillbaka antingen ett fåtal objekt eller ett tomt HTML-skal. Varför? Pinterest är en hel JavaScript-renderad single-page app — din statiska HTTP-förfrågan ser aldrig det riktiga innehållet. I den här guiden går jag igenom varför det händer, vilka metoder som faktiskt fungerar (Playwright, avlyssning av interna API:er och no-code-verktyg som Thunderbit), och ger dig steg-för-steg-kod för att skrapa pins, anslagstavlor, användarprofiler, oändlig scroll och bilder i full upplösning. Oavsett om du vill bygga en scraper för produktion eller bara snabbt få ut data, så har den här artikeln dig täckt.

Vad är Pinterest-skrapning?

Pinterest-skrapning är processen att programmässigt extrahera data från Pinterest — sådant som pin-bilder, titlar, beskrivningar, namnen på anslagstavlor, antal följare och URL:er. I stället för att manuellt bläddra och spara pins en och en använder du kod (eller ett verktyg) för att samla strukturerad data från sökresultat, anslagstavlor eller användarprofiler i stor skala.

Med över 240 miljarder Pins på plattformen och 619 miljoner månatliga aktiva användare i slutet av 2025 är Pinterest en av webbens rikaste källor till visuell data. För företag är den datan guld värd — oavsett om du följer produkttrender, jämför konkurrenters innehåll eller bygger listor för influencer-uträckning.

Varför skrapa Pinterest med Python?

Pinterest är inte längre bara en anslagstavla för bröllopsplanerare. Det är en seriös plattform för affärsinsikter — 85 % av veckovisa Pinners har köpt något baserat på varumärkes-Pins, och 96–97 % av de vanligaste sökningarna är utan varumärke, vilket betyder att användarna kommer med tydlig avsikt men utan lojalitet till ett visst varumärke. Det skapar enorma möjligheter att upptäcka efterfrågan — och det förklarar varför så många team vill ha strukturerad Pinterest-data.

Så här ser det ut per team:

TeamData som behövsAffärsvärde
E-handelsdriftProduktbilder, priser, trendande estetikKonkurrenskraftig prissättning, trendstyrt lager
MarknadsföringPrestanda för anslagstavlor, engagemang för pins, konkurrentinnehållInnehållsstrategi, kampanjbenchmarking
Sälj / leadgenereringKreatörsprofiler, antal följare, kontaktuppgifterInfluencer-uträckning, partnerskapsmålgrupp
FastighetPins för styling av hem, inredningstrender, rumsuppläggFotografering av objekt, stylingstöd
InnehållsskapareTrendande ämnen, populära format, säsongstemanInnehållskalender, research kring visuell stil

Och här kommer det viktiga: Pinterests officiella API är begränsat. Det kräver ett företagskonto, godkännande (inklusive en videodemonstration av din app), och ger dig bara tillgång till data från ditt eget konto. Vill du bläddra i publika anslagstavlor, sökresultat eller konkurrentprofiler är skrapning det praktiska alternativet. Därför vänder sig så många team till Python — eller till no-code-verktyg som Thunderbit när de vill ha resultat utan allt förarbete.

Varför BeautifulSoup ensam misslyckas på Pinterest (och vad som faktiskt fungerar)

Om du har försökt skrapa Pinterest med requests + BeautifulSoup och fått tillbaka 16 objekt eller en tom sida, så inbillar du dig inte. Pinterest är byggt med React och renderar 100 % av sitt innehåll via JavaScript. När du hämtar en Pinterest-URL med en vanlig HTTP-förfrågan skickar servern bara ett minimalt HTML-skal — några <link>- och <script>-taggar, samt en tom <div> där React monterar appen. Alla pin-kort, bilder, titlar och rutnät läggs in efter att JavaScript körts i webbläsaren.

Ingen JavaScript-körning = inga pins.

Så vad fungerar? Så här står sig de vanligaste metoderna:

MetodHanterar JS?Får fram all data?KomplexitetBäst för
requests + BeautifulSoupNej~0–16 objektLågInte lämpligt för Pinterest
Selenium / PlaywrightJaJa, med scroll-logikMedelFull kontroll, Python-pipelines
Avlyssning av Pinterest interna APIJaJa, paginerad JSONHögMaximal data, ingen webbläsare behövs
Tredjeparts Scraper APIJaVarierarLågSkala utan egen infrastruktur
No-code-verktyg (Thunderbit)JaAI-struktureradVäldigt lågIcke-tekniska användare, snabba resultat

För den här guiden rekommenderar jag Playwright som Python-lösning. Den renderar JavaScript, stöder scroll-simulering, underhålls aktivt (78 600+ GitHub-stjärnor, och har vuxit 180 % år över år i jobbannonser), och är 35–45 % snabbare än Selenium i benchmarktester. Vill du ha no-code-vägen tar vi det också.

Pinterests officiella API vs. Python-skrapning vs. no-code: vilken väg ska du välja?

Innan du börjar skriva kod är det värt att fråga: behöver du ens göra det? Här är ett beslutsunderlag:

KriteriumPinterest APIPython-skrapningThunderbit (No-Code)
Godkännande krävsFöretagskonto + videodemonstrationNejNej
Åtkomst till offentliga pins/anslagstavlorBegränsad (endast egen data)FullFull
Nedladdning av bilder i full upplösningVarierarJa, via URL-analysJa, via bildextrahering
Hanterar oändlig scrollEj tillämpligtJa, med kodAutomatiskt
Underhåll krävsLågHög (selectors går sönder)Inget (AI anpassar sig)
Export till Sheets/AirtableManuelltEgen kodInbyggt
UppstartstidTimmar–dagar30–60 min2 minuter

Om du är marknadsförare, jobbar med e-handel eller bara vill ha Pinterest-data i ett kalkylark utan att skriva eller underhålla Python-skript, är Thunderbits AI Web Scraper snabbspåret. Du öppnar vilken Pinterest-sida som helst, klickar på "AI Suggest Fields", trycker på "Scrape" och exporterar direkt till Google Sheets, Excel, Airtable eller Notion. Dess funktion för skrapning av undersidor kan till och med följa enskilda pin-länkar för att berika datan automatiskt. Jag har sett teammedlemmar som aldrig skrivit en rad kod dra in 500+ pins i ett Google Sheet på under tre minuter.

För dig som vill ha full kontroll, vill integrera skrapningen i en Python-pipeline eller helt enkelt gillar hantverket med att bygga saker — fortsätt läsa.

Så sätter du upp din Python-miljö för Pinterest-skrapning

  • Svårighetsgrad: Medelnivå
  • Tidsåtgång: ~30–60 minuter (inklusive kodning och testning)
  • Det här behöver du: Python 3.9+, Chrome-webbläsare (för testning), terminal/kommandorad

Installera Playwright och beroenden

Börja med att skapa en projektmapp och sätta upp en virtuell miljö:

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

Installera Playwright och ladda ner Chromium-binären:

pip install playwright
playwright install chromium

Du kommer också att använda Python:s inbyggda moduler json, os och csv för dataexport. Inga extra installationer behövs för dem.

Mappstruktur för projektet

Jag rekommenderar att hålla ordning från början:

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

I config.py sätter du din user agent-sträng. Pinterest blockerar standard-signaturer från headless-webbläsare, så använd en realistisk sådan:

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ök-URL:en

Konstruera sök-URL:en genom att stoppa in din sökfråga i mallen:

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

Du kan parameterisera detta för vilket sökord som helst. Parametern rs=typed talar om för Pinterest att frågan skrevs in manuellt (inte föreslogs), vilket ibland påverkar relevansen i resultaten.

Steg 2: Starta en headless-webbläsare och ladda sidan

Här är den centrala Playwright-setupen. Lägg märke till den anpassade user agenten — utan den kommer Pinterest sannolikt att blockera dig eller visa en inloggningsvägg.

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)  # Vänta på att JS ska rendera de första pinsen

Efter att detta körts bör sidan ha laddat den första batchen pins — vanligtvis 25–50 stycken.

Steg 3: Extrahera pin-data från sidan

Pinterest kapslar in varje pin i en div med data-test-id='pinWrapper'. Inuti hittar du en länk (<a>) med pin-URL och titel (via aria-label), samt en <img> med miniatyrbildens 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 link.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
            })

Vid det här laget innehåller results de pins som syns i den första vyn. För att få fler måste du scrolla — vilket leder oss till det viktigaste avsnittet.

Steg 4: Spara resultaten som JSON eller CSV

Efter extraktionen skriver du ut datan till filer för enkel användning:

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)

Använd kodningen utf-8-sig för CSV om du planerar att öppna filen i Excel — det förhindrar konstiga tecken.

Skrapa hela Pinterest-anslagstavlor och användarprofiler

Det här är en stor brist i många befintliga guider. Jag kunde inte hitta en enda konkurrerande guide som går på djupet kring skrapning av anslagstavlor eller profiler — ändå är det en av de mest efterfrågade funktionerna i forum. Användare vill ladda ner alla pins från en anslagstavla, organisera bilder i mappar per anslagstavla och hämta profilnivådata som antal följare och listor över anslagstavlor.

Skrapa alla pins från en anslagstavle-URL

URL:er för anslagstavlor följer mönstret https://www.pinterest.com/{username}/{board-name}/. DOM-strukturen liknar sökresultat — pins ligger i div[data-test-id='pinWrapper'] — men du måste scrolla för att ladda allt.

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):  # Säkerhetsgräns
            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)} unika pins insamlade")
            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  # Inget mer innehåll

        await browser.close()
        return all_pins

En sak att hålla koll på: på anslagstavlesidor finns ibland en flik med "More Ideas" som skiljer sparade pins från algoritmiska rekommendationer. Om du bara vill ha användarens faktiskt sparade pins, sluta scrolla när du kommer till den avdelaren.

Skrapa en användarprofil: anslagstavlor, antal följare och pins

Profil-URL:er ser ut så här: https://www.pinterest.com/{username}/. Från en profilsida kan du extrahera:

  • Antal följare / följda: Leta efter div[data-test-id='follower-count']
  • Lista över anslagstavlor: Varje anslagstavla är ett kort som länkar till /{username}/{board-name}/
  • Totalt antal pins: Visas ibland i profilhuvudet
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)

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

        # Extrahera länkar till anslagstavlor
        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}

För att skrapa alla pins över varje anslagstavla i en profil itererar du igenom listan över anslagstavlor och anropar scrape_board() för var och en. Du kan automatiskt organisera nedladdade bilder i mappar per anslagstavla.

Bygg en produktionsklar hantering av oändlig scroll

Det här är avsnittet som skiljer en leksaksscraper från en riktig lösning. Den största smärtan — och jag har sett det i minst ett dussin forumtrådar — är att scrapers bara returnerar 16–25 objekt eftersom de inte scrollar tillräckligt långt, eller använder ett fast antal scrollningar som for i in range(5): scroll() och hoppas på det bästa.

Det angreppssättet är opålitligt. Pinterest laddar nytt innehåll i batcher om ungefär 25 pins, utlöst av scroll-händelser. Om du scrollar fem gånger kanske du får 125 pins — eller kanske bara 75 om nätverket var långsamt, eller 150 om batcherna var mindre. Du behöver ett smartare mönster.

Mönstret scrolla tills inget nytt innehåll finns

Här är en robust scroll-funktion som håller koll på unika pin-ID:n, använder en konfigurerbar timeout, innehåller retry-logik och skriver ut framsteg:

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} nya pins | {len(all_pins)} unika pins totalt")

        if len(all_pins) >= max_pins:
            print(f"  Nådde gränsen max_pins ({max_pins}). Stoppar.")
            break

        if new_this_round == 0:
            no_new_count += 1
            if no_new_count >= 3:
                print("  Inga nya pins efter 3 scrollningar i rad. Slut på innehållet.")
                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("  Sidans höjd är oförändrad och inga nya pins dök upp. Troligen slutet på flödet.")
            break

    return all_pins

Varför den här designen fungerar:

  • Avduplicering via href: Varje pins URL är unik, så vi använder den som ID. Det förhindrar att samma pin räknas två gånger när DOM:en renderas om under scrollning.
  • Tre-försök-regel: Om tre scrollningar i rad ger noll nya pins stoppar vi. Det hanterar fallet där sidan fortfarande laddar men inget nytt innehåll finns.
  • Slumpmässig variation i pausen: Att lägga till 0,5–1,5 sekunders slumpmässig fördröjning mellan scrollningar gör beteendet mer mänskligt och minskar risken att trigga antibot-skydd.
  • Maxgräns för scrollningar: Förhindrar oändliga loopar om något går fel.

Hantera specialfall

  • "More Ideas"-avbrott: På anslagstavlesidor lägger Pinterest ibland in ett avsnitt med "More Ideas". Om du bara vill ha anslagstavlans faktiska pins kan du kontrollera detta element och sluta scrolla när det dyker upp.
  • Rate limiting vid långa sessioner: Om du scrollar genom en anslagstavla med tusentals pins kan Pinterest börja strypa svaren. Om du märker att scrollningar ibland ger noll nya pins (men inte tre i rad), öka din paus till 5+ sekunder.

Hämta Pinterest-bilder i full upplösning (inte miniatyrer)

Det här gör många galna. Du skrapar mängder av pins, laddar ner bilderna, och alla är små 236px-miniatyrer. Användare på forum beskriver det som "skräpkvalitet, typ för liten storlek". Lösningen är att förstå Pinterests struktur för bild-URL:er.

Förstå Pinterests sökvägar för bild-URL:er

Alla Pinterest-bilder levereras från https://i.pinimg.com/{size}/{hash}.jpg. Segmentet {size} styr upplösningen:

Sökväg för storlekMåttAnvändning
/236x/236 px bredStandardrutnät (det du får som standard)
/474x/474 px bredMedelhög upplösning
/736x/736 px bredPin-detalj / utökat läge
/originals/Originalets uppladdade dimensionerFull upplösning

Hjälpfunktion: uppgradera vilken Pinterest-bild-URL som helst till full upplösning

Här är en funktion som skriver om en Pinterest-bild-URL till högsta tillgängliga kvalitet, med fallback-logik:

import requests as req

def upgrade_image_url(url, preferred_size="originals"):
    """Skriv om en Pinterest-bild-URL till högsta tillgängliga upplö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  # Returnera originalet om allt misslyckas

Viktig notis (per 2025): Sökvägen /originals/ ger i allt större utsträckning HTTP 403 Forbidden. Ett dokumenterat problem i gallery-dl bekräftar detta beteende från mitten av 2025. Den pålitliga maxnivån är /736x/. Min funktion testar /originals/ först och faller sedan automatiskt tillbaka till /736x/.

Ladda ner bilder till organiserade mappar

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"  Laddade ner {filename} ({len(resp.content) // 1024} KB)")
            else:
                print(f"  Misslyckades med {filename}: HTTP {resp.status_code}")
        except Exception as e:
            print(f"  Fel vid nedladdning av {filename}: {e}")
        time.sleep(delay + random.uniform(0.3, 0.8))

Lägg in en fördröjning mellan nedladdningarna. Jag använder 1,5–2,3 sekunder med variation. Utan det kommer Pinterest att blockera din IP efter några hundra förfrågningar.

Exportera din skrapade Pinterest-data

Export till CSV eller JSON

Vi gick igenom grunderna tidigare. För större datamängder (10 000+ pins), överväg JSON Lines-format — ett JSON-objekt per rad — eftersom det är lättare att strömma och bearbeta:

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

Export till Google Sheets, Airtable eller Notion

Om du vill skicka data direkt från Python till Google Sheets behöver du biblioteket gspread och ett Google Cloud servicekonto. För Airtable använder du pyairtable. För Notion finns notion-client. Var och en kräver API-nyckel och lägger till verklig komplexitet i din pipeline.

Eller — och jag är lite partisk här, men det är genuint snabbaste vägen — kan du använda Thunderbit för att skrapa Pinterest och exportera till någon av dessa destinationer med ett klick. Inga API-nycklar, inga servicekonton, ingen extra kod. Thunderbit Chrome Extension hanterar exporten inbyggt.

Tips för att undvika att bli blockerad när du skrapar Pinterest

Pinterest antibotsystem bedöms ha 6/10 i svårighetsgrad att kringgå av ScrapeOps — inte trivialt, men inte heller det svåraste målet. Det använder webbläsarfingeravtryck, beteendeanalys och IP-baserad begränsning. Här är vad som fungerar:

  • Rotera user agents: Använd en uppsättning riktiga Chrome-user agents och välj slumpmässigt per session.
  • Lägg in slumpmässiga fördröjningar: 2–5 sekunder mellan scrollningar och förfrågningar, med variation. För sessioner utan proxys, öka till 10–15 sekunder.
  • Använd en realistisk viewport: Sätt viewport={"width": 1920, "height": 1080} — använd inte små eller ovanliga dimensioner.
  • Överväg proxys vid skala: Om du skrapar tusentals pins, rotera residential proxies. Utan dem kan du förvänta dig IP-blockering efter några hundra förfrågningar.
  • Respektera robots.txt: Pinterests robots.txt blockerar de flesta automatiserade crawlers och har cirka 180 regler för disallow. Tänk på detta ur ett compliance-perspektiv.
  • Undvik inloggad skrapning: Håll dig till offentligt synligt innehåll när du är utloggad. Skrapning bakom inloggning innebär både juridiska och tekniska risker.

Thunderbit hanterar antibot- och CAPTCHA-utmaningar automatiskt via sin AI-motor — en sak mindre att underhålla om du väljer no-code-spåret.

Juridiska och etiska aspekter av Pinterest-skrapning

Jag håller det här kort eftersom det inte är huvudpoängen i artikeln, men det är viktigt.

Pinterests användarvillkor (sektion 2a) säger att du går med på att inte "skrapa, samla in, söka, kopiera eller på annat sätt komma åt data eller innehåll från Pinterest på otillåtna sätt, till exempel med automatiska metoder (utan vårt uttryckliga förhandsgodkännande)." När det är sagt har domstolar i allmänhet slagit fast att skrapning av offentligt tillgänglig data inte bryter mot Computer Fraud and Abuse Act — se hiQ v. LinkedIn och Meta v. Bright Data (jan 2024), där domstolen slog fast att skrapning av offentligt synlig data när man är utloggad är lagligt.

Några grundregler:

  • Skrapa bara offentligt synligt innehåll när du är utloggad
  • Använd inte skrapad data för spam eller för att utge dig för att vara andra användare
  • Respektera upphovsrätt för bilder — extrahera metadata när det går, och undvik att kommersiellt vidaredistribuera upphovsrättsskyddade bilder utan tillstånd
  • Om du planerar att använda skrapad data i kommersiella sammanhang, prata med en jurist

För en djupare genomgång av det juridiska läget, se vår guide om juridiska konsekvenser av webbscraping.

Sammanfattning: vad du lärt dig och vad du kan göra härnäst

Nu vet du varför statisk skrapning misslyckas på Pinterest (det är en React SPA — inget JavaScript, ingen data), hur du använder Playwright för att skrapa sökresultat, anslagstavlor och användarprofiler, hur du bygger en produktionsklar hantering av oändlig scroll som inte ger upp efter 16 pins, och hur du får bilder i full upplösning i stället för små miniatyrer.

Snabb sammanfattning av det viktigaste:

  • requests + BeautifulSoup fungerar inte på Pinterest. Slösa inte tid på det.
  • Playwright är det bästa Python-verktyget för jobbet — snabbt, välunderhållet och hanterar JS-rendering nativt.
  • Oändlig scroll kräver en scroll-loop som bygger på avduplicering, inte ett fast antal iterationer.
  • Bilder i full upplösning kräver omskrivning av URL-sökvägen — sikta på /736x/ (eftersom /originals/ ofta ger 403).
  • Skrapning av anslagstavlor och profiler är underutvecklat i befintliga guider men ganska rakt på sak med rätt selectors.
  • För icke-kodare eller team som vill gå snabbt, låter Thunderbit dig skrapa Pinterest i två klick och exportera till Google Sheets, Excel, Airtable eller Notion — ingen Python behövs. Prova gratis via Chrome Extension.

Om du bygger en Python-pipeline ger koden i den här guiden dig en stabil grund. Om du bara behöver datan är Thunderbit genvägen. Hur som helst sitter du inte längre fast med 16 pins och en tom blick.

För mer om skrapning och dataextrahering, kolla in våra guider om hur man webbscrapar med Python, bästa automatiserade webbscrapingverktygen, och skrapa data från webbplats till Excel. Du kan också utforska Thunderbits prissättning eller titta på tutorials på Thunderbit YouTube-kanal.

Vanliga frågor

1. Kan man skrapa Pinterest med BeautifulSoup?

Inte effektivt på egen hand. Pinterest renderar allt innehåll via JavaScript, så requests + BeautifulSoup ser bara ett tomt HTML-skal. Du behöver en headless-webbläsare som Playwright eller Selenium för att först rendera sidan, eller så kan du använda ett no-code-verktyg som Thunderbit som hanterar JS-rendering automatiskt.

2. Hur många pins kan man skrapa från Pinterest i en session?

Det beror på din scroll-logik och hur du hanterar antibot-skydd. Med den produktionsklara lösningen för oändlig scroll i den här guiden (avduplicering, timeout, retry-logik) kan du pålitligt skrapa hundratals till tusentals pins per anslagstavla eller sökfråga. För väldigt stora anslagstavlor får du räkna med flera minuters scrollande och insamling.

3. Varför blir mina skrapade Pinterest-bilder så små?

Som standard visar Pinterest /236x/-miniatyrer i rutnätsvyn. För högre upplösning skriver du om bild-URL:ens sökväg till /736x/ eller /originals/. Observera att /originals/ i allt högre grad ger 403-fel från och med 2025, så /736x/ är den pålitliga maxnivån.

4. Är det lagligt att skrapa Pinterest?

Skrapning av offentligt tillgänglig data accepteras i allmänhet enligt senare domstolsavgöranden (t.ex. hiQ v. LinkedIn, Meta v. Bright Data), men Pinterests användarvillkor förbjuder otillåten automatiserad åtkomst. Håll dig till offentligt innehåll, använd inte skrapad data för spam, respektera upphovsrätt och rådgör med jurist för kommersiella användningsfall.

5. Vad är det bästa no-code-alternativet för att skrapa Pinterest?

Thunderbits AI Web Scraper kan extrahera Pinterest-data — titlar, bilder, URL:er, beskrivningar — i två klick, med inbyggd export till Google Sheets, Excel, Airtable eller Notion. Det hanterar JavaScript-rendering, oändlig scroll och antibot-utmaningar automatiskt, så du behöver inte skriva eller underhålla någon kod.

Läs mer

Shuai Guan
Shuai Guan
VD på Thunderbit | Expert på AI-driven dataautomatisering Shuai Guan är VD för Thunderbit och alumn från University of Michigan Engineering. Med nästan tio års erfarenhet inom teknik och SaaS-arkitektur är han specialiserad på att omvandla avancerade AI-modeller till praktiska, kodfria verktyg för datautvinning. På den här bloggen delar han raka, beprövade insikter om webbskrapning och automatiseringsstrategier som hjälper dig att bygga smartare, datadrivna arbetsflöden. När han inte optimerar dataflöden ägnar han samma detaljblick åt sin passion för fotografi.
Innehållsförteckning
Thunderbit · AI-agent för webbdata

Extrahera data från vilken sida som helst på 1 klick

Betrodd av över 250 000 användare
gratis plan tillgänglig
Från webbsida till kalkylark
Beskriv vad du behöver — Thunderbits AI-agent samlar in det och exporterar till Excel, Google Sheets, Airtable eller Notion. Gratis att börja med.
Chrome Store Rating
PRODUCT HUNT#1 Product of the Week