How to Scrape Pinterest: A Practical Guide to Pins, Boards & Images

Pavlo Zinkovski 14 Jul 2026 10 min read

Web scraping Pinterest means programmatically collecting public data from the platform (pin images, titles and descriptions, board contents, and profile metadata) instead of saving it by hand. It powers trend and creative research, e-commerce product discovery, and image datasets for AI models. This guide covers three ways to do it: Python, no-code tools, and a managed scraping API.

Is It Legal to Scrape Pinterest?

Scraping publicly available Pinterest data is generally treated as permissible under recent US case law (e.g., hiQ v. LinkedIn), but Pinterest’s Terms of Service prohibit automated access, and pin images are protected by copyright; collecting them for redistribution is a separate question from whether scraping is legal. Scrape only public data, avoid anything behind a login, and comply with GDPR/CCPA for any personal data.

What Data Can You Extract from Pinterest?

Method 1: Scrape Pinterest with Python

Python gives you two practical ways to collect public Pinterest data. You can use a headless browser to render the page and scroll through lazy-loaded pins, which is easier to understand and closely reproduces normal browsing. Alternatively, you can inspect and replay the JSON requests Pinterest sends in the background, which is faster and uses fewer computing resources.

1a. Render and scroll with a headless browser

Pinterest loads many pins dynamically as the visitor scrolls, so a basic HTTP request may return only the initial page structure. A headless browser such as Playwright can render the page, execute its JavaScript, and continue scrolling until Pinterest stops adding new pins. This approach is straightforward and works well for public boards, profiles, and search pages, although it consumes more resources than requesting structured JSON directly.

Install Playwright and its Chromium browser:

pip install playwright
playwright install chromium

The following Python example opens a public Pinterest page, scrolls through the results, and extracts each pin’s URL, image URL, available image resolutions, and visible title or description:

from urllib.parse import urljoin

from playwright.sync_api import sync_playwright


PINTEREST_URL = "https://www.pinterest.com/pinterest/official-news/"
MAX_SCROLLS = 30
STABLE_ROUNDS_REQUIRED = 3
SCROLL_DELAY_MS = 1500


def scrape_pinterest_page(url: str) -> list[dict]:
    pins_by_url = {}

    with sync_playwright() as playwright:
        browser = playwright.chromium.launch(headless=True)
        page = browser.new_page(
            viewport={"width": 1440, "height": 1000}
        )

        page.goto(url, wait_until="domcontentloaded", timeout=60_000)
        page.wait_for_timeout(2_000)

        stable_rounds = 0
        previous_pin_count = 0

        for _ in range(MAX_SCROLLS):
            pin_links = page.locator('a[href*="/pin/"]')

            for index in range(pin_links.count()):
                link = pin_links.nth(index)
                href = link.get_attribute("href")

                if not href:
                    continue

                pin_url = urljoin("https://www.pinterest.com", href)
                image = link.locator("img").first

                if image.count() == 0:
                    continue

                image_url = image.get_attribute("src")
                image_srcset = image.get_attribute("srcset")
                image_alt = image.get_attribute("alt")

                # Some visible text may contain the pin title or description.
                card_text = link.inner_text().strip()

                pins_by_url[pin_url] = {
                    "pin_url": pin_url,
                    "title_or_alt_text": image_alt,
                    "visible_text": card_text or None,
                    "image_url": image_url,
                    "image_resolutions": image_srcset,
                }

            current_pin_count = len(pins_by_url)

            # Stop after several scrolls produce no new unique pins.
            if current_pin_count == previous_pin_count:
                stable_rounds += 1
            else:
                stable_rounds = 0
                previous_pin_count = current_pin_count

            if stable_rounds >= STABLE_ROUNDS_REQUIRED:
                break

            page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
            page.wait_for_timeout(SCROLL_DELAY_MS)

        browser.close()

    return list(pins_by_url.values())


if __name__ == "__main__":
    pins = scrape_pinterest_page(PINTEREST_URL)

    print(f"Extracted {len(pins)} unique pins.")

    for pin in pins[:5]:
        print(pin)

The script stores pins in a dictionary keyed by URL, preventing duplicates when the same pin appears in multiple page elements. It also stops only after several consecutive scrolls produce no new results, rather than relying on a fixed page height.

For larger boards, increase MAX_SCROLLS, but retain a delay between scrolls to avoid sending requests too aggressively. You can then save the returned list as JSON or CSV, or download the files referenced by image_url. Pinterest changes its page markup periodically, so selectors such as a[href*="/pin/"] and the surrounding metadata logic should be tested before using the script in production.

1b. Read Pinterest’s JSON responses directly

A headless browser is useful when you need Pinterest to render the page for you, but it carries the overhead of running a full browser. A faster alternative is to inspect the background requests Pinterest makes as you scroll. These XHR or fetch requests often return structured JSON containing pin IDs, descriptions, image URLs, board details, destination links, and other publicly displayed metadata.

Pinterest changes its internal request URLs and parameters over time, so avoid copying a fixed endpoint from an old tutorial. Instead, capture the current request from your browser:

1. Open a public Pinterest board or search page.
2. Open Developer Tools → Network.
3. Filter the requests by Fetch/XHR.
4. Scroll until another batch of pins appears.
5. Inspect the new requests and check their Preview or Response tabs.
6. Find the request whose JSON contains pin IDs, image URLs, or descriptions.
7. Record its request method, URL, query parameters, headers, cookies, and request body, if present.

Most browsers also provide a Copy as cURL option. This is often the easiest way to preserve the complete request before translating it into Python.

The following template replays a captured request with the requests library:

import json

import requests


# Capture these values from the browser's Network tab.
METHOD = "GET"
REQUEST_URL = "PASTE_THE_CURRENT_XHR_REQUEST_URL_HERE"

HEADERS = {
    "User-Agent": "PASTE_YOUR_BROWSER_USER_AGENT_HERE",
    "Accept": "application/json, text/plain, */*",
    "Referer": "PASTE_THE_PUBLIC_BOARD_OR_SEARCH_URL_HERE",
}

COOKIES = {
    # Add only the cookies included in the captured request.
    # "cookie_name": "cookie_value",
}

# Use this only when the captured request includes a JSON body.
REQUEST_BODY = None

session = requests.Session()

response = session.request(
    method=METHOD,
    url=REQUEST_URL,
    headers=HEADERS,
    cookies=COOKIES,
    json=REQUEST_BODY,
    timeout=30,
)

response.raise_for_status()
data = response.json()

# Save the unmodified response first so you can inspect its structure.
with open("pinterest_response.json", "w", encoding="utf-8") as file:
    json.dump(data, file, ensure_ascii=False, indent=2)

print("JSON response saved to pinterest_response.json")

The exact nesting of the response varies, so inspect the saved file before writing your parser. Search for recognizable values such as a visible pin title, /pin/, an image hostname, or fields containing id, description, images, board, or link. Once you identify the relevant object, map its values to the article’s shared data model: pin ID, title or description, image URL and resolutions, destination link, board details, creator information, and publicly shown engagement counts.

You should also look for a pagination value in the response or request, sometimes represented as a cursor, bookmark, or continuation token. Pinterest sends this value with the next background request when more pins are loaded. Repeating the request with each newly returned token lets you collect additional batches without rendering and scrolling through the full page.

This approach is usually faster and less resource-intensive than browser automation because Python processes the structured response directly. Its main drawback is maintenance: request parameters, JSON fields, and pagination logic can change, so capture and verify the live request whenever you update the scraper.

Method 2: No-Code Pinterest Scrapers

No-code tools are the fastest way to collect Pinterest data when you do not want to build and maintain a scraper yourself. They typically let you enter a board, profile, search, or pin URL, choose the fields you need, and export the results without writing Python.

Apify’s Pinterest Scrapers run prebuilt cloud scrapers and can return pin, board, profile, and image data in structured formats. It is a practical option for scheduled jobs or larger exports when you are comfortable configuring an existing scraper.

Browse AI lets you record actions in a browser and turn them into a reusable scraping workflow. This can work well for smaller, repeatable tasks where you mainly need visible page data and simple exports.

Axiom.ai takes a similar browser-automation approach, allowing you to build step-by-step workflows for opening Pinterest pages, scrolling through results, extracting fields, and saving the output.

The main advantage of these tools is speed: you can often reach the first usable dataset much faster than with a custom script. The trade-off is less control over selectors, pagination, output fields, and error handling, along with an ongoing subscription or usage cost. They are a good fit for small or occasional jobs, but custom scraping software or a managed scraping API may be more suitable when you need reliable, high-volume collection.

Method 3: Scraping Pinterest at Scale (API)

The Python approaches above work well for experiments and one-off collection jobs. At production scale, however, maintaining headless browsers, proxy rotation, retries, and access logic can become a separate engineering project. 

A managed Web Scraper API moves that infrastructure behind a single endpoint while leaving field selection and parsing under your control. Infatica’s Web Scraper API can render JavaScript-heavy pages and request localized results from different countries.

Example: Render and parse a Pinterest page

The /render endpoint accepts a Pinterest URL in a POST request and authenticates it through the X-API-Key header. Setting return_html to true returns the rendered HTML directly, which you can then parse into the same pin data model used in the earlier methods.

Install the required packages (you can also read our Beautiful Soup scraping guide):

pip install requests beautifulsoup4

Then store your API key in the INFATICA_API_KEY environment variable and run the following script:

import os
from urllib.parse import urljoin

import requests
from bs4 import BeautifulSoup


API_URL = "https://scrape.infatica.io/render"
PINTEREST_URL = "https://www.pinterest.com/<username>/<board>/"

api_key = os.getenv("INFATICA_API_KEY")

if not api_key:
    raise RuntimeError("Set the INFATICA_API_KEY environment variable.")

response = requests.post(
    API_URL,
    headers={
        "X-API-Key": api_key,
        "Content-Type": "application/json",
    },
    json={
        "url": PINTEREST_URL,
        "country": "US",
        "language": "en-US",
        # Return rendered HTML instead of a JSON response wrapper.
        "return_html": True,
    },
    timeout=90,
)

response.raise_for_status()
soup = BeautifulSoup(response.text, "html.parser")

pins = {}

for link in soup.select('a[href*="/pin/"]'):
    image = link.select_one("img")
    href = link.get("href")

    if not image or not href:
        continue

    pin_url = urljoin("https://www.pinterest.com", href)

    # Keying by URL removes duplicate pin elements.
    pins[pin_url] = {
        "pin_url": pin_url,
        "title": image.get("alt"),
        "image_url": image.get("src"),
        "image_resolutions": image.get("srcset"),
    }

print(f"Extracted {len(pins)} pins.")

for pin in list(pins.values())[:5]:
    print(pin)

In this example, the API handles the browser-rendering and network-access layer, while the script remains responsible for selecting fields and organizing the output. Changing country and language lets you request a localized version of the public page; both parameters use standard country and language codes documented here.

The generic rendering endpoint returns page content rather than a Pinterest-specific dataset, so you still control the parsing schema. For a whole board, you may also need pagination or a workflow that continues loading additional batches, depending on how much content appears in the rendered response. For a one-time export, the headless-browser method may be enough. An API becomes more useful when the same job must run repeatedly or reliably in production. 

How to Avoid Getting Blocked on Pinterest

Pinterest relies heavily on JavaScript, infinite scrolling, and lazy-loaded images, so scraping it is not simply a matter of downloading one HTML page. Blocks are more likely when a scraper sends requests too quickly, uses an unrealistic browser fingerprint, or repeatedly accesses the platform from the same IP address:

Handle infinite scroll and lazy loading

As shown in Method 1, you can handle infinite scroll either by rendering and scrolling the page or by replaying its background JSON requests. Whichever approach you use, wait for each batch to load and stop only after several attempts return no new pins.

Send realistic request headers

Requests made with incomplete or inconsistent headers can stand out from ordinary browser traffic. At minimum, use a current browser User-Agent and appropriate Accept, Accept-Language, and Referer values. When replaying a request captured through DevTools, preserve the headers and cookies that are necessary for that specific public page.

The headers should also agree with one another. For example, pairing a mobile User-Agent with desktop-only browser headers can make the request look artificial. Avoid copying every browser header indiscriminately, however: unnecessary or stale values can be just as suspicious as missing ones.

Throttle requests and rotate IP addresses

Sending many requests in a short period can trigger rate limits or temporary IP restrictions. Add delays, limit concurrency, retry failed requests with exponential backoff, and avoid repeatedly requesting the same resource. Your scraper should slow down after responses such as 429 Too Many Requests rather than retrying immediately.

IP rotation becomes especially relevant when collecting large boards or downloading image datasets. One pin may require requests for the page, metadata, and multiple image resolutions, so the total request volume can grow much faster than the number of records in your output. Residential proxies can distribute that traffic across different IP addresses and locations, reducing the pressure placed on any single connection.

Scraping Pinterest at scale?

Skip the proxy and headless-browser maintenance. Infatica’s Web Scraper API returns clean JSON from a Pinterest URL. 35M+ residential IPs, ethically sourced proxy network, JavaScript rendering and CAPTCHAs handled. Start with 5,000 requests free, no credit card.

Pinterest Scraping FAQ

Pavlo Zinkovski

As Infatica's CTO & CEO, Pavlo shares the knowledge on the technical fundamentals of proxies.