# Pinterest User Pins Scraper – Created, Saved & Full Pin Data (`scrapeberry/pinterest-user-pins-scraper`) Actor

Pinterest User Pins Scraper — scrape a user's saved pins, created pins, and analyze any pin (single or bulk) with full data: images, saves, comments, reactions, board, author. Clean structured JSON.

- **URL**: https://apify.com/scrapeberry/pinterest-user-pins-scraper.md
- **Developed by:** [Scrapeberry](https://apify.com/scrapeberry) (community)
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 pin scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Pinterest User Pins Scraper gives you any Pinterest user's **saved pins**, their **created pins**, and **full pin analysis** for any pin (single or bulk) — every record packed with engagement data: saves, repins, comments, reactions, board, author, and images as clean, structured JSON. Every request hits Pinterest's servers **live**; there is no cached or stored data, so you always get the freshest possible data. No Pinterest API key, no browser, no coding required.

### What does the Pinterest User Pins Scraper do?

Three capabilities that combine freely — check what you need and run:

- **Saved pins** — everything a user has saved, straight from their saved-pins feed.

- **Created pins** — everything a user has actually posted (their own content).

- **Full pin data** — two ways:
  - Paste pin URLs or IDs (one or thousands) for standalone analysis.
  - Or switch on **Full pin data (enrichment)** and every pin collected from the feeds is automatically re-fetched with complete detail — single or bulk, handled automatically.

- **Smart bulk handling** — one pin is instant; thousands are batched with automatic backoff. If Pinterest throttles, the actor stops early and keeps everything it already delivered — you're never billed for skipped pins.

- **Apify Proxy on auto** — no country configuration needed.

- **Fair two-tier billing** — feed pins get a scraping fee plus a platform data-processing fee. Fully analyzed pins get a higher scraping fee plus the same platform fee. You pay only for delivered records.

### How to use it (detailed examples)

#### 1. A user's saved pins (the default)

```json
{
  "users": ["pinterest"],
  "savedPins": true,
  "createdPins": false,
  "maxPinsPerUser": 100
}
```

Real output record (saved-pins tier — 15 fields + provenance):

```json
{
  "id": "1130333206516009145",
  "title": "Creamy Basil Walnut Pasta Recipe",
  "description": "A creamy basil and walnut pasta dish featuring velvety sauce, al dente pasta, and a touch of Parmesan for savory richness.",
  "pin_url": "https://www.pinterest.com/pin/1130333206516009145/",
  "type": "image",
  "image": "https://i.pinimg.com/736x/60/e2/40/60e240d9af83b941e8bd89432e5644fc.jpg",
  "domain": "pinterest.com",
  "saves_count": 0,
  "repins_count": 0,
  "comments_count": 0,
  "reactions_count": 0,
  "board_name": "Creamy Pasta Dishes",
  "pinner_username": "pinterest",
  "creator_username": "",
  "created_at": "2026-05-27T22:56:23.000Z",
  "username": "pinterest",
  "source": "saved_pins"
}
```

#### 2. Saved + created pins together

```json
{
  "users": ["pinterest", "@pinterest"],
  "savedPins": true,
  "createdPins": true,
  "maxPinsPerUser": 100
}
```

Records carry `source: "saved_pins"` or `source: "created_pins"` so the two feeds stay separable in one dataset.

#### 3. Saved pins WITH full pin data (automatic enrichment)

```json
{
  "users": ["pinterest"],
  "savedPins": true,
  "fullPinData": true,
  "maxPinsPerUser": 100
}
```

Every collected pin is automatically re-fetched with complete data — no extra input needed, single or bulk. Enriched records bill at the analysis rate ($0.004) instead of the feed rate ($0.002).

#### 4. Analyze specific pins — single or bulk

```json
{
  "pins": ["https://www.pinterest.com/pin/68741848186/", "50595195810048376"]
}
```

Mix URLs and IDs freely. Real output record (full analysis tier):

```json
{
  "id": "68741848186",
  "title": "The BEST Zucchini Fritters",
  "description": " ",
  "pin_url": "https://www.pinterest.com/pin/68741848186/",
  "type": "image",
  "image": "https://i.pinimg.com/originals/10/12/44/101244853ccd4e5e9288f13cb91a7ecb.jpg",
  "domain": "willcookforsmiles.com",
  "saves_count": 105626,
  "repins_count": 4445,
  "comments_count": 174,
  "reactions_count": 149,
  "board_name": "veggies",
  "pinner_username": "amberwithaar",
  "creator_username": "willcook4smiles",
  "created_at": "2020-08-27T23:00:00.000Z",
  "source": "pin_analysis"
}
```

### What data can this Pinterest user pins scraper extract?

Every pin record carries the same clean 16-field shape (plus `username` and `source` provenance on feed pins):

| Field | Type | Description |
|---|---|---|
| `id` | string | Pin ID |
| `title` / `description` | string | Pin text |
| `pin_url` | string | Pin URL |
| `type` | string | `image`, `video`, `gif`, or `carousel` |
| `image` | string | Image URL |
| `domain` | string | Source website |
| `saves_count` | number | Times saved |
| `repins_count` / `comments_count` / `reactions_count` | number | Engagement metrics |
| `board_name` | string | Board the pin lives on |
| `pinner_username` / `creator_username` | string | Authors |
| `created_at` | date | ISO 8601 |
| `username` | string | Which scraped user produced this record (feed pins) |
| `source` | string | `saved_pins`, `created_pins`, or `pin_analysis` |

### Pricing — two tiers, priced by what each costs to fetch

The actor uses **pay-per-event** pricing with two events. Because every request is made **live against Pinterest's servers in real-time** (there is no cached or stored data), you will see two small charges per delivered pin on your invoice: the tier-specific scraping fee plus a platform data-processing fee.

| Tier | Scraping fee | Dataset fee | **Total per pin** |
|---|---|---|---|
| Feed pins (saved / created) | **$2 per 1,000** ($0.002 each) | $0.01 per 1,000 | **$2.01 per 1,000 pins** |
| Full analysis (standalone pins or enrichment) | **$4 per 1,000** ($0.004 each) | $0.01 per 1,000 | **$4.01 per 1,000 pins** |

Plus:

- **Actor start**: $0.05 per 1,000 starts (default) — Apify covers the first 5 seconds of compute.
- **Dataset item**: $0.01 per 1,000 results (platform data-processing fee charged by Apify).
- Users with no pins, and pins skipped due to rate limits, are **not charged**.

Example costs: a user's 100 saved pins ≈ **$0.20**; 100 pins enriched with full data ≈ **$0.40**; a single pin analysis ≈ **$0.004**.

### Performance

- Feed pins come in bulk pages — **100 pins in seconds**; 1,000 (the per-user cap) in well under a minute.
- Standalone/bulk analysis: ~1 second per pin at default concurrency 5; raise to 10 for large batches.
- Rate-limit aware: automatic backoff, early-stop that keeps delivered records.

### Use cases

- **Influencer auditing** — pull a creator's `created_pins` to see exactly what they posted and how it performed (`saves_count`, `comments_count`).
- **Taste profiling** — `saved_pins` reveals what a user (or a competitor's audience) actually collects.
- **Pin deep-dives** — paste one pin URL for instant analysis, or thousands for a full engagement study.
- **Content research pipelines** — combine with the [Profile Scraper](https://apify.com/scrapeberry/pinterest-profile-scraper) and [Board Scraper](https://apify.com/scrapeberry/pinterest-board-scraper) from the same developer.

### Input

See the **Input tab** for the full form: **Users** (handles, @handles, or profile URLs), the **Saved pins** / **Created pins** / **Full pin data** checkboxes, **Pins to analyze** (URLs or IDs, single or bulk), **Max pins per user**, **Concurrency**, and the standard **proxy configuration** (Apify Proxy on auto).

### Output

The dataset contains one record per delivered pin — download as **JSON, HTML, CSV, or Excel**. The run's **OUTPUT** key summarizes feed pins vs analyzed pins.

### API usage

See the **API tab** for copy-paste snippets. Node.js example with the [Apify SDK](https://docs.apify.com/sdk/js/):

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

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

const run = await client.actor('scrapeberry/pinterest-user-pins-scraper').call({
    users: ['pinterest'],
    savedPins: true,
    createdPins: true,
    maxPinsPerUser: 100,
});

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

### FAQ and disclaimers

**Is the data public?** Yes — the actor reads only what a logged-out visitor sees. It does not log in, access private accounts, or extract private personal data.

> Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

**Why did some pins get skipped?** Pinterest started throttling during a very large batch — the actor stopped early and kept your delivered records, and skipped pins are not billed. Lower concurrency or split the batch.

Found an issue or have an idea? Open a ticket in the **Issues tab** — feedback shapes the roadmap.

# Actor input Schema

## `users` (type: `array`):

Usernames, account IDs, or profile URLs — one per line. Used with the Saved pins / Created pins checkboxes.

## `savedPins` (type: `boolean`):

Scrape everything these users SAVED (their saved-pins feed).

## `createdPins` (type: `boolean`):

Scrape everything these users CREATED (their own posted pins).

## `fullPinData` (type: `boolean`):

Re-fetch complete data for every pin collected from the feeds above — deeper detail at the analysis price ($0.004/pin instead of $0.002/pin).

## `pins` (type: `array`):

Standalone pin URLs or IDs to analyze with full data — single or bulk, one per line. Runs automatically alongside or without the user feeds.

## `maxPinsPerUser` (type: `integer`):

Safety cap per user per feed (100 default, up to 1000).

## `concurrency` (type: `integer`):

Parallel pin fetches during analysis, 1-10. The actor backs off automatically on rate limits.

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

Apify Proxy on auto (recommended) — no country selection needed.

## Actor input object example

```json
{
  "users": [
    "pinterest"
  ],
  "savedPins": true,
  "createdPins": false,
  "fullPinData": false,
  "pins": [],
  "maxPinsPerUser": 100,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Feed pins bill at $0.002 each; analyzed pins (standalone or enriched) at $0.004 each.

## `dataset` (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 = {
    "users": [
        "pinterest"
    ],
    "pins": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeberry/pinterest-user-pins-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 = {
    "users": ["pinterest"],
    "pins": [],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeberry/pinterest-user-pins-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 '{
  "users": [
    "pinterest"
  ],
  "pins": []
}' |
apify call scrapeberry/pinterest-user-pins-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapeberry/pinterest-user-pins-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/9AmcubMFTvhfnDmH5/builds/7bfUPeJBhdZsvjcoY/openapi.json