DEV Community

agenthustler
agenthustler

Posted on

How to Scrape Pinterest Data: Pins, Boards, and User Profiles

#webdev #javascript #programming #webscraping

Pinterest is one of the largest visual discovery platforms on the web, with over 450 million monthly active users sharing and discovering ideas through images and videos. For marketers, researchers, and data analysts, Pinterest data offers invaluable insights into visual trends, consumer preferences, and content performance.

In this comprehensive guide, we'll explore how to scrape Pinterest data — including pins, boards, and user profiles — in a structured and efficient way.

Understanding Pinterest's Data Structure

Before diving into scraping, it's important to understand how Pinterest organizes its data. The platform is built around three core entities:

Pins

A Pin is the fundamental content unit on Pinterest. Each pin contains:

  • Image or video URL — the visual media itself
  • Title and description — text metadata describing the pin
  • Source URL — the original website the pin links to
  • Engagement metrics — saves, comments, and reactions
  • Creator information — who pinned it
  • Board association — which board(s) contain this pin

Boards

Boards are collections of pins organized around a theme. Board data includes:

  • Board name and description
  • Pin count — total number of pins on the board
  • Follower count — how many users follow the board
  • Privacy setting — public or secret
  • Creator — the user who owns the board
  • Category — the board's topic classification

User Profiles

User profiles aggregate a person's Pinterest activity:

  • Username and display name
  • Bio and profile image
  • Follower and following counts
  • Board list — all public boards
  • Pin count — total pins across all boards
  • Account verification status

Why Scrape Pinterest?

There are several legitimate use cases for scraping Pinterest data:

  1. Market Research: Understand what visual content resonates with audiences in specific niches
  2. Trend Analysis: Track emerging visual trends across fashion, home decor, food, and more
  3. Competitor Analysis: See what content your competitors are pinning and how it performs
  4. Content Strategy: Identify high-performing pin formats, descriptions, and keywords
  5. Academic Research: Study visual culture, information sharing patterns, and social networks
  6. SEO Insights: Discover which pins drive traffic to specific websites

Pinterest's Technical Architecture

Pinterest uses a combination of server-side rendering and client-side JavaScript (React). The platform loads initial content via HTML and then fetches additional data through internal API endpoints. Understanding this is critical for effective scraping.

The Pinterest Resource API

Pinterest's frontend communicates with a resource API that returns JSON data. When you browse Pinterest, your browser makes requests to endpoints like:

https://www.pinterest.com/resource/BoardResource/get/
https://www.pinterest.com/resource/UserResource/get/
https://www.pinterest.com/resource/BoardFeedResource/get/
Enter fullscreen mode Exit fullscreen mode

These endpoints accept parameters that specify what data to fetch and support pagination through bookmark tokens.

Pagination with Bookmarks

Pinterest uses a bookmark-based pagination system rather than traditional page numbers. Each API response includes a bookmark field — a token you pass in the next request to get the following batch of results. When the bookmark is -end-, you've reached the last page.

// Example: Fetching paginated board pins
async function fetchBoardPins(boardId, bookmark = '') {
  const params = {
    source_url: `/board/${boardId}/`,
    data: JSON.stringify({
      options: {
        board_id: boardId,
        page_size: 25,
        bookmark: bookmark,
      },
    }),
  };

  const response = await fetch(
    `https://www.pinterest.com/resource/BoardFeedResource/get/?${new URLSearchParams(params)}`
  );
  const data = await response.json();

  return {
    pins: data.resource_response.data,
    bookmark: data.resource_response.bookmark,
  };
}
Enter fullscreen mode Exit fullscreen mode

Building a Pinterest Pin Scraper

Let's build a scraper that extracts pin data from a Pinterest board. We'll use Node.js with Crawlee, which provides robust crawling infrastructure.

Setting Up the Project 

mkdir pinterest-scraper && cd pinterest-scraper
npm init -y
npm install crawlee playwright
Enter fullscreen mode Exit fullscreen mode

The Pin Scraper 

const { PlaywrightCrawler, Dataset } = require('crawlee');

const crawler = new PlaywrightCrawler({
  maxRequestsPerCrawl: 100,
  async requestHandler({ page, request, log }) {
    log.info(`Scraping: ${request.url}`);

    // Wait for pins to load
    await page.waitForSelector('[data-test-id="pin"]', { timeout: 15000 });

    // Scroll to load more pins
    for (let i = 0; i < 5; i++) {
      await page.evaluate(() => window.scrollBy(0, window.innerHeight));
      await page.waitForTimeout(1500);
    }

    // Extract pin data
    const pins = await page.evaluate(() => {
      const pinElements = document.querySelectorAll('[data-test-id="pin"]');
      return Array.from(pinElements).map(pin => {
        const link = pin.querySelector('a[href*="/pin/"]');
        const img = pin.querySelector('img');
        const title = pin.querySelector('[data-test-id="pin-title"]');

        return {
          pinUrl: link ? `https://www.pinterest.com${link.getAttribute('href')}` : null,
          imageUrl: img ? img.src : null,
          title: title ? title.textContent.trim() : null,
          altText: img ? img.alt : null,
        };
      });
    });

    log.info(`Found ${pins.length} pins`);
    await Dataset.pushData(pins);
  },
});

// Run with a board URL
await crawler.run(['https://www.pinterest.com/username/board-name/']);
Enter fullscreen mode Exit fullscreen mode

Scraping User Profile Data

User profiles contain valuable aggregate data. Here's how to extract it:

async function scrapeUserProfile(page, username) {
  await page.goto(`https://www.pinterest.com/${username}/`);
  await page.waitForSelector('[data-test-id="user-profile"]', { timeout: 10000 });

  const profile = await page.evaluate(() => {
    const getName = (sel) => {
      const el = document.querySelector(sel);
      return el ? el.textContent.trim() : null;
    };

    // Extract follower/following counts
    const statsElements = document.querySelectorAll('[data-test-id="user-stats"] span');
    const stats = Array.from(statsElements).map(el => el.textContent.trim());

    return {
      displayName: getName('h1'),
      bio: getName('[data-test-id="user-bio"]'),
      followerCount: stats[0] || null,
      followingCount: stats[1] || null,
      profileImage: document.querySelector('img[alt*="profile"]')?.src || null,
      scrapedAt: new Date().toISOString(),
    };
  });

  return profile;
}
Enter fullscreen mode Exit fullscreen mode

Extracting Board Data

Boards offer structured collections of pins around specific themes:

async function scrapeBoardMetadata(page, boardUrl) {
  await page.goto(boardUrl);
  await page.waitForSelector('[data-test-id="board-header"]', { timeout: 10000 });

  const boardData = await page.evaluate(() => {
    const header = document.querySelector('[data-test-id="board-header"]');

    return {
      name: header?.querySelector('h1')?.textContent?.trim() || null,
      description: header?.querySelector('[data-test-id="board-description"]')
        ?.textContent?.trim() || null,
      pinCount: header?.querySelector('[data-test-id="pin-count"]')
        ?.textContent?.trim() || null,
      followerCount: header?.querySelector('[data-test-id="follower-count"]')
        ?.textContent?.trim() || null,
      lastUpdated: new Date().toISOString(),
    };
  });

  return boardData;
}
Enter fullscreen mode Exit fullscreen mode

Handling Pinterest's Visual Search Data

Pinterest's visual search (Lens) is a powerful feature that lets you find similar images. While scraping visual search results requires more sophisticated techniques, you can extract related pin suggestions:

async function scrapeRelatedPins(page, pinUrl) {
  await page.goto(pinUrl);
  await page.waitForSelector('[data-test-id="related-pins"]', { timeout: 15000 });

  // Scroll to load related pins
  await page.evaluate(() => window.scrollBy(0, 800));
  await page.waitForTimeout(2000);

  const relatedPins = await page.evaluate(() => {
    const section = document.querySelector('[data-test-id="related-pins"]');
    if (!section) return [];

    const pins = section.querySelectorAll('[data-test-id="pin"]');
    return Array.from(pins).map(pin => ({
      url: pin.querySelector('a')?.href || null,
      image: pin.querySelector('img')?.src || null,
      title: pin.querySelector('img')?.alt || null,
    }));
  });

  return relatedPins;
}
Enter fullscreen mode Exit fullscreen mode

Scaling with Apify

Building and maintaining your own scraping infrastructure is complex. You need to handle proxy rotation, browser management, rate limiting, and data storage. This is where Apify comes in.

Apify is a cloud platform for web scraping and automation. It provides:

  • Managed browser infrastructure — no need to run your own Playwright/Puppeteer instances
  • Automatic proxy rotation — avoid IP blocks with residential and datacenter proxies
  • Scheduling — run scrapers on any schedule
  • Dataset storage — export results in JSON, CSV, or Excel
  • Pay-per-result pricing — only pay for what you scrape

Using Pinterest Scrapers from the Apify Store

The Apify Store has ready-to-use Pinterest scrapers that handle all the complexity for you. These actors (Apify's term for cloud scrapers) manage pagination, proxy rotation, and data extraction automatically.

To use a Pinterest scraper from the Apify Store:

  1. Create an Apify account at apify.com
  2. Browse the Store for Pinterest actors
  3. Configure the input — specify board URLs, usernames, or search queries
  4. Run the actor — it handles everything in the cloud
  5. Download results — get structured data in your preferred format

Calling an Apify Actor via API

You can also run Apify actors programmatically:

const { ApifyClient } = require('apify-client');

const client = new ApifyClient({
  token: 'YOUR_APIFY_TOKEN',
});

async function scrapePinterestBoard(boardUrl) {
  const run = await client.actor('YOUR_ACTOR_ID').call({
    startUrls: [{ url: boardUrl }],
    maxItems: 500,
    proxy: {
      useApifyProxy: true,
      apifyProxyGroups: ['RESIDENTIAL'],
    },
  });

  // Fetch results
  const { items } = await client.dataset(run.defaultDatasetId).listItems();
  console.log(`Scraped ${items.length} pins`);
  return items;
}

// Usage
scrapePinterestBoard('https://www.pinterest.com/username/board-name/');
Enter fullscreen mode Exit fullscreen mode

Scheduling Regular Scrapes

For ongoing monitoring, you can schedule Apify actors to run automatically:

// Create a scheduled task
const schedule = await client.schedules().create({
  name: 'pinterest-weekly-scrape',
  cronExpression: '0 9 * * 1', // Every Monday at 9 AM
  actions: [{
    type: 'RUN_ACTOR',
    actorId: 'YOUR_ACTOR_ID',
    runInput: {
      startUrls: [{ url: 'https://www.pinterest.com/trending/' }],
      maxItems: 1000,
    },
  }],
});
Enter fullscreen mode Exit fullscreen mode

Data Processing and Analysis

Once you have your Pinterest data, here's how to process it effectively:

const fs = require('fs');

function analyzePinterestData(pins) {
  // Sort by engagement
  const topPins = pins
    .filter(p => p.saveCount)
    .sort((a, b) => b.saveCount - a.saveCount)
    .slice(0, 20);

  // Extract common keywords from descriptions
  const keywords = {};
  pins.forEach(pin => {
    if (!pin.description) return;
    const words = pin.description.toLowerCase().split(/\s+/);
    words.forEach(word => {
      if (word.length > 4) {
        keywords[word] = (keywords[word] || 0) + 1;
      }
    });
  });

  const topKeywords = Object.entries(keywords)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 50);

  return {
    totalPins: pins.length,
    avgSaves: pins.reduce((sum, p) => sum + (p.saveCount || 0), 0) / pins.length,
    topPins,
    topKeywords,
  };
}
Enter fullscreen mode Exit fullscreen mode

Best Practices and Ethical Considerations

When scraping Pinterest, keep these guidelines in mind:

  1. Respect robots.txt: Check Pinterest's robots.txt file and follow its directives
  2. Rate limiting: Don't send too many requests too quickly — use delays between requests
  3. Terms of Service: Review Pinterest's ToS regarding automated data collection
  4. Personal data: Be cautious with personal user data and comply with GDPR/CCPA
  5. Attribution: If you use scraped content, provide proper attribution
  6. Caching: Cache results to avoid unnecessary repeat requests
  7. Purpose: Only scrape data you have a legitimate use for

Conclusion

Pinterest is a treasure trove of visual data for market research, trend analysis, and content strategy. By understanding the platform's structure and using the right tools, you can extract valuable insights at scale.

For production-grade scraping, platforms like Apify handle the infrastructure complexity — proxy rotation, browser management, and scheduling — so you can focus on analyzing the data rather than maintaining scrapers.

Whether you're tracking fashion trends, analyzing competitor content strategies, or studying visual culture, Pinterest scraping opens up powerful possibilities for data-driven decision making.

Looking for ready-to-use Pinterest scrapers? Check the Apify Store for pre-built actors that handle all the complexity of Pinterest data extraction.

Top comments (0)