# Pinterest Scraper & Monitor - Pins, Boards & Profiles (`valev-lab/pinterest-scraper`) Actor

Scrape Pinterest search, boards, profiles & pin URLs. Schedule monitors that bill only for new pins. Images, saves, hashtags, outbound links - no login.

- **URL**: https://apify.com/valev-lab/pinterest-scraper.md
- **Developed by:** [Daniel Valev](https://apify.com/valev-lab) (community)
- **Categories:** Social media, Marketing, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.65 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does Pinterest Scraper & Monitor do?

**Pinterest Scraper & Monitor** is a **Pinterest API alternative** for public [Pinterest](https://www.pinterest.com/) data. It scrapes **pins from keyword search**, **creator profiles**, **boards**, and **individual pin URLs** — **without login**, cookies, or a browser.

Every pin comes back as a flat, spreadsheet-ready row: full-resolution images, titles, descriptions, hashtags, save counts (when public), pinner and board metadata, and outbound product/affiliate links.

Optional **monitor mode** remembers pins you already stored and returns (and charges for) **only new pins** on the next scheduled run — ideal for competitor boards and brand watches.

[Try it for free](https://console.apify.com) with the default search sample, or jump to the examples below.

### Who is this Pinterest scraper for?

**Marketing & content teams**

- Track trending visuals and rising keywords in your niche
- Analyze competitor boards and top-performing pin copy
- Research hashtags and descriptions that drive saves

**E-commerce & product managers**

- See how products and categories show up on Pinterest
- Collect competitor imagery, alt text, and destination domains
- Build mood boards and merchandising inspiration datasets

**SEO & social specialists**

- Find high-intent visual keywords and outbound link patterns
- Monitor brand mentions and pins linking to your site
- Feed Pinterest research into content calendars

**Analysts, agencies & AI pipelines**

- Large image + metadata datasets for research or ML
- Scheduled JSON/CSV exports via API, webhooks, Make, Zapier, or MCP

### Why use this Pinterest scraper?

- **Four modes in one Actor** — search, profile, board, and pin URL
- **New-pin monitoring** — schedule weekly watches; pay only for unseen pins
- **Automatic deduplication** — overlapping sources → one pin with merged provenance
- **Pure HTTP** — no Playwright/browser CU bloat for this target
- **No login required** — public data only; residential proxy default
- **Full-resolution images** — originals + thumbnails, dimensions, dominant color, alt text
- **Hashtags & outbound links** — parsed from descriptions when present
- **Export anywhere** — JSON, CSV, Excel, HTML, or Apify API / MCP

#### How it compares

| | This Actor | Typical Store scrapers |
|---|---|---|
| Sources | Search + profile + board + pin URL | Often search-only or URL-only |
| Recurring runs | **Monitor: charge new pins only** | Full re-scrape every time |
| Transport | HTTP (fast, low CU) | Often browser-heavy |
| Pricing | Pay per pin from **$1.65 / 1k** (Gold) | Higher PPE or monthly rental |
| Login | Not required | Sometimes cookies / accounts |

### Which mode should I use?

| Mode | Best for | First-run tip |
|---|---|---|
| Search (`searchQueries`) | Trend discovery and topic research | One query, `maxPins: 25` |
| Profile (`profileUrls`) | Creator / brand monitoring | One public profile URL |
| Board (`boardUrls`) | Competitor or campaign boards | `https://www.pinterest.com/{user}/{board}/` |
| Pin (`pinUrls`) | Enriching known pin IDs | 1–20 real `/pin/{id}/` URLs |
| Monitor (`onlyNewPins`) | Recurring board/profile watches | Baseline once, then schedule |

### What data can you extract?

| Category | Fields |
|---|---|
| Pin | `id`, `url`, `title`, `description`, `createdAt` |
| Media | `imageUrl`, `thumbnailUrl`, `imageWidth`, `imageHeight`, `dominantColor`, `altText`, `isVideo` |
| Engagement | `saves` (when Pinterest exposes it) |
| Pinner | `pinnerUsername`, `pinnerName`, `pinnerFollowers` |
| Board | `boardName`, `boardUrl` |
| Links | `link`, `domain`, `hashtags` |
| Provenance | `sourceTypes`, `sourceUrls`, `sourceQueries` |
| Profile source | `profileUrl`, `profileUsername`, `profileName`, `profileFollowers`, `profilePinCount` |
| Monitoring | `firstSeenAt`, `scrapedAt` |

Missing values are `null` (keys are never omitted). Download as JSON, CSV, HTML, or Excel.

#### Output example

```json
{
  "id": "16888567449212717",
  "url": "https://www.pinterest.com/pin/16888567449212717/",
  "title": "Kitchen Essentials | Modern Minimalist Kitchen Ideas & Must-Haves",
  "description": "Create a clean, calming kitchen… #ad #amazonfinds",
  "createdAt": "2026-09-20T11:39:01.000Z",
  "imageUrl": "https://i.pinimg.com/originals/f1/3d/9c/….jpg",
  "thumbnailUrl": "https://i.pinimg.com/236x/f1/3d/9c/….jpg",
  "imageWidth": 768,
  "imageHeight": 1365,
  "dominantColor": "#8b7b6a",
  "altText": "Modern minimalist kitchen with neutral cabinets",
  "isVideo": false,
  "link": "https://example.com/product",
  "domain": "example.com",
  "hashtags": ["ad", "amazonfinds"],
  "saves": 128,
  "pinnerUsername": "example_user",
  "pinnerName": "Example User",
  "pinnerFollowers": 1200,
  "boardName": "Kitchen Ideas",
  "boardUrl": "https://www.pinterest.com/example_user/kitchen-ideas/",
  "sourceTypes": ["search"],
  "sourceUrls": [],
  "sourceQueries": ["minimalist kitchen design"],
  "profileUrl": null,
  "profileUsername": null,
  "profileName": null,
  "profileFollowers": null,
  "profilePinCount": null,
  "firstSeenAt": "2026-09-30T00:00:00.000Z",
  "scrapedAt": "2026-09-30T00:00:00.000Z"
}
```

### How to scrape Pinterest pins

1. Open **Pinterest Scraper & Monitor** in Apify Console and click **Try for free**.
2. Add at least one source: search query, profile URL, board URL, or pin URL.
3. Keep `maxPins` small (10–25) for the first run so you can check fields and cost.
4. Leave proxy on **Apify Proxy → RESIDENTIAL** (datacenter exits often return empty payloads).
5. Click **Start**, then download results from the **Dataset** tab (JSON / CSV / Excel).
6. For recurring watches, enable **monitor mode** (below), save a **Task**, and attach a **Schedule**.

No coding required for Console runs. Developers: see **API** / **MCP** below. Full field docs live on the **Input** tab.

Invalid URLs are logged and skipped. `pin.it` short links are rejected — expand them to full `pinterest.com` URLs first.

### How much does it cost to scrape Pinterest?

**Pay-per-event** — you pay for pins actually written to the dataset. Duplicates, monitor skips, and failed sources are **not** charged. Platform compute/proxy usage is intended to be **included** in the event price.

| | Free | Bronze | Silver | Gold |
|---|---:|---:|---:|---:|
| Per pin | $0.00315 | $0.00275 | $0.00215 | $0.00165 |
| **Per 1,000 pins** | **$3.15** | **$2.75** | **$2.15** | **$1.65** |

Synthetic `apify-actor-start` uses Apify’s default start event (do not add a custom start event).

#### Real-world cost examples (Free tier)

| Workload | Pins | Approx. event charge |
|---|---:|---:|
| Quick sample search | 25 | ~$0.08 |
| One board snapshot | 50 | ~$0.16 |
| Three topic searches | 300 | ~$0.95 |
| Large research batch | 1,000 | $3.15 |
| Weekly monitor (5 new pins) | 5 | ~$0.02 |

With Apify’s free monthly credit (~$5), you can scrape on the order of **~1,500 pins** while you validate the Actor — before any paid plan.

### Monitor only new Pinterest pins

This is the feature that keeps recurring competitor watches cheap:

1. Set `onlyNewPins: true` and a stable `monitoringKey` (e.g. `nike-board-weekly`).
2. **First run** for that key is the **baseline**: all found pins are saved and charged, then recorded.
3. **Later runs** emit and charge **only unseen pin IDs**. Boards/profiles stop after two consecutive pages with zero new pins. Search never early-stops.
4. Create an Actor **Task**, schedule it daily or weekly, and optionally attach a webhook (Slack, email, your backend).

Empty datasets on a successful monitor run usually mean “no new pins” — not a failure.

### Input examples

**Search Pinterest by keyword**

```json
{
  "searchQueries": ["minimalist kitchen design", "japandi living room"],
  "maxPins": 25
}
```

**Scrape a public profile**

```json
{
  "profileUrls": ["https://www.pinterest.com/pinterest/"],
  "maxPins": 50
}
```

**Scrape a competitor board**

```json
{
  "boardUrls": ["https://www.pinterest.com/pinterest/official-news/"],
  "maxPins": 100
}
```

**Enrich individual pins**

```json
{
  "pinUrls": [
    "https://www.pinterest.com/pin/889812838915166081/"
  ]
}
```

**Weekly board monitoring (new pins only)**

```json
{
  "boardUrls": ["https://www.pinterest.com/pinterest/official-news/"],
  "maxPins": 100,
  "onlyNewPins": true,
  "monitoringKey": "pinterest-official-news-weekly"
}
```

### Tips for best results

- Start with `maxPins` 10–25 to confirm the field shape before scaling.
- Prefer specific queries (“japandi kitchen island”) over broad ones (“kitchen”).
- Board URLs must include username and board slug.
- Prefer search/board/profile for volume; use pin URLs to enrich known IDs.
- Keep residential proxy enabled for reliable cloud runs.
- Use a unique `monitoringKey` per watch so schedules do not share state.

### Integrations and API

- Schedule Tasks in Console; send webhooks to Slack, Make, Zapier, or your backend.
- Export datasets or stream via the Apify API.
- Use from AI agents through [Apify MCP](https://docs.apify.com/platform/integrations/mcp).

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('valev-lab/pinterest-scraper').call({
  searchQueries: ['minimalist kitchen design'],
  maxPins: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('valev-lab/pinterest-scraper').call(run_input={
    'searchQueries': ['minimalist kitchen design'],
    'maxPins': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/valev-lab~pinterest-scraper/runs" \
  -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"searchQueries":["minimalist kitchen design"],"maxPins":25}'
```

### Use with AI agents via MCP

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=valev-lab/pinterest-scraper"
    }
  }
}
```

Example prompts: “Search Pinterest for boho bedroom ideas and return the top 50 pins”, “Monitor this board weekly and list only new pins”.

### FAQ

#### Is it legal to scrape Pinterest?

This Actor accesses **public** Pinterest pages only and does not accept login credentials. Legality depends on your jurisdiction, Pinterest’s terms, and how you use the data. Do not scrape private content or use results for spam or harassment. When personal data may appear in public profiles, comply with GDPR and similar laws. If you are unsure, consult your counsel.

#### Do I need a Pinterest account or API key?

No. Public pins and public profile/board metadata only — no OAuth, cookies, or developer approval.

#### Why are some fields null?

Many pins have no title, outbound link, hashtags, or public save count. Search and profile feeds often omit `saves`; board feeds usually include them. `link` is often null for direct uploads.

#### Why did my board return few or zero pins?

Use a public board URL shaped like `https://www.pinterest.com/{username}/{board}/`. Private boards and removed accounts are not supported. A whole run with zero pins (and not because monitoring filtered them) fails with a clear error.

#### How is this different from the official Pinterest API?

The official API needs developer approval, OAuth, and stricter quotas. This Actor works without those credentials and focuses on public pin metadata for research and monitoring. You remain responsible for compliant use.

#### Can I scrape comments or private profiles?

No. Public pins and public profile/board metadata only.

#### What happens on a monitor run with nothing new?

The run succeeds with an empty (or near-empty) dataset and you are not charged for skipped pins — only the synthetic Actor start event applies.

#### Need help?

Open an issue on the Actor’s **Issues** tab in Apify Console, or check the **API** tab for programmatic access.

### Data & privacy

- Public Pinterest content only. No login, cookie, or credential inputs.
- Run input, logs, and datasets stay in the run’s Apify storages unless you export them.
- Delete runs and storages anytime in Console or via the API.

Pinterest is a trademark of its respective owner. This Actor is an independent tool and is not affiliated with, endorsed by, or operated by Pinterest.

# Changelog

This Actor's version history is a separate document: https://apify.com/valev-lab/pinterest-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Pinterest keyword searches. Each query returns up to maxPins results.

## `profileUrls` (type: `array`):

Public Pinterest profile URLs. Format: https://www.pinterest.com/{username}/. Returns profile metadata plus up to maxPins pins.

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

Public board URLs. Format: https://www.pinterest.com/{username}/{board}/.

## `pinUrls` (type: `array`):

Individual pin URLs (/pin/{id}/ or /pin/{slug}--{id}/). Short pin.it links are rejected with a clear error.

## `maxPins` (type: `integer`):

Maximum pins to extract per search query, board, or profile (1–1000). Pin URLs are always one pin each.

## `onlyNewPins` (type: `boolean`):

When true, skip pins already seen for each source. The first run for a source pushes all found pins and records them as the baseline. Later runs push and charge only new pins.

## `monitoringKey` (type: `string`):

Optional name to separate independent monitors. When empty, a key is derived from the normalized input sources.

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

Prefer RESIDENTIAL. Datacenter exits often receive empty Pinterest responses.

## Actor input object example

```json
{
  "searchQueries": [
    "minimalist kitchen design"
  ],
  "profileUrls": [],
  "boardUrls": [],
  "pinUrls": [],
  "maxPins": 5,
  "onlyNewPins": false,
  "monitoringKey": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (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 = {
    "searchQueries": [
        "minimalist kitchen design"
    ],
    "profileUrls": [],
    "boardUrls": [],
    "pinUrls": [],
    "maxPins": 5,
    "monitoringKey": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("valev-lab/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 = {
    "searchQueries": ["minimalist kitchen design"],
    "profileUrls": [],
    "boardUrls": [],
    "pinUrls": [],
    "maxPins": 5,
    "monitoringKey": "",
}

# Run the Actor and wait for it to finish
run = client.actor("valev-lab/pinterest-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 '{
  "searchQueries": [
    "minimalist kitchen design"
  ],
  "profileUrls": [],
  "boardUrls": [],
  "pinUrls": [],
  "maxPins": 5,
  "monitoringKey": ""
}' |
apify call valev-lab/pinterest-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,valev-lab/pinterest-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/URadczBuWwNYleoKX/builds/PTGYbPMa8mEMNFNhy/openapi.json