# Pinterest Image Scraper (Cheap) (`data_api/pinterest-image-scraper-cheap`) Actor

Pinterest image downloader that extracts full-resolution photos from any pin or board URL, so designers and marketers can collect visual assets without clicking through Pinterest one image at a time.

- **URL**: https://apify.com/data\_api/pinterest-image-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 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/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Image Scraper

![Pinterest Image Scraper](cover.jpg)

Saving Pinterest images by hand is slow, and the file you get is usually a shrunken preview, not the real thing. This Pinterest scraper skips all of that. Hand it a pin or board link and it returns the full-resolution image link straight from Pinterest's CDN, along with the pixel size, file type, pin headline, caption, board title, and the handle of whoever pinned it. No browser extensions, no right-click-and-save, no Pinterest login. Run one link or a whole list of boards in a single batch.

### What you get

Every pin comes back as one tidy record with the same set of fields, so your columns line up when you drop the results into a sheet or database. The data splits into three groups:

- **Image** — `imageLink`, `previewLink`, `pixelWidth`, `pixelHeight`, `fileType`
- **Pin details** — `pinPageUrl`, `pinHeadline`, `pinCaption`, `pinnedAt`
- **Board and pinner** — `boardTitle`, `boardLink`, `pinnerHandle`

Each record also carries a `collectedAt` timestamp and an `errorMessage` field that stays empty when the link worked.

### Quick start

1. Click **Try for free** and open the input form.
2. Paste a Pinterest pin or board link into **Single Pinterest link**, or drop several into **List of Pinterest links**.
3. For board links, set **Image cap per board** to control how many images you pull. Pick a proxy type if you want.
4. Hit **Start**, then export your results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Mood boards** — gather a board's worth of inspiration into one dataset instead of saving pins one at a time
- **Design research** — archive reference images from specific boards for briefs and trend decks
- **Content pipelines** — feed full-resolution image links into your own storage, resizing, or tagging steps
- **Competitor and brand tracking** — collect what rivals and industry accounts are pinning
- **Board backups** — keep a copy of a board before it goes private or disappears

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `pinOrBoardUrl` | string | One of `pinOrBoardUrl` or `targetUrls` | A single Pinterest pin or board link. Pin pages and board pages both work. |
| `targetUrls` | array of strings | One of `pinOrBoardUrl` or `targetUrls` | Several pin or board links to run in one batch, one per line. |
| `boardImageLimit` | integer | No | Most images to pull from each board link; ignored for single pins. Default `60`, max `1000`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each HTTP request before giving up. Default `45`. |
| `proxyConfiguration` | object | No | Proxies that route your requests. Datacenter (Anywhere) by default; switch to Residential if Pinterest blocks you. |

#### Example input

```json
{
    "targetUrls": [
        "https://www.pinterest.com/pin/987654321012/",
        "https://www.pinterest.com/handle/board-slug/"
    ],
    "boardImageLimit": 60,
    "timeoutSeconds": 45,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
````

### Output

Results land in an Apify dataset. A single pin link produces one record; a board link produces one record per pin up to your `boardImageLimit`. Every record holds the same fields, so the output stays rectangular whether the pin had full metadata or not.

#### Example output

```json
{
    "pinPageUrl": "https://www.pinterest.com/pin/987654321012/",
    "imageLink": "https://i.pinimg.com/originals/ab/cd/ef/abcdef123456.jpg",
    "previewLink": "https://i.pinimg.com/736x/ab/cd/ef/abcdef123456.jpg",
    "pixelWidth": 1920,
    "pixelHeight": 1080,
    "fileType": "jpg",
    "pinHeadline": "Warm minimalist living room",
    "pinCaption": "Soft neutral tones and clean lines for a calm space.",
    "boardTitle": "Interior Ideas",
    "boardLink": "https://www.pinterest.com/handle/interior-ideas/",
    "pinnerHandle": "handle",
    "pinnedAt": "2024-09-18T10:23:45+00:00",
    "collectedAt": "2026-06-30T08:00:00+00:00",
    "errorMessage": ""
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `pinPageUrl` | string | Web address of the Pinterest pin page |
| `imageLink` | string | Direct link to the full-resolution image file |
| `previewLink` | string | Link to a smaller preview copy of the same image |
| `pixelWidth` | integer | Image width in pixels (0 when not reported) |
| `pixelHeight` | integer | Image height in pixels (0 when not reported) |
| `fileType` | string | File extension: jpg, png, gif, webp, or avif |
| `pinHeadline` | string | Headline shown on the pin |
| `pinCaption` | string | Caption or written description on the pin |
| `boardTitle` | string | Title of the board that holds the pin |
| `boardLink` | string | Web address of that board |
| `pinnerHandle` | string | Handle of the account that saved the pin |
| `pinnedAt` | string | When the pin was first saved on Pinterest (ISO 8601) |
| `collectedAt` | string | When this run captured the record (ISO 8601) |
| `errorMessage` | string | Reason a link failed; empty string on success |

### Tips for best results

- **Start with a few links.** Run a handful before a big batch so URL-format and proxy issues show up early.
- **Switch to Residential if you get blocked.** Datacenter proxies clear most runs; residential helps when you hit repeated 403s on boards.
- **Use board links for volume.** Single pin links return one image each; board links paginate up to your `boardImageLimit`.
- **Raise `timeoutSeconds` on residential proxies.** Slower proxy tiers sometimes need 60 or more seconds to respond.
- **Partial board pulls are normal.** If Pinterest limits the board feed mid-run, you still keep the images already collected from the page.

### How can I use Pinterest image data?

**How can I use the Pinterest Image Scraper to download a whole board?**
Paste a board link and set `boardImageLimit` to how many images you want. The scraper walks the board feed and returns one record per pin, each with the full-resolution `imageLink` you can pass straight to a download or storage step. A single run turns an entire board into a structured image dataset.

**How do I get full-resolution Pinterest images instead of thumbnails?**
The scraper reads the image data baked into each pin page and upgrades the CDN path to the original size, so `imageLink` points at the full-resolution file while `previewLink` keeps the smaller copy. You get both, plus the `pixelWidth` and `pixelHeight` so you know exactly what you are pulling before you download.

**How can I collect Pinterest pin metadata for design research?**
Feed a list of pin or board links into `targetUrls`. Each record pairs the image with its `pinHeadline`, `pinCaption`, `boardTitle`, and `pinnerHandle`, so you can sort and tag inspiration by board or creator instead of staring at a wall of pictures. Export to CSV or Excel and your research is ready to filter.

**How do I export Pinterest images into Google Sheets or a database?**
Run the scraper, then export the dataset as CSV, Excel, JSON, or XML, or pull it through the Apify API. Because every pin shares the same fields, the rows load cleanly into a sheet or table, with `imageLink` and `collectedAt` ready for whatever pipeline comes next.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `pinOrBoardUrl` (type: `string`):

One Pinterest pin or board link to pull images from. Works with a pin page such as https://www.pinterest.com/pin/987654321/ or a board page such as https://www.pinterest.com/handle/board-slug/.

## `targetUrls` (type: `array`):

Several pin or board links to run together in a single batch. Put one link on each line.

## `boardImageLimit` (type: `integer`):

Largest number of images to pull from each board link. Single pin links ignore this value. Defaults to 60 and tops out at 1000.

## `timeoutSeconds` (type: `integer`):

How long to wait on each HTTP call before giving up. Defaults to 45 seconds.

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

Choose the proxies that route your requests. Proxies cut down on IP blocks and rate limiting. Datacenter proxies run quickest; Residential proxies slip past detection more easily.

## Actor input object example

```json
{
  "pinOrBoardUrl": "https://www.pinterest.com/pin/987654321012/",
  "targetUrls": [
    "https://www.pinterest.com/pin/987654321012/",
    "https://www.pinterest.com/handle/board-slug/"
  ],
  "boardImageLimit": 60,
  "timeoutSeconds": 45,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "pinOrBoardUrl": "https://www.pinterest.com/pin/633387444268425/",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/pinterest-image-scraper-cheap").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 = {
    "pinOrBoardUrl": "https://www.pinterest.com/pin/633387444268425/",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/pinterest-image-scraper-cheap").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 '{
  "pinOrBoardUrl": "https://www.pinterest.com/pin/633387444268425/",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_api/pinterest-image-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Image Scraper (Cheap)",
        "description": "Pinterest image downloader that extracts full-resolution photos from any pin or board URL, so designers and marketers can collect visual assets without clicking through Pinterest one image at a time.",
        "version": "0.0",
        "x-build-id": "Yn6dShEh0mWotnzFY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~pinterest-image-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-pinterest-image-scraper-cheap",
                "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/data_api~pinterest-image-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-pinterest-image-scraper-cheap",
                "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/data_api~pinterest-image-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-pinterest-image-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "pinOrBoardUrl": {
                        "title": "Single Pinterest link",
                        "type": "string",
                        "description": "One Pinterest pin or board link to pull images from. Works with a pin page such as https://www.pinterest.com/pin/987654321/ or a board page such as https://www.pinterest.com/handle/board-slug/."
                    },
                    "targetUrls": {
                        "title": "List of Pinterest links",
                        "type": "array",
                        "description": "Several pin or board links to run together in a single batch. Put one link on each line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "boardImageLimit": {
                        "title": "Image cap per board",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Largest number of images to pull from each board link. Single pin links ignore this value. Defaults to 60 and tops out at 1000.",
                        "default": 60
                    },
                    "timeoutSeconds": {
                        "title": "Per-request wait (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each HTTP call before giving up. Defaults to 45 seconds.",
                        "default": 45
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Choose the proxies that route your requests. Proxies cut down on IP blocks and rate limiting. Datacenter proxies run quickest; Residential proxies slip past detection more easily."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
