# Pinterest Pins Scraper — Pin Details & Media (`khadinakbar/pinterest-pins-scraper`) Actor Extract clean, detailed records from exact public Pinterest Pin URLs. Return image and video media, captions, saves, boards, destination links, and creator data in a flat, API-ready schema. - **URL**: https://apify.com/khadinakbar/pinterest-pins-scraper.md - **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community) - **Categories:** Social media, E-commerce, MCP servers - **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $5.00 / 1,000 detailed pinterest pins 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 ### What does Pinterest Pins Scraper do? **Pinterest Pins Scraper turns exact public Pinterest Pin links into clean, detailed, one-row-per-Pin records.** Use it when a workflow already has Pin URLs and needs dependable media URLs, captions, engagement, board, destination-link, and creator fields without a huge nested response. Paste one or many public URLs from [Pinterest](https://www.pinterest.com/), run the Actor, then download the dataset or call it from the Apify API. This Actor is deliberately focused on **Pin details**, not keyword search, board crawling, or profile scraping. That makes it a good enrichment step after a search, outreach, content-research, or ecommerce workflow has identified the specific Pins that matter. It supports JSON, CSV, Excel, HTML, webhooks, schedules, integrations, and API access through the Apify platform. The primary path uses a managed public-data provider. If that path cannot return a usable public record, the Actor makes a controlled serial browser attempt against the public Pin page. No Pinterest login, cookies, or personal account credentials are requested. ### Why use a Pinterest Pin details scraper? Pinterest is useful for content inspiration, affiliate and ecommerce research, visual trend analysis, and keeping a known-Pin database fresh. Copying Pin details by hand becomes slow as soon as a list grows past a few URLs. This Actor gives data and growth teams a stable contract they can feed into a spreadsheet, warehouse, CRM, LLM workflow, or a downstream image-analysis step. Common uses include: - Enriching a curated Pin list with descriptions, media, and destination domains. - Auditing which boards and creators publish content in a niche. - Building visual-content datasets for competitive or trend research. - Checking whether known Pins link to a product page, article, recipe, or other destination. - Adding a deterministic Pinterest step to Make, Zapier, n8n, or a custom API workflow. ### How to scrape Pinterest Pin details 1. Open the **Input** tab and paste one public Pinterest Pin URL per line. 2. Leave **Maximum Pins to Process** at the suggested small batch for a smoke test, or raise it up to 100. 3. Start the run and wait for the terminal `OUTPUT` record to report `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, or `INVALID_INPUT`. 4. Open the Dataset to inspect the validated Pin records. 5. Download JSON, CSV, Excel, or HTML, or consume the dataset URL from an automation. Use links such as `https://www.pinterest.com/pin/1125266656923168531/`. The Actor also accepts `pin.it` short links. Pinterest profile pages, boards, searches, and private or login-only content are intentionally out of scope because they are not individual Pins. ### Input | Field | Required | Description | | --------- | -------- | --------------------------------------------------------------------- | | `pinUrls` | Yes | A list of exact public Pinterest Pin URLs or `pin.it` short links. | | `maxPins` | No | A 1–100 safety limit applied after URL deduplication. Defaults to 10. | Example input: ```json { "pinUrls": ["https://www.pinterest.com/pin/1125266656923168531/"], "maxPins": 10 } ```` ### Output: clean Pinterest Pin records Each successful dataset item follows a flat, stable schema. Fields that Pinterest does not expose are returned as `null`, while `hashtags` is always an array. The Actor validates every record before writing it, so a billed dataset row always has a Pin ID and at least one usable image or video URL. ```json { "pinId": "1125266656923168531", "pinUrl": "https://www.pinterest.com/pin/1125266656923168531/", "title": "Summer pasta recipe", "description": "A quick weeknight pasta.", "imageUrl": "https://i.pinimg.com/originals/example.jpg", "videoUrl": null, "isVideo": false, "saveCount": 1234, "link": "https://example.com/pasta", "sourceDomain": "example.com", "boardName": "Dinner ideas", "pinnerUsername": "example", "hashtags": ["#pasta", "#dinner"], "scrapedAt": "2026-07-15T08:00:00.000Z", "pinSource": "scrapecreators" } ``` You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. The `OUTPUT` key contains terminal status and warnings; `RUN_SUMMARY` gives operational counts that are handy for automation retries and monitoring. | Field group | Main fields | | ----------- | --------------------------------------------------------------------- | | Identity | `pinId`, `pinUrl`, `sourceUrl` | | Content | `title`, `description`, `hashtags`, `createdAt` | | Media | `imageUrl`, `imageWidth`, `imageHeight`, `videoUrl`, `isVideo` | | Engagement | `saveCount`, `commentCount`, `shareCount` | | Context | `boardName`, `boardUrl`, `link`, `sourceDomain` | | Creator | `pinnerUsername`, `pinnerName`, `pinnerFollowers`, `pinnerProfileUrl` | | Provenance | `scrapedAt`, `pinSource` | ### API examples Run the Actor from JavaScript with your Apify API token: ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('khadinakbar/pinterest-pins-scraper').call({ pinUrls: ['https://www.pinterest.com/pin/1125266656923168531/'], maxPins: 10, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` The same workflow in Python: ```python from apify_client import ApifyClient import os client = ApifyClient(os.environ["APIFY_TOKEN"]) run = client.actor("khadinakbar/pinterest-pins-scraper").call(run_input={ "pinUrls": ["https://www.pinterest.com/pin/1125266656923168531/"], "maxPins": 10, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["pinUrl"], item["imageUrl"]) ``` ### How much does it cost to scrape Pinterest Pins? The Actor uses **Pay per event + usage**. It charges **$0.005 for each detailed Pin record** that passes validation and is written to the dataset, plus a **$0.00005 run-start charge**. Underlying Apify platform usage is passed through as well, so browser fallback, memory, and runtime can add a small usage amount. The actor does not charge for invalid URLs, empty source responses, duplicate Pins, failed provider calls, or records that fail validation. A 50-Pin run therefore has event charges of about **$0.25005**, before any platform usage. Use `maxPins` to keep a batch within your intended budget; the SDK respects Apify's maximum run charge guard before persisting another billable record. ### Tips for reliable runs Start with one known public Pin to verify your downstream field mapping. Use canonical `pinterest.com/pin/...` URLs when possible; short links are supported but may require one extra resolution step. Keep the actor focused on exact URLs—use a dedicated Pinterest search or board actor first if you need discovery at scale. Treat a `VALID_EMPTY` outcome as a truthful no-data result rather than a successful extraction, and inspect `OUTPUT.warnings` before automatically retrying `PARTIAL` runs. ### Related Apify Actors - [Pinterest Scraper](https://apify.com/khadinakbar/pinterest-scraper) for broader Pinterest discovery. - [Instagram Reels Scraper](https://apify.com/khadinakbar/instagram-reels-scraper) for short-form visual content research. - [Instagram Comments Scraper](https://apify.com/khadinakbar/instagram-comments-scraper) for engagement analysis. - [TikTok Comments Scraper](https://apify.com/khadinakbar/tiktok-comments-scraper) for public short-video discussion data. - [TikTok Sound Scraper](https://apify.com/khadinakbar/tiktok-sound-scraper) for sound and video-trend research. - [YouTube Transcript Extractor](https://apify.com/khadinakbar/youtube-transcript-extractor) for video content analysis. - [Facebook Marketplace Scraper](https://apify.com/khadinakbar/facebook-marketplace-scraper) for public product research. - [LinkedIn Post Search Scraper](https://apify.com/khadinakbar/linkedin-post-search-scraper) for social-content discovery. ### FAQ, responsible use, and support #### Is Pinterest Pins Scraper legal to use? You are responsible for ensuring your use complies with applicable law, Pinterest's terms, rate limits, intellectual-property rights, and privacy obligations. Only process public URLs you are authorized to use. Do not use the output to collect or infer sensitive personal data, bypass access controls, or redistribute media in a way that infringes the rights of creators or publishers. #### Why is a field `null`? Pinterest does not show every field on every public Pin. Rather than guessing, the Actor keeps the stable key and returns `null` when the source has no reliable public value. #### Why did my run return `PARTIAL`? `PARTIAL` means at least one validated record was stored, but another URL was invalid, empty, unavailable, duplicate, or stopped by the run charge cap. Check `OUTPUT` and `RUN_SUMMARY` for the concrete counts and retry only the unresolved input URLs. For help, feature requests, or a custom Pinterest workflow, use the Actor's **Issues** tab on Apify. Include a public example URL and the desired output fields, but never include passwords, session cookies, or API tokens. # Actor input Schema ## `pinUrls` (type: `array`): Use this when you already know the public Pinterest Pins you want to enrich. Paste one exact Pinterest Pin URL per line, including regular pinterest.com/pin links or pin.it short links. The actor follows the public Pin and returns media, description, saves, board, and creator data when available. Profiles, boards, search URLs, and private content are rejected so each output row remains a single Pin record. ## `maxPins` (type: `integer`): Use this to cap a run when you paste more URLs than you want to process today. The actor deduplicates Pin URLs before applying this limit, which avoids paying twice for the same Pin. Set a small number for a quick smoke test or a larger number for a batch enrichment job. The maximum is 100 Pins per run to keep browser fallback costs predictable. ## Actor input object example ```json { "pinUrls": [ "https://www.pinterest.com/pin/1125266656923168531/" ], "maxPins": 10 } ``` # Actor output Schema ## `results` (type: `string`): Flat, validated Pinterest Pin records. Download as JSON, CSV, Excel, HTML, or fetch through the Apify API. ## `output` (type: `string`): Terminal status, counts, pricing event, provider path, and user-safe warnings for the run. ## `runSummary` (type: `string`): Operational counts and source health for observability and workflow automation. # 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 = { "pinUrls": [ "https://www.pinterest.com/pin/1125266656923168531/" ] }; // Run the Actor and wait for it to finish const run = await client.actor("khadinakbar/pinterest-pins-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "pinUrls": ["https://www.pinterest.com/pin/1125266656923168531/"] } # Run the Actor and wait for it to finish run = client.actor("khadinakbar/pinterest-pins-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 '{ "pinUrls": [ "https://www.pinterest.com/pin/1125266656923168531/" ] }' | apify call khadinakbar/pinterest-pins-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=khadinakbar/pinterest-pins-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Pinterest Pins Scraper — Pin Details & Media", "description": "Extract clean, detailed records from exact public Pinterest Pin URLs. Return image and video media, captions, saves, boards, destination links, and creator data in a flat, API-ready schema.", "version": "1.0", "x-build-id": "dS5lJgrG1mAejV0tv" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/khadinakbar~pinterest-pins-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-khadinakbar-pinterest-pins-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/khadinakbar~pinterest-pins-scraper/runs": { "post": { "operationId": "runs-sync-khadinakbar-pinterest-pins-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/khadinakbar~pinterest-pins-scraper/run-sync": { "post": { "operationId": "run-sync-khadinakbar-pinterest-pins-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", "properties": { "pinUrls": { "title": "Pinterest Pin URLs", "minItems": 1, "maxItems": 100, "type": "array", "description": "Use this when you already know the public Pinterest Pins you want to enrich. Paste one exact Pinterest Pin URL per line, including regular pinterest.com/pin links or pin.it short links. The actor follows the public Pin and returns media, description, saves, board, and creator data when available. Profiles, boards, search URLs, and private content are rejected so each output row remains a single Pin record.", "items": { "type": "string" }, "default": [ "https://www.pinterest.com/pin/1125266656923168531/" ] }, "maxPins": { "title": "Maximum Pins to Process", "minimum": 1, "maximum": 100, "type": "integer", "description": "Use this to cap a run when you paste more URLs than you want to process today. The actor deduplicates Pin URLs before applying this limit, which avoids paying twice for the same Pin. Set a small number for a quick smoke test or a larger number for a batch enrichment job. The maximum is 100 Pins per run to keep browser fallback costs predictable.", "default": 10 } } }, "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 } } } } } } } } } } ```