การดึงข้อมูล Pinterest ด้วย Python: "Pins, Boards และ Infinite Scroll"

อัปเดตล่าสุดเมื่อ April 17, 2026
การดึงข้อมูล Pinterest ด้วย Python: "Pins, Boards และ Infinite Scroll"

เมื่อไม่กี่เดือนก่อน วิศวกรคนหนึ่งของเราหอบสคริปต์ Python ที่เขาเขียนเล่นๆ ตอนสุดสัปดาห์มาให้ดู สคริปต์นั้นตั้งใจจะดึงภาพไอเดียสินค้า (product inspiration) จาก Pinterest สำหรับโปรเจกต์วิจัยตลาด เขารันสคริปต์แล้วสิ่งที่ได้คือ… 16 pins จากบอร์ดที่มีมากกว่า 2,000 รายการ เขานั่งจ้องหน้าจออยู่พักใหญ่ แล้วหันมามองผมก่อนจะพูดว่า “ผมว่ Pinterest กำลังล้อผมเล่นอยู่แน่ๆ”

เขาไม่ได้เจอปัญหานี้คนเดียวครับ นี่คือปัญหาที่ผมเห็นบ่อยที่สุดจากนักพัฒนาที่พยายาม scrape Pinterest ด้วย Python คุณเปิด requests กับ BeautifulSoup ขึ้นมา ใส่ URL ของ Pinterest แล้วสิ่งที่ได้กลับมามักมีแค่ข้อมูลไม่กี่ชิ้น หรือไม่ก็เป็น HTML โครงเปล่าๆ สาเหตุคืออะไร? เพราะ Pinterest เป็นเว็บแอปแบบ single-page ที่เรนเดอร์ด้วย JavaScript เต็มรูปแบบ — คำขอ HTTP แบบ static จึงมองไม่เห็นเนื้อหาจริง บทความนี้ผมจะพาคุณดูว่าทำไมถึงเป็นแบบนั้น วิธีที่ใช้งานได้จริงมีอะไรบ้าง (Playwright, การดัก internal API และเครื่องมือ no-code อย่าง Thunderbit) พร้อมโค้ดแบบ step-by-step สำหรับดึง pins, boards, โปรไฟล์ผู้ใช้, infinite scroll และรูปความละเอียดสูง ไม่ว่าคุณอยากสร้าง scraper ระดับโปรดักชัน หรือแค่ต้องการดึงข้อมูลเร็วๆ บทความนี้มีคำตอบให้ครบ

Pinterest Scraping คืออะไร?

Pinterest scraping คือการดึงข้อมูลจาก Pinterest แบบอัตโนมัติด้วยโปรแกรม เช่น รูป pin, ชื่อเรื่อง, คำอธิบาย, ชื่อบอร์ด, จำนวนผู้ติดตาม และ URL ต่างๆ แทนที่จะไล่เปิดบอร์ดแล้วเซฟ pins ทีละอันด้วยตัวเอง คุณใช้โค้ดหรือเครื่องมือเพื่อเก็บข้อมูลแบบมีโครงสร้างจากผลการค้นหา บอร์ด หรือโปรไฟล์ผู้ใช้ในปริมาณมาก

ด้วยจำนวน Pins มากกว่า 240 พันล้านรายการ บนแพลตฟอร์ม และ ผู้ใช้งานรายเดือน 619 ล้านคน ณ ช่วงปลายปี 2025 Pinterest จึงเป็นหนึ่งในแหล่งข้อมูลภาพที่ทรงคุณค่าที่สุดบนเว็บ สำหรับธุรกิจ ข้อมูลเหล่านี้คือขุมทอง ไม่ว่าคุณจะติดตามเทรนด์สินค้า เปรียบเทียบคอนเทนต์คู่แข่ง หรือสร้างลิสต์สำหรับ outreach ไปยังอินฟลูเอนเซอร์

ทำไมต้องดึงข้อมูล Pinterest ด้วย Python?

Pinterest ไม่ได้เป็นแค่พื้นที่เก็บ mood board ของสายจัดงานแต่งอีกต่อไป แต่กลายเป็นแพลตฟอร์มข้อมูลเชิงธุรกิจที่สำคัญ — 85% ของผู้ใช้รายสัปดาห์ เคยซื้อของจากแบรนด์ที่เห็นบน Pins และ 96–97% ของการค้นหายอดนิยมเป็นการค้นหาแบบไม่ระบุแบรนด์ ซึ่งหมายความว่าผู้ใช้เข้ามาพร้อมความตั้งใจซื้อ แต่ยังไม่มีความภักดีต่อแบรนด์ใดแบรนด์หนึ่ง นี่คือโอกาสมหาศาลด้าน discovery และยังอธิบายว่าทำไมหลายทีมถึงต้องการข้อมูล Pinterest แบบมีโครงสร้าง

สรุปประโยชน์ตามทีมได้แบบนี้:

ทีมข้อมูลที่ต้องการคุณค่าต่อธุรกิจ
ทีม Ecommerce Operationsรูปสินค้า ราคา และสไตล์ที่กำลังมาแรงตั้งราคาสู้ตลาด และวางสต็อกจากเทรนด์
ทีม Marketingประสิทธิภาพของบอร์ด, engagement ของ pin, คอนเทนต์คู่แข่งวางกลยุทธ์คอนเทนต์ และ benchmark แคมเปญ
ทีม Sales / Lead Genโปรไฟล์ครีเอเตอร์, จำนวนผู้ติดตาม, ข้อมูลติดต่อหาอินฟลูเอนเซอร์ และคัดเป้าหมายพาร์ทเนอร์
ธุรกิจอสังหาริมทรัพย์Pins สำหรับจัดบ้าน, เทรนด์ตกแต่ง, ผังห้องใช้เป็นแนวทางถ่ายภาพประกาศขาย และ staging
คอนเทนต์ครีเอเตอร์หัวข้อกำลังมา, ฟอร์แมตยอดนิยม, ธีมตามฤดูกาลวางปฏิทินคอนเทนต์ และศึกษา visual style

และนี่คือจุดสำคัญ: API ทางการของ Pinterest มีข้อจำกัดสูง ต้องใช้บัญชีธุรกิจ ต้องได้รับการอนุมัติ (รวมถึงวิดีโอสาธิตการใช้งานแอป) และยังให้เข้าถึงได้แค่ข้อมูลในบัญชีของคุณเอง ถ้าคุณอยากดูบอร์ดสาธารณะ ผลการค้นหา หรือโปรไฟล์คู่แข่ง การ scrape คือทางเลือกที่ใช้งานได้จริง นี่จึงเป็นเหตุผลที่หลายทีมเลือกใช้ Python — หรือใช้เครื่องมือ no-code อย่าง Thunderbit เมื่ออยากได้ผลลัพธ์เร็วโดยไม่ต้องตั้งค่ามาก

ทำไม BeautifulSoup อย่างเดียวถึงใช้กับ Pinterest ไม่ได้ และอะไรที่ใช้ได้จริง

ถ้าคุณเคยลอง scrape Pinterest ด้วย requests + BeautifulSoup แล้วได้มาแค่ 16 รายการหรือหน้าว่างๆ คุณไม่ได้คิดไปเอง Pinterest สร้างด้วย React และเรนเดอร์เนื้อหา 100% ผ่าน JavaScript เมื่อคุณดึง URL ของ Pinterest ด้วย HTTP request ธรรมดา เซิร์ฟเวอร์จะส่งมาเพียง HTML โครงเปล่าๆ — มีแค่ <link> และ <script> ไม่กี่ตัว พร้อม <div> ว่างๆ ที่ React จะเอาไว้ mount แอป ข้อมูล pin, รูปภาพ, ชื่อเรื่อง และ grid ทั้งหมดจะถูกเติมเข้ามาหลังจาก JavaScript ทำงานในเบราว์เซอร์

ไม่มีการรัน JavaScript = ไม่เห็น pins

แล้วอะไรที่ใช้ได้? ตารางนี้ช่วยเปรียบเทียบแนวทางหลักๆ:

แนวทางรองรับ JS ไหมได้ข้อมูลครบไหมความซับซ้อนเหมาะกับ
requests + BeautifulSoupไม่รองรับ~0–16 รายการต่ำไม่เหมาะกับ Pinterest
Selenium / Playwrightรองรับใช่ แต่ต้องมี logic สำหรับ scrollปานกลางต้องการคุมได้ละเอียด, pipeline ใน Python
ดัก internal API ของ Pinterestรองรับใช่, เป็น JSON แบบแบ่งหน้าสูงดึงข้อมูลจำนวนมาก, ไม่ต้องใช้เบราว์เซอร์
Third-party Scraper APIรองรับแตกต่างกันไปต่ำต้องการสเกลโดยไม่ต้องดูแลโครงสร้างพื้นฐาน
เครื่องมือ no-code (Thunderbit)รองรับใช้ AI จัดโครงสร้างข้อมูลต่ำมากผู้ใช้ไม่สายเทคนิค, ต้องการผลเร็ว

สำหรับบทความนี้ ผมแนะนำให้ใช้ Playwright เป็นทางเลือกฝั่ง Python เพราะมันเรนเดอร์ JavaScript ได้ รองรับการจำลองการ scroll ดูแลโดยชุมชนอย่างดี (ดาวบน GitHub มากกว่า 78,600 ดวง และมีการเติบโตในตลาดงาน 180% YoY) อีกทั้งยัง เร็วกว่า Selenium 35–45% ใน benchmark ถ้าคุณอยากใช้แบบ no-code เดี๋ยวผมก็จะพูดถึงด้วย

Pinterest API ทางการ vs การ scrape ด้วย Python vs no-code: ควรเลือกแบบไหน

ก่อนจะเริ่มเขียนโค้ด ลองถามตัวเองก่อนว่าจำเป็นต้องเขียนจริงไหม นี่คือกรอบการตัดสินใจแบบง่ายๆ:

เกณฑ์Pinterest APIPython ScrapingThunderbit (No-Code)
ต้องขออนุมัติไหมต้องมีบัญชีธุรกิจ + วิดีโอเดโมไม่ต้องไม่ต้อง
เข้าถึง pins/boards สาธารณะได้ไหมจำกัด (เฉพาะข้อมูลของตัวเอง)ได้เต็มรูปแบบได้เต็มรูปแบบ
ดาวน์โหลดรูปความละเอียดสูงแล้วแต่กรณีได้ โดย parse URLได้ ผ่าน image extraction
รองรับ infinite scrollไม่มีได้ ด้วยโค้ดอัตโนมัติ
ต้องดูแลรักษาไหมต่ำสูง (selector เปลี่ยนได้)แทบไม่ต้อง (AI ปรับตัว)
Export ไป Sheets/Airtableต้องทำเองต้องเขียนโค้ดมีในตัว
เวลาในการตั้งค่าหลายชั่วโมง–หลายวัน30–60 นาที2 นาที

ถ้าคุณเป็นนักการตลาด คนดูแล ecommerce operations หรือใครก็ตามที่อยากได้ข้อมูล Pinterest ลงสเปรดชีตโดยไม่ต้องเขียนหรือดูแลสคริปต์ Python Thunderbit AI Web Scraper คือทางด่วน คุณเปิดหน้า Pinterest ไหนก็ได้ กด “AI Suggest Fields” แล้วกด “Scrape” จากนั้น export ไป Google Sheets, Excel, Airtable หรือ Notion ได้ตรงๆ ฟีเจอร์ scraping แบบ subpage ยังตามลิงก์ของ pin แต่ละอันเพื่อเติมข้อมูลให้ครบอัตโนมัติได้อีกด้วย ผมเคยเห็นทีมที่ไม่เคยเขียนโค้ดเลยดึง pins กว่า 500 รายการเข้า Google Sheet ได้ภายในไม่ถึง 3 นาที

ถ้าคุณอยากได้การควบคุมเต็มรูปแบบ อยากเอา scraper ไปเชื่อมกับ pipeline ใน Python หรือแค่ชอบความสนุกของการสร้างเครื่องมือเอง — อ่านต่อได้เลย

การตั้งค่า Python Environment สำหรับ Pinterest Scraping

  • ระดับความยาก: ปานกลาง
  • เวลาที่ใช้: ประมาณ 30–60 นาที (รวมเขียนโค้ดและทดสอบ)
  • สิ่งที่ต้องมี: Python 3.9+, เบราว์เซอร์ Chrome (สำหรับทดสอบ), สิทธิ์เข้าถึง terminal/command line

ติดตั้ง Playwright และ Dependencies

เริ่มจากสร้างโฟลเดอร์โปรเจกต์และตั้งค่า virtual environment:

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

ติดตั้ง Playwright และดาวน์โหลด Chromium browser binary:

pip install playwright
playwright install chromium

คุณจะใช้โมดูลในตัวของ Python อย่าง json, os และ csv สำหรับ export ข้อมูลด้วย ไม่ต้องติดตั้งเพิ่ม

โครงสร้างโฟลเดอร์โปรเจกต์

ผมแนะนำให้จัดระเบียบตั้งแต่ต้น:

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

ใน config.py ให้ตั้งค่า user agent string ของคุณ Pinterest มักบล็อกสัญญาณจาก headless browser แบบเริ่มต้น ดังนั้นควรใช้ค่าที่ดูสมจริง:

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"

ขั้นตอนที่ 1: สร้าง URL สำหรับค้นหาใน Pinterest

สร้าง search URL โดยใส่คำค้นของคุณลงใน template:

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

คุณสามารถทำให้เป็นตัวแปรสำหรับคำค้นใดก็ได้ พารามิเตอร์ rs=typed บอก Pinterest ว่าคำค้นนี้ถูกพิมพ์เอง ไม่ใช่คำแนะนำ ซึ่งบางครั้งมีผลต่อความเกี่ยวข้องของผลลัพธ์

ขั้นตอนที่ 2: เปิด Headless Browser และโหลดหน้าเว็บ

นี่คือแกนหลักของการตั้งค่า Playwright สังเกต user agent แบบกำหนดเอง — ถ้าไม่มี Pinterest มักจะบล็อกคุณหรือพาไปหน้า login wall

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)  # รอให้ JS เรนเดอร์ pins ชุดแรก

หลังจากรันแล้ว หน้าเว็บควรมี pins ชุดแรกโหลดขึ้นมาแล้ว โดยทั่วไปประมาณ 25–50 รายการ

ขั้นตอนที่ 3: ดึงข้อมูล Pin จากหน้าเว็บ

Pinterest ห่อแต่ละ pin ไว้ใน div ที่มี data-test-id='pinWrapper' ภายในจะมีลิงก์ (<a>) ที่เก็บ URL และ title ของ pin (ผ่าน aria-label) และมี <img> ที่เก็บ 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
            })

ตอนนี้ results จะมี pins ที่มองเห็นใน viewport แรก ถ้าต้องการมากกว่านี้ คุณต้อง scroll — ซึ่งเป็นหัวข้อสำคัญที่สุดของบทความนี้

ขั้นตอนที่ 4: บันทึกผลลัพธ์เป็น JSON หรือ CSV

หลังจากดึงข้อมูลได้แล้ว ให้เขียนออกไฟล์เพื่อใช้งานต่อได้สะดวก:

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)

ถ้าคุณจะเปิดไฟล์ใน Excel ให้ใช้ encoding แบบ utf-8-sig จะช่วยป้องกันอักขระเพี้ยน

การ scrape ทั้งบอร์ดของ Pinterest และโปรไฟล์ผู้ใช้

นี่คือช่องว่างสำคัญในบทความสอนทั่วไป ผมหาบทความคู่แข่งที่ลงลึกเรื่อง scraping บอร์ดหรือโปรไฟล์แทบไม่เจอ ทั้งที่เป็นฟีเจอร์ที่คนถามหาบ่อยมากในฟอรั่ม ผู้ใช้ต้องการดาวน์โหลด pins ทั้งบอร์ด จัดรูปภาพแยกเป็นโฟลเดอร์แต่ละบอร์ด และดึงข้อมูลระดับโปรไฟล์ เช่น จำนวนผู้ติดตามและรายการบอร์ด

ดึง pins ทั้งหมดจาก URL ของบอร์ด

URL ของบอร์ดจะมีรูปแบบ https://www.pinterest.com/{username}/{board-name}/ โครงสร้าง DOM คล้ายผลการค้นหา คือ pins ถูกห่อไว้ใน div[data-test-id='pinWrapper'] แต่คุณต้อง scroll เพื่อโหลดทั้งหมด

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):  # กำหนดเพดานความปลอดภัย
            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}: collected {len(all_pins)} unique pins")
            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  # ไม่มีเนื้อหาเพิ่มแล้ว

        await browser.close()
        return all_pins

สิ่งหนึ่งที่ต้องระวังคือ บางครั้งหน้า board จะมีแท็บ “More Ideas” แทรกเข้ามา ซึ่งแยก pins ที่ผู้ใช้บันทึกเองออกจากคำแนะนำเชิงอัลกอริทึม ถ้าคุณต้องการเฉพาะ pins ที่บันทึกไว้จริงของผู้ใช้ ให้หยุด scroll เมื่อเจอส่วนแบ่งนี้

scrape โปรไฟล์ผู้ใช้: บอร์ด, จำนวนผู้ติดตาม และ pins

URL ของโปรไฟล์จะมีรูปแบบ https://www.pinterest.com/{username}/ จากหน้าโปรไฟล์ คุณสามารถดึงข้อมูลได้ เช่น:

  • จำนวนผู้ติดตาม/ผู้ติดตามกลับ: มองหา div[data-test-id='follower-count']
  • รายการบอร์ด: บอร์ดแต่ละอันคือการ์ดที่ลิงก์ไป /{username}/{board-name}/
  • จำนวน pin ทั้งหมด: บางครั้งแสดงอยู่ในหัวข้อโปรไฟล์
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)

        # ดึงจำนวนผู้ติดตาม
        follower_el = await page.query_selector("div[data-test-id='follower-count']")
        followers = await follower_el.inner_text() if follower_el else "N/A"

        # ดึงลิงก์บอร์ด
        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}

ถ้าคุณต้องการ scrape pins ทั้งหมดในทุกบอร์ดของโปรไฟล์ ให้วนลูปรายการบอร์ดแล้วเรียก scrape_board() ทีละอัน คุณยังสามารถจัดเก็บรูปที่ดาวน์โหลดไว้แยกเป็นโฟลเดอร์ตามแต่ละบอร์ดได้โดยอัตโนมัติ

วิธีทำ Infinite Scroll ให้ใช้งานได้จริงระดับโปรดักชัน

นี่คือส่วนที่แยก scraper เล่นๆ ออกจาก scraper ใช้งานจริง ปัญหาอันดับหนึ่ง — และผมเห็นมันในเธรดฟอรั่มอย่างน้อยเป็นสิบๆ ครั้ง — คือ scraper มักดึงได้แค่ 16–25 รายการ เพราะ scroll ไม่ไกลพอ หรือใช้จำนวนครั้งแบบตายตัว เช่น for i in range(5): scroll() แล้วก็หวังให้มันได้ผล

วิธีนั้นไม่เสถียร Pinterest จะโหลดเนื้อหาใหม่เป็นชุดๆ ละประมาณ 25 pins เมื่อมีการ scroll ถ้าคุณ scroll ห้าครั้ง คุณอาจได้ 125 pins — หรืออาจได้แค่ 75 ถ้าเครือข่ายช้า หรือ 150 ถ้าชุดข้อมูลเล็ก คุณต้องใช้รูปแบบที่ฉลาดกว่านั้น

รูปแบบ Scroll จนกว่าจะไม่มีเนื้อหาใหม่

นี่คือฟังก์ชัน scroll ที่แข็งแรงกว่า โดยติดตาม pin ID ที่ไม่ซ้ำ ใช้ timeout ที่ปรับได้ มี retry logic และพิมพ์ความคืบหน้าให้ดู:

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} new pins | {len(all_pins)} total unique pins")

        if len(all_pins) >= max_pins:
            print(f"  ถึงขีดจำกัด max_pins ({max_pins}) แล้ว หยุดทำงาน")
            break

        if new_this_round == 0:
            no_new_count += 1
            if no_new_count >= 3:
                print("  ไม่มี pin ใหม่ติดต่อกัน 3 รอบ ถือว่าเนื้อหาหมดแล้ว")
                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("  ความสูงของหน้าไม่เปลี่ยนและไม่มี pin ใหม่ น่าจะถึงจุดสิ้นสุดของฟีดแล้ว")
            break

    return all_pins

ทำไมวิธีนี้ถึงเวิร์ก:

  • ตัดข้อมูลซ้ำด้วย href: URL ของแต่ละ pin ไม่ซ้ำกัน เราจึงใช้เป็น ID เพื่อป้องกันนับซ้ำเวลาหน้า DOM re-render ระหว่าง scroll
  • กฎสามครั้ง: ถ้า scroll ติดต่อกัน 3 ครั้งแล้วไม่มี pin ใหม่ เราจะหยุด วิธีนี้ช่วยกรณีที่หน้ากำลังโหลด แต่จริงๆ ไม่มีเนื้อหาใหม่แล้ว
  • สุ่มช่วงเวลาพัก: เพิ่มดีเลย์แบบสุ่ม 0.5–1.5 วินาทีระหว่างแต่ละรอบ จะดูเหมือนพฤติกรรมมนุษย์มากขึ้น และลดโอกาสโดนระบบ anti-bot
  • กำหนดเพดาน max scrolls: ป้องกันลูปไม่จบถ้ามีอะไรผิดพลาด

จัดการกรณีขอบเขตและปัญหาเฉพาะ

  • การแบ่งด้วย “More Ideas”: ในหน้า board บางครั้ง Pinterest จะแทรกส่วน “More Ideas” ถ้าคุณต้องการเฉพาะ pins ที่อยู่ในบอร์ดจริง คุณสามารถตรวจหาองค์ประกอบนี้แล้วหยุด scroll เมื่อมันโผล่ขึ้นมา
  • โดน rate limiting ระหว่าง session ยาวๆ: ถ้าคุณ scroll ผ่านบอร์ดที่มี pins หลายพันรายการ Pinterest อาจเริ่มจำกัดการตอบกลับ ถ้าคุณเห็นว่า scroll บางรอบไม่ดึงข้อมูลใหม่เลยเป็นช่วงๆ (แต่ไม่ได้ 3 รอบติด) ให้เพิ่มเวลาพักเป็น 5 วินาทีขึ้นไป

ดึงรูป Pinterest ความละเอียดสูง (ไม่ใช่แค่ thumbnail)

เรื่องนี้ทำให้หลายคนหัวร้อน คุณ scrape pins มาหลายรายการ ดาวน์โหลดรูปออกมา แล้วพบว่าได้แค่ thumbnail 236px ขนาดจิ๋ว ผู้ใช้ในฟอรั่มมักบ่นว่า “คุณภาพแย่มาก เล็กเกินไป” วิธีแก้คือทำความเข้าใจโครงสร้าง URL ของภาพบน Pinterest

ทำความเข้าใจ path ของรูปภาพ Pinterest

รูปภาพของ Pinterest จะถูกเสิร์ฟจาก https://i.pinimg.com/{size}/{hash}.jpg โดย {size} คือส่วนที่กำหนดความละเอียด:

Path ขนาดมิติภาพการใช้งาน
/236x/กว้าง 236pxมุมมองกริดแบบเริ่มต้น (ที่คุณได้ตามปกติ)
/474x/กว้าง 474pxความละเอียดปานกลาง
/736x/กว้าง 736pxหน้า detail ของ pin / มุมมองขยาย
/originals/ขนาดต้นฉบับที่อัปโหลดความละเอียดเต็ม

ฟังก์ชันช่วย: อัปเกรด URL รูป Pinterest ให้เป็นความละเอียดสูงสุด

นี่คือฟังก์ชันที่เขียน URL รูป Pinterest ใหม่ให้ใช้ความละเอียดสูงที่สุดที่มี พร้อม logic สำรองเมื่อใช้งานไม่ได้:

import requests as req

def upgrade_image_url(url, preferred_size="originals"):
    """เขียน URL รูป Pinterest ใหม่ให้เป็นความละเอียดสูงสุดที่หาได้"""
    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  # ถ้าล้มเหลวทั้งหมด ให้คืนค่าเดิม

หมายเหตุสำคัญ (ณ ปี 2025): path /originals/ เริ่มคืนค่า HTTP 403 Forbidden บ่อยขึ้นเรื่อยๆ มี issue ที่บันทึกไว้ใน gallery-dl ยืนยันพฤติกรรมนี้ ณ ช่วงกลางปี 2025 ดังนั้นค่าที่ไว้ใจได้สูงสุดคือ /736x/ ฟังก์ชันนี้จะลอง /originals/ ก่อน แล้วค่อย fallback ไป /736x/ ให้อัตโนมัติ

ดาวน์โหลดรูปลงโฟลเดอร์ที่จัดระเบียบไว้

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"  ดาวน์โหลด {filename} สำเร็จ ({len(resp.content) // 1024} KB)")
            else:
                print(f"  ดาวน์โหลด {filename} ไม่สำเร็จ: HTTP {resp.status_code}")
        except Exception as e:
            print(f"  เกิดข้อผิดพลาดขณะดาวน์โหลด {filename}: {e}")
        time.sleep(delay + random.uniform(0.3, 0.8))

ควรใส่ดีเลย์ระหว่างดาวน์โหลดเพื่อจำกัดอัตราการร้องขอ ผมมักใช้ 1.5–2.3 วินาที พร้อม jitter ถ้าไม่ใส่ Pinterest อาจบล็อก IP ของคุณหลังจาก request ไปไม่กี่ร้อยครั้ง

การ export ข้อมูล Pinterest ที่ scrape มา

Export เป็น CSV หรือ JSON

ก่อนหน้านี้เราได้พูดพื้นฐานไปแล้ว ถ้าชุดข้อมูลใหญ่ (10,000+ pins) ผมแนะนำ JSON Lines — หนึ่ง object ต่อหนึ่งบรรทัด — เพราะสตรีมและประมวลผลง่ายกว่า:

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 ไป Google Sheets, Airtable หรือ Notion

ถ้าคุณอยากส่งข้อมูลจาก Python ไป Google Sheets โดยตรง คุณต้องใช้ไลบรารี gspread และ Google Cloud service account สำหรับ Airtable ให้ใช้ pyairtable สำหรับ Notion ใช้ notion-client แต่ละตัวต้องตั้งค่า API key และเพิ่มความซับซ้อนจริงจังให้กับ pipeline

หรือ — ผมยอมรับว่ามีอคติอยู่บ้าง แต่ก็เป็นทางที่เร็วที่สุดจริงๆ — คุณสามารถใช้ Thunderbit เพื่อ scrape Pinterest แล้ว export ไปยังปลายทางเหล่านี้ได้ในคลิกเดียว ไม่ต้องมี API key ไม่ต้องมี service account ไม่ต้องเขียนโค้ดเพิ่ม Thunderbit Chrome Extension จัดการ export ให้ในตัว

เคล็ดลับป้องกันการโดนบล็อกขณะ scrape Pinterest

ระบบ anti-bot ของ Pinterest ถูกประเมินว่ามีความยากในการ bypass อยู่ที่ 6/10 โดย ScrapeOps — ไม่ง่าย แต่ก็ไม่ใช่เป้าหมายที่ยากที่สุด มันใช้ browser fingerprinting, behavioral analysis และ rate limiting ตาม IP สิ่งที่ได้ผลมีดังนี้:

  • หมุนเวียน user agent: ใช้ชุด user agent ของ Chrome จริงๆ แล้วสุ่มเลือกหนึ่งค่าในแต่ละ session
  • ใส่ delay แบบสุ่ม: รอ 2–5 วินาทีระหว่าง scroll และ request พร้อม jitter ถ้าไม่มี proxy ให้เพิ่มเป็น 10–15 วินาที
  • ใช้ viewport ที่ดูสมจริง: ตั้ง viewport={"width": 1920, "height": 1080} — อย่าใช้ขนาดแปลกๆ หรือเล็กเกินไป
  • ใช้ proxy ถ้าต้องการสเกลใหญ่: ถ้าคุณ scrape หลายพัน pins ให้หมุน residential proxy ด้วย ไม่เช่นนั้นมีโอกาสโดนบล็อก IP หลังจากไม่กี่ร้อย request
  • เคารพ robots.txt: Pinterest robots.txt บล็อก crawler อัตโนมัติส่วนใหญ่ และมี disallow rules ราว 180 รายการ ควรคำนึงถึงเรื่อง compliance
  • หลีกเลี่ยงการ scrape ตอนล็อกอิน: ควรเก็บเฉพาะเนื้อหาที่มองเห็นได้แบบ public ตอนล็อกเอาต์ การ scrape หลังล็อกอินเพิ่มทั้งความเสี่ยงทางกฎหมายและความเสี่ยงทางเทคนิค

Thunderbit จัดการ anti-bot และ CAPTCHA ให้โดยอัตโนมัติผ่าน AI engine — ถ้าคุณเลือก no-code ก็จะมีเรื่องให้ต้องดูแลน้อยลงอีกหนึ่งอย่าง

ข้อควรพิจารณาด้านกฎหมายและจริยธรรมสำหรับ Pinterest Scraping

ขอพูดสั้นๆ เพราะไม่ใช่ประเด็นหลักของบทความ แต่สำคัญมาก

ข้อกำหนดการใช้งานของ Pinterest (Section 2a) ระบุว่าคุณตกลงว่าจะไม่ “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).” อย่างไรก็ตาม ศาลมักวินิจฉัยว่าการ scrape ข้อมูลที่เปิดสาธารณะไม่ถือว่าละเมิด Computer Fraud and Abuse Act — ดู hiQ v. LinkedIn และ Meta v. Bright Data (ม.ค. 2024) ที่ศาลตัดสินว่าการ scrape ข้อมูลที่มองเห็นได้แบบสาธารณะในขณะที่ล็อกเอาต์นั้นถูกกฎหมาย

กติกาพื้นฐานมีดังนี้:

  • scrape เฉพาะเนื้อหาที่เปิดสาธารณะ และทำตอนล็อกเอาต์
  • อย่านำข้อมูลที่ scrape ไปใช้สแปมหรือปลอมเป็นผู้ใช้อื่น
  • เคารพลิขสิทธิ์ของภาพ — ถ้าเป็นไปได้ให้ดึงเฉพาะ metadata และอย่าแจกจ่ายภาพที่มีลิขสิทธิ์ในเชิงพาณิชย์โดยไม่ได้รับอนุญาต
  • ถ้าคุณตั้งใจใช้ข้อมูลเพื่อการค้า ควรปรึกษาทนาย

ถ้าอยากอ่านภาพรวมด้านกฎหมายแบบลึกขึ้น ดูคู่มือ web scraping legal implications ของเราได้

สรุป: คุณได้เรียนรู้อะไร และควรไปต่ออย่างไร

ตอนนี้คุณรู้แล้วว่าทำไมการ scrape แบบ static ถึงใช้ไม่ได้กับ Pinterest (เพราะมันเป็น React SPA — ไม่มี JavaScript ก็ไม่มีข้อมูล) วิธีใช้ Playwright เพื่อ scrape ผลการค้นหา บอร์ด และโปรไฟล์ผู้ใช้ วิธีสร้าง handler สำหรับ infinite scroll ระดับโปรดักชันที่ไม่หยุดแค่ 16 pins และวิธีดึงรูปความละเอียดสูงแทน thumbnail จิ๋วๆ

สรุปประเด็นสำคัญสั้นๆ:

  • requests + BeautifulSoup ใช้กับ Pinterest ไม่ได้ อย่าเสียเวลา
  • Playwright คือเครื่องมือ Python ที่เหมาะที่สุด — เร็ว รองรับดี และเรนเดอร์ JS ได้โดยตรง
  • Infinite scroll ต้องใช้ลูปแบบ deduplication ไม่ใช่นับจำนวนครั้งตายตัว
  • รูปความละเอียดสูง ต้อง rewrite path ของ URL — ใช้ /736x/ เป็นเป้าหมาย (เพราะ /originals/ มักคืน 403)
  • การ scrape บอร์ดและโปรไฟล์ ยังมีบทความสอนน้อย แต่ทำได้ไม่ยากถ้าใช้ selector ถูกต้อง
  • สำหรับคนไม่เขียนโค้ดหรือทีมที่ต้องการความเร็ว Thunderbit ช่วย scrape Pinterest ได้ใน 2 คลิก และ export ไป Google Sheets, Excel, Airtable หรือ Notion — ไม่ต้องใช้ Python ลองใช้ฟรีผ่าน Chrome Extension

ถ้าคุณกำลังสร้าง pipeline ด้วย Python โค้ดในคู่มือนี้คือฐานที่ดีมาก แต่ถ้าคุณแค่ต้องการข้อมูล Thunderbit คือทางลัด ไม่ว่าทางไหน คุณก็ไม่ต้องติดอยู่กับ 16 pins และหน้าจอที่จ้องแล้วได้แต่เงียบอีกต่อไป

สำหรับเรื่องการ scrape และการดึงข้อมูลเพิ่มเติม ลองดูคู่มือของเราเกี่ยวกับ how to web scrape with Python, best automated web scraping tools, และ scraping data from website to Excel นอกจากนี้คุณยังสามารถดู ราคา Thunderbit หรือรับชมวิดีโอสอนบน Thunderbit YouTube Channel ได้ด้วย

คำถามที่พบบ่อย

1. ใช้ BeautifulSoup scrape Pinterest ได้ไหม?

ใช้ไม่ได้ดีเท่าไรด้วยตัวมันเอง เพราะ Pinterest เรนเดอร์เนื้อหาทั้งหมดผ่าน JavaScript ดังนั้น requests + BeautifulSoup จะเห็นแค่ HTML โครงเปล่าๆ คุณต้องใช้ headless browser อย่าง Playwright หรือ Selenium เพื่อเรนเดอร์หน้าก่อน หรือใช้เครื่องมือ no-code อย่าง Thunderbit ที่จัดการการเรนเดอร์ JS ให้อัตโนมัติ

2. หนึ่ง session scrape Pinterest ได้กี่ pins?

ขึ้นอยู่กับ logic ของการ scroll และการรับมือ anti-bot ถ้าใช้ตัวจัดการ infinite scroll ระดับโปรดักชันในคู่มือนี้ (deduplication, timeout, retry logic) คุณจะ scrape ได้อย่างน่าเชื่อถือเป็นหลักร้อยถึงหลักพัน pins ต่อบอร์ดหรือคำค้น สำหรับบอร์ดขนาดใหญ่มาก อาจต้องใช้เวลาหลายนาทีในการ scroll และเก็บข้อมูล

3. ทำไมรูป Pinterest ที่ scrape มาเล็กมาก?

โดยค่าเริ่มต้น Pinterest จะแสดง thumbnail ขนาด /236x/ ในมุมมองกริด ถ้าต้องการความละเอียดสูงขึ้น ให้เขียน path ของ URL รูปใหม่เป็น /736x/ หรือ /originals/ อย่างไรก็ตาม ณ ปี 2025 /originals/ เริ่มคืน error 403 บ่อยขึ้น ดังนั้น /736x/ จึงเป็นตัวเลือกที่เชื่อถือได้ที่สุด

4. การ scrape Pinterest ถูกกฎหมายไหม?

โดยทั่วไปการ scrape ข้อมูลที่เปิดสาธารณะได้รับการยอมรับจากคำตัดสินของศาลในช่วงหลังๆ (เช่น hiQ v. LinkedIn, Meta v. Bright Data) แต่ข้อกำหนดการใช้งานของ Pinterest ห้ามการเข้าถึงด้วยวิธีอัตโนมัติที่ไม่ได้รับอนุญาต ควรยึดเฉพาะเนื้อหาสาธารณะ ไม่ใช้ข้อมูลไปสแปม เคารพลิขสิทธิ์ และปรึกษาผู้เชี่ยวชาญด้านกฎหมายหากจะใช้เชิงพาณิชย์

5. ทางเลือก no-code ที่ดีที่สุดสำหรับการ scrape Pinterest คืออะไร?

Thunderbit AI Web Scraper สามารถดึงข้อมูล pin บน Pinterest — ชื่อ รูป URL คำอธิบาย — ได้ใน 2 คลิก พร้อม export ไป Google Sheets, Excel, Airtable หรือ Notion ในตัว มันรองรับ JavaScript rendering, infinite scroll และปัญหา anti-bot ให้อัตโนมัติ คุณจึงไม่ต้องเขียนหรือดูแลโค้ดเอง

เรียนรู้เพิ่มเติม

Shuai Guan
Shuai Guan
CEO แห่ง Thunderbit | ผู้เชี่ยวชาญด้านการทำงานอัตโนมัติของข้อมูลด้วย AI Shuai Guan เป็น CEO ของ Thunderbit และเป็นศิษย์เก่าคณะวิศวกรรมศาสตร์ มหาวิทยาลัยมิชิแกน ด้วยประสบการณ์เกือบสิบปีในสายเทคโนโลยีและสถาปัตยกรรม SaaS เขาเชี่ยวชาญในการเปลี่ยนโมเดล AI ที่ซับซ้อนให้กลายเป็นเครื่องมือดึงข้อมูลแบบไม่ต้องเขียนโค้ดที่ใช้งานได้จริง บนบล็อกนี้ เขาแบ่งปันมุมมองตรงไปตรงมาและผ่านการใช้งานจริงเกี่ยวกับการทำเว็บสแครปปิงและกลยุทธ์การทำงานอัตโนมัติ เพื่อช่วยให้คุณสร้างเวิร์กโฟลว์ที่ฉลาดขึ้นและขับเคลื่อนด้วยข้อมูลได้ดียิ่งขึ้น เมื่อไม่ได้กำลังปรับแต่งเวิร์กโฟลว์ข้อมูล เขาก็ยังใช้สายตาที่พิถีพิถันแบบเดียวกันกับงานอดิเรกด้านการถ่ายภาพ
สารบัญ
Thunderbit · เอเจนต์ข้อมูลเว็บด้วย AI

ดึงข้อมูลจากทุกหน้าได้ใน 1 คลิก

ได้รับความไว้วางใจจากผู้ใช้กว่า 250,000+ คน
มีแผนใช้ฟรี
จากหน้าเว็บสู่สเปรดชีต
บอกสิ่งที่ต้องการ — Thunderbit’s AI Agent จะดึงข้อมูลและส่งออกไปยัง Excel, Google Sheets, Airtable หรือ Notion เริ่มต้นได้ฟรี
Chrome Store Rating
PRODUCT HUNT#1 Product of the Week