# Pinterest Board Scraper — Board Pins & User Boards (`khadinakbar/pinterest-boards-scraper`) Actor

Scrape Pinterest boards from any board URL or username. Board mode returns board metadata plus every pin (deep pagination). User mode lists all boards a profile owns. Cookieless, no login, HTTP-only. PAY\_PER\_EVENT. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/pinterest-boards-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 pin scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Pinterest Board Scraper — Board Pins & User Boards

**Pinterest Board Scraper** extracts public Pinterest boards, board metadata, and the pins saved to each board. Give it a board URL to collect that board and its pins, or give it a Pinterest username/profile URL to list the public boards owned by that account.

The Actor is built for content research, competitive analysis, creative discovery, dataset creation, and AI-agent workflows. It runs without a Pinterest login, uses an HTTP-only pipeline, and returns structured records that can be exported as JSON, CSV, Excel, XML, or RSS through Apify.

### What can Pinterest Board Scraper do?

- Scrape a Pinterest board by URL and return its metadata plus pins.
- List the public boards owned by one or more Pinterest users.
- Process board URLs, profile URLs, and usernames in the same run.
- Collect image and video URLs, titles, descriptions, engagement metrics, creators, and outbound links.
- Download or analyze pin media using direct image and video URL fields.
- Page beyond Pinterest's small public widget response when deeper provider-backed pagination is available.
- Limit boards and pins per input so the maximum result count and event cost stay predictable.
- Feed clean, typed board and pin records into an Apify Task, API integration, webhook, or MCP client.

This Actor works at the **board level**. It is not intended for scraping a single `/pin/<id>/` URL or for searching Pinterest by keyword.

### Use cases for Pinterest board data

#### Content and trend research

Export the pins collected by brands, publishers, or creators to identify recurring topics, visual styles, products, seasonal themes, and emerging ideas.

#### Competitor and brand analysis

Map how a public Pinterest account organizes its content. Compare board names, descriptions, audience size, pin volume, source domains, and creative choices across accounts.

#### Creative and mood-board datasets

Create structured image or video datasets for inspiration, tagging, classification, computer vision, or human review. Pin records include the best available media URL and direct download fields.

#### SEO and commerce research

Analyze outbound destinations, source domains, product price strings, hashtags, saves, and board context to understand which content drives discovery and referral traffic.

#### AI agents and automation

Use the Actor as a narrow data tool: a Pinterest board URL or username goes in, and predictable JSON records come out. The Actor can be called through the Apify API or exposed through the Apify MCP server.

### What data can I extract?

The dataset contains two record types. Use the `dataType` field to route each row.

#### Board records

| Field | Description |
|---|---|
| `dataType` | Always `board` for a board record |
| `board_id` | Pinterest board identifier when available |
| `name` | Board name |
| `description` | Public board description |
| `board_url` | Canonical Pinterest board URL |
| `pin_count` | Total pin count reported by Pinterest |
| `follower_count` | Public follower count for the board |
| `section_count` | Number of sections on the board |
| `cover_image_url` | Board cover or thumbnail image |
| `owner_username` | Username that owns the board |
| `scraped_at` | ISO 8601 collection timestamp |
| `source_url` | Original URL or username that produced the record |

#### Pin records

| Field | Description |
|---|---|
| `dataType` | Always `pin` for a pin record |
| `pin_id`, `pin_url` | Pinterest pin identifier and canonical URL |
| `title`, `description` | Public pin text |
| `image_url`, `download_image_url` | Best image and direct download URL |
| `image_width`, `image_height` | Image dimensions when available |
| `is_video`, `video_url`, `download_video_url` | Video status and media URLs |
| `save_count`, `comment_count` | Public engagement metrics when available |
| `link`, `source_domain` | Outbound destination and its domain |
| `board_name`, `board_url` | Parent board context |
| `pinner_username`, `pinner_display_name` | Pin creator information |
| `pinner_follower_count` | Creator follower count when available |
| `dominant_color`, `hashtags`, `price` | Additional creative and commerce metadata |
| `created_at`, `scraped_at` | Pin creation time when available and collection time |
| `source_url` | Original input that produced the record |

Pinterest does not expose every field on every pin or board. Optional fields are returned as `null` or an empty array when the public source does not provide them.

### How much will scraping Pinterest cost?

Pinterest Board Scraper uses pay-per-event pricing:

| Event | Price |
|---|---:|
| Actor start | $0.00005 |
| Board scraped | $0.01 per board |
| Pin scraped | $0.004 per pin |

Example event charges:

- One board with 25 returned pins: about **$0.11**
- One board with 100 returned pins: about **$0.41**
- A profile with 30 returned boards and no board pins: about **$0.30**
- Ten boards with 50 returned pins each: about **$2.10**

The examples include board and pin events plus the small Actor-start event. Apify platform usage, including compute and proxy traffic, is charged separately when applicable. Actual cost depends on the number of records returned, not the number requested.

Use `maxPinsPerBoard` and `maxBoardsPerUser` to cap the result volume. Keep `includeBoardPins` disabled when you only need a user's board directory; enabling it can multiply the number of requests and pin events.

### How to use Pinterest Board Scraper

#### Scrape pins from a board URL

```json
{
  "startUrls": [
    "https://www.pinterest.com/nike/back-to-school/"
  ],
  "mode": "board-pins",
  "maxPinsPerBoard": 100
}
```

This returns one board record plus up to 100 unique pin records.

#### List all public boards for a username

```json
{
  "usernames": ["etsy"],
  "mode": "user-boards",
  "maxBoardsPerUser": 50,
  "includeBoardPins": false
}
```

This returns up to 50 board records. It does not scrape the pins inside each board.

#### Mix board URLs, profile URLs, and usernames

```json
{
  "startUrls": [
    "https://www.pinterest.com/nike/back-to-school/",
    "https://www.pinterest.com/etsy/"
  ],
  "usernames": ["marthastewart"],
  "mode": "auto",
  "maxPinsPerBoard": 50,
  "maxBoardsPerUser": 25
}
```

In `auto` mode, a board URL is treated as a board target while a profile URL or username is treated as a user target.

### Input reference

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | string array | Example URLs | Full Pinterest board or profile URLs |
| `usernames` | string array | Empty | Pinterest handles without `@` |
| `mode` | enum | `auto` | Auto-detect inputs or force `board-pins` / `user-boards` |
| `maxPinsPerBoard` | integer | `50` | Maximum pins per board, from 0 to 5,000 |
| `maxBoardsPerUser` | integer | `50` | Maximum public boards per user, from 1 to 500 |
| `includeBoardPins` | boolean | `false` | Also collect pins for every board found in user mode |
| `proxyConfiguration` | object | Apify Residential | Proxy settings for Pinterest profile requests |

Set `maxPinsPerBoard` to `0` when you want board metadata without pin records. Individual pin URLs are skipped because this Actor expects board or profile inputs.

### Output example

Board record:

```json
{
  "dataType": "board",
  "board_id": "123456789",
  "name": "Back To School",
  "description": "Ideas and inspiration for a new school year.",
  "board_url": "https://www.pinterest.com/nike/back-to-school/",
  "pin_count": 215,
  "follower_count": 1046341,
  "section_count": 3,
  "cover_image_url": "https://i.pinimg.com/...",
  "owner_username": "nike",
  "scraped_at": "2026-07-29T12:00:00.000Z",
  "source_url": "https://www.pinterest.com/nike/back-to-school/"
}
```

Pin record:

```json
{
  "dataType": "pin",
  "pin_id": "987654321",
  "title": "Back-to-school outfit ideas",
  "description": "Comfortable outfit inspiration.",
  "pin_url": "https://www.pinterest.com/pin/987654321/",
  "image_url": "https://i.pinimg.com/originals/...",
  "download_image_url": "https://i.pinimg.com/originals/...",
  "is_video": false,
  "video_url": null,
  "save_count": 842,
  "comment_count": 12,
  "link": "https://example.com/back-to-school",
  "source_domain": "example.com",
  "board_name": "Back To School",
  "board_url": "https://www.pinterest.com/nike/back-to-school/",
  "pinner_username": "nike",
  "created_at": null,
  "scraped_at": "2026-07-29T12:00:00.000Z",
  "source_url": "https://www.pinterest.com/nike/back-to-school/"
}
```

### Run Pinterest Board Scraper with the API

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  startUrls: ['https://www.pinterest.com/nike/back-to-school/'],
  maxPinsPerBoard: 100,
};

const run = await client
  .actor('khadinakbar/pinterest-boards-scraper')
  .call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/pinterest-boards-scraper").call(
    run_input={
        "usernames": ["etsy"],
        "maxBoardsPerUser": 50,
        "includeBoardPins": False,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Do not place an Apify API token directly in shared source code. Use an environment variable or your platform's secret manager.

### Use Pinterest Board Scraper through MCP

The Actor is available through the Apify MCP server as `apify--pinterest-boards-scraper`. It is a good fit when an agent needs structured Pinterest board or pin data from a known URL or username.

Use this Actor for board-level collection. For keyword search, individual pins, or broader Pinterest entities, choose one of the dedicated Actors below so the agent calls the narrowest matching tool.

### Reliability and limitations

- Board collection starts with Pinterest's public widget data. Larger board requests can use managed provider-backed pagination.
- User-board collection reads public profile data and can fall back to a managed provider when Pinterest challenges a request.
- The Actor does not access private boards, logged-in feeds, or data hidden behind authentication.
- Deleted, secret, region-restricted, or nonexistent boards may return no records.
- Pinterest can omit engagement, creator, video, product, or timestamp fields from public responses.
- Useful results from successful targets are preserved when another target in the same batch fails.
- Deep pagination depends on upstream availability. Requesting 5,000 pins is a ceiling, not a guarantee that every public board exposes that many retrievable records.

### Scrape Pinterest and social data with dedicated Actors

- [Pinterest Pins, Boards & Profiles Scraper](https://apify.com/khadinakbar/pinterest-scraper) — general Pinterest pins, boards, profiles, and search results.
- [Pinterest Data Extractor](https://apify.com/khadinakbar/pinterest-data-extractor) — auto-detect pins, boards, profiles, URLs, and keywords.
- [Pinterest Search Scraper](https://apify.com/khadinakbar/pinterest-search-scraper) — search Pinterest for pins, boards, and users.
- [Pinterest Profile Scraper](https://apify.com/khadinakbar/pinterest-profile-scraper) — collect public profile statistics and recent pins.
- [Pinterest Video Downloader](https://apify.com/khadinakbar/pinterest-video-downloader) — retrieve Pinterest MP4 and HLS video links.
- [Instagram Posts Scraper](https://apify.com/khadinakbar/instagram-posts-scraper) — scrape Instagram profiles, hashtags, and post URLs.
- [TikTok Trending Videos Scraper](https://apify.com/khadinakbar/tiktok-trending-videos-scraper) — collect trending TikTok videos and metrics.
- [YouTube Shorts Scraper](https://apify.com/khadinakbar/youtube-shorts-scraper) — extract Shorts views, likes, and channel data.
- [Google Images Scraper](https://apify.com/khadinakbar/google-images-scraper) — collect original image URLs, sources, and dimensions.

### Frequently asked questions

#### How many results can I scrape with Pinterest Board Scraper?

You control the upper bound with `maxPinsPerBoard` and `maxBoardsPerUser`. A run can request up to 5,000 pins per board and 500 boards per user. The number actually returned depends on what is public and retrievable from Pinterest and the available upstream routes.

#### Can I integrate Pinterest Board Scraper with other apps?

Yes. Use Apify Integrations, webhooks, Make, Zapier, Google Drive, Google Sheets, Slack, or your own HTTP service. Dataset results can also be downloaded in common formats.

#### Can I use Pinterest Board Scraper with the Apify API?

Yes. Run `khadinakbar/pinterest-boards-scraper` through the JavaScript or Python client, or call the REST API directly. The examples above show the basic workflow.

#### Can I use Pinterest Board Scraper through an MCP Server?

Yes. Add the Apify MCP server to a compatible AI client and select `apify--pinterest-boards-scraper` when the task requires Pinterest boards or the pins saved to a known board.

#### Do I need proxies to scrape Pinterest?

The default input uses Apify Residential proxies for profile-page requests because Pinterest may challenge datacenter traffic. Public widget and managed provider requests use their appropriate routes. Most users should keep the default proxy configuration.

#### Is it legal to scrape Pinterest data?

Scraping public web data can be lawful, but the rules depend on your location, purpose, the data involved, and how you use the results. You are responsible for complying with Pinterest's terms, copyright rules, privacy laws, and regulations such as GDPR or CCPA. Do not collect or process personal data unlawfully, and do not use this Actor to access private or authenticated content.

#### Your feedback

If an expected public board does not return the right data, create an issue on the Actor page with a reproducible public URL, the input used, and the run ID. Please remove tokens, secrets, and personal information before sharing logs.

# Actor input Schema

## `startUrls` (type: `array`):

Pinterest URLs to scrape, one per line. A board URL (e.g. 'https://www.pinterest.com/nike/back-to-school/') returns the board plus its pins. A profile URL (e.g. 'https://www.pinterest.com/etsy/') returns every board that user owns. The mode is auto-detected per URL. NOT for individual pin URLs (/pin/<id>/) — this scraper works at the board level.

## `usernames` (type: `array`):

Pinterest handles (without the @ or URL), one per line — each resolves to every board that user owns. Use this as a shortcut instead of full profile URLs (e.g. 'etsy' is equivalent to the profile URL 'https://www.pinterest.com/etsy/'). Leave empty if you only use startUrls. NOT a board slug — a slug alone is ambiguous, provide the full board URL in startUrls instead.

## `mode` (type: `string`):

Controls how each input is treated. 'auto' (default) detects per URL: board URL -> board pins, profile URL/username -> user boards. 'board-pins' forces every input to be read as a board. 'user-boards' forces every input to be read as a username/profile and lists its boards. Leave on 'auto' unless you are mixing ambiguous inputs.

## `maxPinsPerBoard` (type: `integer`):

Maximum number of pins to return per board in board mode. Up to 50 is served fast and free by Pinterest's widget API; higher values page deeper via the provider fallback. Set to 0 to return only board metadata with no pins. Defaults to 50; hard cap 5000.

## `maxBoardsPerUser` (type: `integer`):

Maximum number of boards to return per user in user-boards mode. Boards are returned newest/most-prominent first as Pinterest orders them on the profile. Defaults to 50; hard cap 500. Does not affect board-pins mode.

## `includeBoardPins` (type: `boolean`):

In user-boards mode, when true, also scrape pins for every board found (each board then costs pin charges up to Max pins per board). When false (default), user-boards mode returns only the board directory (metadata), which is faster and cheaper. Has no effect in board-pins mode, where pins are always scraped.

## `proxyConfiguration` (type: `object`):

Proxy settings for profile-page requests. Residential proxies (default) are strongly recommended — Pinterest challenges datacenter IPs on profile pages. The widget and provider endpoints are called directly and are unaffected by this setting.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.pinterest.com/marthastewart/baking-and-dessert-recipes-and-ideas/"
  ],
  "usernames": [
    "nike",
    "etsy"
  ],
  "mode": "auto",
  "maxPinsPerBoard": 50,
  "maxBoardsPerUser": 50,
  "includeBoardPins": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped board and pin records as structured JSON. Export as JSON, CSV, or Excel.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.pinterest.com/nike/back-to-school/",
        "https://www.pinterest.com/etsy/"
    ],
    "usernames": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/pinterest-boards-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        "https://www.pinterest.com/nike/back-to-school/",
        "https://www.pinterest.com/etsy/",
    ],
    "usernames": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/pinterest-boards-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.pinterest.com/nike/back-to-school/",
    "https://www.pinterest.com/etsy/"
  ],
  "usernames": []
}' |
apify call khadinakbar/pinterest-boards-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/pinterest-boards-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yARPsi6KJQdXftjeA/builds/XmoFY1exfCusim5Ew/openapi.json