# Pinterest Search Scraper — Pins, Boards & Users (`khadinakbar/pinterest-search-scraper`) Actor

Search Pinterest by keyword and get pins, boards, and users as unified, structured JSON. No login. MCP-ready. PAY\_PER\_EVENT at $0.004 per result.

- **URL**: https://apify.com/khadinakbar/pinterest-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 result scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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, Boards & Users

Search Pinterest by **keyword** and get **pins, boards, and users** back in a single run — as clean, unified JSON. No login, no cookies. Built for marketers, SEO and trend researchers, and AI agents that need one reliable Pinterest search tool.

Most Pinterest scrapers only return pins. This one searches the three things people actually look for on Pinterest — **pins** (the images/videos), **boards** (the collections), and **users** (the creators) — and tags every record with `result_type` so you can split them instantly.

### What it does

- **Keyword search** — pass any term ("minimalist kitchen", "fall outfits", "sourdough recipes"). Each query is searched independently.
- **Three result types** — choose `pins`, `boards`, `users`, or any combination.
- **Unified, typed output** — one dataset, every row tagged `result_type: pin | board | user`.
- **No login required** — public search data only.
- **MCP-ready** — designed to be called by Claude, ChatGPT, and other AI agents.
- **Pay per result** — `$0.004` per result. No subscription, no monthly rental.

### When to use this vs. the Pinterest (URL) Scraper

| You have… | Use |
|---|---|
| A **keyword / topic** to search | **This actor** (pinterest-search-scraper) |
| A specific **board / pin / profile URL** | [pinterest-scraper](https://apify.com/khadinakbar/pinterest-scraper) |

This actor is keyword-first. If you already have exact Pinterest URLs, the [pinterest-scraper](https://apify.com/khadinakbar/pinterest-scraper) actor extracts them directly.

### Output

Every record shares: `result_type`, `query`, `position`, `url`, `scraped_at`, `source_url`.

| result_type | Key fields added |
|---|---|
| `pin` | `title`, `description`, `image_url`, `is_video`, `video_url`, `save_count`, `hashtags`, `board_name`, `board_url`, `creator_username`, `creator_follower_count` |
| `board` | `name`, `description`, `pin_count`, `follower_count`, `owner_username`, `cover_image_url`, `category` |
| `user` | `username`, `full_name`, `bio`, `follower_count`, `following_count`, `pin_count`, `board_count`, `is_verified`, `image_url` |

#### Sample pin record

```json
{
  "result_type": "pin",
  "query": "home office setup",
  "position": 1,
  "url": "https://www.pinterest.com/pin/1234567890/",
  "title": "Cozy minimalist home office",
  "description": "Warm wood desk, plants, soft lighting",
  "image_url": "https://i.pinimg.com/originals/ab/cd/ef.jpg",
  "is_video": false,
  "save_count": 1820,
  "hashtags": ["homeoffice", "workspace"],
  "board_name": "Office Inspo",
  "creator_username": "deskgoals",
  "creator_follower_count": 50421,
  "scraped_at": "2026-06-14T10:00:00.000Z"
}
````

#### Sample board record

```json
{
  "result_type": "board",
  "query": "home office setup",
  "position": 1,
  "url": "https://www.pinterest.com/deskgoals/office-inspo/",
  "name": "Office Inspo",
  "pin_count": 312,
  "follower_count": 9800,
  "owner_username": "deskgoals",
  "cover_image_url": "https://i.pinimg.com/736x/aa/bb/cc.jpg"
}
```

#### Sample user record

```json
{
  "result_type": "user",
  "query": "home office setup",
  "position": 1,
  "url": "https://www.pinterest.com/deskgoals/",
  "username": "deskgoals",
  "full_name": "Desk Goals",
  "follower_count": 50421,
  "pin_count": 1204,
  "board_count": 38,
  "is_verified": false
}
```

### Pricing

**Pay per event** — there is no subscription.

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Result scraped (pin, board, or user) | **$0.004** |

Cost is predictable: `queries × result types × max results`. Example — 1 query, `pins`+`boards`+`users`, 25 each = up to 75 results = **~$0.30**. The run prints its cost cap before charging anything.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array (required) | One or more keywords/topics. |
| `resultTypes` | array | Any of `pins`, `boards`, `users`. Default: `pins`. |
| `maxResults` | integer | Max results per query **per type** (1–5000). Default 50. |
| `proxy` | object | Apify Residential proxy by default (recommended). |

#### Example input

```json
{
  "searchQueries": ["home office setup", "minimalist kitchen"],
  "resultTypes": ["pins", "boards", "users"],
  "maxResults": 25,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Use it from code

#### Apify API (JavaScript)

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('khadinakbar/pinterest-search-scraper').call({
  searchQueries: ['fall outfits'],
  resultTypes: ['pins', 'users'],
  maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => i.result_type === 'user'));
```

#### Apify API (Python)

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")

run = client.actor("khadinakbar/pinterest-search-scraper").call(run_input={
    "searchQueries": ["sourdough recipes"],
    "resultTypes": ["pins", "boards"],
    "maxResults": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print([i for i in items if i["result_type"] == "board"])
```

### Use it from an AI agent (MCP)

This actor is exposed through the Apify MCP server as `apify--pinterest-search-scraper`. An agent can call it with a keyword and get typed results back — ideal for "find trending pins, boards, and creators for X" tasks. Connect via `https://mcp.apify.com`.

### How it works

The actor opens Pinterest's public search for each query and result type, captures Pinterest's own internal search responses, and returns them as clean records. It runs through Apify **Residential** proxies with session rotation for reliable, login-free access, and scrolls to paginate up to your `maxResults`.

### FAQ

**Do I need a Pinterest account or cookies?** No. Search is public.

**Can I get boards and users, not just pins?** Yes — that's the point. Set `resultTypes` to include `boards` and/or `users`.

**Why Residential proxy?** Pinterest blocks datacenter IPs. Residential is the default and strongly recommended.

**Does each result type cost extra?** You pay `$0.004` per result returned, regardless of type. Selecting more types returns more results, so plan `maxResults` accordingly.

**I have specific Pinterest URLs, not keywords.** Use [pinterest-scraper](https://apify.com/khadinakbar/pinterest-scraper) instead — it handles board, pin, and profile URLs.

**Some queries return fewer `users` or `boards` than `pins`.** Pinterest simply surfaces fewer of those for some terms; the actor returns whatever the search yields.

### Legal & compliance

This actor scrapes only **publicly available** Pinterest search data and requires no login. Use it in compliance with Pinterest's Terms of Service and all applicable laws (including the GDPR and CCPA). Do not use scraped personal data (e.g. usernames, profiles) for unlawful purposes. You are responsible for how you use the data. This actor is not affiliated with or endorsed by Pinterest.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords, topics, niches, or hashtags to search on Pinterest (e.g. 'minimalist kitchen', 'fall outfits', 'sourdough'). Enter one or more; each term is searched separately and returns up to Max Results per selected result type. Use plain keywords, not URLs. To scrape a specific board, pin, or profile URL instead, use the pinterest-scraper actor.

## `resultTypes` (type: `array`):

Which kinds of Pinterest search results to return: 'pins' (images/videos with creator + board metadata), 'boards' (collections with pin/follower counts), 'users' (creator profiles with follower counts). Select any combination. Each selected type multiplies results and cost. Defaults to pins only if omitted.

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

Maximum results to return for each search query, per result type. Example: 2 queries × pins+boards × 25 = up to 100 results. Lower values run faster and cost less; use 10–50 for research, 500+ for bulk datasets. Range 1–5000. This is a per-bucket cap, not a total cap.

## `proxy` (type: `object`):

Proxy used to reach Pinterest. Apify Residential proxy is the default and is strongly recommended — Pinterest blocks datacenter IPs. Set a country if you need geo-specific search results.

## Actor input object example

```json
{
  "searchQueries": [
    "home office setup"
  ],
  "resultTypes": [
    "pins",
    "boards",
    "users"
  ],
  "maxResults": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped Pinterest search results as structured JSON records, each tagged with result\_type (pin | board | user).

# 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 = {
    "searchQueries": [
        "home office setup"
    ],
    "resultTypes": [
        "pins",
        "boards",
        "users"
    ],
    "maxResults": 10,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": ["home office setup"],
    "resultTypes": [
        "pins",
        "boards",
        "users",
    ],
    "maxResults": 10,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "home office setup"
  ],
  "resultTypes": [
    "pins",
    "boards",
    "users"
  ],
  "maxResults": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Search Scraper — Pins, Boards & Users",
        "description": "Search Pinterest by keyword and get pins, boards, and users as unified, structured JSON. No login. MCP-ready. PAY_PER_EVENT at $0.004 per result.",
        "version": "1.0",
        "x-build-id": "7G2Ua1l243omOht3Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~pinterest-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~pinterest-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~pinterest-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "🔍 Search Queries",
                        "type": "array",
                        "description": "Keywords, topics, niches, or hashtags to search on Pinterest (e.g. 'minimalist kitchen', 'fall outfits', 'sourdough'). Enter one or more; each term is searched separately and returns up to Max Results per selected result type. Use plain keywords, not URLs. To scrape a specific board, pin, or profile URL instead, use the pinterest-scraper actor.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultTypes": {
                        "title": "📂 Result Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which kinds of Pinterest search results to return: 'pins' (images/videos with creator + board metadata), 'boards' (collections with pin/follower counts), 'users' (creator profiles with follower counts). Select any combination. Each selected type multiplies results and cost. Defaults to pins only if omitted.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "pins",
                                "boards",
                                "users"
                            ],
                            "enumTitles": [
                                "Pins",
                                "Boards",
                                "Users / Profiles"
                            ]
                        },
                        "default": [
                            "pins"
                        ]
                    },
                    "maxResults": {
                        "title": "📊 Max Results per Query / Type",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum results to return for each search query, per result type. Example: 2 queries × pins+boards × 25 = up to 100 results. Lower values run faster and cost less; use 10–50 for research, 500+ for bulk datasets. Range 1–5000. This is a per-bucket cap, not a total cap.",
                        "default": 50
                    },
                    "proxy": {
                        "title": "🌐 Proxy Configuration",
                        "type": "object",
                        "description": "Proxy used to reach Pinterest. Apify Residential proxy is the default and is strongly recommended — Pinterest blocks datacenter IPs. Set a country if you need geo-specific search results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```