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

Pinterest Search Scraper gathers pins from any Pinterest search query. Extract images, titles, links, descriptions, creators, and engagement stats. Ideal for trend research, inspiration mining, content planning, and workflows needing structured Pinterest search data.

- **URL**: https://apify.com/api-empire/pinterest-search-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 45 total users, 3 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Extract Pins, Boards and Creators as JSON

Pinterest Scraper extracts pins, boards, and creator data from Pinterest's public search results for any keyword. It runs a logged-out browser session behind a residential proxy, captures Pinterest's internal search feed, and returns one structured row per pin — image or video URLs, title, description, outbound link, and the full board and pinner objects Pinterest attaches to it. Every response is typed, normalized JSON: no HTML, no CSS selectors, no manual parsing. Enter a search term and start pulling clean, structured Pinterest data into your own pipeline.

### What is Pinterest Scraper?

Pinterest Scraper is an Apify Actor that searches Pinterest by keyword and returns structured data for every matching pin, including the board it lives on and the creator (pinner) behind it. It runs logged out — no Pinterest account, password, or API key is required — and routes traffic through Apify's Residential proxy to avoid Pinterest's datacenter-IP blocks. Results stream to the Apify dataset live as they're found, so you can start consuming rows before the run finishes.

- Scrape pins for any search keyword, filtered to all pins or videos only
- Scrape the board object attached to each pin (name, URL, pin count, owner)
- Scrape creator and native-creator data attached to each pin (username, full name, follower count)
- Capture original-resolution image URLs plus playable MP4/HLS video URLs for video pins
- Export as JSON, CSV, or Excel — no proxy setup, no HTML parsing

### What data does Pinterest Scraper collect?

Every run returns pins, and each pin row carries nested board and creator objects, so a single search gives you three layers of Pinterest data in one dataset.

| Data Type | Key Fields | JSON Field Names |
| --- | --- | --- |
| Pins | title, description, destination link, dominant color, image/video URLs | `title`, `description`, `link`, `domain`, `dominant_color`, `image_url`, `video_urls` |
| Boards | board name, board URL, pin count, board owner | `board` (nested object) |
| Creators | pinner username, full name, follower count, native creator | `pinner`, `native_creator` |

#### Need more Pinterest data?

If you need engagement signals beyond pins, boards, and creators — visible comments, likes, helpful votes, and an engagement score per pin — the **Pinterest Pins Videos Search Scraper: Search By Hashtag** Actor in this catalog searches by keyword, profile URL, or board URL and layers per-pin comment scraping on top of the same kind of pin data, with optional AI sentiment scoring per comment.

### How does Pinterest Scraper differ from the official Pinterest API?

Pinterest's own developer API is built for managing your own Pinterest Business account and ads — not for bulk public search — and most endpoints beyond basic account access require app review before you get production credentials. Pinterest Scraper skips that entirely: you provide a search query and it returns public search results immediately.

| Feature | Pinterest API for Developers | Pinterest Scraper |
| --- | --- | --- |
| Access setup | Requires a Pinterest Business account and app review before production use | No account or API key — provide a search query and run |
| Data scope | Primarily your own business account's pins, boards, ads, and analytics | Public search results for any keyword, logged out |
| Entity coverage | Split across separate endpoints per resource | Pins, boards, and creator data returned together in one row |
| Approval process | Manual review process before full access | Starts immediately on the Apify platform |
| Output consistency | JSON shaped per endpoint's own schema | One consistent JSON row per pin across every run |

The official API is the right choice when you're managing your own Pinterest Business presence or ad campaigns. Pinterest Scraper is the right choice when you need public search data at scale without going through app review.

### Why do developers and teams scrape Pinterest?

Pinterest's audience is visual-search-first, which makes its public data useful to a specific set of teams — not a generic "everyone scrapes everything" list.

#### For marketers and brand teams

Marketers use Pinterest Scraper to see what's actually ranking for a keyword right now — which pin titles, descriptions, and `dominant_color` palettes Pinterest is surfacing for a given search term. A brand team researching "laundry room ideas" before a content push can pull the top pins, read their `title` and `description` fields for phrasing patterns, and check the `board` each one lives on to see which creators are already active in that niche — informing both content angle and outreach targets before a single asset is produced.

#### For e-commerce and affiliate teams

Every pin carries a `link` and `domain` field pointing to wherever the pin drives traffic. Affiliate and e-commerce teams run a keyword sweep, group results by `domain`, and see which sites are consistently getting traffic from a given Pinterest search term — a direct signal for which products or content categories are performing in that niche before committing ad or content spend to the same keyword.

#### For researchers and analysts

Academic and market researchers use the scraper to study visual and content trends on a public-data-only basis — no login, no private accounts, no restricted content. A researcher tracking home-decor trend cycles can pull `image_url` and `video_urls` alongside `created_at` timestamps across repeated runs of the same query to build a public, timestamped snapshot of what Pinterest was surfacing for that term at each point in time.

#### For AI engineers and agent builders

Because output is typed JSON with stable field names (`title`, `description`, `pinner`, `board`), an agent can pull Pinterest search results as a tool call and index them into a vector store or RAG pipeline without a parsing step. A content-recommendation agent, for example, can call the Actor with a user's interest keyword, filter the returned rows by `dominant_color` or `video_urls` presence, and pass the matching pins straight into its response — no HTML scraping logic inside the agent loop.

### How to scrape Pinterest (step by step)

1. Open the Pinterest Search Scraper Actor on Apify and start a new run (from the console or via the API).
2. Enter your search `query` — the only required input (e.g. `"laundry room ideas"`).
3. Choose `filter` — all pins or videos only — and set `limit` for how many pins you want (1–10,000).
4. Keep the Apify Residential proxy enabled in `proxyConfiguration` and start the run.
5. Export the dataset as JSON, CSV, or Excel once pins stop streaming in, or pull it live via the API while the run is still going.

#### What to do when Pinterest changes its structure

The scraper reads pins from Pinterest's internal search API responses, not from page markup, so it keeps working even when Pinterest's on-page selectors shift — the source already falls back to network-driven extraction if a UI selector isn't found. The Actor is maintained and the output schema stays stable, so downstream integrations don't need to change when Pinterest's front end does.

### ⬇️ Input

Pinterest Scraper takes four inputs. Only `query` is required.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `query` | Yes | string | Search term to look up on Pinterest, e.g. wallpaper, recipes, DIY ideas (default: `"wallpaper"`) | `"laundry room ideas"` |
| `filter` | No | string | Show all pins or only video pins — `"all"` or `"videos"` (default: `"videos"`) | `"videos"` |
| `limit` | No | integer | How many pins you want, 1–10,000 (default: `10`) | `100` |
| `proxyConfiguration` | No | object | Proxy settings. Residential is strongly recommended — Pinterest blocks datacenter IPs and the run returns zero pins without a residential session (default: Apify Residential) | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

**Example input (JSON):**

```json
{
  "query": "laundry room ideas",
  "filter": "videos",
  "limit": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

The most common input mistake is turning off or downgrading `proxyConfiguration` from Residential — Pinterest blocks datacenter IPs, and the run will complete with zero pins pushed rather than an error.

### ⬆️ Output

Each pin becomes one typed JSON row in the Apify dataset the moment it's found — rows stream in live rather than waiting for the run to finish. Export the dataset as JSON, CSV, or Excel from the Apify console or API. Every pushed row is billed under a single `row_result` charged event; the Actor does not push separate uncharged accounting rows.

#### Scraped Pins

```json
{
  "query": "laundry room ideas",
  "node_id": "140806234212431",
  "type": "pin",
  "title": "Small laundry room makeover",
  "description": "Space-saving laundry ideas for tiny rooms",
  "domain": "thespruce.com",
  "link": "https://www.thespruce.com/small-laundry-room-ideas",
  "dominant_color": "#a09990",
  "created_at": "Tue, 15 Jul 2025 12:51:39 +0000",
  "board": { "name": "Dream house", "url": "/ellysebull/dream-house/", "pin_count": 142, "owner": { "username": "ellysebull" } },
  "reaction_counts": { "1": 460 },
  "native_creator": {},
  "pinner": { "username": "ellysebull", "full_name": "Ellyse Bull", "follower_count": 101 },
  "image_url": "https://i.pinimg.com/originals/57/5d/e1/575de1eed160baf017bc6bd84ae6e1e8.jpg",
  "image_width": 1024,
  "image_height": 1820,
  "video_urls": ["https://v.pinimg.com/videos/mc/hls/57/5d/e1/575de1.m3u8"]
}
```

`reaction_counts` is Pinterest's raw reaction map keyed by an internal reaction-type ID (e.g. `"1": 460`) — it is kept exactly as Pinterest returns it, not relabeled as a "likes" count. `video_urls` is a de-duplicated list of playable MP4/HLS variant URLs and is an empty list for image-only pins.

#### Board data (nested in every pin)

The `board` field on each pin carries Pinterest's own board object as-is — the scraper passes it through unmodified rather than reshaping it:

```json
{
  "name": "Dream house",
  "url": "/ellysebull/dream-house/",
  "pin_count": 142,
  "owner": { "username": "ellysebull" }
}
```

#### Creator data (nested in every pin)

The `pinner` field carries the account that pinned the item; `native_creator` carries Pinterest's separate native-creator attribution, which is commonly an empty object on ordinary repins:

```json
{
  "username": "ellysebull",
  "full_name": "Ellyse Bull",
  "follower_count": 101
}
```

### How many results can you scrape with Pinterest Scraper?

You can request up to 10,000 pins per run — `limit` is capped at 10,000 in the Actor itself, with a default of 10 when not set. Pagination is handled automatically: the Actor scrolls Pinterest's search feed (up to 200 scroll attempts, stopping early after 15 consecutive scrolls with no new pins) and then continues through Pinterest's bookmark-based pagination until either your `limit` is reached or Pinterest stops returning a bookmark. Actual results returned depend on how many public pins Pinterest has for that query — a narrow or unusual search term may return fewer pins than your requested `limit`. If a session gets blocked, the Actor retries up to three times with a fresh browser session and proxy before giving up.

### Integrate Pinterest Scraper and automate your workflow

Pinterest Scraper works with any language or tool that can send an HTTP request.

#### REST API integration

```python
import requests

ACTOR_ID = "YOUR_USERNAME~pinterest-search-scraper"
TOKEN = "YOUR_APIFY_TOKEN"

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"query": "laundry room ideas", "filter": "videos", "limit": 100},
)
pins = resp.json()
for pin in pins:
    print(pin["title"], pin["link"])
```

Works in Python, Node.js, Go, Ruby, cURL.

#### Automation platforms (n8n, Make)

In **n8n**, use the official Apify node's "Run Actor" operation, point it at this Actor by ID, pass `query`/`filter`/`limit` as JSON input, and feed the returned dataset items into downstream nodes. In **Make**, the Apify app's "Run an Actor and Get Dataset Items" module takes the same input JSON and returns each pin as a bundle you can route into a scenario — no code required in either platform.

### Is it legal to scrape Pinterest?

Scraping publicly available Pinterest search results is generally legal; Pinterest Scraper only returns pins, boards, and creator data that are visible on Pinterest's public, logged-out search pages — nothing behind a login. The `pinner` and `native_creator` fields do carry personal data (username, full name, follower count) tied to identifiable creators, so GDPR/CCPA considerations apply to how you store and use that data, particularly for EU or California residents. Consult legal counsel for commercial use cases involving bulk personal data.

### Frequently asked questions

#### Does Pinterest Scraper work without a Pinterest account?

Yes. The Actor runs fully logged out — no Pinterest account, password, or API key is needed. You only need an Apify account to start the run.

#### How often is the scraped data updated?

Every run fetches Pinterest's live search feed at the moment it runs — nothing is served from a cache. Run it again to get the current state of search results for that query.

#### What happens if a search returns no pins?

If Pinterest returns no results, blocks the session, or the response format doesn't match what the Actor expects, the run finishes with zero dataset rows and a status message explaining that no pins were extracted. The Actor already retries the search up to three times with a new browser session and proxy before reaching that state, so a persistent empty result usually means the query itself has little to no public inventory on Pinterest.

#### Can I scrape private or restricted Pinterest content?

No. Pinterest Scraper only returns pins that appear in Pinterest's public, logged-out search results. It does not access private boards, private profiles, or anything requiring a login.

#### Does Pinterest Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as an HTTP endpoint by any agent framework, and every response is typed JSON — `title`, `description`, `board`, `pinner`, `video_urls`, and the rest of the pin schema — with no parsing step needed before passing results into an LLM context or agent tool.

#### How does Pinterest Scraper handle Pinterest's anti-bot system?

It runs a real Chromium browser through Playwright with a rotating set of desktop user agents, a stealth init script that hides common automation tells (`navigator.webdriver`, plugin list, `window.chrome`), and Apify Residential proxy to avoid datacenter-IP blocks. If a session is blocked or redirected to a login wall, the Actor retries with a fresh browser session and proxy rather than continuing on a burned session.

#### Does Pinterest Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with stable field names — no HTML, no selectors, no parsing step. Pass it directly into an LLM context window, index it into a vector store, or route it through an agent tool.

#### Can I use Pinterest Scraper without managing proxies?

Yes. Apify Residential proxy is configured by default in `proxyConfiguration` — you don't manage IP pools, rotation, or sessions yourself; you just keep the built-in proxy setting enabled.

#### What happens when Pinterest changes its structure or blocks the scraper?

The Actor is maintained, and its output schema stays stable — field names and types don't change on your end when Pinterest updates its front end, since the Actor reads from Pinterest's internal search API rather than fragile page markup.

### Your feedback

Found a bug, or need a field this Actor doesn't currently return? Reach out through the Actor's Apify Store page (Issues tab) or your Apify Console support channel — reports get read and feed directly into how this Actor is maintained.

# Actor input Schema

## `query` (type: `string`):

What to search for on Pinterest (e.g. wallpaper, recipes, DIY ideas)

## `filter` (type: `string`):

Show all pins or only video pins

## `limit` (type: `integer`):

How many pins you want (1–10,000)

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

Apify Residential proxy is strongly recommended — Pinterest blocks datacenter IPs and the run will return zero pins without a residential session.

## Actor input object example

```json
{
  "query": "wallpaper",
  "filter": "videos",
  "limit": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("api-empire/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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call api-empire/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/LNSOK0VSYSioaNL73/builds/d6T99ZQddyhxqD8R9/openapi.json