# Pinterest Autocomplete Scraper (`scrapepilotapi/pinterest-autocomplete-scraper`) Actor

- **URL**: https://apify.com/scrapepilotapi/pinterest-autocomplete-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/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 Autocomplete Scraper
==============================

Pinterest Autocomplete Scraper is an Apify Actor that automatically collects **Pinterest autocomplete keyword suggestions** at scale.  
Use it to power Pinterest SEO, content strategy, ad targeting, and niche research by turning a list of seed queries into hundreds of long‑tail keyword ideas.

Instead of manually typing queries into Pinterest search, this actor connects to Pinterest’s autocomplete endpoint, expands your keyword list, and exports the results in a clean dataset you can download or connect to other tools.

### Key features

- **Bulk autocomplete scraping**: Send a list of keywords, URLs, or usernames (all treated as keywords) and get Pinterest’s live autocomplete suggestions for each.
- **Pinterest keyword research at scale**: Discover long‑tail topics, content ideas, and keyword variations for boards, pins, and ads.
- **Smart proxy fallback**: Starts with no proxy, then automatically upgrades to datacenter and finally residential proxies if Pinterest begins blocking requests.
- **Structured, easy‑to‑use output**: Clean dataset with the original keyword, suggestion type, suggestion text, and proxy mode.
- **Compatible with any workflow**: Export results to CSV, JSON, Excel, Google Sheets, or integrate via API.

### Typical use cases

- **Pinterest SEO & content planning**  
  - Find long‑tail keywords people actually type into Pinterest search.  
  - Generate ideas for pin titles, descriptions, and board names.

- **Niche and market research**  
  - Quickly validate niche demand by exploring autocomplete suggestions.  
  - Discover related topics, questions, and trends your audience is searching for.

- **Ad and campaign planning**  
  - Build keyword lists for Pinterest Ads targeting.  
  - Uncover new audience angles based on real user search intent.

### How it works

1. You provide a list of **targets** (keywords, URLs, or usernames).  
2. The actor treats each target as a **keyword seed**.  
3. For every seed, it calls Pinterest’s **autocomplete API** and collects all returned suggestions.  
4. Results are saved to the default dataset, which you can filter, download, or connect to other systems.

Under the hood, the scraper uses a **progressive proxy strategy**:

- Starts with **no proxy** for maximum speed and simplicity.
- If Pinterest blocks requests, it automatically switches to **datacenter proxy**.
- If blocking continues, it escalates to **residential proxy** and then continues the whole run on residential for better stability.

This approach balances reliability, cost, and performance for most scraping workloads.

### Input configuration

The actor accepts the following main input fields:

- **targets (required)**  
  - Type: `array` of strings  
  - Description: List of Pinterest‑related **keywords, URLs, or usernames**. For this actor, they are all treated as keyword seeds for autocomplete.  
  - Example:  
    - `"fashion"`  
    - `"summer outfit"`  
    - `"kitchen decor"`  

- **sort_order**  
  - Type: `string`  
  - Options: `"default"`, `"top"`, `"latest"`  
  - Description: Informational field related to Pinterest result ordering. For the autocomplete endpoint, this currently does **not** change the scraped suggestions, but is included for forward compatibility and alignment with other actors.

- **max_comments**  
  - Type: `integer`  
  - Default: `10`  
  - Description: Compatibility field kept for consistency with other Pinterest actors. It does **not** directly limit the number of autocomplete suggestions, but may be used internally for some logic or future expansion.

- **proxyConfiguration**  
  - Type: `object`  
  - Editor: `proxy`  
  - Default: `{ "useApifyProxy": false }`  
  - Description: Controls how the actor uses proxies. If you are experiencing blocks, you can enable Apify Proxy or customize the configuration for better stability.

### Output dataset

For each autocomplete suggestion, the actor stores a record in the default dataset.  
Each item typically includes:

- **`keyword`** – The original seed keyword you provided in `targets`.  
- **`type`** – Pinterest’s suggestion type (for example, might indicate the nature of the suggestion).  
- **`item`** – The actual autocomplete suggestion string shown by Pinterest.  
- **`proxy_mode`** – Which proxy mode was used when fetching that suggestion (none / datacenter / residential).

You can access the dataset:

- From the **Apify console** (Dataset → Download as CSV, JSON, Excel, etc.).
- Programmatically via the **Apify API** for integration with your own tools, dashboards, or pipelines.

### Getting started

1. Open the **Pinterest Autocomplete Scraper** actor on Apify.  
2. In the input, paste your list of **keywords / URLs / usernames** into the `targets` field (one per line if using the string list editor).  
3. Optionally adjust `sort_order`, `max_comments`, and `proxyConfiguration`.  
4. Click **Start** to run the actor.  
5. After the run finishes, go to the **Dataset** tab to view or download your Pinterest autocomplete keyword suggestions.

### Best practices for Pinterest keyword research

- Start with a **broad list of seed keywords**, then filter for the most relevant, high‑intent autocomplete suggestions.  
- Use suggestions to refine **board topics**, **pin titles**, **descriptions**, and **hashtags**.  
- Combine the dataset with other SEO tools (Google Suggest, keyword planners, etc.) for a more complete keyword strategy.  
- Run the scraper regularly to track how Pinterest autocomplete changes over time and spot **emerging trends** early.

### Support and customizations

If you need:

- Custom output fields or transformations  
- Integration with external tools (Google Sheets, Airtable, Data Studio, BI tools, etc.)  
- Higher‑scale scraping or more complex Pinterest workflows  

💬 Contact us at **dev.scraperengine@gmail.com** with your use case, and we’ll be happy to help.

# Actor input Schema

## `targets` (type: `array`):

📝 One item per line in the editor.

✅ Examples: “summer wedding dress”, “https://www.pinterest.com/search/pins/?q=decor”, “@styleinspo”.

🪄 Everything is treated as a seed keyword for autocomplete — paste freely, we’ll do the cleanup magic. ✨
## `proxyConfiguration` (type: `object`):

🚀 Default: no proxy (speedy & simple).

🔄 If a wall appears: we auto-switch to datacenter proxies, then residential with gentle retries.

🏠 Once residential wins, we keep that cozy mode for the rest of the run so you don’t babysit toggles.

💡 Tip: leave Apify Proxy off unless you already know you need it — the actor still has your back. 🤝

## Actor input object example

```json
{
  "targets": [
    "fashion",
    "outfit"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

# 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 = {
    "targets": [
        "fashion",
        "outfit"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/pinterest-autocomplete-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 = {
    "targets": [
        "fashion",
        "outfit",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/pinterest-autocomplete-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 '{
  "targets": [
    "fashion",
    "outfit"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilotapi/pinterest-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Autocomplete Scraper",
        "version": "0.1",
        "x-build-id": "M9fzHbjzMkZmnvsa2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~pinterest-autocomplete-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-pinterest-autocomplete-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/scrapepilotapi~pinterest-autocomplete-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-pinterest-autocomplete-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/scrapepilotapi~pinterest-autocomplete-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-pinterest-autocomplete-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "🎯 Bulk targets — keywords, links, or @handles",
                        "type": "array",
                        "description": "📝 One item per line in the editor.\n\n✅ Examples: “summer wedding dress”, “https://www.pinterest.com/search/pins/?q=decor”, “@styleinspo”.\n\n🪄 Everything is treated as a seed keyword for autocomplete — paste freely, we’ll do the cleanup magic. ✨",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxies — stay smooth when Pinterest says “slow down”",
                        "type": "object",
                        "description": "🚀 Default: no proxy (speedy & simple).\n\n🔄 If a wall appears: we auto-switch to datacenter proxies, then residential with gentle retries.\n\n🏠 Once residential wins, we keep that cozy mode for the rest of the run so you don’t babysit toggles.\n\n💡 Tip: leave Apify Proxy off unless you already know you need it — the actor still has your back. 🤝"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```