# Pinterest Pins Scraper (`scrapers-hub/pinterest-pins-scraper`) Actor

Pinterest Pins Scraper collects pins and boards by query or URL with owner, pin count, cover and thumbnail images, plus optional sentiment scoring and content categorisation. 📌 For trend research and creative competitor analysis.

- **URL**: https://apify.com/scrapers-hub/pinterest-pins-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 Pins Scraper – Pins, Boards, Videos & Creator Profile Data

The **Pinterest Pins Scraper** extracts pins, video pins, boards, and creator profiles from Pinterest search results at scale, returning media URLs, board references, owner details, and optional sentiment and content-category enrichment for every record. Feed it Pinterest search URLs or plain keywords, choose the result type you want, and it collects structured records you can use for visual trend research, competitor monitoring, affiliate discovery, or building an image dataset.

Pinterest is a visual discovery engine rather than a conventional social network, which makes it uniquely useful as a demand signal. People search Pinterest with intent — planning a kitchen renovation, sourcing a wedding palette, choosing autumn outfits — often months before they buy. Pins surfaced for a keyword are therefore a forward-looking read on consumer taste rather than a record of what already happened.

This Pinterest scraper handles four distinct result types from the same input: all pins, video pins, boards, and profiles. Proxy rotation is handled automatically inside the Actor, no headless browser is required, and an optional cookie header lets you improve reliability and result depth when you need deeper pagination.

***

### 📊 What Data Can You Extract with This Pinterest Scraper?

Records vary by the `type` you request. The fields below cover the full schema across pins, boards, and profiles.

| Category | Fields | What it gives you |
| --- | --- | --- |
| 🆔 Record identity | `id`, `type`, `entity_type`, `name`, `title`, `url` | Unique identifier, record type, entity classification, display name, title, and canonical Pinterest URL |
| 🖼️ Media & imagery | `media`, `coverURL`, `thumbnailURL`, `slashURL` | Media object plus cover, thumbnail, and short-link image URLs for downloading or embedding |
| 👤 Creator & ownership | `owner`, `creator`, `profile` | Owner object, creator reference, and the full profile record when scraping profiles |
| 📋 Board context | `board`, `board_ref`, `pinCount` | The board a pin belongs to, an enriched board reference, and how many pins a board holds |
| 🔍 Provenance | `query`, `source_url`, `seed_type`, `seed_value` | The search query, source page, and the seed that generated the record — essential for attribution |
| 😊 Sentiment enrichment | `sentiment_score`, `sentiment_score_normalized`, `sentiment_confidence`, `sentiment_label` | Heuristic sentiment analysis of the pin description with a raw score, normalised score, confidence, and label |
| 🏷️ Content classification | `content_category_label`, `content_category_path`, `content_category_confidence`, `content_category_match_type` | Category label, hierarchical category path, confidence value, and how the match was made |
| 📦 Extended data | `pin`, `schema`, `extra` | Raw pin payload, schema information, and additional attributes carried through from the source |

The field that changes what you can do with the data is `content_category_path`. Because it is a hierarchical path rather than a single flat label, you can aggregate at whichever level of granularity your analysis needs — roll everything up to a top-level category for a market overview, or drill down to a leaf node to compare narrow niches. Combined with `content_category_confidence`, it lets you exclude weak classifications before charting anything.

***

### 🌟 Key Features of the Pinterest Pins Scraper

| Feature | Description |
| --- | --- |
| 🔀 Four result types | A single `type` selector switches between all pins, video pins, boards, and creator profiles |
| 🔑 Keywords or URLs | Supply plain keyword strings in `queries`, Pinterest search URLs in `startUrls`, or both in one run |
| 📋 Board enrichment | `enrich_boards` fetches full board detail — owner, preview images, cover images — so `board_ref.extra` is complete |
| 🏷️ Content analysis | `content_analysis` attaches hashtags, extracted links, word count, and a has-price flag to each pin |
| 😊 Sentiment scoring | `sentiment_analysis` adds a heuristic sentiment score, normalised value, confidence, and label per pin description |
| 🍪 Optional cookie support | Supply a Pinterest cookie header from a logged-in session to improve reliability and result depth |
| 📈 Per-search result cap | `limit` sets the maximum records saved per keyword, so you can validate cheaply then scale up |
| 🛡️ Automatic proxy rotation | Proxy handling is built into the Actor — there is no proxy field to configure |
| ⚡ Browser-free extraction | Runs over direct HTTP requests without a headless browser, keeping runs light |

***

### 🚀 Why Choose This Pinterest Scraper?

**Four data shapes from one Actor.** Pins, videos, boards, and profiles are usually four separate tools. Switching `type` here means one integration, one output dataset, and one set of credentials to manage regardless of which Pinterest entity you are researching.

**Enrichment is opt-in and priced by you.** `enrich_boards`, `content_analysis`, and `sentiment_analysis` each add data at the cost of extra work per record. Because they are separate toggles, you decide per run whether you want a fast, cheap sweep or a fully enriched dataset.

**Provenance is preserved on every record.** `query`, `source_url`, `seed_type`, and `seed_value` mean you always know which keyword or URL produced a given pin. That matters enormously when you run twenty keywords in one job and need to attribute results back to the right search.

**Content categorisation with a confidence signal.** Returning `content_category_confidence` and `content_category_match_type` alongside the label lets you filter out uncertain classifications rather than treating every category assignment as equally trustworthy.

***

### 📥 Input

```json
{
  "startUrls": [
    { "url": "https://www.pinterest.com/search/pins/?q=home%20decor" }
  ],
  "queries": ["home decor"],
  "type": "all-pins",
  "limit": 50000,
  "enrich_boards": true,
  "content_analysis": false,
  "sentinent_analysis": false
}
```

#### 🔧 Pinterest Scraper Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | prefilled with a home decor search | Pinterest search URLs, e.g. `https://www.pinterest.com/search/pins/?q=home%20decor`. Only URLs containing a `?q=` query are usable |
| `queries` | array | No | prefilled with `home decor` | Plain keyword strings; each is expanded into a Pinterest search |
| `type` | string | No | `all-pins` | What kind of results to collect. Options: `all-pins`, `videos`, `boards`, `profiles` |
| `limit` | integer | No | `50000` | Maximum number of records to save for each keyword search |
| `enrich_boards` | boolean | No | `true` | Fetch full board details (owner, preview images, cover images) so `board_ref.extra` is complete. Adds one cached request per unique board |
| `content_analysis` | boolean | No | `false` | Attach a lightweight `content_analysis` object (hashtags, extracted links, word count, has\_price) to each pin |
| `sentinent_analysis` | boolean | No | `false` | Attach a lightweight heuristic sentiment score for the pin description |
| `cookies` | string | No | — | Optional Pinterest cookie header from a logged-in browser session. Improves reliability and result depth |

Note that the sentiment toggle is spelled `sentinent_analysis` in the input schema — the key name is kept exactly as provided in the original input, so use that spelling when calling the Actor via API.

#### 💡 Input Examples

**Quick validation run on a single keyword**

```json
{
  "queries": ["scandinavian kitchen"],
  "type": "all-pins",
  "limit": 100,
  "enrich_boards": false
}
```

**Video pin research with full enrichment**

```json
{
  "queries": ["diy woodworking", "workshop organisation"],
  "type": "videos",
  "limit": 500,
  "content_analysis": true,
  "sentinent_analysis": true
}
```

**Board and profile discovery from search URLs**

```json
{
  "startUrls": [
    { "url": "https://www.pinterest.com/search/pins/?q=capsule%20wardrobe" }
  ],
  "type": "boards",
  "limit": 200,
  "enrich_boards": true
}
```

***

### 📤 Output

```json
{
  "query": "home decor",
  "id": "1130899671234567890",
  "type": "pin",
  "entity_type": "pin",
  "title": "Minimalist living room styling ideas",
  "url": "https://www.pinterest.com/pin/1130899671234567890/",
  "coverURL": "https://i.pinimg.com/originals/ab/cd/ef/example-cover.jpg",
  "thumbnailURL": "https://i.pinimg.com/236x/ab/cd/ef/example-thumb.jpg",
  "creator": "studio.northlight",
  "board_ref": { "id": "1130899600000000000", "name": "Living Room Ideas" },
  "media": { "type": "image" },
  "source_url": "https://www.pinterest.com/search/pins/?q=home%20decor",
  "seed_type": "query",
  "seed_value": "home decor",
  "sentiment_label": "positive",
  "content_category_label": "Home Decor",
  "content_category_path": ["Home", "Interior Design", "Home Decor"],
  "content_category_confidence": 0.86
}
```

#### 🧾 Pinterest Pin & Media Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | null | Search query that produced this item |
| `id` | string | integer | Unique identifier of the item |
| `name` | string | null | Name of the item |
| `title` | string | null | Title of the item |
| `url` | string | null | Canonical URL of the scraped item |
| `type` | string | null | Type of the item |
| `entity_type` | string | null | Entity type of the item |
| `coverURL` | string | null | URL of the item's cover image |
| `thumbnailURL` | string | null | URL of the thumbnail image |
| `slashURL` | string | null | URL of the item's slash link |
| `media` | object | null | Media object for the item |
| `pin` | — | Pin payload for the item |
| `creator` | string | null | Creator of the item |
| `owner` | object | null | Owner of the item |
| `source_url` | string | null | URL the item was scraped from |
| `seed_type` | string | null | Seed type that generated the item |
| `seed_value` | — | Seed value that generated the item |
| `schema` | object | null | Schema information for the item |
| `extra` | — | Additional attributes for the item |

#### 🧾 Board, Profile & Enrichment Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `board` | object | null | Board record, returned when scraping boards |
| `board_ref` | — | Board reference attached to a pin |
| `pinCount` | integer | null | Number of pins on the board |
| `profile` | object | null | Profile record, returned when scraping profiles |
| `sentiment_score` | number | null | Raw sentiment score for the description |
| `sentiment_score_normalized` | number | null | Normalised sentiment score |
| `sentiment_confidence` | number | null | Confidence in the sentiment result |
| `sentiment_label` | string | null | Sentiment label for the description |
| `content_category_label` | string | null | Content category label assigned to the item |
| `content_category_path` | array | null | Hierarchical content category path |
| `content_category_confidence` | number | null | Confidence in the content category assignment |
| `content_category_match_type` | string | null | How the content category was matched |

Sentiment fields populate only when `sentinent_analysis` is enabled, and board enrichment fields are fullest when `enrich_boards` is left on.

***

### 💻 How to Use the Pinterest Pins Scraper (Step by Step)

#### Step 1: Choose your seeds — keywords or search URLs

You can drive the Pinterest scraper with plain keywords in `queries`, with Pinterest search URLs in `startUrls`, or with both together. Keywords are simpler and each one is expanded into a search automatically. Search URLs give you precise control when you have already refined a search in the browser and want to reproduce it exactly. Only URLs containing a `?q=` query parameter are usable, so copy the URL from an actual Pinterest search results page rather than a board or profile page.

#### Step 2: Select the result type you need

The `type` field determines the shape of every record in the run. `all-pins` returns visual posts, `videos` restricts to video pins, `boards` returns pin collections, and `profiles` returns creator pages. Because the four types produce different fields, run them as separate jobs when you need more than one — that keeps each dataset consistent and much easier to analyse.

#### Step 3: Set a sensible result limit

`limit` caps the number of records saved per keyword search and defaults to 50000, which is effectively unlimited for most searches. Start far lower — 100 to 500 — while you confirm the keywords return the kind of pins you expected. Once the seeds are validated, raise the limit for the full collection run. A cheap validation pass before a large job is the single most effective habit in Pinterest scraping.

#### Step 4: Decide which enrichments to enable

`enrich_boards` is on by default and fetches full board details so `board_ref.extra` is populated; it adds one cached request per unique board, so disable it for faster, cheaper runs when board context does not matter. `content_analysis` attaches hashtags, extracted links, word count, and a has-price flag. `sentinent_analysis` adds heuristic sentiment scoring of the pin description. Enable only what your analysis actually consumes.

#### Step 5: Optionally supply Pinterest cookies

The `cookies` field accepts a cookie header copied from a logged-in browser session. This is optional, but it improves reliability and result depth, particularly on deep paginated runs where anonymous access returns thinner results. Treat the cookie value as a credential: it grants session-level access, so store it securely and rotate it if it stops working.

#### Step 6: Run the Pinterest scraper and inspect the dataset

Press **Start** and watch the log as each seed is expanded and results are collected. When the run finishes, open the Dataset tab and check three things: that `query` and `seed_value` correctly attribute records to their source, that `thumbnailURL` and `coverURL` are populated for visual records, and that any enrichment fields you enabled actually contain values.

#### Step 7: Export, deduplicate, and schedule recurring runs

Export as JSON, CSV, Excel, XML, or HTML, or read the dataset through the API. Deduplicate on `id`, which is unique per Pinterest entity, when combining runs across keywords or dates. Pinterest search results shift as new content is pinned, so scheduling the Pinterest pins scraper weekly turns a one-time snapshot into a visual trend series showing which aesthetics, products, and creators are gaining traction.

***

### 🔌 API Access & Integrations

Run the Pinterest scraper synchronously and get dataset items back directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~pinterest-pins-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["home decor", "scandinavian kitchen"],
    "type": "all-pins",
    "limit": 200,
    "enrich_boards": false
  }'
```

Group pins by content category with the Python client:

```python
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/pinterest-pins-scraper").call(run_input={
    "queries": ["capsule wardrobe", "autumn outfits"],
    "type": "all-pins",
    "limit": 300,
    "content_analysis": True,
    "sentinent_analysis": True,
})

categories = Counter()
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    confidence = item.get("content_category_confidence") or 0
    if confidence >= 0.7 and item.get("content_category_label"):
        categories[(item.get("query"), item["content_category_label"])] += 1

for (query, label), count in categories.most_common(20):
    print(f"{query} -> {label}: {count} pins")
```

The Actor also connects to Zapier, Make, Google Sheets, and Slack, and supports webhooks that fire on run completion so fresh Pinterest data can flow into your reporting stack automatically.

***

### 💡 Best Use Cases for Pinterest Pins Data

#### 🎨 Visual trend forecasting

Pinterest search behaviour leads purchasing by months, which makes pin volume and category distribution a genuine leading indicator. Run the same `queries` on a schedule and track how `content_category_label` and `content_category_path` shift over time to see which aesthetics are rising before they reach mainstream retail.

#### 🛍️ E-commerce product and niche research

Enable `content_analysis` and use the has-price signal and extracted links it attaches to identify which pins are commercially oriented rather than purely inspirational. Cross-reference `content_category_path` with `query` to find niches where shopping intent is high but competition is thin.

#### 👥 Creator and influencer discovery

Set `type` to `profiles` or read the `creator` and `owner` fields on pin records to build a list of the accounts consistently surfacing for your keywords. Combined with `pinCount` on boards, this identifies prolific curators in your category who are worth approaching for partnerships.

#### 📋 Board curation and content strategy analysis

Scraping with `type` set to `boards` and `enrich_boards` enabled returns board names, owners, and preview imagery alongside `pinCount`. Studying how successful boards in your niche are titled and organised is one of the fastest ways to work out how your own boards should be structured.

#### 🎥 Video pin performance research

Restricting `type` to `videos` isolates Pinterest's video content, where the `media` object and `thumbnailURL` give you the assets and the `title` gives you the framing. Analysing which video pins dominate a keyword shows what hook and thumbnail style earn attention in that category.

#### 🖼️ Image dataset and mood board assembly

`coverURL` and `thumbnailURL` supply direct image links for every pin, making it straightforward to assemble a curated visual reference set for a design brief, a mood board, or a training corpus — with `query` and `source_url` preserved so every image retains its provenance.

#### 😊 Audience sentiment and messaging research

With `sentinent_analysis` enabled, `sentiment_label` and `sentiment_confidence` characterise the emotional tone of pin descriptions in a category. Comparing sentiment distributions across competing keywords reveals which framings resonate positively and which language your own captions should avoid.

***

### ⚙️ Tips for Better Pinterest Scraping Results

- **Validate with a small `limit` first.** Run 100 records per keyword to confirm your seeds return the right content, then scale up. The default of 50000 is a ceiling, not a target.
- **Run one `type` per job.** Pins, videos, boards, and profiles have different field shapes; mixing them in a single dataset makes downstream analysis needlessly awkward.
- **Disable `enrich_boards` when board context is irrelevant.** It costs one additional cached request per unique board, which is meaningful on large runs and pointless if you never read `board_ref.extra`.
- **Use specific multi-word keywords.** Broad seeds like "decor" return a diffuse mix; "scandinavian kitchen shelving" returns a coherent set you can actually analyse.
- **Filter on `content_category_confidence` before aggregating.** Treating low-confidence classifications as equal to high-confidence ones will quietly distort any category chart you build.
- **Supply cookies for deep paginated runs.** Anonymous access is fine for shallow collection; a logged-in cookie header improves reliability and result depth when you are pulling thousands of records per keyword.

***

### 🛠️ Troubleshooting

**My `startUrls` produced no results.**
Only Pinterest URLs containing a `?q=` query parameter are usable by this scraper. Board URLs, profile URLs, and individual pin URLs will not work as seeds. Copy the URL from an actual Pinterest search results page, or use the `queries` field with plain keywords instead.

**Sentiment fields are all null.**
Sentiment analysis is opt-in and disabled by default. Enable it by setting `sentinent_analysis` to `true` — note the spelling, which is preserved exactly as it appears in the input schema.

**`board_ref` is present but sparse.**
Full board detail is fetched only when `enrich_boards` is enabled. With it disabled, `board_ref` carries the basic reference without the enriched `extra` payload containing owner and preview imagery.

**I am getting fewer results than my `limit` allows.**
`limit` is a ceiling per keyword search, not a guarantee. Narrow or unusual keywords simply do not have that many matching pins. Broaden the keyword, add more seeds to `queries`, or supply a cookie header to improve result depth on deep pagination.

**Results thin out on very large runs.**
Anonymous deep pagination returns progressively less. Supplying a valid Pinterest cookie header in the `cookies` field improves reliability and depth. If a cookie stops working, refresh it from a current logged-in browser session.

***

### ❓ Frequently Asked Questions About Pinterest Scraping

**What can the Pinterest Pins Scraper extract?**
Pins, video pins, boards, and creator profiles from Pinterest search results, including media URLs, board references, owner and creator details, provenance fields, and optional sentiment and content-category enrichment.

**Do I need Pinterest login credentials?**
No. The `cookies` field is optional. Supplying a cookie header from a logged-in browser session improves reliability and result depth, but the Pinterest scraper works without it.

**How do I scrape only video pins?**
Set `type` to `videos`. That restricts the run to Pinterest's video content rather than all visual posts.

**Can I use keywords instead of URLs?**
Yes. Put plain keyword strings in `queries` and each one is expanded into a Pinterest search automatically. You can also combine keywords with `startUrls` in the same run.

**What kind of Pinterest URLs work as seeds?**
Only search URLs containing a `?q=` query parameter, such as `https://www.pinterest.com/search/pins/?q=home%20decor`.

**What does `enrich_boards` actually add?**
It fetches full board details — owner, preview images, cover images — so that `board_ref.extra` is complete. It costs one cached request per unique board encountered.

**Why is the sentiment input field spelled `sentinent_analysis`?**
The key name is kept exactly as provided in the original input schema. Use that spelling when calling the Actor through the API, or the toggle will be ignored.

**How many pins can I collect per keyword?**
`limit` controls the maximum records saved per keyword search and defaults to 50000. The practical ceiling also depends on how many results Pinterest surfaces for that keyword.

**Does the Pinterest scraper need proxy configuration?**
No. Proxy rotation is handled automatically inside the Actor and there is no proxy field in the input schema.

**Does it use a headless browser?**
No. It works over direct HTTP requests, which keeps runs faster and lighter than browser-based Pinterest scraping.

**How do I attribute results back to the keyword that produced them?**
Use `query`, `seed_type`, and `seed_value`, which are carried on every record, plus `source_url` for the exact page the item came from. This matters when you run many keywords in one job.

**Can I download the images the scraper finds?**
The records include `coverURL` and `thumbnailURL` as direct image links. Downloading and reusing those images is subject to the rights of whoever created them, so check licensing before republishing.

**How do I deduplicate results across scheduled runs?**
Deduplicate on `id`, which is unique per Pinterest entity. Keep `query` alongside it if the same pin can legitimately appear under several keywords.

**What export formats does the Pinterest scraper support?**
Apify datasets export to JSON, CSV, Excel, XML, and HTML, and are also readable through the dataset API. Zapier, Make, Google Sheets, Slack, and webhook integrations are all supported.

**Can I get a customised version of this Pinterest scraper?**
Yes. Email `scraperhubapi@gmail.com` to discuss additional fields, different result types, or integration with your own analytics pipeline.

***

### 🆘 Support & Feedback

If the Pinterest scraper returns unexpected results, misses records, or a run fails, report it on the **Issues** tab of the Actor page. Including your input configuration and the run ID makes reproduction much faster.

For custom work — larger Pinterest data pipelines, additional enrichment, or a tailored version of this Pinterest pins scraper built around your own schema — email `scraperhubapi@gmail.com`.

If this Actor is useful for your visual research, please leave a review on the Apify Store. Ratings and written feedback directly influence which features get built next.

***

### ⚖️ Disclaimer

The Pinterest Pins Scraper collects publicly visible content from Pinterest search results. It does not bypass authentication or access private boards, secret boards, or any content that is not publicly available. Where a cookie header is supplied, it is used only to access content that the corresponding session can already see.

You are responsible for how you use the data this Pinterest scraper produces. Comply with Pinterest's terms of service, crawl at reasonable rates, and respect the platform's technical limits. Pins, boards, and profiles frequently relate to identifiable individuals — creators, owners, and the people shown in images — so where you process such records, data protection law including the GDPR applies to you as the data controller, and you must establish a lawful basis, honour data subject rights, and apply appropriate retention limits.

Images and media returned by this Actor remain the property of their creators. Collecting a URL is not a licence to republish the asset; obtain permission before reusing any creative work commercially. Data is provided as-is and reflects the state of Pinterest search results at the time of the run.

If you believe data returned by this Actor should be removed or corrected, email `scraperhubapi@gmail.com` with the details and the request will be reviewed.

# Actor input Schema

## `startUrls` (type: `array`):

Pinterest search URLs, e.g. https://www.pinterest.com/search/pins/?q=home%20decor. Only URLs containing a ?q= query are usable.

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

Plain keyword strings; each is expanded into a Pinterest search.

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

What kind of results to collect for the keywords / URLs above.

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

Maximum number of records to save for each keyword search. Use a smaller number for fast validation, and increase it for a larger dataset.

## `enrich_boards` (type: `boolean`):

Fetch full board details (owner, preview images, cover\_images) so board\_ref.extra is complete. Adds one cached request per unique board. Disable for faster/cheaper runs.

## `content_analysis` (type: `boolean`):

Attach a lightweight content\_analysis object (hashtags, extracted links, word count, has\_price) to each pin.

## `sentinent_analysis` (type: `boolean`):

Attach a lightweight heuristic sentiment score for the pin description. (Key name kept as provided in the original input.)

## `cookies` (type: `string`):

Optional Pinterest cookie header from a logged-in browser session. Improves reliability and result depth. Proxy is handled automatically in code — no proxy field needed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
    }
  ],
  "queries": [
    "home decor"
  ],
  "type": "all-pins",
  "limit": 50000,
  "enrich_boards": true,
  "content_analysis": false,
  "sentinent_analysis": false
}
```

# Actor output Schema

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

Records scraped by Pinterest Pins Scraper, stored in the run's default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
        }
    ],
    "queries": [
        "home decor"
    ],
    "limit": 50000
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/pinterest-pins-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 = {
    "startUrls": [{ "url": "https://www.pinterest.com/search/pins/?q=home%20decor" }],
    "queries": ["home decor"],
    "limit": 50000,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/pinterest-pins-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 '{
  "startUrls": [
    {
      "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
    }
  ],
  "queries": [
    "home decor"
  ],
  "limit": 50000
}' |
apify call scrapers-hub/pinterest-pins-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/pinterest-pins-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/LjAA6RSCwWKCR1jJR/builds/TXtWy60PsaIj499VJ/openapi.json