Pinterest Scraping: How to Extract Pins and Categories

Pinterest is a goldmine of visual and intent data: hundreds of millions of people curating products, recipes, styles, and ideas into boards, tagged and organized into topics. For marketers, trend researchers, and e-commerce teams, that curation is worth analyzing — which is why Pinterest scraping keeps coming up. This guide covers how to extract pins, boards, and the category/topic taxonomy from Pinterest in 2026, the two real routes (the official API versus scraping public data), the anti-blocking measures you'll hit, and working patterns for each. Whether you want a quick category list or a full Pinterest data extraction pipeline, here's the practical picture.

Years ago you could grab the whole category list in a minute with a simple Chrome scraper extension — and for tiny one-off jobs that still works. But Pinterest today is a JavaScript-heavy app with real bot defenses, so let's do this properly.

What you can extract from Pinterest

Depending on the route you take, the reachable data includes:

• Pins — image/video URL, title, description, destination link, dominant colors, and engagement signals like save counts.
• Boards — title, description, pin count, owner, and the pins they contain.
• User/profile data — public profile fields, follower counts, and public boards.
• Topics / interests (the modern "categories") — Pinterest's browsable taxonomy and the pins within each topic.
• Search results and related pins — what surfaces for a keyword, useful for keyword and trend research.

Route 1: the official Pinterest API (v5)

Before scraping anything, check whether the official Pinterest API v5 covers your need — it's the sanctioned, stable path.

What to know in 2026:

• It's free, but gated by approval. A Trial tier lets you test in a sandbox (on the order of ~1,000 requests/day, with test tokens that expire in about a day and pins that stay hidden from the public). Standard (production) access requires submitting your app for review — typically including a video demo of your OAuth flow — before your integration goes live.
• It's OAuth-scoped to accounts that authorize your app. You get your own (or a consenting user's) pins, boards, and account/analytics data, plus some public content and media data.
• It has hard limits on breadth. The API does not hand you arbitrary users' private boards or pins, and it doesn't expose general search data. There are also data-storage restrictions — you're generally expected to fetch fresh via the API rather than warehouse most of it (campaign analytics being the notable exception).

Bottom line: the API is excellent for managing your own Pinterest presence, publishing pins, and pulling your ads/analytics. It's a poor fit for broad collection of public data across boards, topics, and search — which is exactly where scraping comes in. This is the same API-vs-scraping trade-off you see on most large platforms.

Route 2: scraping public Pinterest data

Most public Pinterest content — pins, public boards, topic feeds — is viewable without logging in, and that's the material a scraper targets. A caveat first: Pinterest's terms of service restrict unauthorized automated collection, so limit yourself to public data, stay well within reasonable rates, don't touch anything behind a login you're not entitled to, and get your own read on whether your use is permissible. With that framing, here's how the site actually serves data and how to extract it.

How Pinterest loads its data

Pinterest is a single-page app: the initial HTML is mostly a shell, and the real content streams in as you scroll (infinite pagination) via internal JSON endpoints its front-end calls. Under the hood, the web app hits resource endpoints — URLs of the shape /resource/<Something>Resource/get/ that take a JSON data parameter (with the board, username, topic, or query, plus options) and return structured JSON. Pagination is driven by a bookmark cursor the response hands back, which you feed into the next request to get the following page.

That gives you two extraction strategies:

1. Call the internal JSON endpoint directly — fastest and lightest, no browser needed.
2. Drive a headless browser and scroll — heavier but resilient to endpoint changes.

Strategy A: the hidden JSON endpoint

The efficient approach is to reproduce the request the page makes to its own hidden API. You discover the exact endpoint and payload by opening DevTools → Network, loading a board or topic, and watching the /resource/.../get/ calls — then replay them from code, following the bookmark for pagination. Endpoint and field names do change over time, so treat the following as the shape, not a contract:

import requests, json

def fetch_board_page(username, board, bookmark=None):
    options = {"username": username, "slug": board, "page_size": 25}
    if bookmark:
        options["bookmarks"] = [bookmark]
    params = {"data": json.dumps({"options": options, "context": {}})}

    r = requests.get(
        "https://www.pinterest.com/resource/BoardFeedResource/get/",
        params=params,
        headers={
            "User-Agent": "Mozilla/5.0 ...",        # a real browser UA
            "X-Requested-With": "XMLHttpRequest",
            "Accept": "application/json",
        },
    )
    payload = r.json()
    pins = payload["resource_response"]["data"]
    next_bookmark = payload["resource_response"].get("bookmark")
    return pins, next_bookmark

# paginate until the bookmark signals the end
bookmark, all_pins = None, []
while True:
    pins, bookmark = fetch_board_page("someuser", "some-board", bookmark)
    all_pins.extend(pins)
    if not bookmark or bookmark == "-end-":
        break

From each pin object you pull the image URL, title/description, destination link, and save counts. The same pattern, against the search or topic resource, gives you keyword results or a topic feed.

Strategy B: headless browser with scrolling

When you'd rather not chase internal endpoints, drive a real browser with Playwright or another headless browser, scroll to trigger lazy loading, and read the rendered pins from the DOM:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://www.pinterest.com/someuser/some-board/")

    seen = set()
    for _ in range(20):                      # scroll to load more pins
        page.mouse.wheel(0, 4000)
        page.wait_for_timeout(1500)
        for a in page.query_selector_all("a[href*='/pin/']"):
            href = a.get_attribute("href")
            if href:
                seen.add(href)

    print(f"collected {len(seen)} pin links")
    browser.close()

This is slower and heavier but survives endpoint churn, and it handles anything that only appears after rendering. For big jobs, many teams combine the two — a browser to bootstrap a session, then the JSON endpoint for speed.

No-code and ready-made options

If you don't want to build a Pinterest scraper from scratch, there are ready-made ones: hosted scraping actors/APIs and marketplace tools that expose Pinterest board/pin/search extraction behind a simple interface, and browser scraper extensions for small pulls like grabbing a category or board list. These trade flexibility and cost for convenience.

Getting the categories / topics

The original interest here was Pinterest's category list. Pinterest has since reworked flat "categories" into a richer system of topics/interests (and surfaces like Today). You can still enumerate the taxonomy: crawl Pinterest's topic/interest directory pages (or the resource endpoint that backs them) to collect topic names and slugs, then, for each topic slug, page through its feed to pull the pins. The result is exactly what the old one-minute scrape produced — a table of categories and their links — just against the modern structure, and now extended with the pins inside each.

Avoiding blocks

Pinterest runs moderate but real anti-bot defenses — rate limiting and bot detection — so aggressive scraping gets throttled or blocked. To keep a web scraping Pinterest job healthy:

• Use rotating residential proxies. Datacenter IPs get flagged quickly on social platforms; residential rotating proxies distribute requests across many real IPs.
• Throttle and randomize. Add human-like delays, cap concurrency, and vary your pacing rather than firing a steady machine-gun of requests.
• Send realistic browser context. A current User-Agent, matching headers, and — for HTTP-level scraping — a browser-like TLS fingerprint help you blend in past anti-scraping protection.
• Handle pagination and de-dupe. Follow the bookmark cursor to completion and dedupe pins by ID, since feeds repeat.
• Be ready for the occasional challenge. If you hit a verification wall, back off; at scale, plug in a CAPTCHA-solving service.
• Scrape only public data, and keep volumes reasonable and respectful.

FAQ

Is Pinterest scraping legal? Scraping publicly available data is broadly treated differently from accessing private/gated content, but Pinterest's terms restrict automated collection, and rules vary by jurisdiction. Stick to public data, respect rate limits, and get legal advice for anything commercial.

Should I use the API or scrape? Use the API for your own account, publishing, and ads/analytics. Scrape when you need broad public data — arbitrary boards, topic feeds, or search — that the API doesn't expose.

Do I need to log in? Most public pins and boards are viewable without login. Some features require an account; only scrape what your access legitimately permits.

What's the fastest way to build one? Discover the internal JSON endpoint in DevTools and paginate it with the bookmark cursor. Fall back to a headless browser when the endpoint shifts.

Summary

There are two honest routes into Pinterest data: the official API v5, which is free but approval-gated and scoped to your own account rather than broad public collection, and scraping public content, which is where you go for pins, boards, topics, and search across the site. The efficient scraping method is to replay Pinterest's internal /resource/.../get/ JSON endpoints with bookmark-based pagination; the resilient method is a headless browser that scrolls and reads the rendered DOM. Either way, rotating residential proxies, realistic browser fingerprints, and polite pacing are what keep you unblocked. If you'd rather receive clean Pinterest datasets than build and maintain a social-media scraper, scraping.pro runs Pinterest data extraction as a managed service and delivers structured results ready to analyze.