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

Scrape Pinterest’s autocomplete suggestions to discover trending and long-tail keywords. Ideal for SEO experts, content strategists, and bloggers optimizing for Pinterest search intent and user discovery.

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

## Pricing

from $2.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Suggestions, Rank & Creator Data

Pinterest Autocomplete Scraper turns a list of seed keywords into Pinterest's own autocomplete suggestions — the same terms Pinterest shows a person typing into its search box. Each result returns as structured JSON with the suggestion text (`item`), its type, Pinterest's own rank, a direct search URL, and — for suggested creator accounts — username, display name, and verification flags. No parsing required. Run it directly from the Apify Console or the API to start building a Pinterest keyword list.

### 🧭 What is Pinterest Autocomplete Scraper?

Pinterest Autocomplete Scraper is an Apify Actor that queries Pinterest's live typeahead endpoint for a list of seed keywords and returns every suggestion Pinterest offers — both keyword phrases and, when Pinterest surfaces them, creator/account suggestions — as flat, structured JSON rows. It requires no Pinterest account or login; requests are sent the same way an anonymous visitor's browser calls Pinterest's search box. It's built for SEO researchers, Pinterest marketers, and developers who want Pinterest's own suggestion data fed into a keyword pipeline, dashboard, or AI agent without writing scraping code.

### 🔓 What Pinterest autocomplete data is publicly available to scrape?

Pinterest serves autocomplete suggestions to any visitor typing into its search box, logged in or not — no account is required to see them.

| Data Category | Publicly Available | Restricted (requires a logged-in Pinterest session) |
| --- | --- | --- |
| Keyword/query suggestions | Yes — the same list shown to anonymous visitors on pinterest.com/ideas/ | Personalized suggestions drawn from your own search and board history |
| Suggestion rank/order | Yes | — |
| Creator/account suggestions (username, display name, handle) | Yes | Full creator profile — follower counts, boards, pin history |
| Verified / verified-merchant flags | Yes | — |
| Direct Pinterest search & profile links | Yes | — |
| Resolved response language | Yes | Locale forced by a signed-in account's own language settings |
| Trending/seasonal ranking shifts | Partially — reflected live in suggestion order | Full historical trend data — Pinterest Trends product |

Pinterest Autocomplete Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 📦 What data can I extract with Pinterest Autocomplete Scraper?

Every run returns Pinterest's suggestion metadata for each keyword, plus dedicated fields for any suggested creator account.

| Field Name | Description |
| --- | --- |
| `keyword` | The seed keyword you provided in `targets`. |
| `type` | `query` for a keyword suggestion, `user` for a creator/account result, or `status` for a no-suggestion row. |
| `item` | The suggestion text, or the creator's display name when `type` is `user`. |
| `rank` | Pinterest's own position for this suggestion (`resultIndex`; 0 = top result). |
| `suggestionId` | Pinterest's own identifier for the suggestion. |
| `searchUrl` | A direct Pinterest link for the suggestion or account. |
| `resolvedTerm` | The term Pinterest's response confirms it actually processed. |
| `resolvedLanguage` | The language Pinterest resolved the response in. |
| `seedContainedInSuggestion` | `true`/`false` if the suggestion text literally contains your seed keyword; `null` for creator results. |
| `fetchStatus` | `ok` for a normal row, `ok_no_suggestions` when Pinterest confirmed there are none, `failed` when the keyword could not be resolved after retries. |
| `scrapedAt` | ISO 8601 timestamp of when the row was collected. |

#### Creator/account fields

Populated only when `type` is `user`; `null` otherwise.

| Field Name | Description |
| --- | --- |
| `creatorUsername` | The suggested account's Pinterest username. |
| `creatorName` | The account's display name. |
| `creatorHandle` | The account's handle, as returned by Pinterest (`subLabel`). |
| `creatorAvatarUrl` | URL of the account's medium-size avatar image. |
| `creatorIsVerified` | `true` if Pinterest shows the account as verified. |
| `creatorIsVerifiedMerchant` | `true` if Pinterest shows the account as a verified merchant. |

#### 🤖 Add-on: Need additional Pinterest data?

Scraper-Engine doesn't currently publish a dedicated Pinterest pin or board scraper, but Pinterest Autocomplete Scraper pairs well with other keyword- and social-data tools in the account — use **Amazon Search Scraper** to cross-check keyword demand on a second platform, or **Instagram Post Details Scraper** and **TikTok Scraper** to pull adjacent social content for the same niche.

### 🛠️ Why not build this yourself?

Pinterest does not publish a public autocomplete or typeahead API for third-party developers — its official Pinterest API (v5, developers.pinterest.com) covers pins, boards, ads, catalogs, and account management, not search-suggestion data. The endpoint this Actor calls (`/resource/AdvancedTypeaheadResource/get/`) is the same internal endpoint pinterest.com's own search box uses; it is not a documented, versioned contract, so Pinterest can change its response shape, required headers, or blocking behavior without notice.

Building this yourself means reverse-engineering that endpoint, keeping request headers current as Pinterest's web app changes, and building your own proxy rotation and retry logic to survive 403/429 responses — the exact escalation this Actor already runs (direct request → Apify Datacenter proxy → Apify Residential proxy, with per-request retries). Running the Actor keeps that ongoing maintenance off your plate.

### ▶️ How to use Pinterest Autocomplete Scraper

1. Open Pinterest Autocomplete Scraper on its Apify Store listing (or find it by name in the Apify Console).
2. Provide `targets` — one or more seed keywords, one per line.
3. Optionally set `proxyConfiguration` if you consistently see empty results.
4. Start the run.
5. Download results as JSON, CSV, or Excel from the dataset, or read them via the Apify API.

#### How to scale to bulk suggestion extraction

`targets` accepts an array, so any number of seed keywords are processed in the same run — there's no need to loop runs per keyword. If `targets` is left empty, the Actor logs a warning and falls back to a small built-in default keyword list (`fashion`, `outfit`, `dress`, `skirt`, `shirt`, `pants`, `shoe`, `bag`, `hat`, `accessory`) rather than failing, so an empty input still produces a demo-sized dataset.

### 💡 What can you do with Pinterest autocomplete data?

- 🔍 **SEO content planners** use `item`, `rank`, and `seedContainedInSuggestion` to shortlist long-tail Pinterest search phrases worth targeting in pin titles and descriptions.
- 📈 **Paid social marketers** use `item` and `resolvedLanguage` to build region- and language-specific keyword lists for Pinterest Ads campaigns.
- 🕵️ **Market researchers** use `type` and `creatorIsVerifiedMerchant` to spot when Pinterest is surfacing competing brand accounts alongside a product keyword.
- 🤖 **AI engineers** feed the JSON output of `item`, `type`, and `rank` directly into a RAG pipeline or an LLM prompt to generate on-brand Pinterest pin copy grounded in real search demand, with no HTML parsing.
- 🔁 **Growth teams** re-run the same `targets` list on a schedule and diff `item`/`rank` across runs to track how Pinterest's suggestions shift over time.

### 🛡️ How does Pinterest Autocomplete Scraper handle rate limits and blocking?

The Actor automatically escalates through three connection stages if Pinterest's typeahead endpoint returns a blocking-like response (HTTP 403/429 without a JSON body) or comes back with zero suggestions across every keyword: first a direct request with no proxy, then an Apify Datacenter proxy, then up to three attempts through Apify Residential proxy. Whichever stage first returns unblocked results with at least one suggestion is used; if every stage is exhausted, the Actor keeps the results from its final attempt rather than failing the run outright. Within each stage, keywords are fetched concurrently (up to 15 requests in parallel, capped at 30 total / 15 per host connections), and each individual request retries up to 3 times with a randomized delay of roughly 1–2 seconds before it's marked failed. There is no CAPTCHA-solving step — the Actor relies on browser-realistic request headers and proxy rotation, not challenge-solving, to avoid blocking.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `targets` | Yes | array of strings | One keyword per line. Each entry is sent to Pinterest as-is and returns whatever suggestions Pinterest offers for that exact term. | `["summer wedding dress", "kitchen decor", "minimalist tattoo"]` |
| `proxyConfiguration` | No | object | Optional. Leave at the default for standard use. If you consistently see empty results, enable Apify Proxy here. | `{"useApifyProxy": false}` |

#### Example input

```json
{
  "targets": ["summer wedding dress", "kitchen decor", "minimalist tattoo"],
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### ⬆️ Output

Results are written to the Actor's dataset as typed, normalized JSON — one row per suggestion, plus one status row for any keyword that returned no suggestions. Export as JSON, CSV, Excel, or read rows directly from the API.

⚠️ Every pushed row — including `status` rows with `fetchStatus: "failed"` or `"ok_no_suggestions"` — is charged under the `row_result` event. A keyword search that genuinely returns nothing still produces (and charges for) one row. Filter `fetchStatus != "ok"` after a run if you want to isolate the keywords that returned no usable data.

#### Example output

A keyword suggestion row:

```json
{
  "keyword": "kitchen decor",
  "type": "query",
  "item": "kitchen decor ideas",
  "rank": 0,
  "suggestionId": "ac_GwPMhEq2",
  "searchUrl": "https://www.pinterest.com/search/pins/?q=kitchen%20decor%20ideas",
  "resolvedTerm": "kitchen decor",
  "resolvedLanguage": "en",
  "seedContainedInSuggestion": true,
  "creatorUsername": null,
  "creatorName": null,
  "creatorHandle": null,
  "creatorAvatarUrl": null,
  "creatorIsVerified": null,
  "creatorIsVerifiedMerchant": null,
  "fetchStatus": "ok",
  "scrapedAt": "2026-08-15T09:12:47.201Z"
}
```

A creator/account suggestion row:

```json
{
  "keyword": "minimalist tattoo",
  "type": "user",
  "item": "Minimalist Tattoo Studio",
  "rank": 4,
  "suggestionId": "ac_user_88213",
  "searchUrl": "https://www.pinterest.com/minimalisttattoostudio/",
  "resolvedTerm": "minimalist tattoo",
  "resolvedLanguage": "en",
  "seedContainedInSuggestion": null,
  "creatorUsername": "minimalisttattoostudio",
  "creatorName": "Minimalist Tattoo Studio",
  "creatorHandle": "@minimalisttattoostudio",
  "creatorAvatarUrl": "https://i.pinimg.com/avatars/minimalisttattoostudio_140.jpg",
  "creatorIsVerified": true,
  "creatorIsVerifiedMerchant": false,
  "fetchStatus": "ok",
  "scrapedAt": "2026-08-15T09:12:49.558Z"
}
```

### ⚙️ How does it work?

Pinterest Autocomplete Scraper calls the same JSON endpoint (`/resource/AdvancedTypeaheadResource/get/`) that pinterest.com's own "/ideas/" search box calls when a person types a term — it doesn't parse rendered HTML. Requests carry browser-realistic headers (a current Chrome user-agent, standard `sec-fetch-*` and `accept` headers) and, when needed, route through Apify Datacenter or Residential proxies to avoid IP-based blocking. No headless browser is launched; the response is Pinterest's own JSON payload for the query, which the Actor parses into flat rows. Only what Pinterest returns to an anonymous visitor is captured — no login, cookies, or personalization involved. Because the Actor reads Pinterest's structured API response rather than visual markup, the output schema stays the same shape even if Pinterest changes the search page's HTML or CSS.

### 🔌 Integrations

Pinterest Autocomplete Scraper runs on the Apify platform, so it works with any tool that can call the Apify API or the `apify-client` SDK.

#### Calling Pinterest Autocomplete Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("YOUR_USERNAME/pinterest-autocomplete-scraper").call(run_input={
    "targets": ["summer wedding dress", "kitchen decor", "minimalist tattoo"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["item"], item["type"], item["rank"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node pointed at the Actor's run endpoint, authenticated with your Apify token. In Make, use Apify's native module to start a run and pass the resulting dataset items downstream. In LangChain, use the Apify integration (`ApifyWrapper` / `ApifyDatasetLoader`) to run the Actor and load its output straight into a document pipeline.

### ⚖️ Is it legal to scrape Pinterest autocomplete suggestions?

Scraping Pinterest's publicly served autocomplete suggestions is generally lawful — this is the same JSON response Pinterest sends to any anonymous visitor typing into its own search box, not data pulled from behind a login wall. Pinterest Autocomplete Scraper returns only that public suggestion data: keyword phrases, ranks, and the handful of public identifiers (username, display name, verification flags) Pinterest itself surfaces for suggested creator accounts. This is primarily aggregate search-suggestion data governed by Pinterest's Terms of Service and applicable database-rights law, not a personal-data extraction tool — no private profile fields or contact details are collected. The `creatorUsername`, `creatorName`, and `creatorHandle` fields are public identifiers only; treat them carefully if you store or process them in bulk, since aggregating even public account identifiers can implicate GDPR or CCPA depending on your use case. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What Pinterest autocomplete fields does Pinterest Autocomplete Scraper return?

The core fields are `item` (the suggestion text or creator name), `type` (`query`, `user`, or `status`), `rank`, `searchUrl`, and `resolvedLanguage`. See [What data can I extract](#-what-data-can-i-extract-with-pinterest-autocomplete-scraper) for the full set of 17 fields.

#### Does Pinterest Autocomplete Scraper require a Pinterest account or login?

No. The Actor sends the same request an anonymous browser makes to Pinterest's search box — no cookies, session token, or Pinterest account credentials are used or required.

#### How many keywords can I extract suggestions for in one run?

`targets` accepts any number of seed keywords in a single array, processed concurrently in the same run — there's no fixed cap in the input schema. Pinterest itself returns a fixed set of suggestions per keyword (no pagination), so more results come from adding more seed keywords, not from paging a single one.

#### What happens if a keyword returns zero suggestions?

Pinterest sometimes has no suggestions for a term — that's a real answer, not a scraper failure. The Actor pushes a `status` row for that keyword with `fetchStatus: "ok_no_suggestions"` (Pinterest responded but had nothing to offer) or `fetchStatus: "failed"` (no usable response after all retries), instead of silently dropping the keyword.

#### Can I scrape multiple Pinterest keywords at once?

Yes. Pass any number of keywords in `targets`, one per line, and every one is processed in the same run.

#### Does Pinterest Autocomplete Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes, as an HTTP endpoint. Any agent framework that can call the Apify API — including custom tool-calling setups for Claude or ChatGPT — can start a run and read back typed JSON.

#### How does Pinterest Autocomplete Scraper compare to other Pinterest autocomplete scrapers?

As observed on the "Pinterest Autocomplete Scraper" listing published by scraper-mind on the Apify Store (checked 2026-08-15), that Actor accepts one `query` string at a time with an optional `max_results` cap and alphabetic prefix/suffix expansion. Pinterest Autocomplete Scraper (this Actor) instead accepts a full list of seed keywords (`targets`) processed in a single run, and separates creator/account suggestions from keyword suggestions into dedicated `creatorUsername`, `creatorName`, `creatorHandle`, `creatorIsVerified`, and `creatorIsVerifiedMerchant` fields rather than mixing accounts into the keyword list.

#### Does Pinterest Autocomplete Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across runs — no HTML parsing, no CSS selectors. Pass rows directly to an LLM, index them into a vector store, or feed them to an agent tool.

#### What happens when Pinterest changes its layout or anti-bot system?

The Actor is maintained and its output schema is designed to stay stable across Pinterest front-end changes, since it reads Pinterest's structured API response rather than parsing rendered HTML. No specific update turnaround time is published.

#### Can I use Pinterest Autocomplete Scraper without managing proxies or browser infrastructure?

Yes. The Actor handles proxy selection and escalation (direct → Datacenter → Residential) and request retries internally — you don't need to configure or run your own proxy pool or headless browser.

#### Which Pinterest autocomplete fields work best for AI training data and RAG indexing?

For RAG, index `item` (the suggestion text) alongside `keyword` and `resolvedTerm` for query context. For training data, `type`, `rank`, and `seedContainedInSuggestion` return as consistently structured typed primitives (string, integer, boolean) across every run.

### 🔗 Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Amazon Search Scraper | Amazon search-result listings for a given keyword — useful for cross-platform keyword validation. |
| Instagram Post Details Scraper | Post-level detail data from Instagram. |
| TikTok Scraper | Video and account data from TikTok. |
| Reddit Scraper | Post and discussion data from Reddit. |
| Google Play Scraper | App listing data from the Google Play Store. |

### 💬 Your feedback

Found a bug, or need a Pinterest field this Actor doesn't return yet? Let us know through the Issues tab on the Actor's Apify Store page, or via the Console's built-in support/contact option — reports like this directly shape the next update.

# Actor input Schema

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

One keyword per line. Each entry is sent to Pinterest as-is and returns whatever suggestions Pinterest offers for that exact term.

Example: "summer wedding dress", "kitchen decor", "minimalist tattoo".

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

Optional. Leave at the default for standard use. If you consistently see empty results, enable Apify Proxy here.

## Actor input object example

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

# Actor output Schema

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

Autocomplete suggestions for every seed keyword, including creator matches and a status row for keywords that returned nothing.

# 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("scraper-engine/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("scraper-engine/pinterest-autocomplete-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "targets": [
    "fashion",
    "outfit"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/pinterest-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/pinterest-autocomplete-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dcU3H8pdWMJXWNkzH/builds/EwMARWXMnqdYO7RI2/openapi.json