# Pinterest Pin Scraper API – Data & Metadata (`lance_api/pinterest-pin-scraper-api`) Actor

Extract structured Pinterest Pin data including titles, descriptions, images, videos, creators, boards, outbound links, engagement, and available product metadata from public Pin URLs.

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

## Pricing

from $1.00 / 1,000 processed pins

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 Pin Scraper API

**Turn public Pinterest Pin URLs, short links, or Pin IDs into clean structured data—including media, creator, board, engagement, outbound links, and available shopping metadata.**

Use this Pinterest Pin API when you already know which Pins you need. Submit up to 100 public Pin URLs, `pin.it` links, or numeric Pin IDs and receive stable, normalized JSON instead of Pinterest's raw internal response.

- **Structured Pin details:** Titles, descriptions, dates, domains, hashtags, source links, and outbound URLs.
- **Image and video media:** Normalized image variants plus available MP4/HLS video details.
- **Creator, board, and engagement context:** Public attribution, collection context, saves, comments, shares, repins, and reactions when exposed.
- **Optional commerce and captions:** Product fields and native subtitle references only when Pinterest provides them.
- **Duplicate-aware result pricing:** Every input keeps its own Dataset item, while the same canonical Pin is processed and billed only once. Standard pricing is $2.00 per 1,000 results, or as low as $1.00 per 1,000 with eligible Apify Store discounts.

This Actor is intentionally focused on **known Pin detail extraction**. It does not perform keyword search, full board/profile crawling, related-Pin discovery, full comment pagination, or AI transcription.

### ✨ Key features

#### Stable, normalized Pinterest Pin data

Get a predictable public schema without exposing Pinterest's raw internal response. This makes downstream API integrations, databases, and automations less dependent on Pinterest's internal field layout.

#### Image and video media

Receive the best available Pin image, normalized image variants, thumbnails, and available video details. Video Pins can include a recommended video URL plus MP4/HLS formats, dimensions, duration, and reliable audio evidence when it can be detected.

#### Creator, board, and engagement context

Understand who is associated with a Pin, which public board contains it, and which engagement signals Pinterest exposes. Missing values remain `null` instead of being presented as invented zeroes or empty text.

#### Optional shopping data

Enable `includeShoppingData` for available product ID, name, brand, price, currency, availability, product URL, and rating. Product data is returned only when Pinterest exposes evidence for it.

#### Native caption metadata

Enable `includeCaptions` to inspect Pinterest-provided caption or subtitle references on video Pins. This is native metadata only—the Actor does not run speech recognition, translation, or transcript generation.

#### Batch processing with canonical de-duplication

Process up to 100 inputs per run. Equivalent URLs and IDs that resolve to the same canonical Pin still receive separate Dataset items, while that canonical Pin generates only one `processed-pin` billing event.

### 🚀 Quick start

1. Paste a public Pinterest Pin URL, `pin.it` link, or numeric Pin ID into `urls`.
2. Keep the default options enabled for Pin, media, creator, board, and engagement details.
3. Click **Start**.
4. Open the run's **Dataset** tab.
5. Read the normalized `pin`, `media`, `creator`, `board`, and `engagement` groups. Enable shopping or captions when your workflow needs them.

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

### Supported Pinterest inputs

- Full Pin URL: `https://www.pinterest.com/pin/29695678789181460/`
- Supported regional Pinterest domain: `https://jp.pinterest.com/pin/29695678789181460/`
- Pinterest short link: `https://pin.it/3AxJbLdcH`
- Numeric Pin ID: `29695678789181460`

The Actor does not accept search pages, board URLs, profile URLs, related-Pin pages, or arbitrary non-Pinterest URLs.

### Input

| Field | Type | Required | Default | Limits | Description |
|---|---|---:|---|---|---|
| `urls` | array of strings | Yes | One tested public video Pin | 1–100 items | Public Pinterest Pin URLs, supported regional domains, `pin.it` links, or numeric Pin IDs. Every input receives a Dataset item. Canonical duplicates are billed once. |
| `includeMedia` | boolean | No | `true` | — | Includes normalized images, video URLs, thumbnails, dimensions, and available video formats. Disable it for a smaller text-focused response. |
| `includeCreator` | boolean | No | `true` | — | Includes public creator ID, username, name, profile URL, avatar, and follower count when exposed. |
| `includeBoard` | boolean | No | `true` | — | Includes public board ID, name, and canonical URL when Pinterest exposes board context. |
| `includeEngagement` | boolean | No | `true` | — | Includes available saves, repins, comments, shares, reactions, and reaction counts. |
| `includeShoppingData` | boolean | No | `false` | — | Includes available product and shopping fields. Leave it off for cleaner general-purpose output. |
| `includeCaptions` | boolean | No | `false` | — | Includes native Pinterest caption/subtitle references for video Pins and checks exposed HLS audio evidence. It does not create a transcript. |

The optional output-group switches do **not** multiply result billing. Multiple images, formats, product fields, or caption tracks remain part of one processed Pin result.

#### Duplicate inputs

Duplicate inputs remain separate Dataset items so input-to-output mapping stays clear. Inputs resolving to the same `pinId` are billed only once per run, including equivalent full URLs, regional URLs, numeric IDs, and successfully resolved short links.

### Input examples

#### One Pin

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

#### Numeric Pin ID

```json
{
  "urls": [
    "29695678789181460"
  ]
}
```

#### `pin.it` short link

```json
{
  "urls": [
    "https://pin.it/3AxJbLdcH"
  ]
}
```

#### Batch with shopping and native captions

```json
{
  "urls": [
    "https://www.pinterest.com/pin/29695678789181460/",
    "https://www.pinterest.com/pin/550354016972119338/",
    "https://www.pinterest.com/pin/1000502873449586873/"
  ],
  "includeMedia": true,
  "includeCreator": true,
  "includeBoard": true,
  "includeEngagement": true,
  "includeShoppingData": true,
  "includeCaptions": true
}
```

#### Compact Pin-only output

```json
{
  "urls": [
    "29695678789181460"
  ],
  "includeMedia": false,
  "includeCreator": false,
  "includeBoard": false,
  "includeEngagement": false,
  "includeShoppingData": false,
  "includeCaptions": false
}
```

The core `pin` object remains in successful results. The optional groups are omitted when disabled.

### Short output example

```json
{
  "inputUrl": "https://www.pinterest.com/pin/29695678789181460/",
  "normalizedUrl": "https://www.pinterest.com/pin/29695678789181460/",
  "pinId": "29695678789181460",
  "success": true,
  "status": "success",
  "pin": {
    "id": "29695678789181460",
    "type": "video",
    "title": "The most amazing places on earth",
    "description": null
  },
  "media": {
    "type": "video",
    "bestImageUrl": "https://i.pinimg.com/originals/21/21/d4/2121d49dca2b98155ad842ef60318d6b.jpg",
    "video": {
      "bestVideoUrl": "https://v1.pinimg.com/videos/iht/expMp4/1b/e9/90/1be990e86e2a4964ef1e9b8778fe935d_720w.mp4",
      "durationMs": 12100,
      "width": 720,
      "height": 1280,
      "hasAudio": null
    }
  },
  "scrapedAt": "2026-08-24T14:37:06.390Z"
}
```

### Output

Every submitted input produces one Dataset item in the original order, including duplicates and failures. Successful image and video Pins both use `status: "success"`; distinguish them with `pin.type` and `media.type`.

Optional groups are omitted when disabled. Individual fields use `null` when Pinterest does not expose a value or the Actor cannot determine it reliably.

### Complete output field reference

#### Core processing fields

| Field | Type | Nullable | Meaning |
|---|---|---:|---|
| `inputUrl` | string | No | Original input after surrounding whitespace is removed. |
| `normalizedUrl` | string | Yes | Canonical Pinterest Pin URL when normalization or short-link resolution succeeds. |
| `pinId` | string | Yes | Numeric Pinterest Pin ID. |
| `success` | boolean | No | `true` when the public Pin was parsed into the normalized schema. |
| `status` | string | No | Stable processing status described below. |
| `scrapedAt` | string | No | ISO 8601 UTC timestamp generated by the Actor. |

#### `pin`

The core `pin` object is included for successful results.

| Field | Type | Nullable | Meaning |
|---|---|---:|---|
| `pin.id` | string | No | Numeric Pinterest Pin ID. |
| `pin.type` | string | No | Detected `video`, `image`, `gif`, or `unknown` type. |
| `pin.url` | string | No | Canonical public Pinterest Pin URL. |
| `pin.title` | string | Yes | Title exposed by Pinterest. |
| `pin.description` | string | Yes | Description exposed by Pinterest. |
| `pin.createdAt` | string | Yes | Pinterest-provided creation date string; it is not guaranteed to be normalized. |
| `pin.sourceUrl` | string | Yes | Source URL exposed in Pin rich metadata. |
| `pin.outboundUrl` | string | Yes | Public destination URL associated with the Pin. |
| `pin.domain` | string | Yes | Domain or source label exposed by Pinterest. |
| `pin.hashtags` | array of strings | — | Hashtags extracted from the available description. |

#### `media`

Included when `includeMedia` is `true`.

| Field | Type | Nullable | Meaning |
|---|---|---:|---|
| `media.type` | string | No | Detected `video`, `image`, `gif`, or `unknown` media type. |
| `media.bestImageUrl` | string | Yes | Best available original/high-resolution image or thumbnail URL. |
| `media.images` | array | — | Normalized image variants. |
| `media.video` | object | Yes | Available normalized video details; `null` for image Pins. |

Each `media.images` item contains `quality`, nullable `width` and `height` in pixels, and `url`.

#### `media.video`

| Field | Type | Nullable | Meaning |
|---|---|---:|---|
| `bestVideoUrl` | string | Yes | Recommended available video URL, with progressive MP4 preferred over HLS when present. |
| `thumbnailUrl` | string | Yes | Pinterest-provided video thumbnail or best Pin image. |
| `durationMs` | number | Yes | Duration in milliseconds. |
| `width` | number | Yes | Selected video width in pixels. |
| `height` | number | Yes | Selected video height in pixels. |
| `hasAudio` | boolean | Yes | Audio evidence from an exposed HLS manifest. `null` means not reliably determined. |
| `formats` | array | — | Available video variants. |

Each `formats` item can contain:

- `quality`: Pinterest quality identifier.
- `format`: `mp4`, `hls`, or `unknown`.
- `mimeType`: nullable detected MIME type.
- `width` and `height`: nullable pixels.
- `durationMs`: nullable milliseconds.
- `bitrate`: nullable bitrate exposed by Pinterest.
- `thumbnailUrl`: nullable thumbnail.
- `url`: direct media URL.

#### `creator`

Included when `includeCreator` is `true`; the whole value can be `null`.

- `id`: nullable Pinterest user ID.
- `username`: nullable public username.
- `fullName`: nullable display name.
- `profileUrl`: nullable canonical profile URL.
- `avatarUrl`: nullable public avatar URL.
- `followerCount`: nullable numeric follower count exposed by Pinterest.

#### `board`

Included when `includeBoard` is `true`; the whole value can be `null`.

- `id`: nullable board ID.
- `name`: nullable board name.
- `url`: nullable canonical public board URL.

#### `engagement`

Included when `includeEngagement` is `true`.

- `saves`: nullable number of saves exposed by Pinterest.
- `repins`: nullable repin count.
- `comments`: nullable comment count. This Actor does not crawl comment text or pagination.
- `shares`: nullable share count.
- `reactions`: nullable sum of exposed reaction counts.
- `reactionCounts`: nullable map keyed by Pinterest reaction identifier.

These values can change after a run and may differ by geography or Pinterest response.

#### `product`

Included when `includeShoppingData` is `true`; the value is `null` when Pinterest does not expose product evidence.

- `id`: nullable product reference ID.
- `name`: nullable product name.
- `brand`: nullable brand or merchant name.
- `price`: nullable numeric price. Pinterest's zero/missing value is returned as `null`, not interpreted as a free product.
- `currency`: nullable currency code.
- `availability`: nullable availability value such as `out_of_stock`.
- `url`: nullable product or merchant URL.
- `rating`: nullable numeric rating.

#### `captions`

Included when `includeCaptions` is `true`.

- `available`: boolean indicating whether at least one native track reference was found.
- `tracks`: array of native tracks containing nullable `language`, nullable `label`, detected `format`, and direct `url`.

Caption tracks are Pinterest-provided metadata. They are not AI-generated transcripts.

#### `error`

Unsuccessful items include:

- `error.code`: stable machine-readable error code.
- `error.message`: plain-English explanation for API users.

Internal exception text, cookies, proxy passwords, and authentication headers are not returned.

### Status values

| Status | Meaning | Main output | `processed-pin` event\* |
|---|---|---|---:|
| `success` | An image, video, or GIF Pin was parsed successfully. | Normalized `pin` and selected optional groups. | Yes |
| `no_media` | The Pin was reached but no supported media was found. | `NO_MEDIA` error. | Yes |
| `invalid_input` | The input was empty, malformed, or not a supported Pinterest Pin URL/ID. | `INVALID_INPUT` or `INVALID_PIN_URL`. | No when rejected before processing |
| `not_found` | Pinterest reports that the Pin cannot be found. | `PIN_NOT_FOUND` error. | Yes |
| `private` | The Pin is private or requires authentication. | `PRIVATE_PIN` error. | Yes |
| `rate_limited` | Pinterest temporarily rate-limited the request. | `RATE_LIMITED` error. | Yes |
| `blocked` | Pinterest blocked the request from the current network path. | `BLOCKED` error. | Yes |
| `timeout` | Pinterest did not respond before the timeout. | `TIMEOUT` error. | Yes |
| `error` | The Pin was unavailable, unsupported, or could not be parsed. | A matching stable `error.code`. | Yes |

\*Only the first processed occurrence of a canonical Pin is billed. Canonical duplicates do not generate another event. A syntactically valid `pin.it` input that enters processing can be billed even if redirect resolution later fails.

Failures do not stop the rest of a batch. Every failed input is written to the Dataset in its original position.

### Error codes

| Code | Meaning |
|---|---|
| `INVALID_INPUT` | The input is empty or missing. |
| `INVALID_PIN_URL` | The value is not a supported Pinterest Pin URL or numeric Pin ID. |
| `PIN_NOT_FOUND` | Pinterest reports that the Pin cannot be found. |
| `PIN_UNAVAILABLE` | The Pin is currently unavailable or a network request failed. |
| `PRIVATE_PIN` | The Pin is private or requires authentication. |
| `NO_MEDIA` | The Pin was parsed but contains no supported media. |
| `RATE_LIMITED` | Pinterest temporarily rate-limited the request. |
| `BLOCKED` | Pinterest blocked the request from the current network path. |
| `TIMEOUT` | Pinterest did not respond within the request timeout. |
| `PARSE_FAILED` | Pinterest responded, but the Pin could not be normalized safely. |

### Output examples

#### Image Pin

```json
{
  "inputUrl": "https://www.pinterest.com/pin/550354016972119338/",
  "normalizedUrl": "https://www.pinterest.com/pin/550354016972119338/",
  "pinId": "550354016972119338",
  "success": true,
  "status": "success",
  "pin": {
    "id": "550354016972119338",
    "type": "image",
    "url": "https://www.pinterest.com/pin/550354016972119338/",
    "title": null,
    "description": null,
    "createdAt": "Mon, 11 Oct 2021 01:46:00 +0000",
    "sourceUrl": "https://notentirelyaverage.com/salted-burnt-caramel-custard/",
    "outboundUrl": "https://notentirelyaverage.com/salted-burnt-caramel-custard/",
    "domain": "notentirelyaverage.com",
    "hashtags": []
  },
  "media": {
    "type": "image",
    "bestImageUrl": "https://i.pinimg.com/originals/f8/4e/fe/f84efee12675666101577f980fea18e2.png",
    "images": [
      {
        "quality": "orig",
        "width": 683,
        "height": 1024,
        "url": "https://i.pinimg.com/originals/f8/4e/fe/f84efee12675666101577f980fea18e2.png"
      }
    ],
    "video": null
  },
  "scrapedAt": "2026-08-24T14:40:00.000Z"
}
```

Pinterest values can change over time. This example shows the normalized structure of a real tested public image Pin.

#### Shopping Pin

```json
{
  "inputUrl": "https://www.pinterest.com/pin/1000502873449586873/",
  "normalizedUrl": "https://www.pinterest.com/pin/1000502873449586873/",
  "pinId": "1000502873449586873",
  "success": true,
  "status": "success",
  "pin": {
    "id": "1000502873449586873",
    "type": "image",
    "title": null,
    "description": "COSRX BHA Power Liquid | Shop Korean Skincare in CAN & US | Sukoshi Mart",
    "outboundUrl": "https://sukoshimart.com/products/cosrx-bha-blackhead-power-liquid",
    "domain": "sukoshimart.com"
  },
  "product": {
    "id": "-2951750088062004643",
    "name": null,
    "brand": null,
    "price": null,
    "currency": "USD",
    "availability": "out_of_stock",
    "url": "https://sukoshimart.com/products/cosrx-bha-blackhead-power-liquid",
    "rating": null
  },
  "scrapedAt": "2026-08-24T14:46:14.431Z"
}
```

#### Invalid input

```json
{
  "inputUrl": "https://example.com/not-a-pinterest-pin",
  "normalizedUrl": null,
  "pinId": null,
  "success": false,
  "status": "invalid_input",
  "error": {
    "code": "INVALID_PIN_URL",
    "message": "The input is not a supported Pinterest Pin URL or numeric Pin ID."
  },
  "scrapedAt": "2026-08-24T14:37:05.365Z"
}
```

### 🔌 API usage

Use the real Actor ID `lance_api/pinterest-pin-scraper-api`. Keep your token in the `APIFY_TOKEN` environment variable and never place a real token in source code.

#### JavaScript

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

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

const input = {
    urls: ['https://www.pinterest.com/pin/29695678789181460/'],
    includeMedia: true,
    includeCreator: true,
    includeBoard: true,
    includeEngagement: true,
    includeShoppingData: false,
    includeCaptions: false,
};

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

console.log(items[0]);
```

#### Python

```python
import os
from apify_client import ApifyClient

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

run = client.actor('lance_api/pinterest-pin-scraper-api').call(run_input={
    'urls': ['https://www.pinterest.com/pin/29695678789181460/'],
    'includeMedia': True,
    'includeCreator': True,
    'includeBoard': True,
    'includeEngagement': True,
    'includeShoppingData': False,
    'includeCaptions': False,
})

items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(items[0])
```

#### cURL

This synchronous endpoint starts the Actor, waits for completion, and returns the default Dataset items:

```bash
curl --request POST \
  "https://api.apify.com/v2/acts/lance_api~pinterest-pin-scraper-api/run-sync-get-dataset-items" \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "urls": ["https://www.pinterest.com/pin/29695678789181460/"],
    "includeMedia": true,
    "includeCreator": true,
    "includeBoard": true,
    "includeEngagement": true,
    "includeShoppingData": false,
    "includeCaptions": false
  }'
```

### 💳 Pricing

**Simple result-based pricing:** each unique canonical Pinterest Pin that enters processing produces one `processed-pin` billing event. Duplicate inputs can still receive separate Dataset items, but they are not charged again.

Standard Free pricing is **$0.0020 per result — $2.00 per 1,000 results**. Eligible Apify Store discounts can reduce this to **$0.0010 per result — $1.00 per 1,000 results**.

- **One processed unique canonical Pin:** one event.
- **Canonical duplicate:** no additional charge.
- **Image, video, or GIF Pin:** one event when it is the first processed occurrence.
- **No-media, unavailable, private, blocked, rate-limited, timeout, or parse-failed result:** one event when processing was attempted for that unique canonical input.
- **Malformed input or unsupported domain rejected before Pinterest processing:** no event.
- **Multiple images, video formats, product fields, or caption tracks:** still one event.
- **Optional output groups:** enabling or disabling them does not multiply billing.

Check the Actor's **Pricing** tab for the current plan-specific rate. Control event cost by limiting the number of unique canonical Pins submitted in each run.

### 💡 Use cases

#### Pinterest content research

Build structured research datasets from known public Pins, including titles, descriptions, media, attribution, and destination links.

#### Media cataloging

Use normalized image and available video variants to organize public Pinterest media references in a CMS, DAM, or review workflow.

#### Creator and board analysis

Use creator and board context to understand public attribution and collection placement. The Actor returns the data; your downstream system can perform analysis or aggregation.

#### Engagement analysis

Collect available saves, comments, shares, repins, and reactions for reporting, comparison, or trend research across a known list of Pins.

#### Commerce and shopping enrichment

Enable product data to enrich catalogs or research commerce-focused Pins with available currency, availability, product URLs, and other exposed fields.

#### AI and RAG pipelines

Feed normalized Pin text, media URLs, and metadata into your own retrieval, classification, summarization, or multimodal workflow. The Actor itself does not perform AI analysis.

#### Data warehouse and API automation

Load predictable JSON into a database, spreadsheet, ETL job, scheduled Apify Task, or internal API without parsing Pinterest's raw internal response.

### How it works

1. Validate each Pin URL, short link, or numeric Pin ID.
2. Resolve supported short links and normalize the canonical Pin URL.
3. Reuse equivalent canonical Pin requests where possible.
4. Retrieve the public Pin detail data over HTTP with bounded retries and timeouts.
5. Normalize Pin, media, creator, board, engagement, shopping, and caption fields.
6. Save one Dataset item for every submitted input, including duplicates and failures.
7. Apply `processed-pin` billing once per unique canonical Pin that entered processing.

The Actor uses HTTP requests rather than a full browser and does not expose Pinterest's internal endpoint or raw response as its public API.

### FAQ

#### What Pinterest inputs are supported?

Public Pin detail URLs on supported Pinterest domains, `pin.it` short links, and numeric Pin IDs. Search, profile, and board URLs are not accepted.

#### Can I use only a numeric Pin ID?

Yes. For example, submit `29695678789181460` as an item in `urls`.

#### Does it support `pin.it` short links?

Yes. The Actor follows supported public redirects and returns the canonical `normalizedUrl` and `pinId` when resolution succeeds.

#### Can I process up to 100 Pins?

Yes. `urls` accepts 1–100 items, and every input receives a Dataset item.

#### How are duplicates handled and charged?

Equivalent inputs remain separate Dataset items for clear input mapping. If they resolve to the same canonical Pin, that Pin is billed only once in the run.

#### Does it return both image and video Pins?

Yes. Both return `status: "success"` when parsed. Use `pin.type` or `media.type` to distinguish them. Video information is returned only when Pinterest exposes video media.

#### Does it return shopping data?

Enable `includeShoppingData`. Product fields are returned only when Pinterest exposes product evidence; otherwise `product` is `null`.

#### Does it scrape native captions or generate transcripts?

With `includeCaptions`, the Actor returns native Pinterest caption/subtitle references when available. It does not perform ASR, transcript generation, or translation.

#### What happens if a Pin is private or unavailable?

The input still receives a structured failure item with `status` and `error.code`. A valid Pinterest input that entered processing counts as one result unless it is a canonical duplicate.

#### How am I charged?

Each unique canonical Pin that enters processing generates one `processed-pin` event. Inputs rejected before Pinterest processing are not charged, and duplicates do not generate another event. See the Pricing tab for your plan's current rate.

#### Can AI agents use this Actor?

AI systems can call the Actor through the Apify API or an integration that supports Apify Actors, then use the returned structured data in downstream workflows. A dedicated MCP section is not included until this Actor's Apify MCP availability has been verified.

### Limitations

- Public Pin detail extraction only.
- Private, deleted, login-required, region-restricted, or unavailable Pins may fail or expose limited fields.
- Pinterest decides which metadata, media, creator, board, engagement, product, and caption fields are available.
- Shopping data is returned only when Pinterest exposes product evidence.
- Native captions are returned only when exposed; no ASR, transcript generation, or translation is performed.
- Direct image and video CDN URLs may expire, rotate, or become unavailable after a run.
- No keyword search, related-Pin discovery, full board crawl, full profile crawl, or full comment pagination.
- No permanent media hosting or automatic copying of media files into storage.
- No outbound-site scanning and no access-control bypass.

### Public data and responsible use

Use this Actor only for publicly accessible Pinterest Pin data and comply with Pinterest's terms, Apify's terms, applicable privacy laws, copyright rules, and other applicable law.

Do not use it to access private information, bypass controls, harass people, send spam, create unlawful profiles, or redistribute copyrighted media without the necessary rights or permission. You are responsible for your inputs and downstream use of returned data and URLs.

### Support

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

Include the Run ID, a non-sensitive public Pin URL or ID, the returned `status`, `error.code`, and expected versus actual behavior. **Do not send your Apify token, cookies, sessions, API keys, passwords, proxy credentials, or other private credentials.**

# Actor input Schema

## `urls` (type: `array`):

Add one or more known public Pinterest Pin URLs. Multiple URLs can be processed in one run. Numeric Pin IDs and pin.it short links are also supported.

## `includeMedia` (type: `boolean`):

Include images, video URLs, thumbnails, dimensions, and available video formats. Turn this off if you only need textual Pin metadata and want a smaller response.

## `includeCreator` (type: `boolean`):

Include public information about the creator associated with the Pin, such as username, display name, profile URL, and avatar when available.

## `includeBoard` (type: `boolean`):

Include information about the board associated with the Pin when Pinterest exposes it. Useful for understanding the Pin's collection context.

## `includeEngagement` (type: `boolean`):

Include engagement signals Pinterest exposes for the Pin, such as saves, comments, shares, or reactions. Disable this when you only need content and media data.

## `includeShoppingData` (type: `boolean`):

Include available product metadata such as price, brand, availability, and product references. Enable this for commerce-focused Pins; leave it off for cleaner general-purpose datasets. This may add processing when Pinterest exposes commerce data.

## `includeCaptions` (type: `boolean`):

Include native caption or subtitle track information for video Pins when Pinterest exposes it. Leave this off if you only need standard Pin metadata. This does not perform transcription.

## Actor input object example

```json
{
  "urls": [
    "https://www.pinterest.com/pin/29695678789181460/"
  ],
  "includeMedia": true,
  "includeCreator": true,
  "includeBoard": true,
  "includeEngagement": true,
  "includeShoppingData": false,
  "includeCaptions": false
}
```

# Actor output Schema

## `results` (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 = {
    "urls": [
        "https://www.pinterest.com/pin/29695678789181460/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/pinterest-pin-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 = { "urls": ["https://www.pinterest.com/pin/29695678789181460/"] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/pinterest-pin-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 '{
  "urls": [
    "https://www.pinterest.com/pin/29695678789181460/"
  ]
}' |
apify call lance_api/pinterest-pin-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-pin-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/e9n6G1SMefkCkTLQM/builds/3joxCrQfKBM4OQQ5e/openapi.json