# Pinterest Scraper — Pins, Videos, Boards & Profiles (`peerless_columbine/pinterest-pins-boards-profiles-scraper`) Actor

Export public Pinterest keyword searches and known pins, boards or profiles. Includes media URLs, source provenance, real cursor pagination and optional offline English sentiment/topic analysis. Independent tool.

- **URL**: https://apify.com/peerless_columbine/pinterest-pins-boards-profiles-scraper.md
- **Developed by:** [tingyou333 zhuang](https://apify.com/peerless_columbine) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 94.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 pinterest 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Pinterest Public Data — Pins, Videos, Boards & Profiles

Collect anonymous public Pinterest search results and known pins, boards, profiles or Ideas pages. Export titles, descriptions, images/video URLs, creators, available engagement fields and source provenance as JSON, CSV or Excel. Independent third-party tool; not affiliated with Pinterest.

### Quick start

```json
{
  "queries": ["gardening"],
  "type": "all-pins",
  "limit": 30,
  "maxPagesPerSeed": 2
}
```

Choose `all-pins`, `videos`, `boards` or `profiles` for keyword searches. `startUrls` accepts public Pinterest URLs and can be combined with queries. `limit` is a maximum per input, not a guarantee. Residential proxy access is enabled by default and incurs separate Apify proxy usage charges. Compute, storage and transfer are also additional to any displayed result fee. Start with a small limit to measure your own total cost.

### Search, URLs and pagination

Search uses the current public `BaseSearchResource` feed and follows its actual returned bookmark. It preserves source ordering, deduplicates IDs across the run, and never invents result rows or pagination links. Pins and videos share an ID namespace. A requested source page size can differ from the actual returned size.

Known pin URLs return that pin. A direct board URL returns its pins by default; `boardMode="board"` requests metadata. A profile URL returns profile metadata by default; `profileMode="pins"` or `"boards"` collects its contents. Category/Ideas pages require an actual embedded public feed; they are not replaced with keyword results. Public short links may redirect to supported targets. Board sections and private/account pages are unsupported.

Search URLs support `/search/pins/`, `/search/videos/`, `/search/boards/` and `/search/users/` with `q`; `filters=videos` is supported. Unknown filters, date/price/sort constraints and unsafe URLs are rejected rather than silently ignored. `language` sets Accept-Language; it is not an exit-country setting or a guarantee of the language of returned pins.

### Optional text analysis

Set `sentinent_analysis=true` (the input spelling is intentional) and/or `content_analysis=true`. The default `analysisProvider="lexical"` runs locally, without an API key or external model fees.

Sentiment uses title and image alt text with [VADER 3.3.2](https://github.com/cjhutto/vaderSentiment), an MIT-licensed English sentiment tool. Outputs include a compound score in \[-1,1], `(score+1)/2`, positive/negative/neutral label and the label's VADER text proportion in `sentiment_confidence`. That proportion is not a calibrated probability. Missing text omits sentiment fields and reports `missing_text` in `_analysis`.

Content classification uses title, alt text, descriptions, hashtags and destination domain. Our independent 17-topic English taxonomy covers home decor, gardening, recipes, crafts, fashion, beauty, travel, fitness, weddings, art, design, photography, pets, parenting, technology, sports and education. Matching rows receive a category label/path, rule strength and match kind (`exact_label`, `label_terms`, `exact_alias`, `alias_terms`, `hashtag`). No match omits category fields and reports `no_taxonomy_match`. Rule strengths are not calibrated probabilities. Analysis is text-only: images are never interpreted or uploaded.

Offline analysis supports requested English locales. A non-English `language` with offline analysis enabled fails before collection. English settings do not guarantee English source text; results on other languages are unreliable. Scores and topic labels are our own implementation and can differ from other tools; exact competitor numerical/taxonomy parity is not claimed.

For an explicit alternative, `analysisProvider="openai"` requires `allowPaidAnalysis=true`, an explicit `aiModel`, and `PINTEREST_ANALYSIS_API_KEY` in Actor environment. It makes at most `maxAiRequests` fixed-endpoint requests, without retries. Responses must satisfy the output schema; content match kind is `model`. Model fees are outside Apify spending caps. This optional BYO model route has offline adapter tests but no live model-quality/cost acceptance; use the default offline route for the verified analysis workflow.

### Output

Every valid row includes `type`, `schema`, `entity_type`, source `id`, `url`, `source_url`, `seed_type` and `seed_value`, plus relevant `pin`, `profile`, `board`, `creator`, `board_ref`, `media` and `extra` data. IDs remain strings. `_provenance` records observation time, resource, source page and requested language.

Public fields are source-dependent. Missing counts are omitted, not changed to zero. Search results may contain fewer fields than direct pin detail. Media URLs are exported, not downloaded, and may expire. Source video durations are retained in milliseconds with an explicit unit. Profile/board preview image maps are normalized into arrays.

### Limits and run status

| Control | Default | Meaning |
|---|---|---|
| `limit` | 50000 | Unique saved rows per seed |
| `maxResults` | 50000 | Global unique saved-row ceiling |
| `maxPagesPerSeed` | 100 | Feed pages per seed |
| `pageSize` | 25 | Requested source page size |
| `maxRequests` | 1000 | HTTP attempts including redirects/retries |
| `maxRetries` | 1 | Bounded GET retries on network errors/selected 5xx; no TLS or 401/403/429 retry |
| `requestTimeoutSecs` | 25 | Timeout per source attempt |
| `requestDelaySecs` | 1 | Sequential request spacing |
| `language` | en-US | Requested language header |
| `maxAiRequests` | 10 | Optional model requests only |

Read the separate `SUMMARY` record alongside the dataset. It contains per-input pages, actual page sizes, rows, duplicates, invalid records, errors, stop reasons and truncation. Status is `SUCCEEDED`, `SUCCEEDED_WITH_LIMITS`, `EMPTY`, `PARTIAL` or `FAILED`. Explicit empty feeds are distinguished from missing payloads, app shells and source errors. Partial rows are retained and the platform run fails so automation can detect incomplete collection. A result/page/request/spending ceiling is not proof of source exhaustion.

A 401/403/429 or login/challenge redirect stops the entire run before another target/proxy route. This decision happens at headers; an uncaptured body has null bytes/hash, not an empty response. TLS failures stop remaining inputs and certificate verification stays enabled. A missing target or non-public board ends that target. No personal cookies, logins or challenge solver are used.

### Connections, charges and coverage

Default `proxyConfiguration` uses existing Apify RESIDENTIAL service. Explicit `useApifyProxy=false` uses direct access; direct cloud access can fail even when local access works. Supported proxy settings include groups/country and custom public HTTP(S) `proxyUrls`. Public target DNS/IP and TLS checks remain enforced. Only the exact SDK-injected cloud proxy gateway can use its configured private service address; custom private proxies and source destinations are blocked. Credentials are not logged. `dnsResolver="google-doh"` is an explicit option for fake-IP local networks; it is never an automatic fail-open.

Only valid stored rows generate the default dataset-item event when result pricing is configured. Errors and duplicates do not generate rows or duplicate charges. Apify compute/storage/transfer, Residential traffic, subscription fees and optional model costs are separate. Spending caps and small input limits should be set before larger runs.

Source endpoints are undocumented and can change. Bounded acceptance samples do not prove all queries, locales, large feeds or long-term availability. The optional analysis is independently implemented; output field compatibility does not imply identical ranking, taxonomy or scores. For schedules/API integrations, inspect both dataset and SUMMARY and alert on PARTIAL/FAILED or truncation.

# Actor input Schema

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

Search, pin, board, profile, category or ideas URLs. One string per URL; no login links.

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

Applies to queries. Direct search URLs determine their own result scope.

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

Each query is fetched separately; mixed-language text is preserved.

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

Maximum unique saved rows for each query or URL. maxResults and maxPagesPerSeed also bound the run.

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

Add English VADER sentiment from title and image alt text. Offline by default: no API key or model charge. Empty text omits sentiment fields. Other languages require the explicit BYO model.

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

Classify public pin text with our independent English topic labels and aliases. Adds category fields only when a rule matches; rule strength is not a calibrated probability. No external model required.

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

Defaults to the existing Apify Residential service, which incurs account usage charges. This route returned bounded real pins, videos, boards and profiles in cloud tests. Set useApifyProxy=false for direct local access. Custom HTTP(S) proxies must be public.

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

Accept-Language header, not an exit-IP country override.

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

Use google-doh explicitly on fake-IP DNS networks. Validated public IP connection and TLS verification remain required.

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

Profile metadata, paginated saved pins or paginated boards. Does not change keyword profiles searches.

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

Return paginated pins or one board metadata record.

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

lexical performs offline English sentiment/topic analysis when flags are enabled. openai is an optional BYO-key text model with explicit paid-request gates; its outputs use match_type=model.

## `allowPaidAnalysis` (type: `boolean`):

Required only for analysisProvider=openai. Model charges are outside Apify limits. Offline lexical analysis makes no model requests.

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

Required only for analysisProvider=openai. Explicit Responses-compatible model with structured outputs.

## `maxPagesPerSeed` (type: `integer`):

Hard client-side bound.

## `pageSize` (type: `integer`):

Pinterest may return more or fewer; the saved-row limits are always enforced.

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

Hard client-side bound.

## `maxRequests` (type: `integer`):

Hard client-side bound.

## `requestTimeoutSecs` (type: `integer`):

Hard client-side bound.

## `maxRetries` (type: `integer`):

Hard client-side bound.

## `maxAiRequests` (type: `integer`):

Hard cap on optional BYO model requests. Does not limit offline lexical analysis.

## `requestDelaySecs` (type: `number`):

All source requests are sequential.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.pinterest.com/pin/563018699561284/"
  ],
  "type": "all-pins",
  "limit": 5,
  "sentinent_analysis": false,
  "content_analysis": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "language": "en-US",
  "dnsResolver": "system",
  "profileMode": "profile",
  "boardMode": "pins",
  "analysisProvider": "lexical",
  "allowPaidAnalysis": false,
  "maxPagesPerSeed": 100,
  "pageSize": 25,
  "maxResults": 50000,
  "maxRequests": 1000,
  "requestTimeoutSecs": 25,
  "maxRetries": 1,
  "maxAiRequests": 10,
  "requestDelaySecs": 1
}
```

# Actor output Schema

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

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.pinterest.com/pin/563018699561284/"
    ],
    "limit": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("peerless_columbine/pinterest-pins-boards-profiles-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": ["https://www.pinterest.com/pin/563018699561284/"],
    "limit": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("peerless_columbine/pinterest-pins-boards-profiles-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": [
    "https://www.pinterest.com/pin/563018699561284/"
  ],
  "limit": 5
}' |
apify call peerless_columbine/pinterest-pins-boards-profiles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,peerless_columbine/pinterest-pins-boards-profiles-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/eHZjpfZec2XOA92nn/builds/uxDgfkNBNquyhryNY/openapi.json