# Pinterest Search Scraper - Pins and Creators (`benthepythondev/pinterest-search-scraper`) Actor

Scrape Pinterest search results with pin titles, descriptions, images, destination URLs, boards, creators, follower counts, saves and ranks.

- **URL**: https://apify.com/benthepythondev/pinterest-search-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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 - Pins, Creators, Boards and Trends

Turn Pinterest searches into structured datasets without manually opening pins or copying details into a spreadsheet. Pinterest Search Scraper collects public pin results for one or more keywords and returns the pin title, description, image, destination link, creator, board, save count, search rank, and other useful research fields.

The Actor is designed for marketers, ecommerce teams, trend researchers, content strategists, agencies, and analysts who need repeatable Pinterest search data. Results can be downloaded as JSON, CSV, Excel, XML, or RSS, sent to a webhook, processed in Make or Zapier, or read through the Apify API.

### What can Pinterest Search Scraper do?

- Search Pinterest for multiple keywords in one run.
- Collect public pins beyond the first visible result batch using bounded pagination.
- Preserve the original rank for each query so you can compare search visibility.
- Return the best available pin image and its dimensions.
- Capture outbound destination URLs and source domains for content and commerce research.
- Include creator usernames, names, follower counts, and public profile URLs when available.
- Include board names and board URLs when Pinterest exposes them.
- Deduplicate pins within each query automatically.
- Export clean rows to the Apify default dataset.
- Run on a schedule to monitor changing search results over time.

### Typical use cases

#### Pinterest SEO and ranking monitoring

Run the same keyword list daily or weekly and compare `rank`, `id`, and `url`. This helps you see which pins remain visible, which creators enter the result set, and whether a campaign gains or loses search exposure.

#### Product and visual trend research

Search product categories, styles, seasonal phrases, materials, colors, or audience interests. Use the returned titles, descriptions, images, boards, and save counts to identify recurring themes before planning a campaign or product collection.

#### Creator and competitor discovery

The result includes public creator identity fields alongside each pin. Group results by `pinner_username`, compare follower counts, and find creators repeatedly ranking for a topic. This can support manual partnership research without pretending that every visible profile is a qualified lead.

#### Content ideation

Analyze titles, descriptions, destination domains, and board names to understand how a topic is framed on Pinterest. The data is useful for building editorial briefs, visual mood boards, keyword clusters, and landing-page inspiration.

#### Ecommerce destination analysis

Use `destination_url` and `domain` to identify sites receiving Pinterest traffic for a query. This can reveal marketplaces, publisher pages, brand stores, and product collections associated with a niche.

### Input

The Actor accepts a list of search phrases plus two safety limits.

```json
{
  "queries": [
    "minimalist home office",
    "sustainable packaging ideas"
  ],
  "maxResultsPerQuery": 50,
  "maxPagesPerQuery": 5
}
````

#### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array of strings | Pinterest keywords or phrases. The default is `web scraping`. |
| `maxResultsPerQuery` | integer | Maximum unique pins returned for each query. Default: 10. Maximum: 1,000. |
| `maxPagesPerQuery` | integer | Maximum Pinterest result pages requested per query. Default: 2. Maximum: 50. |

Start with a small result limit when testing a new keyword set. Increase it only when the first output confirms the query produces useful pins.

### Output

Each dataset item represents one public Pinterest pin found for one query.

```json
{
  "id": "123456789012345678",
  "url": "https://www.pinterest.com/pin/123456789012345678/",
  "title": "Minimal home office setup",
  "description": "A compact workspace with natural light and hidden storage.",
  "destination_url": "https://example.com/minimal-office",
  "domain": "example.com",
  "image_url": "https://i.pinimg.com/originals/example.jpg",
  "image_width": 1000,
  "image_height": 1500,
  "created_at": "2026-06-15T12:00:00",
  "repin_count": 842,
  "reaction_counts": {},
  "pinner_id": "99887766",
  "pinner_username": "designstudio",
  "pinner_name": "Design Studio",
  "pinner_followers": 24500,
  "pinner_profile_url": "https://www.pinterest.com/designstudio/",
  "board_id": "44556677",
  "board_name": "Home Office Ideas",
  "board_url": "https://www.pinterest.com/designstudio/home-office-ideas/",
  "search_query": "minimalist home office",
  "rank": 1,
  "scraped_at": "2026-07-11T09:30:00+00:00"
}
```

Pinterest does not expose every field for every pin. Organic pins, product pins, promoted content, older records, and different account types can contain different metadata. Missing upstream values are returned as `null` rather than invented.

### Pricing

This Actor uses pay per event pricing:

- Actor start: $0.00005 per run.
- Result: $0.003 for each pin saved to the default dataset.

A run returning 100 pins costs about $0.30005 in Actor charges, excluding your normal Apify platform usage. A 10-result test costs about $0.03005. You are charged for rows actually saved, not for the configured maximum when fewer results exist.

### Run with the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/benthepythondev~pinterest-search-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["email marketing ideas"],"maxResultsPerQuery":25,"maxPagesPerQuery":3}'
```

After the run finishes, read the default dataset through the API or use the dataset link shown in the run output. Apify client libraries are also available for Python and JavaScript.

### Automation ideas

- Schedule weekly searches and send new pin URLs to Google Sheets.
- Trigger an n8n workflow that groups pins by creator and destination domain.
- Send high-save pins to a manual content-review queue in Airtable.
- Compare two scheduled datasets to detect ranking changes.
- Feed titles and descriptions into your own classification or topic-modeling pipeline.

Do not rely on Pinterest ranking as a permanent metric. Search results can vary by time, region, experiment, and Pinterest product changes. Store the `scraped_at`, `search_query`, and `rank` fields whenever you compare runs.

### Reliability and technical approach

The Actor uses Pinterest's public web search flow with a Chrome-compatible HTTP client. It first loads the public search page to obtain the current application version, then requests the same structured web resource used by Pinterest's search interface. This avoids rendering a full browser and keeps runs fast and inexpensive. Requests are retried with bounded delays, results are deduplicated, and a run fails explicitly if Pinterest returns no pins instead of silently reporting success with an empty dataset.

No Pinterest login, cookies from your account, or third-party scraping API key is required. Pinterest can change its public web interface, so production users should monitor scheduled runs and report reproducible failures with the input and run ID.

### Responsible use

This Actor collects public Pinterest search data. Use it only for lawful purposes and follow Pinterest's terms, applicable privacy rules, intellectual-property rights, and your organization's compliance requirements. Do not use the output for harassment, sensitive profiling, spam, or automated outreach without a lawful basis. Images and text remain the property of their respective owners; receiving a URL in a dataset does not grant reuse rights.

### Frequently asked questions

#### Does it download image files?

It returns the best public image URL and dimensions. Apify stores the metadata row, not a copied image file. Your workflow can download permitted assets separately when you have the appropriate rights.

#### Can I search several keywords?

Yes. Add up to 50 non-empty queries. The result limit applies separately to each query.

#### Why do some pins have no destination URL or follower count?

Pinterest's public response varies by pin and creator type. The Actor keeps unavailable values empty rather than guessing.

#### Can I monitor results over time?

Yes. Create an Apify schedule and store each run's dataset. Compare pin IDs and ranks between dates.

#### Is this an official Pinterest API?

No. This independent Actor reads public data exposed by Pinterest's web interface and is not affiliated with or endorsed by Pinterest.

### You might also like

- [Pinterest Profile Scraper](https://apify.com/benthepythondev/pinterest-profile-scraper) for detailed creator profile metrics.
- [Instagram Intelligence Scraper](https://apify.com/benthepythondev/instagram-intelligence-scraper) for public Instagram research.
- [TikTok Profile Scraper](https://apify.com/benthepythondev/tiktok-profile-scraper) for creator profile data.
- [YouTube Search Results Scraper](https://apify.com/benthepythondev/youtube-search-results-scraper) for video discovery and rankings.

### Support and reviews

If a run fails, open an issue on the Actor page and include the run ID, a redacted example input, and the result you expected. Reproducible reports are prioritized. If the Actor saves you time, a short Apify Store review helps other users evaluate it and helps guide future improvements.

**Keywords:** Pinterest scraper, Pinterest search scraper, Pinterest pins API, Pinterest trend research, Pinterest SEO, Pinterest keyword scraper, Pinterest creator discovery, Pinterest board data, social media research, visual trend analysis.

# Actor input Schema

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

Keywords or phrases to search for on Pinterest.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of unique pins returned for each query.

## `maxPagesPerQuery` (type: `integer`):

Safety limit for Pinterest result pages requested per query.

## Actor input object example

```json
{
  "queries": [
    "web scraping",
    "marketing automation"
  ],
  "maxResultsPerQuery": 10,
  "maxPagesPerQuery": 2
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "web scraping",
        "marketing automation"
    ],
    "maxResultsPerQuery": 10,
    "maxPagesPerQuery": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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": [
        "web scraping",
        "marketing automation",
    ],
    "maxResultsPerQuery": 10,
    "maxPagesPerQuery": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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": [
    "web scraping",
    "marketing automation"
  ],
  "maxResultsPerQuery": 10,
  "maxPagesPerQuery": 2
}' |
apify call benthepythondev/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Search Scraper - Pins and Creators",
        "description": "Scrape Pinterest search results with pin titles, descriptions, images, destination URLs, boards, creators, follower counts, saves and ranks.",
        "version": "1.0",
        "x-build-id": "sQj9AUm4fx9wrfUTO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~pinterest-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~pinterest-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~pinterest-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords or phrases to search for on Pinterest.",
                        "default": [
                            "web scraping"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum pins per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique pins returned for each query.",
                        "default": 10
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety limit for Pinterest result pages requested per query.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
