# Pinterest Scraper — Pins, Boards & Keyword Search (`bovi/pinterest-scraper`) Actor

**Scrape Pinterest pins** by keyword, board URL, or username. Returns 23 fields per pin — title, image URLs, **repin count**, dominant color, pinner, board, external link. Hits `in.pinterest.com` resource API (JSON 200) — not the HTML frontend that blocks scrapers. No login, no API key.

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

## Pricing

from $2.89 / 1,000 pins

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 Scraper — Pins, Boards & Keyword Search

**Pinterest Scraper** lets you scrape Pinterest pins by keyword search, board URL, or username — no official Pinterest API key, no login required. It targets the `in.pinterest.com/resource/*` internal API endpoints that return clean JSON (HTTP 200) instead of the bot-blocked `www.pinterest.com` HTML frontend that returns 403 to scrapers. Every result includes a `parse_confidence` score so you know your data is clean. Pay only per pin collected.

### Why This Pinterest Scraper Beats @maximedupre/pinterest-keyword-scraper

| Feature | This actor | @maximedupre |
|---|---|---|
| Scrape modes | keywords + boards + usernames | keywords only |
| Endpoint | `in.pinterest.com` resource API (JSON, always 200) | `www.pinterest.com` HTML (frequent 403) |
| Output fields | 23 fields incl. repin count, dominant color, pinner | ~8 fields |
| Parser health signal | `parse_confidence` + `warnings` in every record | None |
| Proxy | Configurable residential (buyer-paid) | Fixed |

### What Pinterest Data You Get

Each pin record includes 23 fields:

| Field | Description |
|---|---|
| `id` | Pinterest pin ID |
| `pin_url` | Canonical pin URL (`https://www.pinterest.com/pin/{id}/`) |
| `title` | Pin title or grid title |
| `description` | Pin description (falls back to alt text) |
| `alt_text` | Auto-generated or manual alt text |
| `image_url` | Largest available image (736px or original) |
| `image_url_236x` | Thumbnail image (236px) |
| `dominant_color` | Hex dominant color of the pin image |
| `repin_count` | Number of saves/repins |
| `link` | External URL the pin points to |
| `domain` | Domain of the external link |
| `pinner_id` | Numeric pinner (user) ID |
| `pinner_username` | Pinner username |
| `pinner_full_name` | Pinner display name |
| `board_id` | Numeric board ID |
| `board_name` | Board display name |
| `board_url` | Full board URL |
| `created_at` | Pin creation time (ISO-8601 UTC) |
| `source_mode` | `"search"` / `"board"` / `"user_boards"` |
| `parse_confidence` | 0–1 parse quality score (1.0 = perfect) |
| `warnings` | List of quality warning codes (empty = clean) |
| `scraped_at` | Batch scrape timestamp (ISO-8601 UTC) |

### Pinterest Scraper Use Cases

- **Content research** — discover trending Pinterest pins for any niche by keyword
- **Competitor analysis** — scrape a competitor's Pinterest boards to see their pinning strategy
- **Influencer monitoring** — bulk-export a creator's full Pinterest presence by username
- **E-commerce product research** — find product pins with external links for affiliate/market research
- **Image dataset collection** — harvest labeled images with dominant color metadata for ML

### How to Use the Pinterest Scraper

#### Scrape Pinterest by Keyword (content & trend research)

```json
{
  "keywords": ["minimalist home office", "sustainable fashion"],
  "maxItems": 200,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

#### Scrape Pinterest Board by URL (archive or monitor a specific board)

```json
{
  "boardUrls": [
    "https://www.pinterest.com/user/my-board/",
    "https://www.pinterest.com/anotheruser/products/"
  ],
  "maxItems": 500
}
```

#### Scrape Pinterest User Profile (full account export)

```json
{
  "usernames": ["somedesigner", "@anotheraccount"],
  "maxItems": 100
}
```

#### Mixed — all three Pinterest scrape modes in one run

```json
{
  "keywords": ["bohemian decor"],
  "boardUrls": ["https://www.pinterest.com/user/board/"],
  "usernames": ["targetuser"],
  "maxItems": 100
}
```

### Pricing — Pay Per Pinterest Pin

This actor uses **pay-per-result** pricing: **$5.00 per 1,000 pins** (PPE — pay per result, no per-run fees). You are charged only for pins successfully scraped and returned in your dataset. Scraping 500 pins costs ~$2.50. Most runs (100–200 pins) cost less than $1.

### How Pinterest Scraper Reliability Works

- Targets `in.pinterest.com/resource/*` endpoints — not the HTML frontend that blocks scrapers
- Chrome TLS impersonation via `curl_cffi` — passes Pinterest's TLS/JA3 fingerprint checks without Playwright overhead
- `parse_confidence` and `warnings` fields in every record provide machine-readable parser health signals
- Residential proxy strongly recommended; proxy cost billed to your Apify account at standard rates

### Frequently Asked Questions

**Does this scraper need a Pinterest login?**
No. The `in.pinterest.com` resource endpoints return public pin data without authentication.

**What proxy should I use?**
Residential proxy is strongly recommended. Pinterest aggressively blocks datacenter IPs. Configure `proxyConfiguration` with `RESIDENTIAL` group.

**Can I scrape private Pinterest boards?**
No. Private boards require Pinterest login, which is not supported. Only public pins are accessible.

**What does `maxItems` do in username mode?**
In username mode, the `maxItems` limit applies per board, not per user total. A user with 10 boards at `maxItems=50` can return up to 500 pins.

**What is `repin_count`?**
Extracted from `aggregated_pin_data.aggregated_stats.saves`. May be `null` for newly created pins.

***

*Not affiliated with Pinterest. Data retrieved from publicly accessible Pinterest endpoints.*

### Integrations

Built for social-media marketers and visual-content researchers pulling pins, boards, and keywords for trend and audience analysis — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

# Actor input Schema

## `keywords` (type: `array`):

Search keywords to scrape Pinterest pins for. Each keyword triggers a keyword-search crawl via the Pinterest internal search resource. Use this mode for content research, trend discovery, or competitor product analysis.

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

Full Pinterest board URLs to scrape (e.g. https://www.pinterest.com/username/board-name/). Each URL returns all pins from that board up to maxItems. Use this mode when you know the exact board you want to monitor or archive.

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

Pinterest usernames whose boards you want to scrape. The actor fetches all public boards for each user, then collects pins from each board up to maxItems. Use this mode to monitor a creator's full Pinterest presence. Accepts bare usernames (e.g. 'anthropic'), @handles (e.g. '@anthropic'), or profile URLs.

## `maxItems` (type: `integer`):

Maximum number of pins to collect per keyword, board URL, or user. For users, this limit applies per board. Set to 0 for no limit. Default: 100.

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

Proxy configuration for Pinterest requests. Residential proxies are strongly recommended — Pinterest blocks datacenter IPs aggressively. Defaults to Apify Residential proxy group. The proxy cost is billed to the run owner.

## Actor input object example

```json
{
  "keywords": [
    "interior design ideas"
  ],
  "boardUrls": [],
  "usernames": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "keywords": [
        "interior design ideas"
    ],
    "boardUrls": [],
    "usernames": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/pinterest-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 = {
    "keywords": ["interior design ideas"],
    "boardUrls": [],
    "usernames": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/pinterest-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 '{
  "keywords": [
    "interior design ideas"
  ],
  "boardUrls": [],
  "usernames": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/pinterest-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Scraper — Pins, Boards & Keyword Search",
        "description": "**Scrape Pinterest pins** by keyword, board URL, or username. Returns 23 fields per pin — title, image URLs, **repin count**, dominant color, pinner, board, external link. Hits `in.pinterest.com` resource API (JSON 200) — not the HTML frontend that blocks scrapers. No login, no API key.",
        "version": "0.1",
        "x-build-id": "y1vPDCDgV7nceLsVG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~pinterest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-pinterest-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/bovi~pinterest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-pinterest-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/bovi~pinterest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-pinterest-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search keywords to scrape Pinterest pins for. Each keyword triggers a keyword-search crawl via the Pinterest internal search resource. Use this mode for content research, trend discovery, or competitor product analysis.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "boardUrls": {
                        "title": "Board URLs",
                        "type": "array",
                        "description": "Full Pinterest board URLs to scrape (e.g. https://www.pinterest.com/username/board-name/). Each URL returns all pins from that board up to maxItems. Use this mode when you know the exact board you want to monitor or archive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Pinterest usernames whose boards you want to scrape. The actor fetches all public boards for each user, then collects pins from each board up to maxItems. Use this mode to monitor a creator's full Pinterest presence. Accepts bare usernames (e.g. 'anthropic'), @handles (e.g. '@anthropic'), or profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max pins per keyword / board / user",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pins to collect per keyword, board URL, or user. For users, this limit applies per board. Set to 0 for no limit. Default: 100.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy configuration for Pinterest requests. Residential proxies are strongly recommended — Pinterest blocks datacenter IPs aggressively. Defaults to Apify Residential proxy group. The proxy cost is billed to the run owner.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
