# Pinterest Keyword Research Scraper (`automation-lab/pinterest-keyword-research-scraper`) Actor

Extract Pinterest keyword ideas, related searches, and public pin results for SEO, content, ecommerce, and trend research.

- **URL**: https://apify.com/automation-lab/pinterest-keyword-research-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Keyword Research Scraper

Extract Pinterest keyword ideas, related searches, and public pin results for SEO, content, ecommerce, and trend research.

### What does Pinterest Keyword Research Scraper do?

Pinterest Keyword Research Scraper turns Pinterest search terms into structured research data.

It collects related query suggestions and public pin result metadata from Pinterest search pages.

Use it to understand what people search, save, and click around visual topics.

The actor is built for public Pinterest search data and does not require a Pinterest login.

### Who is it for?

#### SEO teams

Find Pinterest-style long-tail keywords for blog posts, landing pages, and image search content.

#### Ecommerce teams

Research product trends, style modifiers, seasonal demand, and destination domains in your niche.

#### Content marketers

Plan boards, articles, newsletters, and social campaigns from real Pinterest search language.

#### Agencies

Run repeatable keyword discovery for multiple clients without copying data by hand.

#### Trend researchers

Track visual-topic demand across categories like fashion, decor, weddings, food, crafts, and beauty.

### Why use this actor?

Pinterest is a discovery engine, not just a social network.

Search results reveal how users describe intent visually.

Manual collection is slow, inconsistent, and hard to repeat.

This actor gives you clean rows that can be exported to CSV, JSON, Excel, Google Sheets, or your own database.

### What data can I extract?

| Field | Description |
| --- | --- |
| `type` | `pin` or `related_query` |
| `keyword` | Original keyword searched |
| `searchUrl` | Pinterest search URL |
| `rank` | Rank within the keyword result group |
| `relatedQuery` | Related Pinterest query text |
| `pinId` | Pinterest pin ID |
| `pinUrl` | Public Pinterest pin URL |
| `title` | Pin title when available |
| `description` | Pin description when available |
| `imageUrl` | Pin image URL |
| `destinationUrl` | External destination URL when public |
| `destinationDomain` | Destination domain |
| `creatorName` | Creator display name |
| `creatorUsername` | Creator username |
| `creatorUrl` | Pinterest creator profile URL |
| `boardName` | Board name |
| `boardUrl` | Pinterest board URL |
| `repinCount` | Public save/repin count when returned |
| `commentCount` | Public comment count when returned |
| `extractedAt` | ISO timestamp |

### How much does it cost to scrape Pinterest keywords?

The actor uses pay-per-event pricing.

You pay a small start fee and a per-result fee for each saved row.

A small test with two keywords and 25 pin rows per keyword is designed to be inexpensive.

Increase result limits only after you confirm the output matches your workflow.

### Input options

`keywords` is the main input.

Add terms like `home decor`, `summer outfits`, `wedding centerpieces`, or `healthy dinner ideas`.

`searchUrls` is optional.

Use it when you already have Pinterest search URLs from a browser or another workflow.

`maxResultsPerKeyword` controls public pin rows per keyword.

`includePins` can be turned off if you only want keyword suggestions.

`includeRelatedQueries` can be turned off if you only want pin examples.

### Example input

```json
{
  "keywords": ["home decor", "summer outfits"],
  "maxResultsPerKeyword": 25,
  "includePins": true,
  "includeRelatedQueries": true
}
````

### Example output

```json
{
  "type": "pin",
  "keyword": "home decor",
  "rank": 1,
  "pinUrl": "https://www.pinterest.com/pin/123456789/",
  "title": "Cozy Reading Nook",
  "imageUrl": "https://i.pinimg.com/...jpg",
  "destinationDomain": "example.com",
  "creatorName": "Example Creator",
  "boardName": "Home Ideas",
  "extractedAt": "2026-05-27T08:00:00.000Z"
}
```

### How to scrape Pinterest keyword data

1. Open the actor on Apify.

2. Enter one or more Pinterest keywords.

3. Keep the default result limit for your first run.

4. Start the actor.

5. Download the dataset as CSV, JSON, XML, Excel, or HTML.

6. Repeat weekly or monthly for trend monitoring.

### Tips for better results

Use specific visual phrases.

Try modifiers such as `ideas`, `aesthetic`, `outfits`, `room`, `wedding`, `template`, `DIY`, or `2026`.

Compare broad and narrow terms.

Run seasonal terms before the season starts.

Keep keyword batches focused by niche for cleaner analysis.

### Common use cases

- Pinterest SEO keyword discovery

- Content calendar planning

- Ecommerce product trend research

- Competitor destination-domain discovery

- Blog image topic research

- Affiliate content ideation

- Agency client reports

- Social media campaign planning

### Integrations

Send the dataset to Google Sheets for editorial planning.

Export CSV into Airtable for keyword clustering.

Load JSON into a warehouse for historical trend tracking.

Trigger the actor from Make or Zapier for recurring reports.

Use Apify webhooks to notify Slack when a run finishes.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pinterest-keyword-research-scraper').call({
  keywords: ['home decor'],
  maxResultsPerKeyword: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/pinterest-keyword-research-scraper').call({
    'keywords': ['home decor'],
    'maxResultsPerKeyword': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~pinterest-keyword-research-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["home decor"],"maxResultsPerKeyword":25}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/pinterest-keyword-research-scraper
```

Claude Code setup:

```bash
claude mcp add apify-pinterest-keywords https://mcp.apify.com/?tools=automation-lab/pinterest-keyword-research-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-pinterest-keywords": {
      "url": "https://mcp.apify.com/?tools=automation-lab/pinterest-keyword-research-scraper"
    }
  }
}
```

Example prompts:

- Run Pinterest keyword research for `coastal bedroom` and summarize related queries.

- Find public Pinterest pin examples for `summer wedding centerpieces`.

- Export destination domains from the latest dataset.

### Data quality notes

Pinterest may return different results by time, locale, device, and ranking experiments.

Some pins do not expose destination URLs or descriptions publicly.

Related query modules are returned when Pinterest includes them in the public search response.

The actor keeps optional fields empty rather than inventing values.

### Performance

The actor uses HTTP requests and does not launch a browser.

This keeps runs fast and inexpensive.

For best reliability, avoid very large keyword batches in one run.

Split large research projects by topic or client.

### Legality

This actor extracts publicly available Pinterest search data.

You are responsible for using the data in accordance with applicable laws, Pinterest terms, and privacy rules.

Do not use the actor to collect private account data or bypass access controls.

### Troubleshooting

#### Why did I get fewer pins than requested?

Pinterest may return stories, modules, or repeated items mixed with pins.

The actor saves unique public pin rows and skips non-pin modules.

#### Why are some destination URLs missing?

Not every public pin exposes an external destination in the search result payload.

Use the Pinterest pin URL for manual follow-up when destination data is not returned.

#### Why did a keyword produce no rows?

The term may have few results, Pinterest may have changed its response, or the request was temporarily limited.

Try a broader keyword and a small result limit.

### FAQ

#### Does this require Pinterest login?

No. It uses public search data.

#### Can I scrape boards or profiles?

This actor focuses on keyword search research. Use a dedicated Pinterest scraper for boards or profiles.

#### Can I schedule it?

Yes. Use Apify schedules for daily, weekly, or monthly monitoring.

#### Can I export to Google Sheets?

Yes. Export the dataset or connect it through Apify integrations.

### Related scrapers

Explore more Automation Lab actors at https://apify.com/automation-lab/.

Useful adjacent categories include social media scrapers, ecommerce scrapers, SEO tools, and image search tools.

### Changelog

#### 0.1

Initial version with keyword inputs, related query rows, public pin rows, and HTTP-based extraction.

### Support

If Pinterest changes its public response or your keyword produces unexpected output, open an Apify issue with the run URL and input.

We use run logs and datasets to diagnose changes quickly.

# Actor input Schema

## `keywords` (type: `array`):

Pinterest search keywords to research.

## `searchUrls` (type: `array`):

Optional full Pinterest search URLs. The actor extracts the q= keyword.

## `maxResultsPerKeyword` (type: `integer`):

Maximum public pin result rows to save for each keyword.

## `includePins` (type: `boolean`):

Save public pin rows with title, image, destination, creator, and board details.

## `includeRelatedQueries` (type: `boolean`):

Save Pinterest related query / guide suggestions when returned by the search endpoint.

## Actor input object example

```json
{
  "keywords": [
    "home decor",
    "summer outfits"
  ],
  "searchUrls": [
    {
      "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
    }
  ],
  "maxResultsPerKeyword": 20,
  "includePins": true,
  "includeRelatedQueries": true
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "home decor",
        "summer outfits"
    ],
    "searchUrls": [
        {
            "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pinterest-keyword-research-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 = {
    "keywords": [
        "home decor",
        "summer outfits",
    ],
    "searchUrls": [{ "url": "https://www.pinterest.com/search/pins/?q=home%20decor" }],
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "home decor",
    "summer outfits"
  ],
  "searchUrls": [
    {
      "url": "https://www.pinterest.com/search/pins/?q=home%20decor"
    }
  ]
}' |
apify call automation-lab/pinterest-keyword-research-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Keyword Research Scraper",
        "description": "Extract Pinterest keyword ideas, related searches, and public pin results for SEO, content, ecommerce, and trend research.",
        "version": "0.1",
        "x-build-id": "YytdxPioFHDn0eyjd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pinterest-keyword-research-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pinterest-keyword-research-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~pinterest-keyword-research-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pinterest-keyword-research-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~pinterest-keyword-research-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pinterest-keyword-research-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Pinterest search keywords to research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Pinterest search URLs",
                        "type": "array",
                        "description": "Optional full Pinterest search URLs. The actor extracts the q= keyword.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerKeyword": {
                        "title": "Max pin results per keyword",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum public pin result rows to save for each keyword.",
                        "default": 20
                    },
                    "includePins": {
                        "title": "Include pin results",
                        "type": "boolean",
                        "description": "Save public pin rows with title, image, destination, creator, and board details.",
                        "default": true
                    },
                    "includeRelatedQueries": {
                        "title": "Include related queries",
                        "type": "boolean",
                        "description": "Save Pinterest related query / guide suggestions when returned by the search endpoint.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
