# Pinterest Search Scraper: Product Page Details Extractor (`scrapio/pinterest-search-scraper`) Actor

Pinterest Search Scraper extracts product page details from search results, including titles, prices, descriptions, images, product links, sellers, ratings, and availability. Ideal for product research, competitor analysis, trend discovery, price monitoring, and e-commerce intelligence.

- **URL**: https://apify.com/scrapio/pinterest-search-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (community)
- **Categories:** Automation, Lead generation, SEO tools
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## 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 Search Scraper — Extract Pins, Links and Product Data

Pinterest Search Scraper: Product Page Details Extractor turns a Pinterest keyword search into structured JSON: every pin's outbound destination link and domain, a per-run link summary (unique domains, counts, top destinations), and — for shopping pins — best-effort product data (price, currency, brand, availability) parsed from the pin's own structured data. Unlike scraping frameworks that return raw HTML, this scraper returns typed JSON — ready for your model, your database, or your pipeline without any parsing. This guide covers every input and output field plus three concrete deployment strategies for turning search-based pin data into a running pipeline.

### 🧭 What Does Pinterest Search Scraper: Product Page Details Extractor Do?

This Actor searches Pinterest for a keyword (e.g. "nike shoes") and streams back every pin found, including its outbound destination link, normalized domain, and — when the pin looks like a shopping pin — parsed price, currency, brand, and availability from the pin's closeup page. It runs logged-out; no Pinterest account, login, or cookies are required. At the end of a run it appends one aggregated link-summary row and mirrors the same data to a key-value store record.

- Keyword-based pin search with live, response-driven streaming (no wait for the whole run to finish before rows appear)
- Destination-link extraction — `link`/`domain` are already present in Pinterest's own search payload, at zero extra request cost
- Domain include/exclude filtering (`domainFilter`, `excludedDomains`) and a "linked pins only" mode (`includeOnlyLinkedPins`)
- Best-effort product data for shopping pins: price, currency, brand, availability, product name — parsed from `application/ld+json` `@type=Product`
- A derived `linkSummary` row: unique domain count, per-domain pin counts, top destinations, linked/product coverage fractions
- Video URL harvest for video pins (`videoUrls`)
- Automatic retry with a fresh browser session (up to 3 attempts) if a session gets blocked

### ⚡ Features & Capabilities

The Actor combines real-time pin search with two layers of enrichment — link intelligence and product-data extraction — that most keyword-search scrapers skip entirely.

#### Core features

- **Live keyword search** — searches `pinterest.com/search/pins/` for `searchTerm` and pushes pins to the dataset as Pinterest's own internal `/resource/BaseSearchResource/get/` responses arrive, not after a fixed scroll budget
- **Destination link + domain on every row** — `hasLink`, `destinationUrl`, `destinationDomain` are populated straight from the search payload for every pin, whether or not product data is requested
- **Domain filtering** — `domainFilter` (substring allow-list) and `excludedDomains` (substring block-list) apply before a row is counted against `maxPins`
- **Product data (best-effort)** — for pins that look like shopping pins (`is_shopping_ad`, `is_eligible_for_pdp`, `rich_metadata.products`, or simply carrying an outbound `link`), the Actor fetches the pin's closeup page in the same browser session and parses the `ld+json` `Product` block for `productName`, `productPrice`, `productCurrency`, `productBrand`, `productAvailability`
- **Link summary row** — one `rowType: "linkSummary"` row per run with `totalPins`, `linkedPinCount`, `linkedPinFraction`, `uniqueDomainCount`, `topDomains`, `domainCounts`, `productPinCount`, `productPinsWithPrice`, `productLookupsPerformed`; also written to the `LINK_SUMMARY` key-value store record
- **Video pin support** — `pinType: "videos"` filters to video pins only, and `videoUrls` harvests variant video URLs from `videos.video_list`
- **Backward-compatible input** — base-actor keys `query`, `filter`, and `limit` are still accepted as fallbacks for `searchTerm`, `pinType`, and `maxPins`
- **Manual stealth + Residential proxy support** — a stealth init script masks the most-fingerprinted automation tells (`navigator.webdriver`, plugins, languages), and the Actor retries with a fresh session up to 3 times before giving up

#### Pinterest Search Scraper: Product Page Details Extractor within the Scrapio data stack

This Actor covers pins discovered through a Pinterest **keyword search**, with destination-link and product-data enrichment. For pins pulled from a specific Pinterest **board or profile** (with board metadata and owner enrichment attached), use Pinterest Pins Videos Search Scraper With Board Collection instead — it fetches a board/profile's real pins rather than treating the URL as a search term.

### Why do developers and data teams scrape Pinterest?

Pinterest search results sit at the intersection of visual discovery and commerce — a large share of shopping-intent pins link straight to a retailer's product page. That makes the destination link, domain, and product fields this Actor extracts unusually direct signals for several distinct audiences.

#### 🏢 E-commerce, affiliate and dropshipping research

Affiliate marketers and product researchers run a category keyword (e.g. "leather sofa") through the Actor, then filter on `isProductPin` and `productPrice` to build a live shortlist of trending shopping pins with real price/brand data. `destinationDomain` shows exactly which retailers are winning that keyword's Pinterest traffic, and `domainFilter` lets a researcher restrict a run to competitor or partner domains (e.g. `["amazon.com", "etsy.com"]`) before it's even pulled. The output lands as one row per pin, ready to load into a spreadsheet or a product-tracking database without any HTML parsing.

#### 📊 AI training data and RAG indexing

`title`, `description`, and the product fields (`productName`, `productBrand`, `productPrice`) are the high-information text and structured-data fields for this dataset. For RAG, indexing `title` + `description` alongside `destinationDomain` lets an agent answer "what products are trending for X on Pinterest and where do they link" without re-scraping. For training data, the product fields return as consistent typed primitives (string, float, string) across every row where a lookup succeeded, which keeps a training set free of ad-hoc HTML cleanup.

#### 📱 Competitive and market intelligence

Run the same `searchTerm` on a schedule and track `domainCounts` from the `linkSummary` row over time — a rising count for a specific competitor domain signals they're gaining Pinterest visibility (organic or paid) for that keyword. Tracking `productPrice` across runs for pins tied to a known competitor domain also surfaces price changes without visiting the retailer's site directly.

#### 🔬 Research and academic use

Researchers studying visual-commerce behavior, platform-to-retailer traffic patterns, or e-commerce link ecosystems can use `destinationDomain` and `linkedPinFraction` as a public, reproducible dataset. This Actor only returns data already visible to a logged-out visitor — no private account data, no login-gated content.

#### 🎥 Product and SaaS development

Teams building price-monitoring tools, affiliate-link directories, or social-commerce dashboards can run this Actor as the ingestion layer: `destinationUrl` feeds a link-resolution service, `productPrice`/`productCurrency` feed a price-history table, and the `linkSummary` row feeds a per-keyword dashboard tile without any additional aggregation code.

### 🍚 Input Parameters

All parameters are read from `.actor/input_schema.json`. Only `searchTerm` is required.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchTerm` | Yes | string | Keyword to search on Pinterest. Shopping-style queries work best. | `"nike shoes"` |
| `pinType` | No | string (enum) | `"all"` or `"videos"`. Default `"all"`. | `"all"` |
| `maxPins` | No | integer | How many pins to extract (1–10,000). Default `100`. | `100` |
| `includeOnlyLinkedPins` | No | boolean | Keep only pins with an outbound link. Default `false`. | `false` |
| `domainFilter` | No | array of string | Keep only pins whose destination domain contains one of these (substring match). Default `[]`. | `["amazon.com", "etsy.com"]` |
| `excludedDomains` | No | array of string | Drop pins whose destination domain contains one of these. Default `[]`. | `["pinterest.com"]` |
| `includeLinkSummary` | No | boolean | Append the `linkSummary` row (and `LINK_SUMMARY` KV record). Default `true`. | `true` |
| `includeProductData` | No | boolean | Fetch and parse product price/brand/availability for likely product pins. Default `true`. | `true` |
| `maxProductLookups` | No | integer | Cap on closeup product-detail fetches per run (0 = unlimited). Default `30`. | `30` |
| `proxyConfiguration` | No | object | Apify proxy configuration. Residential strongly recommended. Default `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}`. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

**Example input:**

```json
{
  "searchTerm": "nike shoes",
  "pinType": "all",
  "maxPins": 100,
  "includeOnlyLinkedPins": false,
  "domainFilter": ["amazon.com", "etsy.com"],
  "excludedDomains": ["pinterest.com"],
  "includeLinkSummary": true,
  "includeProductData": true,
  "maxProductLookups": 30,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

#### Supported URL types and input formats

This Actor takes a **keyword**, not a Pinterest URL — `searchTerm` is used to build a `pinterest.com/search/pins/?q=...` request internally. There is no direct pin, board, or profile URL input on this variant (for board/profile URLs, see the related board-collection scraper below). For backward compatibility, the base actor's raw keys `query`, `filter`, and `limit` are also accepted and take priority over `searchTerm`/`pinType`/`maxPins` when present in the input JSON.

- **Broad category search, all domains:** `{"searchTerm": "leather sofa", "maxPins": 200}`
- **Video pins only, filtered to two marketplaces:** `{"searchTerm": "skincare routine", "pinType": "videos", "domainFilter": ["amazon.com", "sephora.com"]}`
- **Linked pins only, no product lookups (fast run):** `{"searchTerm": "home office desk", "includeOnlyLinkedPins": true, "includeProductData": false}`

### 📦 Output Format

Output is typed, normalized JSON pushed live to the dataset — one row per pin plus one aggregated summary row per run. Export directly from the Apify platform (JSON, CSV, Excel, or via the API) with no post-processing required.

#### Output for pins

```json
{
  "rowType": "pin",
  "query": "nike shoes",
  "node_id": "1234567890123456789",
  "type": "pin",
  "title": "Nike Air Max 90 - White/Black",
  "description": "Classic Nike Air Max 90 sneakers in white and black colorway.",
  "domain": "nike.com",
  "link": "https://www.nike.com/t/air-max-90-mens-shoes-6n3vDV",
  "dominant_color": "#f2f2f2",
  "created_at": "Tue, 04 Mar 2025 18:22:10 +0000",
  "board": { "id": "987654321", "name": "Sneakers", "url": "/username/sneakers/" },
  "reaction_counts": { "1": 42 },
  "native_creator": {},
  "pinner": { "id": "555000111", "username": "sneakerhead", "full_name": "Sneaker Head" },
  "image_url": "https://i.pinimg.com/originals/aa/bb/cc/aabbcc.jpg",
  "image_width": 1000,
  "image_height": 1500,
  "pinUrl": "https://www.pinterest.com/pin/1234567890123456789/",
  "destinationUrl": "https://www.nike.com/t/air-max-90-mens-shoes-6n3vDV",
  "destinationDomain": "nike.com",
  "hasLink": true,
  "videoUrls": null,
  "isProductPin": true,
  "productName": "Nike Air Max 90",
  "productPrice": 129.99,
  "productCurrency": "USD",
  "productBrand": "Nike",
  "productAvailability": "InStock",
  "scrapedAt": "2026-07-25T09:14:02Z"
}
```

#### Output for link summary

```json
{
  "rowType": "linkSummary",
  "query": "nike shoes",
  "totalPins": 100,
  "linkedPinCount": 72,
  "linkedPinFraction": 0.72,
  "uniqueDomainCount": 18,
  "topDomains": [
    { "domain": "nike.com", "count": 21 },
    { "domain": "amazon.com", "count": 9 },
    { "domain": "footlocker.com", "count": 6 }
  ],
  "domainCounts": { "nike.com": 21, "amazon.com": 9, "footlocker.com": 6 },
  "productPinCount": 14,
  "productPinsWithPrice": 11,
  "productLookupsPerformed": 30,
  "scrapedAt": "2026-07-25T09:14:44Z"
}
```

#### Schema stability and export options

Field names stay stable across runs — every pin row carries the full set of fields above regardless of whether a value was found; unmatched product fields return `null` rather than being omitted, so downstream code can rely on a consistent key set. If Pinterest changes its internal payload shape, new upstream fields are additive; existing keys documented here keep their meaning. Results can be exported from the Apify platform as JSON, CSV, Excel, or fetched programmatically via the Apify API/SDK — no delivery mechanism beyond the standard Apify dataset/key-value store is built into this Actor.

### 💡 Pinterest Search Scraper: Product Page Details Extractor Strategy Guide

#### 🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run per incoming keyword (e.g. a new product category added to your catalog), then read the dataset as rows stream in rather than waiting for run completion. For each row, append `destinationUrl`, `destinationDomain`, and — when `isProductPin` is `true` — `productPrice`/`productBrand`/`productAvailability` to your source record. Because rows are pushed live via `Actor.push_data`, a consumer polling the dataset gets partial results within seconds of the run starting, not only at the end.

#### 🎯 Strategy 2: Scheduled monitoring and alerting

Schedule the same `searchTerm` to run daily or weekly using an Apify Schedule. After each run, diff the new `linkSummary` row's `domainCounts` against the previous run's — a domain's count jumping or a new domain entering `topDomains` signals a shift in who is winning that keyword's Pinterest traffic. For product pins already seen before (matched on `destinationUrl`), diff `productPrice` between runs to alert on price changes.

#### 🎯 Strategy 3: Bulk dataset build

For a research or training dataset, iterate a list of keywords, calling the Actor once per keyword (each call is a separate, independent run), and aggregate every run's dataset into one CSV or a shared database table keyed on `node_id`. `maxProductLookups` bounds the extra product-page fetches per run, keeping cost and runtime predictable across a large keyword list; set it to `0` only if you need every product-like pin looked up.

#### Strategy comparison at a glance

| Strategy | Best for | Run pattern | Output format |
| --- | --- | --- | --- |
| Real-time enrichment | Enriching inbound records as they arrive | One run per record, read live | Streamed JSON rows |
| Scheduled monitoring | Tracking domain/price shifts over time | Recurring scheduled runs, diffed | JSON rows + `linkSummary` diff |
| Bulk dataset build | Research or training datasets | One run per keyword, aggregated | CSV / database table |

### 🌴 Related Pinterest Scrapers & Tools

| Scraper Name | What it extracts |
| --- | --- |
| Pinterest Pins Videos Search Scraper With Board Collection | Real pins from a Pinterest board or profile URL, with board metadata and optional owner enrichment |
| Amazon Search Products Scraper | Amazon search-result products (ASIN, price, rating, review count, image) by keyword |
| Amazon Bestsellers Scraper By Category | Amazon Best Sellers products plus the full category/browse-node tree |
| eBay Scraper: Sold Listings & Price Trend Analytics | eBay sold/completed listings with a derived price-trend summary (average, min/max, per-condition) |
| eBay Seller Scraper — Full Listings, Specifics & Shipping | Full per-seller inventory with item condition, shipping, specifics and description |

### How to integrate Pinterest Search Scraper: Product Page Details Extractor with your stack

Pinterest Search Scraper: Product Page Details Extractor works with any language or tool that can make an HTTP request to the Apify API. The examples below use the official Apify SDKs.

#### Python

```python
import csv
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

keywords = ["nike shoes", "leather sofa", "skincare"]

rows = []
for term in keywords:
    run_input = {
        "searchTerm": term,
        "maxPins": 100,
        "includeProductData": True,
        "maxProductLookups": 30,
        "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
    }
    run = client.actor("Scrapio/pinterest-search-scraper-product-page-details-extractor").call(run_input=run_input)
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        if item.get("rowType") == "pin":
            rows.append(item)
        elif item.get("rowType") == "linkSummary":
            print(f"{term} -> {item['uniqueDomainCount']} unique domains, {item['productPinCount']} product pins")

with open("pinterest_pins.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()) if rows else [])
    writer.writeheader()
    writer.writerows(rows)
```

#### Node.js

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

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });

const run = await client.actor('Scrapio/pinterest-search-scraper-product-page-details-extractor').call({
    searchTerm: 'nike shoes',
    maxPins: 100,
    includeProductData: true,
    domainFilter: ['amazon.com', 'etsy.com'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const pins = items.filter((row) => row.rowType === 'pin');
console.log(`Fetched ${pins.length} pins, ${pins.filter((p) => p.isProductPin).length} with product data`);
```

#### Async and scheduled pipelines

Runs are asynchronous by default — `call()` blocks until the run finishes, or use `client.actor(...).start()` to kick off a run and poll `client.run(runId).get()`/`waitForFinish()` from your own process. For recurring extraction, use an Apify Schedule against this Actor rather than a webhook — combine it with the dataset's `iterate_items()`/`listItems()` to pull only new rows since the last check.

### 🎯 Who Needs Pinterest Search Scraper: Product Page Details Extractor? (Use Cases & Industries)

#### 🏢 E-commerce, affiliate and dropshipping research

An affiliate site owner runs `searchTerm: "standing desk"` weekly, keeps only rows with `isProductPin: true`, and builds a comparison table from `productName`, `productPrice`, and `destinationUrl` — refreshed without manually re-checking each retailer's page.

#### 📊 AI/ML and RAG teams

A RAG pipeline ingests `title` + `description` + `destinationDomain` per pin so an assistant can answer "what's trending on Pinterest for skincare and which brands/sites show up" using only structured Pinterest data, with no HTML to strip first.

#### 📱 Marketing and competitive intelligence

A brand's marketing team tracks `domainCounts` for their own domain and named competitors across weekly runs of their category keywords, flagging when a competitor's share of pins for that keyword rises.

#### 🔬 Researchers

Academic and market researchers studying platform-to-retailer traffic patterns use `destinationDomain` and `linkedPinFraction` as a public, reproducible signal of which retailers dominate a given Pinterest search topic — scoped to data already visible to a logged-out visitor.

#### 🎥 Product and SaaS builders

Teams building a price-monitoring or social-commerce dashboard product use this Actor as their Pinterest ingestion layer, feeding `productPrice`/`productCurrency` into a price-history table and the `linkSummary` row into a per-keyword overview tile.

### Is it legal to scrape Pinterest?

Scraping publicly accessible web data is generally lawful in the United States — see *hiQ Labs v. LinkedIn* (9th Cir. 2019, reaffirmed 2022), which held that scraping data not gated behind a login does not violate the Computer Fraud and Abuse Act. This Actor runs logged-out and only reads pin data a visitor could see without signing in.

Separately, Pinterest's Terms of Service restrict automated access; violating a platform's ToS is a contract/civil matter between the user and the platform, not a criminal one, but it can still carry consequences such as IP blocking or account action. This Actor returns pin, link, and product-page data — not private user account data — so data-protection (GDPR/CCPA) obligations generally do not attach to its output; they can still apply if a `pinner` or `native_creator` object in the output is treated as personal data in your jurisdiction.

Pinterest Search Scraper: Product Page Details Extractor returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

### ❓ Frequently asked questions

#### Does Pinterest Search Scraper: Product Page Details Extractor work without a Pinterest account?

Yes. The Actor runs entirely logged-out — no Pinterest account, login, or cookies are required or used at any point in the run.

#### How does the Actor handle Pinterest's anti-scraping measures?

It launches a fresh headless Chromium session per attempt with a manual stealth init script (masking `navigator.webdriver`, plugin list, and languages), rotates user agents, and retries up to 3 times with exponential backoff if a session returns an HTTP error or gets redirected to a login wall. Apify Residential proxy is strongly recommended — Pinterest commonly blocks datacenter IPs outright.

#### Can I run it at scale without getting blocked?

Reliability depends heavily on using Residential proxy; without one, the Actor logs a warning and runs are far more likely to return zero pins. There is no published uptime or success-rate figure for this Actor — treat proxy configuration as the primary lever you control.

#### How fresh is the data this Actor returns?

Every run performs a live fetch against Pinterest's search endpoint at the time it runs; nothing is cached or served from a prior run. `scrapedAt` on every row is the actual timestamp of that fetch.

#### Which fields work best for AI training and RAG indexing?

For RAG, index `title` and `description` (the free-text fields) alongside `destinationDomain` for retrieval context. For training data, `productName`, `productBrand`, `productPrice`, and `productCurrency` are the most consistently typed fields across rows where a product lookup succeeded — all return as plain strings/numbers with `null` (never a placeholder) where no product data was found.

#### Does product data cover every pin?

No — it's best-effort and limited to pins that look like shopping pins. Non-product pins always return `null` for `productName`/`productPrice`/`productCurrency`/`productBrand`/`productAvailability`, and `isProductPin` is `null` for pins never looked up (because `includeProductData` was off, or `maxProductLookups` was already hit). The run log reports the real product-coverage fraction rather than assuming full coverage.

#### Does this Actor work with Claude, ChatGPT, and other AI agent tools?

It's callable as an HTTP endpoint via the Apify API by any agent framework that can make a REST call — there is no dedicated MCP server for this Actor. Every response is typed JSON, so an agent can consume dataset rows directly without an HTML-parsing step.

#### Am I charged for every row in the dataset?

Yes for this Actor — every pin row and the `linkSummary` row are pushed with `charged_event_name="row_result"`, so each row that reaches the dataset is one billed `row_result` event. There are no separate uncharged diagnostic rows; a pin that fails mid-processing is skipped and logged rather than pushed.

#### What happens if Pinterest returns no results or blocks the session?

The Actor retries up to 3 times with a fresh browser session and backoff. If every attempt still pushes zero pins, the run ends with an explanatory status message (session likely blocked, search had no results, or the response format changed) rather than silently succeeding with an empty dataset.

### ℹ️ Disclaimer

Pinterest Search Scraper: Product Page Details Extractor extracts only publicly available data from Pinterest. This tool is intended for lawful use cases only. Users are responsible for complying with Pinterest's terms of service and applicable data protection laws in their jurisdiction.

# Actor input Schema

## `searchTerm` (type: `string`):

What to search for on Pinterest. For link/product intelligence, shopping-style queries work best (e.g. "nike shoes", "leather sofa", "skincare"). Example: nike shoes.

## `pinType` (type: `string`):

Extract all pins, or restrict to video pins only. Default: all.

## `maxPins` (type: `integer`):

How many pins to extract (1–10,000). Example: 100.

## `includeOnlyLinkedPins` (type: `boolean`):

When on, only pins that link out to an external website are kept (skips pins with no destination). Default: off.

## `domainFilter` (type: `array`):

Keep only pins whose destination domain contains one of these values (substring match, case-insensitive). Empty = all domains. Example: \["amazon.com", "etsy.com"].

## `excludedDomains` (type: `array`):

Drop pins whose destination domain contains one of these values (substring match). Example: \["pinterest.com"].

## `includeLinkSummary` (type: `boolean`):

Append one summary row (rowType=linkSummary) with unique domains, per-domain counts, top destinations and product coverage. Also saved to the LINK\_SUMMARY key-value record. Default: on.

## `includeProductData` (type: `boolean`):

For likely product pins, fetch the closeup page and parse ld+json for price, currency, brand and availability. Best-effort: non-product pins stay null. Costs one extra request per product-pin lookup. Default: on.

## `maxProductLookups` (type: `integer`):

Cap on how many closeup product-detail fetches to perform per run (0 = unlimited). Keeps runtime/cost bounded. Example: 30.

## `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
{
  "searchTerm": "nike shoes",
  "pinType": "all",
  "maxPins": 100,
  "includeOnlyLinkedPins": false,
  "domainFilter": [
    "amazon.com",
    "etsy.com"
  ],
  "excludedDomains": [],
  "includeLinkSummary": true,
  "includeProductData": true,
  "maxProductLookups": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

## `linkSummary` (type: `string`):

Unique destination domains, per-domain counts, top destinations, and linked/product-pin coverage fractions for the run.

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

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

# Run the Actor and wait for it to finish
run = client.actor("scrapio/pinterest-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domainFilter": [
    "amazon.com",
    "etsy.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapio/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapio/pinterest-search-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/c43ZoG8eN2mMxJCKo/builds/cDdCc684UOakbyaeF/openapi.json