# Pinterest Keyword Scraper (`maximedupre/pinterest-keyword-scraper`) Actor

Collect Pinterest autocomplete keyword suggestions from seed terms or Pinterest search URLs. Export ranked ideas with source URLs, suggestion IDs, and scrape timestamps for SEO, content planning, and research.

- **URL**: https://apify.com/maximedupre/pinterest-keyword-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** SEO tools, Social media
- **Stats:** 4 total users, 1 monthly users, 99.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.45 / 1,000 pinterest keyword suggestions

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 scraper for autocomplete ideas

Pinterest Keyword Scraper collects keyword suggestions from [Pinterest](https://www.pinterest.com/) autocomplete. Add seed terms such as `home office ideas`, `summer outfits`, or `healthy dinner recipes`, and the Actor returns ranked Pinterest search suggestions you can export, schedule, or use through the Apify API.

Use this Pinterest keyword scraper when you need real Pinterest autocomplete phrases for content planning, Pinterest SEO research, pin title ideas, board naming, niche research, or keyword expansion. It accepts plain keyword seeds and Pinterest search URLs, then saves one dataset item per suggestion with rank, source seed, suggestion text, Pinterest search URL, raw suggestion ID when available, and scrape time.

No Pinterest login, cookies, API key, or developer account is required from you. The Actor is focused on public autocomplete suggestions, not pin scraping, board scraping, profile scraping, search volume, CPC, or trend forecasts.

### ✅ What this Pinterest keyword scraper does

- Finds Pinterest autocomplete suggestions for one or more seed keywords.
- Accepts Pinterest search URLs and normalizes them into search terms.
- Saves one row per keyword suggestion.
- Keeps the original seed and normalized seed on every row.
- Preserves Pinterest autocomplete rank so you can sort suggestions by source order.
- Adds a Pinterest search URL for each suggestion when enabled.
- Deduplicates suggestions across the run by default.
- Lets you cap suggestions per seed and total saved items for predictable runs.
- Works with Apify dataset exports, schedules, webhooks, integrations, and API access.

The default input is small enough for a quick first run. For larger keyword research jobs, add more seeds and raise the total suggestion limit.

### 📦 Data you can extract

Each dataset item is one Pinterest autocomplete suggestion. Fields include:

- `seed` - original keyword or Pinterest search URL from the input.
- `normalizedSeed` - keyword text used for Pinterest autocomplete.
- `inputType` - `keyword` or `searchUrl`.
- `seedIndex` - position of the seed in your input list.
- `suggestion` - suggested Pinterest keyword phrase.
- `rank` - one-based autocomplete rank for that seed.
- `suggestionType` - Pinterest item type when available.
- `suggestionId` - raw Pinterest autocomplete ID when available.
- `pinterestSearchUrl` - Pinterest search URL for the suggestion when enabled.
- `sourceAutocompleteUrl` - source request URL used for traceability.
- `isDuplicate` - whether the suggestion had already appeared earlier in the run.
- `scrapedAt` - UTC timestamp when the row was saved.

Some autocomplete items can be brand, profile, or topic-like suggestions instead of plain phrases. The Actor keeps the suggestion text and type so you can decide what to keep in your own workflow.

### 🚀 How to run

1. Add one or more keyword seeds in `Pinterest keywords`.
2. Keep `Suggestions per keyword` at `10` for a small first run.
3. Keep `Total suggestion limit` at `100`, or lower it when testing.
4. Leave deduplication on unless you want to see repeated suggestions per seed.
5. Run the Actor and open the dataset.

You can also paste Pinterest search URLs such as `https://www.pinterest.com/search/pins/?q=home%20office%20ideas`. The Actor extracts the `q` search term and uses it as the seed.

### ⚙️ Input

```json
{
	"seeds": [
		"home office ideas",
		"summer outfits",
		"healthy dinner recipes"
	],
	"maxSuggestionsPerSeed": 10,
	"maxItems": 100,
	"dedupeSuggestions": true,
	"includeSearchUrls": true
}
````

#### ⚙️ Input fields

- `seeds` - Pinterest keyword phrases or Pinterest search URLs.
- `maxSuggestionsPerSeed` - maximum autocomplete suggestions to request for each seed.
- `maxItems` - maximum suggestion rows to save across the whole run.
- `dedupeSuggestions` - save repeated suggestion text only once across all seeds.
- `includeSearchUrls` - include a Pinterest search URL for each suggestion.

### 📊 Output example

```json
{
	"seed": "home office ideas",
	"normalizedSeed": "home office ideas",
	"inputType": "keyword",
	"seedIndex": 0,
	"suggestion": "home office ideas for small spaces",
	"rank": 1,
	"suggestionType": "query",
	"suggestionId": "ac_example",
	"pinterestSearchUrl": "https://www.pinterest.com/search/pins/?q=home+office+ideas+for+small+spaces",
	"sourceAutocompleteUrl": "https://www.pinterest.com/resource/AdvancedTypeaheadResource/get/?...",
	"isDuplicate": false,
	"scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML from Apify, or read it through the Apify API.

### 💡 Common use cases

#### 🔎 Pinterest SEO research

Collect autocomplete phrases around your niche and use them to shape pin titles, board names, descriptions, and content briefs.

#### 🗓️ Content calendar planning

Run batches of seasonal or product-related seeds, then group the returned suggestions into themes for upcoming pins or blog posts.

#### 🛍️ Ecommerce keyword expansion

Start with product categories such as `linen dress`, `nursery decor`, or `meal prep containers` and collect long-tail Pinterest search ideas for listings, ads, or creative briefs.

#### 🔁 Repeat keyword monitoring

Schedule the same seed list weekly or monthly and compare exported datasets to spot new autocomplete suggestions.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each Pinterest suggestion saved to the dataset. There is no Actor-start charge in this actor-owned pricing contract.

Use `maxSuggestionsPerSeed`, `maxItems`, and deduplication to keep runs bounded and predictable.

### ⚠️ Limits and caveats

- The Actor returns Pinterest autocomplete suggestions, not search volume, CPC, keyword difficulty, or trend scores.
- Pinterest may return people, brands, or topic-like suggestions alongside keyword phrases.
- Private Pinterest data, logged-in recommendations, pins, boards, profiles, comments, and media downloads are outside this Actor's scope.
- Empty or very narrow seed terms can return few or no suggestions.
- Source-site availability can change. When a seed cannot be collected, the Actor keeps useful rows from other seeds when possible and reports the skipped seed in the run log.

### ❓ FAQ

#### 🔐 Do I need a Pinterest account?

No. You do not need to provide Pinterest credentials, cookies, API keys, or a developer account.

#### 📌 Can I scrape Pinterest pins with this Actor?

No. This Actor is only for Pinterest autocomplete keyword suggestions. Use a Pinterest pin, board, or profile scraper when you need visual content or profile data.

#### 🔗 Can I enter Pinterest search URLs?

Yes. Paste a Pinterest search URL with a `q` parameter, and the Actor will use that query as the keyword seed.

#### 📈 Does this include search volume or trend data?

No. The output is based on Pinterest autocomplete suggestions and ranks. It does not include volume, CPC, competition, or trend forecasts.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~pinterest-keyword-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Quora Search Scraper ↗](https://apify.com/maximedupre/quora-search-scraper) - Find public Quora questions for SEO, content, and audience research.
- [Reddit Scraper ↗](https://apify.com/maximedupre/reddit-scraper) - Search Reddit posts and comments around a topic, brand, or trend.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Collect paid Google Shopping product ads for ecommerce keyword research.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Export image search results for visual research and creative briefs.
- [Product Hunt Scraper ↗](https://apify.com/maximedupre/product-hunt-scraper) - Collect Product Hunt launch rows for startup and market research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `seeds` (type: `array`):

Enter keyword seeds such as home office ideas, or paste Pinterest search URLs. Add multiple seeds to build a larger Pinterest keyword list in one run.

## `maxSuggestionsPerSeed` (type: `integer`):

Maximum Pinterest autocomplete suggestions to collect for each keyword seed.

## `maxItems` (type: `integer`):

Maximum Pinterest suggestion rows to save across the whole run.

## `dedupeSuggestions` (type: `boolean`):

Save each suggestion phrase only once when multiple keyword seeds return the same autocomplete idea.

## `includeSearchUrls` (type: `boolean`):

Include a Pinterest search URL for each suggestion so exported keyword ideas are easy to inspect later.

## Actor input object example

```json
{
  "seeds": [
    "home office ideas",
    "summer outfits",
    "healthy dinner recipes"
  ],
  "maxSuggestionsPerSeed": 10,
  "maxItems": 100,
  "dedupeSuggestions": true,
  "includeSearchUrls": true
}
```

# Actor output Schema

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

Open the dataset with Pinterest keyword suggestions ready for export or API access.

# 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 = {
    "seeds": [
        "home office ideas",
        "summer outfits",
        "healthy dinner recipes"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/pinterest-keyword-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 = { "seeds": [
        "home office ideas",
        "summer outfits",
        "healthy dinner recipes",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/pinterest-keyword-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 '{
  "seeds": [
    "home office ideas",
    "summer outfits",
    "healthy dinner recipes"
  ]
}' |
apify call maximedupre/pinterest-keyword-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Keyword Scraper",
        "description": "Collect Pinterest autocomplete keyword suggestions from seed terms or Pinterest search URLs. Export ranked ideas with source URLs, suggestion IDs, and scrape timestamps for SEO, content planning, and research.",
        "version": "0.0",
        "x-build-id": "sUGrKnANeWVLekPYD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~pinterest-keyword-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-pinterest-keyword-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/maximedupre~pinterest-keyword-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-pinterest-keyword-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/maximedupre~pinterest-keyword-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-pinterest-keyword-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",
                "required": [
                    "seeds"
                ],
                "properties": {
                    "seeds": {
                        "title": "Pinterest keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter keyword seeds such as home office ideas, or paste Pinterest search URLs. Add multiple seeds to build a larger Pinterest keyword list in one run.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxSuggestionsPerSeed": {
                        "title": "Suggestions per keyword",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum Pinterest autocomplete suggestions to collect for each keyword seed.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Total suggestions",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum Pinterest suggestion rows to save across the whole run.",
                        "default": 100
                    },
                    "dedupeSuggestions": {
                        "title": "Deduplicate suggestions?",
                        "type": "boolean",
                        "description": "Save each suggestion phrase only once when multiple keyword seeds return the same autocomplete idea.",
                        "default": true
                    },
                    "includeSearchUrls": {
                        "title": "Include search URLs?",
                        "type": "boolean",
                        "description": "Include a Pinterest search URL for each suggestion so exported keyword ideas are easy to inspect later.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
