# Pinterest Video Downloader (`maximedupre/pinterest-video-downloader`) Actor

Download media from public Pinterest pins. Paste pin URLs, pin.it links, or pin IDs to get video and image URLs, thumbnails, titles, descriptions, pinner data, board data, and optional Apify storage links.

- **URL**: https://apify.com/maximedupre/pinterest-video-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.65 / 1,000 processed pinterest 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/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 video downloader for public pins

Pinterest Video Downloader extracts media from public [Pinterest](https://www.pinterest.com/) pins. Paste full Pinterest pin URLs, `pin.it` short links, or bare pin IDs, then export direct video and image URLs with thumbnails, titles, descriptions, pinner data, board data, media variants, and scrape timestamps.

Use this Actor when you already have Pinterest pins and need a repeatable Pinterest pin downloader for content review, creative research, mood boards, social media operations, archiving, or an API workflow. The default run is small: keep the prefilled public video pin, leave **Media type** set to `Videos and images`, and start the Actor to inspect the output before adding your own list.

The Actor works with public pin pages only. You do not need to provide Pinterest cookies, a login, or a Pinterest API key. Private pins, removed pins, login-only pages, boards, profiles, search pages, comments, followers, and Pinterest ads are outside this Actor's scope.

### ✅ What this Actor does

- Accepts public Pinterest pin URLs.
- Accepts `pin.it` short links and resolves them to the matching pin.
- Accepts bare numeric Pinterest pin IDs.
- Returns video URLs when Pinterest exposes video media.
- Returns image URLs when Pinterest exposes image media.
- Lets you choose videos only, images only, or both.
- Saves one dataset row per successfully processed public pin.
- Adds normalized pin URLs and pin IDs so you can deduplicate or join results.
- Adds thumbnails, titles, descriptions, pinner data, board data, source links, saves when available, and scrape timestamps.
- Returns nested `mediaVariants` so you can choose a different image or video variant downstream.
- Can optionally save the best media file to Apify key-value storage.
- Skips invalid, private, removed, unavailable, or no-media pins without saving failure rows.

### 📦 Data you can export

Each output row represents one public Pinterest pin where downloadable media was found. Core fields include:

- `input` and `inputIndex`
- `resolvedUrl` and `normalizedPinUrl`
- `pinId`
- `mediaType` with `video` or `image`
- `title` and `description`
- `thumbnailUrl`
- `bestMediaUrl`
- `downloadUrl`, `fileSizeBytes`, and `storageKey` when Apify storage is enabled
- `video` with the selected video variant when available
- `images` with image variants
- `mediaVariants` with all discovered media variants
- `pinner`
- `board`
- `engagement.saves` when Pinterest exposes it
- `sourceDomain` and `sourceLink`
- `sourcePageFetchedAt` and `scrapedAt`

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule repeat runs, or connect it to webhooks and integrations.

### 🚀 How to run

1. Open the Actor input.
2. Add one or more Pinterest pin targets in **Pinterest pins**.
3. Keep the default **Pin limit** for a small test, or raise it for a larger batch.
4. Choose **Videos and images**, **Videos only**, or **Images only**.
5. Leave **Save media to Apify storage** off if direct Pinterest media URLs are enough.
6. Start the Actor and open the dataset.

Example targets:

```text
https://www.pinterest.com/pin/39617671718303098/
39617671718303098
````

You can also paste real `pin.it` short links copied from Pinterest.

### 🔧 Input options

#### 📌 Pinterest pins

Paste public Pinterest pin URLs, `pin.it` short links, or bare numeric pin IDs. Board URLs, profile URLs, search URLs, private pages, and login-only pages are skipped because this Actor is built for known pin targets.

#### 🔢 Pin limit

Controls how many unique pin targets the Actor processes in a run. The default is `5`, and the public maximum is `1000`.

#### 🎬 Media type

Use `Videos and images` for the broadest output. Use `Videos only` or `Images only` when your downstream workflow needs one media type.

#### 💾 Save media to Apify storage

When disabled, the Actor returns direct Pinterest media URLs. When enabled, the Actor downloads the best media file for each successful pin and saves it to the run's key-value store, then adds a `downloadUrl` to the dataset row.

### 🧾 Output example

```json
{
  "input": "https://www.pinterest.com/pin/39617671718303098/",
  "normalizedPinUrl": "https://www.pinterest.com/pin/39617671718303098/",
  "pinId": "39617671718303098",
  "mediaType": "video",
  "title": "😍😍",
  "thumbnailUrl": "https://i.pinimg.com/videos/thumbnails/originals/...",
  "bestMediaUrl": "https://v1.pinimg.com/videos/mc/720p/...",
  "video": {
    "type": "video",
    "url": "https://v1.pinimg.com/videos/mc/720p/...",
    "width": 1080,
    "height": 1920,
    "durationSeconds": 8.208,
    "quality": "720p",
    "format": "mp4"
  },
  "images": [],
  "mediaVariants": [
    {
      "type": "video",
      "url": "https://v1.pinimg.com/videos/mc/720p/...",
      "width": 1080,
      "height": 1920,
      "durationSeconds": 8.208,
      "quality": "720p",
      "format": "mp4"
    }
  ],
  "scrapedAt": "2026-05-29T14:49:09.700Z"
}
```

Field availability depends on what Pinterest exposes on the public pin page. Nullable fields stay `null` when the value is not available.

### 💳 Pricing

This Actor uses pay-per-event pricing:

- **Processed Pinterest pin**: charged for each successful public pin row saved to the dataset.
- **Stored Pinterest media**: charged per stored megabyte only when **Save media to Apify storage** is enabled.

There is no actor-start charge. Keep storage mode off for direct media URLs and the lowest-cost first run.

### ⚠️ Limits and caveats

- Public Pinterest pins only.
- No Pinterest login, cookies, or user credentials are accepted.
- No board, profile, search, follower, comment, ad, or keyword discovery scraping.
- No media row is saved for invalid, private, removed, unavailable, or no-media pins.
- Direct Pinterest media URLs may depend on Pinterest availability. Enable Apify storage when you want the Actor to save the best media file to your run storage.
- This Actor extracts media from Pinterest pin pages. It does not download from external websites linked by a pin.

### ❓ FAQ

#### 🔗 Can I use `pin.it` short links?

Yes. Paste the `pin.it` link into **Pinterest pins**. The Actor resolves it to the matching public Pinterest pin when possible.

#### 🎞️ Can I download both videos and images?

Yes. Leave **Media type** set to `Videos and images`. The row includes `bestMediaUrl`, plus nested `video`, `images`, and `mediaVariants` fields when Pinterest exposes those values.

#### 💾 Does this Actor save files or only return URLs?

By default, it returns direct Pinterest media URLs. Turn on **Save media to Apify storage** to save the best media file to the run's key-value store and add a storage `downloadUrl`.

#### 🧩 Why did my pin not appear in the dataset?

The Actor saves rows only for public pins where downloadable media is found. Invalid targets, private pins, removed pins, unavailable pages, and pins without matching media are skipped and reported in the run log.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~pinterest-video-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Collect Pinterest autocomplete suggestions for keyword and content planning.
- [Instagram Downloader API ↗](https://apify.com/maximedupre/instagram-downloader-api) - Export media URLs and metadata from public Instagram posts, reels, and TV links.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Save public TikTok video or audio files to Apify storage.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Export image URLs and metadata from Unsplash keyword search results.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete keyword suggestions from seed terms.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `pinterestTargets` (type: `array`):

Paste public Pinterest pin URLs, pin.it short links, or bare numeric pin IDs. Board, profile, search, private, removed, and login-only pages are skipped.

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

Maximum number of unique Pinterest pins to process in this run. Keep the default for a small test before adding a larger list.

## `mediaType` (type: `string`):

Choose whether to return videos, images, or both when a public pin exposes them.

## `rehostMediaToKvStore` (type: `boolean`):

Download the best media file and save it to the run's key-value store. Leave off when direct Pinterest media URLs are enough.

## Actor input object example

```json
{
  "pinterestTargets": [
    "https://www.pinterest.com/pin/39617671718303098/"
  ],
  "maxItems": 5,
  "mediaType": "both",
  "rehostMediaToKvStore": false
}
```

# Actor output Schema

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

Open the dataset with Pinterest pin media URLs and metadata.

# 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 = {
    "pinterestTargets": [
        "https://www.pinterest.com/pin/39617671718303098/"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/pinterest-video-downloader").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 '{
  "pinterestTargets": [
    "https://www.pinterest.com/pin/39617671718303098/"
  ]
}' |
apify call maximedupre/pinterest-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Video Downloader",
        "description": "Download media from public Pinterest pins. Paste pin URLs, pin.it links, or pin IDs to get video and image URLs, thumbnails, titles, descriptions, pinner data, board data, and optional Apify storage links.",
        "version": "0.1",
        "x-build-id": "MgVnlF0dAg3WgufUx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~pinterest-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-pinterest-video-downloader",
                "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/maximedupre~pinterest-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-pinterest-video-downloader",
                "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/maximedupre~pinterest-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-pinterest-video-downloader",
                "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",
                "required": [
                    "pinterestTargets"
                ],
                "properties": {
                    "pinterestTargets": {
                        "title": "Pinterest pins",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Paste public Pinterest pin URLs, pin.it short links, or bare numeric pin IDs. Board, profile, search, private, removed, and login-only pages are skipped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Pin limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique Pinterest pins to process in this run. Keep the default for a small test before adding a larger list.",
                        "default": 5
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "both",
                            "video",
                            "image"
                        ],
                        "type": "string",
                        "description": "Choose whether to return videos, images, or both when a public pin exposes them.",
                        "default": "both"
                    },
                    "rehostMediaToKvStore": {
                        "title": "Save media to Apify storage",
                        "type": "boolean",
                        "description": "Download the best media file and save it to the run's key-value store. Leave off when direct Pinterest media URLs are enough.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```