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:
| Team | Data som behövs | Affärsvärde |
|---|---|---|
| E-handelsdrift | Produktbilder, priser, trendande estetik | Konkurrenskraftig prissättning, trendstyrt lager |
| Marknadsföring | Prestanda för anslagstavlor, engagemang för pins, konkurrentinnehåll | Innehållsstrategi, kampanjbenchmarking |
| Sälj / leadgenerering | Kreatörsprofiler, antal följare, kontaktuppgifter | Influencer-uträckning, partnerskapsmålgrupp |
| Fastighet | Pins för styling av hem, inredningstrender, rumsupplägg | Fotografering av objekt, stylingstöd |
| Innehållsskapare | Trendande ämnen, populära format, säsongsteman | Innehå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:
| Metod | Hanterar JS? | Får fram all data? | Komplexitet | Bäst för |
|---|---|---|---|---|
requests + BeautifulSoup | Nej | ~0–16 objekt | Låg | Inte lämpligt för Pinterest |
| Selenium / Playwright | Ja | Ja, med scroll-logik | Medel | Full kontroll, Python-pipelines |
| Avlyssning av Pinterest interna API | Ja | Ja, paginerad JSON | Hög | Maximal data, ingen webbläsare behövs |
| Tredjeparts Scraper API | Ja | Varierar | Låg | Skala utan egen infrastruktur |
| No-code-verktyg (Thunderbit) | Ja | AI-strukturerad | Väldigt låg | Icke-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:
| Kriterium | Pinterest API | Python-skrapning | Thunderbit (No-Code) |
|---|---|---|---|
| Godkännande krävs | Företagskonto + videodemonstration | Nej | Nej |
| Åtkomst till offentliga pins/anslagstavlor | Begränsad (endast egen data) | Full | Full |
| Nedladdning av bilder i full upplösning | Varierar | Ja, via URL-analys | Ja, via bildextrahering |
| Hanterar oändlig scroll | Ej tillämpligt | Ja, med kod | Automatiskt |
| Underhåll krävs | Låg | Hög (selectors går sönder) | Inget (AI anpassar sig) |
| Export till Sheets/Airtable | Manuellt | Egen kod | Inbyggt |
| Uppstartstid | Timmar–dagar | 30–60 min | 2 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 storlek | Mått | Användning |
|---|---|---|
/236x/ | 236 px bred | Standardrutnät (det du får som standard) |
/474x/ | 474 px bred | Medelhög upplösning |
/736x/ | 736 px bred | Pin-detalj / utökat läge |
/originals/ | Originalets uppladdade dimensioner | Full 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: Pinterestsrobots.txtblockerar 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


