# Pinterest Scraper API – Pins, Search, Boards & Profiles (`lance_api/pinterest-scraper-api`) Actor

Scrape public Pinterest Pins, search results, Boards, and Profiles into structured JSON. Extract images, videos, creators, engagement, outbound links, and available product data from keywords, URLs, Pin IDs, pin.it links, or usernames.

- **URL**: https://apify.com/lance\_api/pinterest-scraper-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** Social media, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 scraped results

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?

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

## How to integrate an Actor?

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

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

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

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

# README

## 📌 Pinterest Scraper All-in-One

Scrape public Pinterest search results, Pins, Boards, Profiles, images, videos, engagement signals, outbound links, creators, and available product data into clean JSON.

Pinterest Scraper All-in-One is an Apify Actor for collecting structured data from public Pinterest pages. Use it with search keywords, Pinterest URLs, Pin IDs, Board URLs, Profile URLs, profile usernames, Search URLs, or `pin.it` links. The Actor detects each target automatically and returns normalized, API-ready results.

It is built for content research, Pinterest SEO, creator discovery, product research, competitor monitoring, trend analysis, and automated data pipelines.

You are charged for successful, unique scraped Pin/results that are processed and returned. Duplicate results inside the same input scope are skipped and not charged.

This is an unofficial tool for public Pinterest data. It does not access private content, logged-in-only data, cookies, comments, follower lists, or non-public user information.

### ✨ Key Features

- **All-in-one input support**: keyword search, Pinterest Search URLs, Pin URLs, Pin IDs, `pin.it` links, Board URLs, Profile URLs, and profile usernames in a dedicated Profiles field.
- **Simple input page**: choose what you want to scrape first, then adjust only the options that apply to that input type.
- **Automatic target detection**: paste a Pinterest URL and the Actor figures out whether it is a Pin, Board, Profile, or Search page.
- **Rich output by default**: the Actor returns useful Pin, creator, attribution, board, media, engagement, outbound, and product fields whenever Pinterest exposes them publicly.
- **Efficient fetching internally**: the Actor uses data already available in Pinterest responses first and only requests an individual Pin page when it is likely to add meaningful public fields.
- **Duplicate skipping**: equivalent targets in the same run are normalized and processed once.
- **Result-based pricing**: billing is based on returned scraped Pin/results, not on pages visited.

### ⚡ Quick Input Examples

#### Search by keyword

```json
{
  "searchQueries": ["home decor"],
  "maxResults": 20
}
```

#### Scrape Pinterest URLs

```json
{
  "startUrls": [
    "https://www.pinterest.com/pin/550354016972119338/",
    "https://www.pinterest.com/HadleyJamesatHome/entryway-lighting-design-ideas/"
  ],
  "maxResults": 20
}
```

#### Scrape profiles

```json
{
  "profiles": [
    "jfcain",
    "https://www.pinterest.com/HadleyJamesatHome/"
  ],
  "profileContent": "pins",
  "maxResults": 20
}
```

### Input

Provide at least one value in `searchQueries`, `startUrls`, or `profiles`.

The Actor only runs keyword search when you provide `searchQueries`. If you leave Search queries empty and provide only URLs or profiles, no keyword search is performed.

#### 🔍 Search

Use this when you want to discover Pinterest content by topic.

| Field | Type | Required | Default | Description |
|---|---:|---:|---|---|
| `searchQueries` | array of strings | No | `[]` | Search Pinterest by one or more keywords. Examples: `home decor`, `summer outfits`, `healthy recipes`. Each keyword is processed as a separate search input. |

#### 🔗 Pinterest URLs

Use this when you already have Pinterest URLs.

| Field | Type | Required | Default | Description |
|---|---:|---:|---|---|
| `startUrls` | array of strings | No | `[]` | Pinterest URLs to scrape. Supported URLs include individual Pins, Boards, Profiles, Pinterest Search result pages, and `pin.it` short links. For plain usernames, use `profiles`. Numeric Pin IDs are still accepted for API compatibility. |

Supported URL examples:

- Pin URL: `https://www.pinterest.com/pin/550354016972119338/`
- Board URL: `https://www.pinterest.com/username/board-name/`
- Profile URL: `https://www.pinterest.com/username/`
- Search URL: `https://www.pinterest.com/search/pins/?q=home%20decor`
- Short Pin URL: `https://pin.it/example`

Pinterest Search URLs keep their own search type. For example, `/search/videos/` is treated as video search even if `searchType` is set to `pins`.

#### 👤 Profiles

Use this when you want to scrape Pinterest profiles by username or profile URL.

| Field | Type | Required | Default | Description |
|---|---:|---:|---|---|
| `profiles` | array of strings | No | `[]` | Pinterest usernames or profile URLs. Examples: `jfcain`, `@jfcain`, `https://www.pinterest.com/jfcain/`. This field is only for Profile targets. |

Profile URLs are accepted in both `startUrls` and `profiles`. If you enter the same profile in both places, the Actor normalizes and deduplicates it.

#### ⚙️ Options

These options control result volume or behavior for specific input types.

| Field | Type | Required | Default | Description |
|---|---:|---:|---|---|
| `maxResults` | integer | No | `20` | Maximum number of content results to return for each search, board, or profile input. Profile and board metadata rows do not count toward this limit. For Profiles with `pins_and_boards`, the limit applies independently to Pins and Boards. Minimum `1`, maximum `5000`. |
| `searchType` | string | No | `pins` | Choose what type of Pinterest results to return for keyword searches. Only applies to `searchQueries`. Allowed values: `pins`, `videos`, `boards`. |
| `profileContent` | string | No | `pins` | Choose what content to collect when scraping Pinterest profiles. Only applies to Profile inputs from `profiles` or Profile URLs. Allowed values: `pins`, `boards`, `pins_and_boards`, `profile_only`. |

#### 🔧 Advanced

| Field | Type | Required | Default | Description |
|---|---:|---:|---|---|
| `proxyConfiguration` | object | No | `{ "useApifyProxy": false }` | Optional proxy settings for Pinterest requests. Leave disabled unless you need a specific proxy configuration. When disabled, requests stay direct and the Actor does not silently switch to proxy fallback. |

### How Multiple Inputs Are Processed

`searchQueries`, `startUrls`, and `profiles` can be used together. Every keyword, URL, Pin ID, or profile is normalized into an internal target and processed as its own input scope.

Equivalent targets are deduplicated. For example, these two inputs refer to the same profile and are scraped once:

```json
{
  "startUrls": ["https://www.pinterest.com/jfcain/"],
  "profiles": ["jfcain"]
}
```

For list-style inputs, `maxResults` applies per input, not to the whole run. For example, two search queries with `maxResults: 100` can return up to 200 content results.

For Profile inputs:

- `profile_only`: returns the Profile metadata row only.
- `pins`: returns the Profile metadata row plus up to `maxResults` Pins.
- `boards`: returns the Profile metadata row plus up to `maxResults` Boards.
- `pins_and_boards`: returns the Profile metadata row plus up to `maxResults` Pins and up to `maxResults` Boards.

For Board inputs, the Board metadata row is returned before the Board Pins and does not count against `maxResults`.

### More Input Examples

#### Search Pinterest Pins

```json
{
  "searchQueries": ["home decor", "summer outfits"],
  "searchType": "pins",
  "maxResults": 100
}
```

#### Search Pinterest Videos

```json
{
  "searchQueries": ["workout ideas"],
  "searchType": "videos",
  "maxResults": 50
}
```

#### Search Pinterest Boards

```json
{
  "searchQueries": ["wedding planning"],
  "searchType": "boards",
  "maxResults": 50
}
```

#### Scrape a Pin by URL or ID

```json
{
  "startUrls": [
    "https://www.pinterest.com/pin/550354016972119338/",
    "29695678789181460"
  ]
}
```

#### Scrape a Board

```json
{
  "startUrls": [
    "https://www.pinterest.com/HadleyJamesatHome/entryway-lighting-design-ideas/"
  ],
  "maxResults": 100
}
```

#### Scrape a Profile URL

```json
{
  "startUrls": ["https://www.pinterest.com/HadleyJamesatHome/"],
  "profileContent": "pins",
  "maxResults": 100
}
```

#### Scrape a Profile Username

```json
{
  "profiles": ["jfcain"],
  "profileContent": "pins",
  "maxResults": 100
}
```

#### Mix Different Input Types

```json
{
  "searchQueries": ["home decor"],
  "startUrls": [
    "https://www.pinterest.com/pin/550354016972119338/",
    "https://www.pinterest.com/search/videos/?q=home%20decor",
    "https://www.pinterest.com/HadleyJamesatHome/entryway-lighting-design-ideas/"
  ],
  "profiles": ["jfcain"],
  "maxResults": 50
}
```

### API Usage

Use the Actor ID `lance_api/pinterest-scraper-api`.

#### JavaScript

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  searchQueries: ['home decor'],
  maxResults: 20,
  searchType: 'pins',
};

const run = await client.actor('lance_api/pinterest-scraper-api').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("lance_api/pinterest-scraper-api").call(
    run_input={
        "searchQueries": ["home decor"],
        "maxResults": 20,
        "searchType": "pins",
    }
)

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

### Output

The Dataset can contain four result types:

- `pin`: a Pinterest Pin result.
- `profile`: public Profile metadata.
- `board`: public Board metadata.
- `error`: a per-input error record. A failed input does not stop the whole batch unless the Actor input itself is invalid.

All rows include:

- `inputType`: where the result came from, such as `search`, `pin`, `board`, `profile`, or `unknown`.
- `inputValue`: the original keyword, URL, username, or ID.
- `resultType`: `pin`, `profile`, `board`, or `error`.
- `scrapedAt`: ISO 8601 timestamp in UTC.

The Actor automatically returns rich metadata whenever it is publicly available. There is no data-depth setting to choose. Fields that Pinterest does not expose for a specific result are returned as `null` or empty arrays instead of forcing extra low-value requests.

### Complete Output Field Reference

#### Top-Level Fields

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `success` | boolean | Yes | Present on error rows as `false`. Successful result rows may omit it. |
| `inputType` | string | No | Input scope that produced the row: `search`, `pin`, `board`, `profile`, or `unknown`. |
| `inputValue` | string | No | Original user-provided input or search keyword. |
| `resultType` | string | No | `pin`, `profile`, `board`, or `error`. |
| `pin` | object | Yes | Pin data for `pin` rows. |
| `creator` | object | Yes | Creator data for Pin rows when available. |
| `originalCreator` | object | Yes | Reserved for original creator data when Pinterest exposes it. Currently often `null`. |
| `attribution` | object | Yes | Brand, merchant, publisher, or source attribution when Pinterest exposes it separately from the creator. |
| `board` | object | Yes | Board data for Pin rows or Board metadata rows. |
| `engagement` | object | Yes | Available engagement metrics when Pinterest exposes them. |
| `media` | object | Yes | Available image and video metadata. |
| `product` | object | Yes | Available product or Rich Pin fields when Pinterest exposes meaningful shopping data. |
| `profile` | object | Yes | Profile metadata for `profile` rows. |
| `error` | object | Yes | Error details for `error` rows. |
| `scrapedAt` | string | No | UTC ISO 8601 timestamp, for example `2026-08-25T00:00:00Z`. |

#### `pin`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `id` | string | Yes | Pinterest Pin ID. |
| `url` | string | Yes | Public Pinterest Pin URL. |
| `type` | string | Yes | Media type reported by Pinterest, commonly `image` or `video`. |
| `title` | string | Yes | Pin title when available. |
| `description` | string | Yes | Pin description when available. |
| `altText` | string | Yes | Alt text when Pinterest exposes it. |
| `createdAt` | string | Yes | Creation timestamp as exposed by Pinterest. |
| `isPromoted` | boolean | Yes | Whether the Pin is marked as promoted when exposed. |
| `sourceUrl` | string | Yes | Source URL when exposed. |
| `outboundUrl` | string | Yes | External destination URL when exposed. |
| `domain` | string | Yes | Domain derived from Pinterest payload. |
| `hashtags` | array | Yes | Hashtags parsed from the Pin title and description. |

#### `creator`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `id` | string | Yes | Creator ID when exposed. |
| `username` | string | Yes | Pinterest username. |
| `fullName` | string | Yes | Public display name. |
| `profileUrl` | string | Yes | Public Pinterest Profile URL. |
| `avatarUrl` | string | Yes | Avatar image URL. |
| `followerCount` | number | Yes | Public follower count when exposed. |
| `verified` | boolean | Yes | Pinterest verification flag when exposed. This is not email or identity verification by this Actor. |
| `isVerifiedMerchant` | boolean | Yes | Pinterest merchant verification flag when exposed in the public payload. |
| `isPrimaryWebsiteVerified` | boolean | Yes | Pinterest primary website verification flag when exposed in the public payload. |

#### `attribution`

`attribution` uses the same normalized account shape as `creator`. It comes from Pinterest attribution fields such as `grid_attribution` when available.

`creator` is the account that pinned or owns the Pin record. `attribution` is the brand, merchant, publisher, or source account Pinterest attaches to the grid item. They can be the same account, different accounts, or `null`. `originalCreator` is kept separate and remains `null` unless Pinterest exposes a distinct original creator source.

#### `board`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `id` | string | Yes | Board ID when exposed. |
| `name` | string | Yes | Board name. |
| `description` | string | Yes | Board description. |
| `category` | string | Yes | Board category when exposed. |
| `privacy` | string | Yes | Board privacy value. Public Boards normally return `public`. |
| `pinCount` | number | Yes | Public Pin count when exposed. |
| `followerCount` | number | Yes | Public Board follower count when exposed. |
| `url` | string | Yes | Public Board URL. |
| `coverUrl` | string | Yes | Board cover image URL. |
| `owner` | object | Yes | Board owner with `id`, `username`, and `fullName` when available. |

#### `media`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `type` | string | Yes | Media type reported by Pinterest. |
| `dominantColor` | string | Yes | Dominant color when exposed. |
| `bestImageUrl` | string | Yes | Best available image URL selected from Pinterest image variants. |
| `images` | array | Yes | Image variants with `variant`, `width`, `height`, and `url`. |
| `video` | object | Yes | Video metadata when Pinterest exposes video formats. |

`media.video` can include `bestVideoUrl`, `thumbnailUrl`, `durationMs`, `width`, `height`, `hasAudio`, and `formats`. `durationMs` is in milliseconds. `hasAudio` is currently `null` when the public payload does not reliably expose audio information.

#### `engagement`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `saves` | number | Yes | Save count when exposed. |
| `repins` | number | Yes | Repin count when exposed. |
| `comments` | number | Yes | Comment count when exposed. |
| `shares` | number | Yes | Share count when exposed. |
| `reactions` | number | Yes | Reaction count when exposed. |
| `reactionDetail` | object | Yes | Reaction breakdown when exposed. |

Pinterest may expose some engagement metrics separately or not at all. The Actor does not merge different metrics into one artificial number.

#### `product`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `isProduct` | boolean | No | Present as `true` only when meaningful product fields are available. |
| `name` | string | Yes | Product name. |
| `siteName` | string | Yes | Merchant, publisher, or site name from Pinterest Rich Pin data. |
| `productUrl` | string | Yes | Product URL when exposed. |
| `price` | object | Yes | Price object with `value`, `currency`, and `formatted`. |
| `originalPrice` | object | Yes | Original list price with `value` and `formatted` when exposed. |
| `discount` | object | Yes | Discount object with `percentage` and `formatted` when exposed. |
| `availability` | object | Yes | Availability object. Currently includes `inStock` when exposed. |
| `rating` | object | Yes | Rating object with `value`, `ratingCount`, and `reviewCount` when exposed. |

#### `profile`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `id` | string | Yes | Profile ID when exposed. |
| `username` | string | Yes | Pinterest username. |
| `fullName` | string | Yes | Public display name. |
| `profileUrl` | string | Yes | Public Profile URL. |
| `bio` | string | Yes | Public bio. |
| `websiteUrl` | string | Yes | Public website URL. |
| `avatarUrl` | string | Yes | Avatar image URL. |
| `followerCount` | number | Yes | Public follower count when exposed. |
| `followingCount` | number | Yes | Public following count when exposed. |
| `pinCount` | number | Yes | Public Pin count when exposed. |
| `verified` | boolean | Yes | Pinterest verification flag when exposed. |

#### `error`

| Field | Type | Nullable | Description |
|---|---:|---:|---|
| `code` | string | No | Machine-readable error code. |
| `message` | string | No | Human-readable error message. |
| `details` | object | Yes | Additional details when available. |

### Status Values

The run summary stored in `OUTPUT` contains one summary object per input scope. List-style inputs may include:

| Status | Meaning | Dataset rows | Charged? |
|---|---|---|---|
| `limit_reached` | The Actor reached `maxResults` for that input. | Successful returned rows. | Yes, for returned unique scraped Pin/results. |
| `no_more_results` | Pinterest reported no more public results before `maxResults`. | Successful returned rows, if any. | Yes, for returned unique scraped Pin/results only. |
| `pagination_stalled` | Pagination stopped because Pinterest did not advance the bookmark. | Returned rows collected before the stall. | Yes, for returned unique scraped Pin/results only. |
| `blocked` | Pinterest returned retryable blocked or suspicious empty responses. | Usually an `error` row, unless partial results were already collected. | Error rows are not charged. Returned successful scraped Pin/results are charged. |
| `error` | The input failed with a structured error. | `error` row. | No. |

Possible error codes include `INVALID_INPUT`, `UNSUPPORTED_URL`, `PIN_NOT_FOUND`, `PROFILE_NOT_FOUND`, `BOARD_NOT_FOUND`, `NO_RESULTS`, `PAGINATION_STALLED`, `RATE_LIMITED`, `BLOCKED`, `TIMEOUT`, `PARSE_FAILED`, and `MEDIA_UNAVAILABLE`.

### Complete Output Example

```json
{
  "inputType": "search",
  "inputValue": "home decor",
  "resultType": "pin",
  "pin": {
    "id": "902760687832445696",
    "url": "https://www.pinterest.com/pin/902760687832445696/",
    "type": "image",
    "title": "Hawthorne Vintage Wall Sconce | Traditional Brass Hallway Lighting",
    "description": "A public Pinterest Pin description...",
    "altText": null,
    "createdAt": null,
    "isPromoted": false,
    "sourceUrl": null,
    "outboundUrl": "https://hadleyjamesathome.com/products/hawthorne-vintage-wall-sconce",
    "domain": "hadleyjamesathome.com",
    "hashtags": []
  },
  "creator": {
    "id": null,
    "username": "HadleyJamesatHome",
    "fullName": "Hadley James at Home",
    "profileUrl": "https://www.pinterest.com/HadleyJamesatHome/",
    "avatarUrl": "https://i.pinimg.com/75x75/example.jpg",
    "followerCount": null,
    "verified": null
  },
  "originalCreator": null,
  "attribution": null,
  "board": {
    "id": null,
    "name": "Entryway Lighting Design Ideas",
    "url": "https://www.pinterest.com/HadleyJamesatHome/entryway-lighting-design-ideas/",
    "pinCount": null,
    "followerCount": null
  },
  "engagement": {
    "saves": 120,
    "repins": null,
    "comments": 3,
    "shares": null,
    "reactions": null,
    "reactionDetail": null
  },
  "media": {
    "type": "image",
    "dominantColor": "#b08a64",
    "bestImageUrl": "https://i.pinimg.com/originals/51/16/90/511690c2692d705acee310f555cfc62f.jpg",
    "images": [
      {
        "variant": "orig",
        "width": 1000,
        "height": 1500,
        "url": "https://i.pinimg.com/originals/51/16/90/511690c2692d705acee310f555cfc62f.jpg"
      }
    ],
    "video": null
  },
  "product": null,
  "scrapedAt": "2026-08-25T00:00:00Z"
}
```

#### Error Example

```json
{
  "success": false,
  "inputType": "unknown",
  "inputValue": "https://example.com/not-a-pinterest-url",
  "resultType": "error",
  "error": {
    "code": "UNSUPPORTED_URL",
    "message": "Only public Pinterest URLs are supported: https://example.com/not-a-pinterest-url"
  },
  "scrapedAt": "2026-08-25T00:00:00Z"
}
```

### 💳 Pricing

This Actor uses result-based pricing. The billing unit is a returned, processed, unique scraped Pin/result.

If you provide a direct Pin URL, Pin ID, `pin.it` link, Board URL, Profile URL, Search URL, username in `profiles`, or search keyword, the Actor will process that input. Successful returned scraped Pin/results are charged. Duplicate results inside the same input scope are skipped and not charged. Error rows are not charged.

For inputs that can produce many Pins, such as search keywords, Pinterest Search URLs, Boards, and Profiles, billing is based on the final number of returned scraped Pin/results. In other words, if a search keyword returns 250 scraped Pins, you are charged for 250 results.

| Apify user level | Price per 1,000 results | Approx. price per result |
|---|---:|---:|
| Free | `$2.20` | `$0.0022` |
| Starter | `$1.80` | `$0.0018` |
| Scale | `$1.50` | `$0.0015` |
| Business | `$1.20` | `$0.0012` |

Pricing notes:

- **Direct Pin inputs**: charged when the Pin is successfully processed and returned.
- **Search keywords and Search URLs**: charged by the number of returned scraped Pin/results.
- **Board and Profile inputs**: charged by the number of returned scraped Pin/results from that Board or Profile.
- **Profile and Board metadata rows**: included for context and not counted as scraped Pin/result billing units.
- **Duplicate results within the same input scope**: not charged.
- **Invalid inputs, unsupported URLs, not-found records, and error rows**: not charged.
- **No public results returned**: not charged.

For the latest published price, check the Actor's Pricing tab on Apify.

### Use Cases

#### Pinterest SEO and Content Research

Collect public titles, descriptions, hashtags, creators, Boards, image URLs, and outbound domains to understand what content appears for a topic.

#### Trend and Creative Research

Use keyword and video search to gather public Pins for mood boards, creative analysis, visual trend tracking, and AI-assisted content workflows.

#### Creator Discovery

Scrape public Profile and Pin context to identify creators, brands, publishers, and accounts active in a niche.

#### Competitor and Brand Monitoring

Track public Pins, Boards, outbound links, domains, product references, and engagement signals for selected competitors or categories.

#### E-Commerce and Affiliate Research

Collect available Rich Pin product data, merchant names, prices, product URLs, source domains, and public Pin metadata for market research.

#### Dataset and API Automation

Use the Actor in scheduled Apify jobs, API workflows, dashboards, enrichment pipelines, and AI data preparation.

### How It Works

The Actor uses public Pinterest web responses and HTML bootstrap metadata. It does not run a browser, does not download media files, and does not require Pinterest cookies from the user.

For search, Board, and Profile Pin feeds, it follows Pinterest bookmark pagination until it reaches `maxResults`, Pinterest returns no more public results, or pagination stops.

For discovered Pins, the Actor first uses the data already present in the Pinterest response. It may request the individual Pin page only when useful high-value fields are likely missing, such as core Pin metadata, creator data, media data, or product/Rich Pin information. It does not send extra requests just to fill low-value or rarely exposed fields.

Proxy is disabled by default. When proxy is disabled, Pinterest requests are made directly and the Actor does not silently fail over to proxy. When proxy is enabled in Advanced settings, Pinterest requests use the configured Apify Proxy.

### Public Data and Responsible Use

This Actor is intended for public Pinterest data only. Use the results responsibly and follow Pinterest's terms, Apify's terms, privacy laws, anti-spam rules, and copyright requirements.

Do not use this Actor to harass people, send spam, build unlawful profiles, bypass access controls, collect private information, or copy content in a way that violates rights holders' interests.

### FAQ

#### What can I scrape with this Pinterest scraper?

You can scrape public Pinterest Pins, keyword search results, video search results, Board search results, Board Pins, public Profile metadata, public Profile Pins, and public Profile Boards when Pinterest exposes them.

#### Can I use a Pin ID instead of a URL?

Yes. Numeric Pin IDs such as `550354016972119338` are accepted in `startUrls` for API compatibility.

#### Can I enter a username in Pinterest URLs?

For the cleanest new input experience, enter usernames in `profiles`, for example `jfcain`. Pinterest URLs should contain full Pinterest URLs. The backend still accepts plain usernames in `startUrls` for backward compatibility with older API calls.

#### Can I scrape `pin.it` short links?

Yes. Public `pin.it` links are accepted and resolved as Pin inputs.

#### What does `searchType` affect?

`searchType` only affects keyword searches from `searchQueries`. It does not affect Pin URLs, Board URLs, Profile URLs, or entries in `profiles`. Pinterest Search URLs decide their own type from the URL path.

#### What does `profileContent` affect?

`profileContent` only affects Profile inputs. It controls whether the Actor returns profile Pins, profile Boards, both, or only the Profile metadata row.

#### How does billing work?

Billing is based on returned unique scraped Pin/results. If a search returns 100 scraped Pins, you are charged for 100 results. If a direct Pin input returns one Pin, you are charged for one result. Duplicate results skipped inside the same input scope and error rows are not charged.

#### Are Profile and Board metadata rows counted as scraped Pins?

No. Profile and Board metadata rows are included to help you understand where the scraped Pins came from. Pricing is based on returned scraped Pin/results.

#### What happens when Pinterest returns no results?

If no public results are returned, the Actor reports a structured `NO_RESULTS` error or a run summary with no returned results. No returned result means no result charge.

#### Does the Actor scrape comments, followers, or private Pins?

No. V1 does not scrape comments, follower lists, following lists beyond public count fields, private Pins, private Boards, authenticated feeds, or logged-in-only content.

#### Does it download image or video files?

No. It returns image and video URLs exposed by Pinterest. It does not download, store, or re-upload the media files.

#### Does it verify creators or emails?

No. The `verified` field is Pinterest's public verification flag when exposed. It is not email verification or identity verification by this Actor.

#### Why are some fields `null`?

Pinterest does not expose every field for every Pin, Board, Profile, or search result. `null` means the value was not available in the public payload. It is different from `0` or `false`.

### Limitations

- Only public Pinterest data is supported.
- Private content, deleted content, restricted content, logged-in-only feeds, and regionally unavailable pages may fail or return partial data.
- Comments crawling, related Pins, Topics, Trending feeds, Board Sections, follower lists, and authenticated account data are not supported in V1.
- Profile Board collection depends on Boards exposed in the public Profile payload and may not represent every Board on very large Profiles.
- Product data is only returned when Pinterest exposes meaningful Rich Pin or shopping fields.
- Engagement metrics may be missing, delayed, rounded, or exposed differently across Pinterest surfaces.
- The Actor returns media URLs, not downloaded media files.
- The Actor does not translate content, classify images, run ASR, scan external websites, or validate external product pages.

### Support

For help, contact **lanceapi2026@hotmail.com** or open an issue on the Actor's Issues page.

When reporting a problem, include the Apify Run ID, a non-sensitive sample input, the status or error code, and a short description of what you expected. Do not send Apify tokens, cookies, passwords, private keys, or other secrets.

# Actor input Schema

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

Search Pinterest by one or more keywords. This field starts keyword searches only. Examples: home decor, summer outfits, healthy recipes.

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

Add Pinterest URLs to scrape. Supported URLs include individual Pins, Boards, Profiles, Pinterest Search result pages, and pin.it short links. For plain usernames, use the Pinterest profiles field below.

## `profiles` (type: `array`):

Enter Pinterest usernames or profile URLs to scrape profile information and profile content. Examples: jfcain, https://www.pinterest.com/jfcain/.

## `maxResults` (type: `integer`):

Maximum number of content results to return for each search, board, or profile input. Profile and board metadata rows do not count toward this limit. For Profiles with Pins and boards selected, the limit applies independently to Pins and Boards.

## `searchType` (type: `string`):

Choose what type of Pinterest results to return for keyword searches. Only applies to Search queries. Pinterest Search URLs keep the type from the URL, such as /search/pins/ or /search/videos/.

## `profileContent` (type: `string`):

Choose what content to collect when scraping Pinterest profiles. Only applies to profile inputs, including profile URLs in Pinterest URLs and usernames or profile URLs in Pinterest profiles.

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

Optional proxy settings for Pinterest requests. Leave disabled unless you need a specific proxy configuration.

## Actor input object example

```json
{
  "searchQueries": [],
  "startUrls": [
    "https://www.pinterest.com/deadrebellin/einrichtungsinspo/"
  ],
  "profiles": [],
  "maxResults": 20,
  "searchType": "pins",
  "profileContent": "pins",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "startUrls": [
        "https://www.pinterest.com/deadrebellin/einrichtungsinspo/"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": ["https://www.pinterest.com/deadrebellin/einrichtungsinspo/"] }

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.pinterest.com/deadrebellin/einrichtungsinspo/"
  ]
}' |
apify call lance_api/pinterest-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

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/Ueo7FtduTp6TMuqrq/builds/rtKG0BLHsvOrH2Dtu/openapi.json