# Pinterest Trends Scraper (`blueskyscraper/pinterest-trends-scraper`) Actor

Get Pinterest Trends data: growing, top and seasonal topics by market with search volume and change, plus weekly keyword interest history and forecasts. No login.

- **URL**: https://apify.com/blueskyscraper/pinterest-trends-scraper.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Features:** Limited permissions
- **Stats:** 16 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 trend topics

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Pinterest Trends as data: trending topics by market and category with growth and seasonality figures, the weekly interest history for any keyword, the related trends Pinterest shows for a keyword, Pinterest's own forecast kept apart from the facts, and the date Pinterest has computed its numbers up to.

![Pinterest Trends scraper input: what you fill in](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/pinterest-trends-scraper/input.png)

![Pinterest Trends scraper output: real rows from a run](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/pinterest-trends-scraper/output.png)

### Tested head-to-head on 6 November 2026

The same request (US, growing topics, 20 rows) went through this Actor and four other Pinterest Trends Actors.

| | This Actor | Others |
|---|---|---|
| Rows delivered | 20 of 20 | 20 of 20 |
| Fields per topic | 47 | 9–33 |
| Weekly history for your own words | Yes | Some |
| Forecast kept apart from facts | Yes | Some |

### What it gives

| Mode | Returns |
|---|---|
| `trending` | Top topics for a market, optionally one of 24 Pinterest categories (`category`): rank, search count, normalized index, year-over-year / week-over-week / month-over-month change, seasonality score, the topic's categories |
| `trending` + `includeSeries` | The same plus the weekly history for those topics |
| `series` | Weekly interest history for your keywords: peak, average, half-to-half change, Pinterest's own week/month/year growth rates |
| `series` + `includeRelated` | The same plus the related trends for each keyword |
| `related` | The "Related trends" Pinterest shows on a keyword's page (up to 5 per keyword), each with its own weekly history |
| `date` | The source update date, the lag to today, and the real history horizon measured on a sample word |

Measured on 9 November 2026: source update date **2026-11-06** (lag 3 days); the 730-day window for `dog food` returned **105 weekly points, 2024-11-08 … 2026-11-06**; related trends for `christmas nails`: classy christmas nails, christmas nails 2026, christmas nail ideas, grinch nails, short christmas nails.

### How to read the numbers

- **The index is relative and kept on Pinterest's own scale.** Values are Pinterest's 0–100 integers, untouched. By default each word is scaled to its own peak = 100, so compare points of the *same* word over time. Turn on `normalizeAgainstGroup` and all words of one request share one scale (100 = peak of the group) and can be compared. Every series row has a `normalization` object: where 100 lies (`own_history_peak`, `own_forecast_upper_bound`, `group_peak`), the group, and whether words are comparable.
- **A word Pinterest does not track is unknown, not zero.** It comes back as a free row with `availability: "not_tracked"` and `reason: "not_tracked_by_pinterest"`. A tracked word with no interest has real zeros in `points` (counted in `zeroPoints`). A refused window or date is a different reason (`pinterest_rejected_the_window_or_date`), never "word not found".
- **History and forecast are stored apart.** `points` holds only measured weeks. Pinterest's forecast (ask for it with `predictedDays`, 14–91 days) goes to `forecast` with `value`, `lower`, `upper`; peak, average and change are computed from facts only. With a forecast Pinterest rescales the word so that 100 is the highest forecast upper bound, and the row says so (`scaleIncludesForecast`, `historyPeakValue`, `forecastUpperMax`).
- **Growth figures are Pinterest's own.** `growth` has week-over-week, month-over-month and year-over-year percent from Pinterest. Year-over-year comes only with the 730-day window; otherwise it is null with the reason.
- **Granularity, period and horizon are stated.** Points are weekly (`granularity: "week"`). Pinterest serves windows of 30, 90, 180, 365 and 730 days only (other numbers are moved to the nearest one, with a notice). History reaches back about two years; a window can end at most about one year before the update date.
- **Update lag is visible.** Every row has `sourceUpdateDate` (what Pinterest says it has computed to) and `lagDays` (today minus that date).
- **Related terms are checked.** For a word Pinterest does not know, its related answer is a generic list of popular words; we do not pass that off as related terms — you get a free notice with the ignored list instead. Each related row says whether it shares a word with your keyword (`sharesWordWithRequest`).
- **If Pinterest rate-limits the ranked list**, the same list is taken from its front-page endpoint (`listSource: "default_top_trends"`); search count, normalized index and seasonality are then null, growth comes from Pinterest's growth rates, and a notice says so.

### Example rows

```json
{"type":"trend_topic","term":"happy november","rank":3,"searchCount":41,"normalizedCount":41,
 "yoyChange":{"percent":20,"index":2},"seasonalityScore":0.86,
 "provenance":{"source":"pinterest_trends","country":"US","availableAt":null,"checksum":"sha256:…"}}

{"type":"keyword_series","term":"dog food","granularity":"week","pointsCount":13,
 "firstDate":"2026-08-14","lastDate":"2026-11-06","peakValue":100,"sourceUpdateDate":"2026-11-06","lagDays":3,
 "growth":{"weekOverWeekPercent":9,"monthOverMonthPercent":-20,"yearOverYearPercent":null},
 "points":[{"date":"2026-08-14","count":61,"normalizedCount":61,"predictedUpper":null,"predictedLower":null}],
 "forecast":[],"normalization":{"peakEquals100":"own_history_peak","comparableAcrossWords":false}}

{"type":"related_term","requestTerm":"christmas nails","relatedTerm":"christmas nail ideas","relatedRank":3,
 "sharesWordWithRequest":true,"pointsCount":13,"peakValue":4,
 "forecast":[{"date":"2026-11-13","value":9,"lower":5,"upper":16}],
 "normalization":{"peakEquals100":"own_forecast_upper_bound","scaleIncludesForecast":true}}
```

### What is not here

- **Absolute search volumes.** Pinterest publishes only relative indexes.
- **Daily points.** Pinterest serves weekly points only (daily aggregation is refused).

### Input

| Field | Default | Meaning |
|---|---|---|
| `mode` | `trending` | `trending`, `series`, `related` or `date` |
| `country` | `US` | Pinterest market code |
| `keywords` | — | words for the `series` and `related` modes, up to 20 per source request |
| `trendType` | `growing` | `growing`, `top_monthly`, `top_yearly` or `seasonal` |
| `category` | all | one Pinterest category, e.g. `food_and_drink`, `animals`, `home_decor` |
| `limit` | 20 | topics to return |
| `includeSeries` | false | trending mode: also the weekly history of the topics |
| `includeRelated` | false | series mode: also the related trends of each word |
| `days` | 90 | history window: 30, 90, 180, 365 or 730 |
| `endDate` | source date | end of the window (back to about one year) |
| `predictedDays` | 0 | Pinterest forecast: 0 or 14–91 days |
| `normalizeAgainstGroup` | false | one shared scale for all words of a request |
| `maxItems` | 200 | upper limit on data rows |

### Change values

`searchCount` is the relative figure Pinterest publishes for the topic, not a number of searches.

`percent` is a real percentage: `-10` means 10% down. A value of `10001` is the source's cap for a topic with almost no earlier volume, so read it as "new", not as an exact number.

### Price

Pay per event, no subscription.

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| Trending topic (also a related term whose history Pinterest did not return) | $0.00115 | $0.001 | $0.00078 | $0.0006 |
| Keyword series (also a related term with its history) | $0.0024 | $0.00216 | $0.00192 | $0.00168 |
| Source update date | $0.002 | $0.0018 | $0.0016 | $0.0014 |
| Run start | $0.009 | $0.009 | $0.009 | $0.009 |

### FAQ

**Do I need a login, cookies or my own proxy?** No. Paste your input and press Start.

**How do I use the data elsewhere?** Export the dataset as JSON, CSV or Excel, schedule the Actor, or call it through the Apify API, n8n, Make and the Apify MCP server for AI agents.

**What if there is no data for my input?** You get a free row with type `error` or `notice` that explains why. Data rows are the only rows you pay for, plus the small run start fee.

**Something looks wrong?** Open an issue on the Issues tab with the run link. We read every one.

# Actor input Schema

## `mode` (type: `string`):

What to fetch. Trending topics: the current topics for a market (optionally one category). Keyword interest history: weekly history for your words. Related terms: the 'Related trends' Pinterest shows for each of your words, each with its own weekly history. Source update date: the date Pinterest computed its numbers for, the lag to today and the real history horizon.

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

Pinterest market code: US, GB, CA, DE, FR, ES, IT, AU and others.

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

Words for the "Keyword interest history" and "Related terms" modes. One source call takes a batch of up to 20 words.

## `trendType` (type: `string`):

Which Pinterest list to read: growing topics, top topics of the month, top topics of the year, or seasonal topics.

## `category` (type: `string`):

Only topics of one Pinterest category (the same filter as on trends.pinterest.com). Empty = all categories.

## `limit` (type: `integer`):

How many topics to take from the list.

## `includeSeries` (type: `boolean`):

In the trending mode, also fetch the interest history for the topics found (up to 20 topics). Charged per series.

## `includeRelated` (type: `boolean`):

In the keyword history mode, also fetch the related trends Pinterest shows for each word (up to 5 per word, each with its weekly history). Charged per related term.

## `days` (type: `integer`):

History length in days. Pinterest serves only 30, 90, 180, 365 and 730; any other number is moved to the nearest of these. Points are weekly (90 days ≈ 13 points). Year-over-year growth comes only with 730.

## `endDate` (type: `string`):

End of the window (YYYY-MM-DD). Empty = the latest date the source has computed. Pinterest accepts end dates back to about one year before its update date.

## `predictedDays` (type: `integer`):

How many days of Pinterest's own forecast to ask for: 0, or 14 to 91 in whole weeks (other numbers are rounded). The forecast comes in a separate `forecast` list with lower and upper bounds and is never mixed with the measured `points`. Note: with a forecast Pinterest rescales the word so that 100 is the highest forecast upper bound. Not every word has a forecast.

## `normalizeAgainstGroup` (type: `boolean`):

Off: each word is scaled to its own peak = 100 (shape over time, not comparable between words). On: all words of one request share a scale where 100 is the peak of the whole group, so you can compare them.

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

The upper limit on data rows in this run.

## Actor input object example

```json
{
  "mode": "trending",
  "country": "US",
  "keywords": [
    "dog food",
    "dog treats",
    "cat food"
  ],
  "trendType": "growing",
  "category": "",
  "limit": 20,
  "includeSeries": false,
  "includeRelated": false,
  "days": 90,
  "predictedDays": 0,
  "normalizeAgainstGroup": false,
  "maxItems": 200
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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": [
        "dog food",
        "dog treats",
        "cat food"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/pinterest-trends-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": [
        "dog food",
        "dog treats",
        "cat food",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/pinterest-trends-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 '{
  "keywords": [
    "dog food",
    "dog treats",
    "cat food"
  ]
}' |
apify call blueskyscraper/pinterest-trends-scraper --silent --output-dataset

```

## MCP server setup

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