# Pinterest Board Scraper - Pins and Metadata (`benthepythondev/pinterest-board-scraper`) Actor

Scrape public Pinterest boards and pins with board, owner, image, video, engagement, creator and destination metadata through a fast no-login HTTP engine.

- **URL**: https://apify.com/benthepythondev/pinterest-board-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 - Pins and Metadata

Collect ordered pins and board metadata from public Pinterest boards without a Pinterest login, browser runtime, proxy, or external API key. The Pinterest Board Scraper accepts one or more board URLs and returns one clean dataset row per pin, including the board, owner, creator, media, engagement, destination, and rank fields needed for content research and repeat monitoring.

The Actor uses Pinterest's public server-rendered board state for the first page and the same structured board-feed resource used by the website for pagination. That keeps runs fast and bounded while preserving the exact board order seen at collection time.

### What can you use it for?

- Monitor a public board for newly added pins.
- Export a board into JSON, CSV, Excel, XML, RSS, or Parquet.
- Analyze board topics, creators, destination domains, and content formats.
- Build a visual-content research table for a marketing or editorial team.
- Track ordered pin ranks over time instead of replacing old snapshots.
- Find recurring creators and source domains within a curated board.
- Separate image pins from video pins for later review.
- Feed a reviewed set of pins into n8n, Make, Zapier, Airtable, or a warehouse.

This Actor extracts public source records. It does not download or license the media files, access private boards, log in as a user, send messages, save pins, or modify Pinterest accounts.

### Input

Paste full public board URLs in `boardUrls`. A valid URL includes both the board owner and board slug, for example:

```json
{
  "boardUrls": [
    {"url": "https://www.pinterest.com/suma5048/python/"}
  ],
  "maxResultsPerBoard": 25,
  "maxPagesPerBoard": 20
}
````

#### Input fields

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `boardUrls` | array | one public example | Pinterest board URLs to collect. |
| `maxResultsPerBoard` | integer | `25` | Maximum unique pins saved for each board. |
| `maxPagesPerBoard` | integer | `20` | Hard pagination safety limit per board. |

Small defaults make the first run inexpensive and keep automated health checks fast. Increase `maxResultsPerBoard` only after a small run confirms that the selected board and output fields fit the workflow.

### Output

Every dataset row represents one unique pin in one board. Board and owner metadata is repeated intentionally so each row remains useful when exported without joins.

```json
{
  "id": "803400021071834978",
  "url": "https://www.pinterest.com/pin/803400021071834978/",
  "title": "Python Notes for Beginners (Easy + Quick Guide)",
  "description": "Learn Python easily with simple and short notes",
  "destination_url": null,
  "domain": "Uploaded by user",
  "image_url": "https://i.pinimg.com/originals/02/02/4f/example.jpg",
  "image_width": 1079,
  "image_height": 1610,
  "is_video": false,
  "video_url": null,
  "save_count": 1044,
  "creator_username": "bca_notes_hub",
  "board_id": "803400089716751612",
  "board_name": "PYTHON",
  "board_url": "https://www.pinterest.com/suma5048/python/",
  "board_pin_count": 908,
  "board_follower_count": 49,
  "owner_username": "suma5048",
  "rank": 1,
  "scraped_at": "2026-07-11T10:30:00+00:00"
}
```

#### Pin and media fields

- `id`, `url`, `title`, `description`, and `created_at`
- `destination_url` and `domain`
- `image_url`, `image_width`, and `image_height`
- `is_video` and the best available `video_url`
- `save_count` and `reaction_counts`
- `rank`, which is the pin's order in this run

#### Creator fields

- `creator_id`, `creator_username`, and `creator_name`
- `creator_profile_url`

The creator can differ from the board owner when a pin was saved from another Pinterest account.

#### Board and owner fields

- `board_id`, `board_name`, `board_url`, `board_description`, and `board_privacy`
- `board_pin_count`, `board_follower_count`, `board_collaborator_count`, and `board_section_count`
- `board_created_at`, `board_modified_at`, and `board_cover_image_url`
- `owner_id`, `owner_username`, `owner_name`, `owner_followers`, and `owner_profile_url`

### Monitoring a board over time

Use an Apify schedule or saved Task with a small result limit. Append snapshots rather than overwriting the prior dataset, and compare records by `board_id` plus `id`. A pin that appears for the first time is a new board addition. A changed `rank` means its relative position changed between observations.

Pinterest can reorder public feeds and update counts. Store `scraped_at` with every comparison and avoid treating a rank movement as proof of campaign impact. The Actor reports what the public source returned at a point in time; attribution requires separate evidence.

### Integrations

The default dataset can be downloaded directly or delivered through Apify integrations:

- Use a webhook to notify n8n, Make, or Zapier after a successful run.
- Send new pin IDs to Airtable, Google Sheets, a CRM, or a review queue.
- Load snapshots into BigQuery, Snowflake, PostgreSQL, or object storage.
- Call the Actor through the Apify API from Python, JavaScript, or any HTTP client.
- Build an RSS-style alert from rows not present in the previous snapshot.

Keep human review between discovery and any publication or outreach action. A public profile or destination link is not automatic permission to contact, reuse, or republish content.

### Pricing

This Actor uses transparent pay-per-event pricing:

- `$0.005` when the Actor starts.
- `$0.0015` for each unique pin saved to the default dataset.

A run that saves 100 pins costs about `$0.155` in Actor charges before ordinary Apify platform usage. Failed requests, ignored modules, duplicates, and pins beyond the configured maximum do not create result rows.

### Reliability and limits

The scraper uses Chrome-compatible TLS impersonation with direct HTTP requests. It does not require residential proxy traffic or a full browser. Requests have explicit timeouts, three bounded retries, page limits, and per-board result limits. Duplicate pin IDs are removed within each board run.

If Pinterest returns no usable public board data, the Actor fails instead of silently reporting a successful empty dataset. That behavior makes scheduled monitoring failures visible. Source websites can change their public responses; report a reproducible board URL through the Actor's Issues tab if a current public board stops working.

### Responsible use

Use the Actor only for legitimate collection of public data. Follow Pinterest's terms, applicable privacy and marketing laws, intellectual-property rights, and your organization's policies. Do not use it for harassment, stalking, sensitive profiling, spam, bypassing access controls, or copying media without the required rights or license.

Image and video URLs point to source media. Retain links and the minimum metadata needed for the workflow unless you have a documented right and reason to store the underlying files.

### Frequently asked questions

#### Does it require a Pinterest account?

No. It reads data Pinterest exposes on public board pages and their public board-feed resource.

#### Can it scrape private or secret boards?

No. The Actor does not authenticate and does not bypass privacy settings.

#### Can I scrape multiple boards in one run?

Yes. Add multiple entries to `boardUrls`. The result limit applies separately to each board.

#### Why is board metadata repeated on every row?

Repeated metadata makes CSV and spreadsheet exports self-contained. You can normalize it into separate board and pin tables downstream if needed.

#### Are all counts guaranteed to be present?

No. Pinterest may omit a count, creator, destination, or media variant for some pins. Missing source values are returned as `null` rather than guessed.

#### How should I detect new pins?

Store previous pin IDs for each `board_id`, then compare them with the next run. Use `rank` and `scraped_at` for ordered historical snapshots.

### You might also like

- [Pinterest Search Scraper](https://apify.com/benthepythondev/pinterest-search-scraper) for topic-based pin discovery.
- [Pinterest Profile Scraper](https://apify.com/benthepythondev/pinterest-profile-scraper) for public profile enrichment.
- [Pinterest Keyword Suggestions Scraper](https://apify.com/benthepythondev/pinterest-keyword-suggestions-scraper) for autocomplete research before searching.

If the Actor saved time or replaced manual work, leave a Store review. Reviews help prioritize reliability work and future field additions.

Keywords: Pinterest board scraper, Pinterest pins API, Pinterest board export, Pinterest data scraper, Pinterest monitoring, Pinterest creator research, Pinterest images, Pinterest video pins, Pinterest marketing research, public Pinterest data.

# Actor input Schema

## `boardUrls` (type: `array`):

Public Pinterest board URLs. Each URL must contain both the owner username and board slug.

## `maxResultsPerBoard` (type: `integer`):

Maximum unique pins saved for each board.

## `maxPagesPerBoard` (type: `integer`):

Pagination safety limit for each board.

## Actor input object example

```json
{
  "boardUrls": [
    {
      "url": "https://www.pinterest.com/suma5048/python/"
    }
  ],
  "maxResultsPerBoard": 25,
  "maxPagesPerBoard": 20
}
```

# Actor output Schema

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

No description

# 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 = {
    "boardUrls": [
        {
            "url": "https://www.pinterest.com/suma5048/python/"
        }
    ],
    "maxResultsPerBoard": 25,
    "maxPagesPerBoard": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/pinterest-board-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 = {
    "boardUrls": [{ "url": "https://www.pinterest.com/suma5048/python/" }],
    "maxResultsPerBoard": 25,
    "maxPagesPerBoard": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "boardUrls": [
    {
      "url": "https://www.pinterest.com/suma5048/python/"
    }
  ],
  "maxResultsPerBoard": 25,
  "maxPagesPerBoard": 20
}' |
apify call benthepythondev/pinterest-board-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/pinterest-board-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Board Scraper - Pins and Metadata",
        "description": "Scrape public Pinterest boards and pins with board, owner, image, video, engagement, creator and destination metadata through a fast no-login HTTP engine.",
        "version": "1.0",
        "x-build-id": "CcY3JU4oIwkbpxzWh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~pinterest-board-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-pinterest-board-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~pinterest-board-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-pinterest-board-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~pinterest-board-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-pinterest-board-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "boardUrls"
                ],
                "properties": {
                    "boardUrls": {
                        "title": "Pinterest board URLs",
                        "type": "array",
                        "description": "Public Pinterest board URLs. Each URL must contain both the owner username and board slug.",
                        "default": [
                            {
                                "url": "https://www.pinterest.com/suma5048/python/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerBoard": {
                        "title": "Maximum pins per board",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique pins saved for each board.",
                        "default": 25
                    },
                    "maxPagesPerBoard": {
                        "title": "Maximum pages per board",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Pagination safety limit for each board.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
