# 📌 Pinterest Trend & Reach Report (`scrapier/pinterest-trend-reach-report`) Actor Scrape Pinterest search results with the Pinterest Search Scraper. Extract pins, images, descriptions, URLs, and engagement stats by keyword or topic. Perfect for trend tracking, market research, and content inspiration. Fast, reliable, and scalable for bulk searches. - **URL**: https://apify.com/scrapier/pinterest-trend-reach-report.md - **Developed by:** [Scrapier](https://apify.com/scrapier) (community) - **Categories:** Social media, Lead generation, Videos - **Stats:** 16 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing $24.99/month + usage To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors ## 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 Search Scraper — Pins Plus a Trend & Reach Report Search Pinterest for any keyword and get two things from one run: every matching pin as a structured JSON row, and a run-level **Trend & Reach Report** — color palette, creator/board reach, posting cadence, engagement, and image-format distribution — computed only from the pins that run just scraped. Every analytics value traces back to a real scraped field: a count, an average, a median, a ratio, or a hue bucket, never a modeled score. Point it at a keyword and get pins today, plus the shape of the trend behind them. ### What is Pinterest Search Scraper — Pins Plus a Trend & Reach Report? Pinterest Search Scraper — Pins Plus a Trend & Reach Report queries Pinterest's public pin-search results for a single keyword and returns two outputs: one dataset row per matching pin (identical schema to a plain Pinterest search scraper), and — unless you turn it off — a run-level analytics object written to the key-value store. No Pinterest account, login, or session cookie is required; the input schema has no auth field at all, only a search query and a proxy configuration. What sets this apart from a plain search scrape is the second output: a **Trend & Reach Report** that turns the same pins you already paid for into color, reach, and cadence intelligence, without a second run or a second bill. Key capabilities: - **Per-pin search scrape** — title, description, dominant color, creator, board, reaction counts, and destination link for every matching pin, streamed live to the dataset as they're found. - **Content-type filter** — restrict the search (and the report) to video pins only, or include all pin types, via `filter`. - **Adjustable sample size** — scrape anywhere from 1 to 10,000 pins per run via `limit`, which also sets the report's statistical sample size. - **Trend & Reach Report** — a single key-value store record aggregating engagement, color palette, creator/board/domain reach, posting cadence, and image-format shape across the whole sample. - **Configurable ranking depth** — control how many entries appear in each of the report's rankings (top pinners, top boards, top domains, top hex colors, top pins) via `topN`. - **Raw mode** — set `rawData` to skip the report entirely and get pin-only output, identical to a plain search scraper. ### What data can you get with Pinterest Search Scraper — Pins Plus a Trend & Reach Report? The actor writes to two separate storages in the same run: the default dataset (pins) and the key-value store (the report). | Result Type | Extracted Fields | Primary Use Case | | --- | --- | --- | | Pins (dataset row) | `query`, `node_id`, `type`, `title`, `description`, `domain`, `link`, `dominant_color`, `created_at`, `board`, `reaction_counts`, `native_creator`, `pinner`, `image_url`, `image_width`, `image_height`, `scrapedAt` | Raw pin content for feeds, boards, moodboards, or LLM context | | Trend & Reach Report (key-value store, `TREND_REPORT`) | `query`, `filter`, `generatedAt`, `pinCount`, `analytics.engagement`, `analytics.colorPalette`, `analytics.reach`, `analytics.cadence`, `analytics.imageFormats`, `scrapedAt` | Keyword-level trend, color, and creator-reach research without building your own aggregation pipeline | #### Trend & Reach Report This is the report available at every run (unless `rawData=true`), written to the key-value store under the `TREND_REPORT` key. It has five sections, each derived only from the fields already present on the scraped pins: - **`engagement`** — `totalReactions`, `avgReactionsPerPin`, `medianReactionsPerPin`, `maxReactions`, a raw `reactionsByTypeId` breakdown (Pinterest's internal reaction-type IDs are kept unlabeled — Pinterest does not expose their human names, so the actor does not guess them), and `topPinsByReactions` (the `topN` highest-reaction pins). - **`colorPalette`** — each pin's real `dominant_color` hex value is classified into a hue family (red, orange, yellow, green, cyan, blue, purple, pink, plus black/white/gray neutrals for low-saturation or extreme-brightness colors), then rolled up into `paletteFamilies` (share of pins and average reactions per family), `topDominantHex` (the most common raw hex values), and sample-wide `avgSaturation` / `avgBrightness`. - **`reach`** — `uniquePinners`, `uniqueBoards`, `topPinnersByFollowers` (ranked by each pinner's own `follower_count`), `topBoardsByPinCount` (ranked by each board's `pin_count`), and `topDomains` (most common `domain` values among the linked pins). - **`cadence`** — `oldest` / `newest` pin dates, `medianAgeDays`, `pinsLast30Days`, `pinsLast90Days`, and a `pinsByMonth` histogram, all parsed from each pin's `created_at` field. - **`imageFormats`** — `portrait` / `landscape` / `square` counts (from each pin's width-to-height ratio) plus sample-wide `avgWidth`, `avgHeight`, and `avgAspectRatio`. ```json { "query": "minimalist living room", "filter": "videos", "generatedAt": "2026-07-26T09:12:41.000Z", "pinCount": 200, "analytics": { "colorPalette": { "pinsAnalyzed": 187, "paletteFamilies": [ { "family": "white", "count": 61, "sharePct": 32.6, "avgReactions": 14.2 }, { "family": "gray", "count": 40, "sharePct": 21.4, "avgReactions": 9.8 } ], "topDominantHex": [{ "hex": "#f4f1ec", "count": 22 }], "avgSaturation": 0.184, "avgBrightness": 0.771 } }, "scrapedAt": "2026-07-26T09:10:02.000Z" } ``` #### Pins — creator and board metadata Every pin row carries two nested objects straight from Pinterest's own response: `pinner` (the account that posted the pin — `username`, `full_name`, `follower_count`, among whatever else Pinterest returns on that object) and `board` (the board the pin was saved to — `name`, `url`, `pin_count`). These are the fields the `reach` section of the Trend & Reach Report ranks on, but they're also available raw on every dataset row for anyone who wants to build their own creator or board leaderboard instead of using the built-in one. ### Why not build this yourself? Pinterest's developer platform is scoped to managing a business account's own pins, boards, and ad campaigns — it is not a public endpoint for querying and returning someone else's search results by keyword, which is what this actor does. Building that query surface in-house means reverse-engineering Pinterest's internal search resource endpoints yourself, keeping up with a UI that the actor's own selectors already have to fall back gracefully around ("Pinterest UI selectors change often" is a real condition the scraper handles), maintaining a residential proxy pool (Pinterest blocks datacenter IPs outright), and re-implementing retry and block-detection logic (login-wall redirects, HTTP 4xx responses) from scratch. This actor already does all of that, and you pay per pin returned rather than per engineering hour spent keeping a scraper alive. ### What is the difference between Pinterest Trends data and a Pinterest Trend & Reach Report? Pinterest Trends data is a platform-side statistic: a normalized search-volume index for a keyword, independent of any specific set of search results. A Trend & Reach Report, as built by this actor, is the opposite — it is computed entirely from the actual pins a specific search returned, so every number in it (a color share, a follower count, a posting-cadence histogram) traces to a pin you can also see in the dataset. This distinction matters because they answer different questions. Pinterest's own Trends product (surfaced by other Pinterest Trends scrapers, which return fields like `term`, `normalizedCount`, `weeklyChange`, and `seasonalityScore` — as observed on the Apify Store on 2026-07-26) tells you whether a keyword is rising or falling in aggregate search interest. It does not tell you what the top results for that keyword actually look like, who is posting them, or what colors dominate them. A Trend & Reach Report answers exactly that: for the query you ran, which colors are winning, which creators and boards have the reach, and how fresh the results are. This actor returns both kinds of signal in one place — per-pin rows (`type`, `dominant_color`, `pinner`, `board`, `reaction_counts`, …) in the dataset, and the derived `analytics` object in `TREND_REPORT` — rather than requiring a separate Trends lookup and a separate search scrape. ### How to scrape Pinterest with Pinterest Search Scraper — Pins Plus a Trend & Reach Report? 1. Open **Pinterest Search Scraper — Pins Plus a Trend & Reach Report** on its Apify Store listing and click **Try for free** (or **Run**, if you already have it saved). 2. Enter your search term in `query` — this is the only required field. 3. Set your real query controls: `filter` (`all` or `videos`) to restrict the content type, `limit` to set how many pins to scrape (and the report's sample size), and `topN` to size the report's rankings. 4. Start the run. Leave `proxyConfiguration` on its Residential default — Pinterest blocks datacenter IPs, so an unconfigured or datacenter proxy will typically return zero pins. 5. Download the pin rows as JSON or CSV from the dataset, and read the aggregated report from the key-value store record `TREND_REPORT`. ```json { "query": "minimalist living room", "filter": "videos", "limit": 200, "topN": 10 } ``` #### How to run multiple queries in one job The input schema takes a single `query` string per run — there is no array or batch-upload field for multiple keywords in one job. To cover several keywords, start one run per keyword, either from the Console or via the Apify API/`apify_client`, looping over your keyword list and calling the actor once per keyword. Each run produces its own dataset and its own `TREND_REPORT` record, so reports never mix across keywords. ### ⬇️ Input The input schema exposes one required field and five optional ones — a search query, a content-type filter, two size controls, a raw-output toggle, and proxy configuration. | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `query` | Yes | string | What to search for on Pinterest. Default is `"wallpaper"`. | `"minimalist living room"` | | `filter` | No | string (enum: `all`, `videos`) | Show all pins or only video pins; also restricts what the report aggregates over. Default is `"videos"`. | `"all"` | | `limit` | No | integer (1–10,000) | How many pins to scrape. Also the report's sample size — a larger `limit` gives more stable color/reach/cadence statistics. Default is `10`. | `200` | | `topN` | No | integer (1–100) | How many entries to list in each report ranking (top pinners, boards, domains, hex colors, pins by reactions). Default is `10`. | `5` | | `rawData` | No | boolean | When `true`, streams per-pin rows only and skips the Trend & Reach Report — base-scraper behavior. Default is `false`. | `true` | | `proxyConfiguration` | No | object | Proxy settings. Apify Residential proxy is strongly recommended — Pinterest blocks datacenter IPs. Default is `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }`. | see below | Example JSON input: ```json { "query": "minimalist living room", "filter": "all", "limit": 500, "topN": 15, "rawData": false, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } } ``` ⚠️ **Common pitfall:** `filter` defaults to `"videos"`, not `"all"` — if you want every pin type (the more common expectation for a general Pinterest search), set `filter` to `"all"` explicitly. The actor also normalizes `filter` internally: any value other than the literal string `"videos"` is treated as `"all"`, so only that one exact value narrows the search. Separately, if you call the actor via the API and omit `limit` from the payload entirely (rather than sending the Console's pre-filled default), the actor's own internal fallback is `100`, not the `10` shown as the schema default — always send an explicit `limit` if you want a specific pin count. ### ⬆️ Output Output is typed, normalized JSON with a consistent schema across runs — the pin schema and the `analytics` object shape never change based on what Pinterest returns. Export the dataset as JSON, CSV, Excel, or any other format the Apify platform supports; read the report directly from the key-value store record. #### Scraped results Default dataset — one row per pin, byte-identical to a plain Pinterest search scraper's per-pin schema plus `scrapedAt`: ```json [ { "query": "minimalist living room", "node_id": "998234723847", "type": "pin", "title": "Minimalist Living Room With Warm Oak Accents", "description": "", "domain": "example-decor-blog.com", "link": "https://example-decor-blog.com/minimalist-living-room-ideas", "dominant_color": "#e8e2d6", "created_at": "Tue, 03 Mar 2026 14:22:10 +0000", "board": { "id": "6011223344", "name": "Living Room Ideas", "url": "/user123/living-room-ideas/", "pin_count": 214 }, "reaction_counts": { "1": 12, "3": 4 }, "native_creator": {}, "pinner": { "id": "50019283746", "username": "modern.interiors", "full_name": "Modern Interiors Studio", "follower_count": 84210 }, "image_url": "https://i.pinimg.com/originals/aa/bb/cc/aabbcc112233.jpg", "image_width": 736, "image_height": 1104, "scrapedAt": "2026-07-26T09:10:02.000Z" }, { "query": "minimalist living room", "node_id": "998234723999", "type": "pin", "title": "Scandinavian Minimalist Lounge Setup", "description": "Neutral palette, low-profile furniture, natural light", "domain": "", "link": "", "dominant_color": "#d9d2c4", "created_at": "Sat, 21 Feb 2026 08:03:55 +0000", "board": { "id": "6011223399", "name": "Scandi Home", "url": "/user456/scandi-home/", "pin_count": 88 }, "reaction_counts": { "1": 31 }, "native_creator": {}, "pinner": { "id": "50019284000", "username": "nordic.living.co", "full_name": "Nordic Living Co.", "follower_count": 15320 }, "image_url": "https://i.pinimg.com/originals/dd/ee/ff/ddeeff445566.jpg", "image_width": 1000, "image_height": 1500, "scrapedAt": "2026-07-26T09:10:03.000Z" }, { "query": "minimalist living room", "node_id": "998234724102", "type": "pin", "title": "Minimal Grey Sofa Corner", "description": "", "domain": "example-furniture-shop.com", "link": "https://example-furniture-shop.com/products/minimal-grey-sofa", "dominant_color": "#b7b3ab", "created_at": "Mon, 06 Jul 2026 19:47:02 +0000", "board": { "id": "6011224410", "name": "Furniture Finds", "url": "/user789/furniture-finds/", "pin_count": 41 }, "reaction_counts": {}, "native_creator": {}, "pinner": { "id": "50019290111", "username": "graystudio", "full_name": "Gray Studio", "follower_count": 6042 }, "image_url": "https://i.pinimg.com/originals/11/22/33/112233445566.jpg", "image_width": 900, "image_height": 1200, "scrapedAt": "2026-07-26T09:10:05.000Z" } ] ``` The default dataset view surfaces only 10 columns for a compact table — `node_id`, `type`, `title`, `dominant_color`, `image_width`, `image_height`, `domain`, `link`, `created_at`, `scrapedAt`. The underlying row is larger: `query`, `description`, `board`, `reaction_counts`, `native_creator`, `pinner`, and `image_url` are all present on every row and available via the API or a JSON/CSV export — they're simply not columns in the default table view. Key-value store record `TREND_REPORT` — the full `analytics` object described above, present unless `rawData=true`. ### How can I use the data extracted with Pinterest Search Scraper — Pins Plus a Trend & Reach Report? - **🎨 Design and content teams:** Read `colorPalette.paletteFamilies` to see which hue family dominates a niche right now, and pull `topDominantHex` to build an actual color swatch for a moodboard or campaign brief — no manual color-picking across dozens of pins. - **🤖 AI engineers and LLM developers:** Feed the pin array or the `TREND_REPORT` object directly to an LLM as grounded context — the agent issues a query, receives structured JSON (real hex colors, real creator handles, real dates), and generates an answer or brief without hallucinating trend data. - **📊 Market researchers:** Use `reach.topPinnersByFollowers` and `reach.topDomains` to see which accounts and destination sites have real reach in a niche, and `cadence.pinsByMonth` to see whether interest in a query is accelerating or cooling. - **🛍️ Product and merchandising teams:** Cross-reference `colorPalette` and `imageFormats` against your own catalog to spot a gap — a color family or image orientation that's trending in search results but underrepresented in your current lineup. ### How do you monitor Pinterest trends over time? Monitoring here means re-running the same `query` on a schedule and diffing the `TREND_REPORT` between runs rather than reading a single snapshot in isolation. What changes between runs is the input to every decision: a shift in `colorPalette.paletteFamilies` shares means the visual trend itself is moving; a jump in `reach.topPinnersByFollowers` follower counts or a new name entering `reach.topBoardsByPinCount` means a new creator or board is gaining ground in that search; a change in `cadence.pinsLast30Days` versus the previous run's figure tells you whether fresh content is accelerating or slowing for that keyword. The fields worth diffing run-over-run are `analytics.colorPalette.paletteFamilies[].sharePct`, `analytics.reach.topPinnersByFollowers`, `analytics.reach.topBoardsByPinCount`, `analytics.cadence.pinsLast30Days`, and `analytics.engagement.avgReactionsPerPin`. A practical loop: schedule a run per keyword you track, store each run's `TREND_REPORT` (by `generatedAt`), and alert when a color family's `sharePct` moves sharply or a new name appears in the top pinners or boards list. This actor has no built-in scheduling of its own — point an Apify Schedule at it for the repeated-run half of that loop, and read each run's key-value store record afterward, either from the Console or via the API. ### Integrate Pinterest Search Scraper — Pins Plus a Trend & Reach Report and automate your workflow Pinterest Search Scraper — Pins Plus a Trend & Reach Report works with any language or tool that can send an HTTP request, using the standard Apify API and its official client SDKs. #### REST API with Python ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("scrapier/pinterest-trend-reach-report").call( run_input={"query": "minimalist living room", "filter": "all", "limit": 200} ) ## Per-pin rows from the default dataset for pin in client.dataset(run["defaultDatasetId"]).iterate_items(): print(pin["title"], pin["dominant_color"]) ## The Trend & Reach Report from the key-value store report = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("TREND_REPORT") print(report["value"]["analytics"]["colorPalette"]["paletteFamilies"]) ``` #### Scheduled monitoring and delivery The actor has no built-in webhook or delivery feature of its own. Use an Apify Schedule to trigger repeated runs against a keyword, and either poll the run's dataset and `TREND_REPORT` key-value record via the API afterward, or attach an Apify webhook to the run's completion event to push a notification into your own pipeline. ### Is it legal to scrape Pinterest results? Yes — scraping Pinterest's public search results is scraping publicly accessible data, and this actor returns only what any visitor to pinterest.com sees without logging in. The pin, board, and image data returned is public content protected primarily by Pinterest's Terms of Service and database/content rights rather than personal-data law, since the primary entity here is a pin, not a person. That said, each pin's `pinner` object includes a public username, display name, and follower count for the account that posted it — self-published, publicly visible profile data, but data that can identify a natural person, so GDPR/CCPA considerations can apply if you store or profile individuals from it rather than just the pin content. Scraping for one-off research and scraping to build an ongoing dataset for AI training or resale carry different risk profiles. Consult your legal team for commercial use cases involving bulk data storage. ### ❓ Frequently asked questions #### Can I get only video pins? Yes — set `filter` to `"videos"` (the default) to restrict both the search and the report to video pins, or `"all"` to include every pin type Pinterest returns for the query. #### Does the actor accept a Pinterest search URL instead of a keyword? No — only a plain text `query` is accepted. Internally the actor builds the Pinterest search URL itself (`https://www.pinterest.com/search/pins/?q=&rs=typed`, with `content_type=videos` appended when `filter` is `"videos"`), so you never construct the URL yourself. #### How does the actor handle Pinterest's anti-bot measures? It runs a real Chromium browser via Playwright with a stealth init script that hides the most-fingerprinted automation tells (`navigator.webdriver`, `navigator.plugins`, `navigator.languages`, `window.chrome`), rotates between four desktop Chrome user agents, and strongly recommends Apify Residential proxy — Pinterest blocks datacenter IPs outright. If a session gets a blocked-looking response (HTTP 4xx, or a redirect to Pinterest's login wall), the actor discards that session and retries with a fresh browser and proxy connection, up to 3 attempts total, with exponential backoff between them. #### Does the actor extract the Trend & Reach Report? Yes — it's written to the key-value store under the key `TREND_REPORT`, with `engagement`, `colorPalette`, `reach`, `cadence`, and `imageFormats` sections inside its `analytics` object. It is absent whenever `rawData` is set to `true`. #### How many pins does the actor return per query? Up to the `limit` you set (1–10,000, default 10). It stops early once it has pushed that many unique pins, or after up to 200 scroll attempts, or after 15 consecutive scroll/pagination fetches that produce no new pins — whichever comes first. #### How do I monitor a keyword's Pinterest trend over time? Schedule a run against the same `query` on a recurring basis (via Apify Schedules), store each run's `TREND_REPORT` by its `generatedAt` timestamp, and diff the fields you care about — `colorPalette.paletteFamilies` shares, `reach.topPinnersByFollowers`, `reach.topBoardsByPinCount`, and `cadence.pinsLast30Days` — against the previous run to see what changed. #### Does this work with Claude, ChatGPT, and other AI agent frameworks? It's callable as a standard Apify Actor through the Apify API and the `apify_client` / `apify-client` SDKs, so any agent framework that can make an HTTP request or use an Apify client can trigger a run and read back both the pin dataset and the `TREND_REPORT` object as grounded context for an answer. #### How does this compare to other Pinterest scrapers? Pinterest Trend Spy (`ddevx/pinterest-trend-spy`) returns micro-niche keyword bubbles, autocomplete suggestions, an intent-scoring model, AI image prompts, and email extraction from pin content, on flat monthly pricing — as observed on the Apify Store on 2026-07-26. Pinterest Trends Scraper (`automation-lab/pinterest-trends-scraper`) returns Pinterest's own official Trends metrics (`term`, `normalizedCount`, `weeklyChange`, `seasonalityScore`) by country and does not scrape individual pins, boards, or profiles at all — also as observed on 2026-07-26. This actor is the only one of the three that returns full per-pin search results and derives its trend signal (color, reach, cadence) directly from those same results rather than from a separate intent model or Pinterest's own Trends index. #### Can I use this without managing proxies or Pinterest credentials? Yes for credentials — no Pinterest account, login, or session cookie is required or accepted anywhere in the input schema. Proxies are not fully managed for you: the actor uses whatever you configure in `proxyConfiguration`, and Apify Residential proxy is strongly recommended, since Pinterest blocks datacenter IPs and an unconfigured or datacenter-only proxy will typically return zero pins and an empty report. ### 💬 Your feedback Found a bug, or need a field this actor doesn't currently return? Let Scrapier know through the actor's Issues tab on its Apify Store listing, or via the Console's built-in support contact — reports like this directly shape what gets added next. # Actor input Schema ## `query` (type: `string`): What to search for on Pinterest. Example: query="minimalist living room" collects matching pins and builds a color/reach/cadence report for that keyword. Default is "wallpaper". ## `filter` (type: `string`): Show all pins or only video pins. Example: filter="videos" restricts the scrape (and therefore the report) to video pins only. Default is "videos". ## `limit` (type: `integer`): How many pins to scrape (1–10,000). This is also the sample size the Trend & Reach Report aggregates over — a larger limit gives more stable color/reach/cadence statistics. Example: limit=200. Default is 10. ## `topN` (type: `integer`): How many entries to list in each ranking of the report (top pinners by followers, top boards by pin count, top domains, top dominant hex colors, top pins by reactions). Example: topN=5 lists the 5 biggest of each. Default is 10. ## `rawData` (type: `boolean`): When enabled, the actor behaves like the base scraper: it streams the per-pin rows to the dataset and does NOT build the aggregated Trend & Reach Report. Example: rawData=true when you only want the raw pin records. Default is false. ## `proxyConfiguration` (type: `object`): Apify Residential proxy is strongly recommended — Pinterest blocks datacenter IPs and the run will return zero pins (and an empty report) without a residential session. ## Actor input object example ```json { "query": "wallpaper", "filter": "videos", "limit": 10, "topN": 10, "rawData": false, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `pins` (type: `string`): One item per pin (base per-pin schema + scrapedAt). ## `trendReport` (type: `string`): Run-level aggregate: engagement, colorPalette, reach, cadence, imageFormats. Absent when rawData=true. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("scrapier/pinterest-trend-reach-report").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], } } # Run the Actor and wait for it to finish run = client.actor("scrapier/pinterest-trend-reach-report").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 '{ "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call scrapier/pinterest-trend-reach-report --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=scrapier/pinterest-trend-reach-report", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/4VgcOwrghG9Hf8C2J/builds/pZB8J4VAwI7oYHwFL/openapi.json