# Pinterest Search Scraper – Full Pin Data by Keyword (`scrapeberry/pinterest-search-scraper`) Actor

Pinterest Search Scraper scrapes full pin data by keyword — title, description, image, saves, repins, comments, reactions, board and author for every result. Fast, structured JSON for market research, content planning and data pipelines.

- **URL**: https://apify.com/scrapeberry/pinterest-search-scraper.md
- **Developed by:** [Scrapeberry](https://apify.com/scrapeberry) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 search results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Search Scraper scrapes **full pin data by keyword** — for every result: title, description, image, saves, repins, comments, reactions, board, author, and dates as clean, structured JSON. Every request hits Pinterest's servers **live**; there is no cached or stored data, so you always get the freshest possible search results. A no-browser **Pinterest search API alternative**: keywords in, full pin records out, no coding required.

### What does the Pinterest Search Scraper do?

This Pinterest keyword scraper searches Pinterest for one or many queries and returns up to **1,000 full pin records per query**. Each result is enriched beyond a plain search listing — the actor fetches the complete pin data behind every result, so you get engagement metrics (saves, comments, reactions), the source domain, and the board + author behind each pin.

- **Full data per result** — not just links: `saves_count`, `repins_count`, `comments_count`, `reactions_count` for every pin.
- **Multi-keyword** — one query per line, hundreds of keywords per run.
- **Up to 1,000 results per query** — default 100, raise it in one field.
- **Country targeting** — route requests through North American or European proxy IPs (US, CA, GB, DE, FR, NL, ES, IT, PL, SE) or Auto.
- **Fast** — plain HTTP, no browser; rate-limit aware with automatic backoff.
- **Fair billing** — pay only for pins actually delivered. Expect two small charges per result because every scrape is live (no cache): a **$4 per 1,000** scraping fee plus a tiny platform data-processing fee. Failed/skipped queries are returned **at no charge**.

### What data can this Pinterest search scraper extract?

| Field | Type | Description |
|---|---|---|
| `query` | string | The keyword that produced this result |
| `id` | string | Unique pin ID |
| `title` | string | Pin title |
| `description` | string | Pin description |
| `pin_url` | string | Pin URL |
| `type` | string | `image`, `video`, `gif`, or `carousel` |
| `image` | string | Original-size image URL |
| `domain` | string | Source website (e.g. `recipe-blog.com`) |
| `saves_count` | number | Times the pin was saved |
| `repins_count` | number | Repins |
| `comments_count` | number | Comments |
| `reactions_count` | number | Total reactions |
| `board_name` | string | Board the pin lives on |
| `pinner_username` | string | Who pinned it |
| `creator_username` | string | Original creator |
| `created_at` | date | Pin creation date (ISO 8601) |

### Input

See the **Input tab** for the full form. Key options:

- **Search queries** — one keyword per line (required).
- **Results per query** — default 100, up to 1,000.
- **Proxy country** — Auto (all countries) or a North American / European country for the proxy exit IP.
- **Concurrency** — parallel pin fetches, 1–10 (default 5).
- **Proxy configuration** — Apify Proxy with a sticky session (default); switch **Residential** on if datacenter IPs get throttled.

### Output

The dataset contains one record per delivered pin. Download it as **JSON, HTML, CSV, or Excel**.

The run's **OUTPUT** key summarizes per-query counts: found, delivered, skipped (rate limits), plus totals. Only delivered results are billed.

### Example

Real output for the query `"zucchini recipes"` — every field returned by this Pinterest keyword scraper:

```json
{
  "query": "zucchini recipes",
  "id": "68741848186",
  "title": "The BEST Zucchini Fritters",
  "description": " ",
  "pin_url": "https://www.pinterest.com/pin/68741848186/",
  "type": "image",
  "image": "https://i.pinimg.com/originals/10/12/44/101244853ccd4e5e9288f13cb91a7ecb.jpg",
  "domain": "willcookforsmiles.com",
  "saves_count": 105619,
  "repins_count": 4439,
  "comments_count": 174,
  "reactions_count": 149,
  "board_name": "veggies",
  "pinner_username": "amberwithaar",
  "creator_username": "willcook4smiles",
  "created_at": "2020-08-27T23:00:00.000Z"
}
```

### Pricing — how much does it cost to search Pinterest?

This Pinterest search scraper uses **pay-per-event** pricing. Because every request is made **live against Pinterest's servers in real-time** (there is no cached or stored data), you will see two small charges per successfully delivered result on your invoice:

| Charge | Amount | Why |
|---|---|---|
| **Search result delivered** | **$4 per 1,000 results** ($0.004 each) | The main scraping fee — charged only for pins successfully delivered to your dataset. Each full result includes a dedicated per-pin data fetch, not just a search listing. |
| **Result** (dataset item) | **$0.01 per 1,000 results** ($0.00001 each) | Platform data-processing/storage fee charged by Apify for every item written to the dataset. |
| **Actor start** | $0.05 per 1,000 starts (default) | Fixed per-run start fee; Apify covers the first 5 seconds of compute. |

**Total cost:** roughly **$4.01 per 1,000 results** delivered.

Queries that return nothing are **not charged** beyond the start event; pins skipped due to rate limits are also **not charged**.

A run with 3 queries × 100 results costs about **$1.20** plus a few cents of platform usage. New Apify accounts include free platform credit — enough to try hundreds of results.

### Performance

- 100 results at default concurrency ≈ **30–60 seconds** (search pagination + full fetches).
- 1,000 results ≈ **5–8 minutes**; raise concurrency for faster bulk runs.
- Automatic backoff when Pinterest throttles — the actor stops a query early and keeps the results it already delivered.

### Use cases

- **Content research** — find the highest-saving pins for any keyword and reverse-engineer what resonates (`saves_count`, `comments_count`).
- **SEO & competitor analysis** — which domains (`domain` field) win your keywords on Pinterest, and who pins them.
- **Influencer discovery** — surface active creators (`creator_username`) in your niche by engagement.
- **Market research & trend tracking** — schedule weekly runs of the same keywords to watch engagement shift.
- **Data pipelines** — normalized JSON/CSV drops straight into spreadsheets, BI, or ETL.

### API usage

Run the Pinterest search scraper programmatically — see the **API tab** for copy-paste snippets. Node.js example with the [Apify SDK](https://docs.apify.com/sdk/js/):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('scrapeberry/pinterest-search-scraper').call({
    searchQueries: ['zucchini recipes', 'air fryer chicken'],
    resultsPerQuery: 100,
    country: 'US',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Or schedule recurring runs from the actor page to build an engagement time series per keyword.

### FAQ and disclaimers

**Is the data public?** Yes — the actor reads only what a logged-out visitor sees. It does not log in, access private accounts, or extract private personal data.

> Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

**Why did a query deliver fewer results than requested?** Pinterest caps some searches, and the actor stops early when it detects rate limiting — you are never billed for skipped pins. Lower concurrency or switch to residential proxies for full-depth runs.

Found an issue or have an idea? Open a ticket in the **Issues tab** — feedback shapes the roadmap.

# Actor input Schema

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

Pinterest search keywords, one per line. Each query returns up to 'Results per query' full pin records.

## `resultsPerQuery` (type: `integer`):

Maximum number of full pin results per query (100 default, up to 1000).

## `concurrency` (type: `integer`):

Parallel pin fetches, 1-10. Higher is faster but may trigger Pinterest rate limits (the actor backs off automatically).

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

Country of the Apify Proxy exit IP (North America & Europe supported). Auto = all available countries (recommended default).

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

Apify Proxy with a sticky session (recommended). The country selector above overrides the proxy country. Residential recommended if datacenter IPs get blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "zucchini recipes"
  ],
  "resultsPerQuery": 100,
  "concurrency": 5,
  "country": "AUTO",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Across all queries; only delivered results are billed.

## `dataset` (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 = {
    "searchQueries": [
        "zucchini recipes"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeberry/pinterest-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchQueries": ["zucchini recipes"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapeberry/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 '{
  "searchQueries": [
    "zucchini recipes"
  ]
}' |
apify call scrapeberry/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapeberry/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/GFAGze93LzvCpzGBj/builds/fOcBNl2ER20518sL3/openapi.json