# Pinterest Search Scraper (`headlessagent/pinterest-search-scraper`) Actor

Collect pins from any Pinterest search using Pinterest Search Scraper. Retrieve images, titles, links, descriptions, creator details, and engagement metrics. Perfect for trend analysis, idea discovery, content planning, and any workflow that requires structured Pinterest search data.

- **URL**: https://apify.com/headlessagent/pinterest-search-scraper.md
- **Developed by:** [Headless Agent](https://apify.com/headlessagent) (community)
- **Categories:** Social media, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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 Search Scraper

Scrape Pinterest search results — no API key or login required. Get clean, formatted JSON with pin details including images, links, reactions, tags, and pinner info.

### 🤔 What can Pinterest Search Scraper do?

This Actor lets you **search Pinterest and extract pin data** from the search results. Just provide one or more search queries and get structured results:

🔍 Search Pinterest by any keyword and get back detailed pin data

🖼️ Extract pin images in **original resolution**, titles, descriptions, and source links

👤 Get pinner profile info — username, full name, follower count, verification status

❤️ Collect reaction counts and total reactions for each pin

🏷️ Extract tags and visual annotations

📊 Control how many results you want with `maxResults` — scrape as many pins as you need

🔁 Rotate proxies to avoid rate limiting (optional)

📦 Download results in **JSON, CSV, XML, or Excel** from the Apify Dataset

🦾 Integrate via **API, webhooks, SDKs** (Python & Node.js), or connect with tools like Zapier, n8n, Make, and more

### ✅ What data can I scrape from Pinterest?

#### From each pin:

- 🆔 Pin ID and URL
- 📝 Title and description
- 🖼️ Original image URL and dimensions (width × height)
- 🔗 Source link and domain
- 👤 Pinner info (username, full name, profile image, followers, verification)
- ❤️ Reaction counts and total reactions
- 🏷️ Tags
- 📅 Created date
- 🎬 Video flag (is_video)

### 🔧 How to scrape data from Pinterest

1. [Create](https://console.apify.com/sign-up) a free Apify account.
2. Open Pinterest Search Scraper.
3. Add **search queries** (one or more).
4. Optionally set **max results per query** and **proxy URLs** to avoid rate limiting.
5. Click **Save & Start** and wait for the data to be extracted.
6. Download your data in JSON, CSV, XML, Excel, or access it via API.

### ⬇️ Input

| Field       | Type       | Description                                                                 |
|-------------|------------|-----------------------------------------------------------------------------|
| `queries`   | `string[]` | **Required.** List of Pinterest search queries to scrape.                   |
| `maxResults` | `integer`  | Maximum number of results per query (default: 20).                          |
| `proxy`     | `string[]` | Optional list of proxy URLs (`http://` or `socks5://` format). Rotated per query. |

#### Example input

```json
{
    "queries": ["minimalist home decor", "japanese interior design"],
    "maxResults": 50,
    "proxy": ["http://user:pass@host:port"]
}
````

### ⬆️ Output

Results are pushed to the Apify Dataset. Each item includes the `search_query` field so you know which query produced each result.

#### 📌 Pin data sample

```json
{
    "search_query": "minimalist home decor",
    "id": "1234567890123456789",
    "pin_url": "https://www.pinterest.com/pin/1234567890123456789",
    "title": "Minimalist Living Room Ideas",
    "description": "Beautiful minimalist living room with natural light",
    "link": "https://example.com/minimalist-decor",
    "domain": "example.com",
    "image_orig_url": "https://i.pinimg.com/originals/xx/xx/xxx.jpg",
    "image_orig_width": 736,
    "image_orig_height": 1104,
    "pinner": {
        "id": "987654321098",
        "username": "homedecorideas",
        "full_name": "Home Decor Ideas",
        "image_url": "https://i.pinimg.com/75x75_RS/xxx.jpg",
        "follower_count": 125000,
        "is_verified_merchant": false,
        "verified_identity": true,
        "profile_url": "https://www.pinterest.com/homedecorideas"
    },
    "reaction_counts": {
        "like": 42,
        "save": 15
    },
    "total_reactions": 57,
    "tags": ["home decor", "minimalist", "living room"],
    "created_at": "2024-01-15T10:30:00Z",
    "is_video": false
}
```

### 🔗 Integrations

You can connect Pinterest Search Scraper with almost any cloud service or web app through [Apify integrations](https://apify.com/integrations). Connect with **Zapier, n8n, Make, Slack, Google Sheets, Google Drive, Airbyte, GitHub**, and many more.

You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever a run finishes — for example, getting a notification or automatically processing the scraped data.

### 🦾 Using the Apify API

The Apify [API](https://docs.apify.com/api/v2) gives you programmatic access to Pinterest Search Scraper. You can start runs, fetch datasets, monitor execution, and integrate the scraper into your own workflows.

- **Python**: Use the [`apify-client`](https://pypi.org/project/apify-client/) PyPI package
- **Node.js**: Use the [`apify-client`](https://www.npmjs.com/package/apify-client) NPM package

### ❓ FAQ

#### Can I search multiple queries in one run?

Yes. The `queries` field accepts an array. Each query is processed sequentially and results are tagged with the `search_query` field.

#### How many results can I get per query?

The default is 20 pins per query. You can increase this with the `maxResults` field (e.g. 50, 100, 250). Note that Pinterest may limit the number of available results for certain queries.

#### Can I use multiple proxies?

Yes. The `proxy` field accepts an array of proxy URLs. Proxies are rotated round-robin across queries to help avoid rate limiting.

#### Does this require a Pinterest account or API key?

No. The scraper uses Pinterest's public search API — no login or API key needed.

#### Is it legal to scrape Pinterest?

This scraper only extracts publicly available data. It does not access any data behind authentication. However, scraped results could contain personal data protected by [GDPR](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation) and other regulations. Ensure you have a legitimate reason for scraping and consult legal counsel if unsure. See also Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `queries` (type: `array`):

List of Pinterest search queries to scrape.

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

Maximum number of pin results to scrape per query (default: 20).

## `proxy` (type: `array`):

Optional list of proxy URLs (e.g. http://user:pass@host:port). If provided, proxies will be rotated per request.

## Actor input object example

```json
{
  "queries": [
    "minimalist home decor"
  ],
  "maxResults": 20,
  "proxy": []
}
```

# 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 = {
    "queries": [
        "minimalist home decor"
    ],
    "maxResults": 20,
    "proxy": []
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "queries": ["minimalist home decor"],
    "maxResults": 20,
    "proxy": [],
}

# Run the Actor and wait for it to finish
run = client.actor("headlessagent/pinterest-search-scraper").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 '{
  "queries": [
    "minimalist home decor"
  ],
  "maxResults": 20,
  "proxy": []
}' |
apify call headlessagent/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Search Scraper",
        "description": "Collect pins from any Pinterest search using Pinterest Search Scraper. Retrieve images, titles, links, descriptions, creator details, and engagement metrics. Perfect for trend analysis, idea discovery, content planning, and any workflow that requires structured Pinterest search data.",
        "version": "1.0",
        "x-build-id": "xRhvXueNoUp9gNqpi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/headlessagent~pinterest-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-headlessagent-pinterest-search-scraper",
                "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/headlessagent~pinterest-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-headlessagent-pinterest-search-scraper",
                "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/headlessagent~pinterest-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-headlessagent-pinterest-search-scraper",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of Pinterest search queries to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results per Query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pin results to scrape per query (default: 20)."
                    },
                    "proxy": {
                        "title": "Proxy URLs",
                        "type": "array",
                        "description": "Optional list of proxy URLs (e.g. http://user:pass@host:port). If provided, proxies will be rotated per request.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```