# Pinterest User Scraper (`scrapers-hub/pinterest-user-scraper`) Actor

📌 Pinterest User Scraper extracts public Pinterest profiles—usernames, bios, followers, boards, pins, outbound links & engagement. 🔍 Export CSV/JSON for marketing research, influencer discovery, competitor analysis, and growth automation. 🚀

- **URL**: https://apify.com/scrapers-hub/pinterest-user-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Pinterest Profile Scraper: The Ultimate Professional Tool for High-Fidelity Data Extraction 🚀

Welcome to the most advanced and reliable **Pinterest Profile Scraper** available on the Apify platform! Whether you are a digital marketer looking to identify rising influencers, a market researcher analyzing consumer trends, or an e-commerce brand owner tracking competitor growth, this actor is designed to provide you with the raw power and granular data you need to succeed on one of the world's most visual and influential social media platforms. 🎨

Pinterest has evolved far beyond a simple "pinning" site; it is now a powerhouse of social commerce, visual search, and trend discovery. However, getting access to accurate, real-time data from Pinterest profiles can be a significant challenge due to the platform's sophisticated bot-detection mechanisms and complex, JavaScript-driven architecture. Our Pinterest Profile Scraper solves these challenges by leveraging residential proxies, dynamic request headers, and high-fidelity internal API access to deliver seamless results every time. 💎

#### Why Scrape Pinterest Profiles in 2026? 📊

In the modern digital landscape, data is the new oil. For Pinterest, this data represents the visual aspirations and purchasing intent of over 450 million monthly active users. Understanding the profiles behind these pins can unlock incredible value across multiple industries.

The value of Pinterest data lies in its unique nature. Unlike Instagram, where data is often focused on vanity metrics, Pinterest is a "search and discovery" engine. When a user pins something, they are expressing an intent to buy, build, or create. By scraping user profiles, you are tapping into a database of human aspirations.

##### Influencer Identification and Vetting 🌟

Finding the right creators to partner with is harder than ever. Brands need more than just a follower count; they need to know if a creator is a verified merchant, what their board structure looks like, and how often they are saving new content. Our scraper provides all of this metadata, allowing you to build a comprehensive "influence score" for any user on the platform.

##### Competitor Benchmarking and Intelligence 📈

Keep a close eye on your competitors’ Pinterest presence. Are they growing their boards regularly? What does their "About" section say? Are they a verified merchant? By tracking these metrics over time, you can reverse-engineer their content strategy and identify gaps in your own approach.

##### Market Sentiment & Trend Analysis 🔍

By scraping hundreds or thousands of profiles within specific niches (e.g., "Boho Home Decor" or "Sustainable Fashion"), you can analyze common keywords in bios, identify linked websites, and understand what the community is focusing on. This is invaluable for product development and marketing messaging.

##### Lead Generation for Agencies and B2B 📥

For agencies and B2B services, identifying business profiles with verified websites and large follower bases can be a goldmine for outreach. Our scraper identifies if a profile is a "partner" or a "verified merchant," allowing you to filter for high-value prospects.


#### input 

```json
usernames = [
        "wholefoods",
]



````

#### output

```json
[
    {
        "username": "wholefoods",
        "node_id": "VXNlcjoxMDI1Mjc0NjY0MjUyODY4NTc=",
        "full_name": "Whole Foods Market",
        "seo_canonical_domain": "www.pinterest.com",
        "follower_count": 498609,
        "image_medium_url": "https://i.pinimg.com/75x75_RS/0f/ef/f4/0feff4f325c0d60bd1b64abcfe438402.jpg",
        "is_partner": true,
        "indexed": true,
        "id": "102527466425286857",
        "is_verified_merchant": false,
        "profile_cover": {
            "source": "all_user_pins",
            "type": "profilecoversource"
        },
        "last_pin_save_time": "Thu, 15 Jan 2026 19:20:09 +0000",
        "domain_verified": true,
        "is_ads_only_profile": false,
        "verified_identity": {
            "name": "wholefoods",
            "verified": true
        },
        "eligible_profile_tabs": [
            {
                "id": "15730351616191",
                "type": "profiletab",
                "tab_type": 1,
                "name": "Created",
                "is_default": false
            },
            {
                "id": "15730351616527",
                "type": "profiletab",
                "tab_type": 0,
                "name": "Saved",
                "is_default": true
            }
        ],
        "seo_description": "See what Whole Foods Market (wholefoods) has discovered on Pinterest, the world's biggest collection of ideas.",
        "website_url": "http://www.wholefoodsmarket.com/",
        "is_inspirational_merchant": false,
        "is_private_profile": false,
        "image_xlarge_url": "https://i.pinimg.com/280x280_RS/0f/ef/f4/0feff4f325c0d60bd1b64abcfe438402.jpg",
        "is_primary_website_verified": true,
        "is_gco_account": false,
        "type": "user",
        "created_at": "Thu, 31 May 2018 04:28:16 +0000",
        "pin_count": 3975,
        "seo_title": "Whole Foods Market (wholefoods) - Profile | Pinterest",
        "domain_url": "www.wholefoodsmarket.com",
        "first_name": "Whole Foods Market",
        "board_count": 41,
        "about": "We’re the place to discover new flavors, new favorites and new ideas, whatever those might be. Whatever Makes You Whole.",
        "partner": {
            "node_id": "UGFydG5lcjoxMDI1Mjc0NjY0MjUyODY4NTc="
        },
        "following_count": 772
    }
]

```

#### Unparalleled Feature Set for Professionals 🛠️

Our scraper isn't just a basic tool; it's a comprehensive extraction engine built for production-grade environments. Here’s what makes it stand out:

##### 1. High-Fidelity Data Extraction 🧬

We don't just scrape the surface. We dive deep into Pinterest's internal data structures to extract fields that are often hidden from standard scrapers. This includes technical metadata like `node_id`, `verified_identity`, and `is_inspirational_merchant`. These data points provide a 360-degree view of the user's status and authority on the platform.

##### 2. Advanced Proxy Management with Residential IPs 🌍

To ensure maximum reliability and prevent IP bans, this actor is pre-configured to utilize **Apify's Residential Proxies**. Pinterest uses sophisticated rate-limiting and browser fingerprinting. By using residential proxies, our scraper mimics real user behavior from diverse geographical locations, making your scraping activities virtually indistinguishable from organic traffic.

##### 3. Sophisticated Anti-Blocking Mechanisms 🛡️

We use dynamic timestamps, rotating headers, and specialized cookies to ensure that your requests look like legitimate browser sessions. Our system handles common issues like "403 Forbidden" and "429 Too Many Requests" by intelligently managing the request lifecycle and mimicking browser-level behavior (like the `x-requested-with` and `referer` headers).

##### 4. Blazing Fast Asynchronous Execution ⚡

Built on a foundation of asynchronous Python logic (`asyncio`), the scraper can process long lists of usernames with incredible efficiency. It doesn't wait for one request to finish before starting the next one, allowing you to scale your data collection efforts without hitting bottlenecks.

##### 5. Seamless Data Integration 📥

The data is automatically formatted into clean, structured JSON objects and pushed to the Apify Dataset. This makes it ready for immediate export to Excel, CSV, or direct integration into your own database or CRM via the Apify API.

#### Deep Dive: Comprehensive Data Fields 💎

When you run this Pinterest User Scraper, you aren't just getting a name and a count. You get a full digital snapshot of the profile. Here is a detailed breakdown of the data points we capture:

##### Basic Identity & Branding 👤

- **`username`**: The unique handle of the Pinterest user.
- **`full_name`**: The display name used by the account.
- **`first_name`**: The user's first name, useful for personalizing outreach.
- **`about`**: The full bio or "about" section where users describe their brand or personality.
- **`id`**: The internal Pinterest unique identifier (numeric).
- **`node_id`**: Global GraphQL node ID used for more advanced integrations.

##### Growth & Engagement Metrics 📉

- **`follower_count`**: The total number of users following this profile. High follower counts indicate authority.
- **`following_count`**: The total number of accounts this user follows.
- **`pin_count`**: Total number of pins saved. This indicates the user's activity level.
- **`board_count`**: Total number of public boards. Indicates how well-organized their content is.
- **`last_pin_save_time`**: A timestamp indicating the last time this user saved a pin. Use this to filter out dead accounts.

##### Visual Assets & Media 🖼️

- **`image_medium_url`**: URL for the standard-size profile picture.
- **`image_xlarge_url`**: URL for high-resolution profile images.
- **`profile_cover`**: Data regarding the user's cover banner, providing insight into their branding aesthetics.

##### Verification & Professional Status ✅

This is where our scraper truly shines. We extract professional metadata that's crucial for B2B and e-commerce use cases:

- **`is_verified_merchant`**: Indicates if the user is part of the Pinterest Verified Merchant Program.
- **`domain_verified`**: Whether the website linked in the profile has been officially claimed and verified by Pinterest.
- **`is_partner`**: Indicates an official business partnership with Pinterest.
- **`verified_identity`**: Granular details about the level and type of verification.
- **`is_inspirational_merchant`**: A unique Pinterest flag for high-impact, high-growth sellers.
- **`is_ads_only_profile`**: Indicates if the account is primarily used for running advertisements.

##### SEO & Discovery Metadata 🔍

- **`seo_title`**: The specific title tag Pinterest generates for search engines.
- **`seo_description`**: The meta description used for SEO indexing. This often contains the most relevant keywords for that profile.
- **`website_url`**: The direct link to the user's external website (blog, store, etc.).

#### How to Use the Pinterest Profile Scraper 🚀

Getting started is designed to be effortless. You don't need to be a developer to get world-class data.

##### Step 1: Input Preparation 📝

In the Apify Console, navigate to the "Input" tab. You will see a field for "Usernames." You can enter usernames in several ways:

1. **Manual Entry**: Type usernames directly into the array.
2. **Bulk Upload**: Copy and paste a large list from a spreadsheet or text file.
3. **JSON Input**: Provide a structured JSON object if you are calling the actor from another script.

Example input:

```json
{
  "usernames": ["wholefoods", "crateandbarrel", "anthropologie", "westelm"]
}
```

##### Step 2: Proxy Configuration 🛡️

We strongly recommend using **Residential Proxies**. While the actor will work with data center proxies, the success rate on a platform like Pinterest is significantly higher with residential IPs. By default, the actor is set to use Apify's residential proxy pool.

##### Step 3: Run and Monitor 📺

Click the "Start" button. You can monitor the progress in the "Logs" tab. You'll see real-time updates as the scraper successfully processes each profile and pushes the data to the dataset.

##### Step 4: Export Your Data 📥

Once the run is complete, head over to the "Dataset" tab. Here you can download your data in various formats:

- **Excel/CSV**: For traditional analysis.
- **JSON**: For developers.
- **HTML Table**: For a quick visual overview.

#### Strategic Use Cases for Modern Businesses 💼

##### E-commerce and Retail Brands 🛒

If you are an e-commerce brand, Pinterest is likely a major source of traffic for you. Using this scraper, you can:

- **Monitor Competitors**: Track which competitors are getting "Verified Merchant" status and what keywords they use in their bios to outrank you in Pinterest search.
- **Find Content Partners**: Search for profiles with high `pin_count` and `follower_count` in your niche to identify potential affiliate or brand partners.
- **Analyze Trends**: Use the `seo_description` of top-performing profiles to understand what keywords are currently trending in your category.

##### Marketing Agencies and Consultants 🤝

Providing data-backed insights to your clients is a massive competitive advantage. You can use this scraper to:

- **Audit Client Profiles**: Compare a client's metrics ($followers$, $pins$, $boards$) against industry benchmarks.
- **Lead Generation**: Identify business profiles that haven't claimed their domain (`domain_verified` = false) and offer your services to help them optimize their Pinterest presence.
- **Influencer Vetting**: When building an influencer campaign, use our data to verify that the creators actually have the reach they claim.

##### Content Creators and Bloggers ✍️

Understanding what "big" creator profiles look like can help you optimize your own.

- **SEO Optimization**: Analyze the `seo_title` and `seo_description` of top creators to see how they structure their metadata for maximum discoverability.
- **Content Strategy**: See how many boards successful creators maintain to get a feel for how to organize your own content.

#### Comparison: Our Scraper vs. The Official Pinterest API ⚖️

Many users ask why they should use a scraper instead of the official API. The answer lies in accessibility, speed, and depth of data.

| Feature | Official Pinterest API | Pinterest Profile Scraper Actor |
| :--- | :--- | :--- |
| **Barrier to Entry** | High (Requires App Approval and Review) | None (Start immediately) |
| **Rate Limits** | Very Restrictive | Scalable (via Proxies) |
| **Data Richness** | Limited to public "safe" endpoints | Full access to internal profile metadata |
| **Implementation** | Complex (OAuth, Token Management) | Simple (Input names, get data) |
| **Cost** | Often variable based on tiers | Fixed cost based on Apify usage |

#### Detailed Technical Explanation 🧠

This actor works by simulating a high-precision browser request to Pinterest's internal "Resource" API.

##### Handling the Internal API

Pinterest uses a specific endpoint (`UserResource/get`) to fetch profile data. This endpoint requires several critical components to function correctly:

1. **Context Object**: A JSON object that describes the requesting environment.
2. **Options Object**: Contains the target `username` and the `field_set_key` (typically set to `unauth_profile` for public scraping).
3. **CSRF Tokens**: Security tokens provided by Pinterest to prevent cross-site request forgery. Our scraper automatically manages these tokens for you.

##### The Role of Residential Proxies

Data center proxies (the common, cheap type) are often blocked by Pinterest because they easy to identify as belonging to a server farm. Residential proxies, however, provide IP addresses tied to real household devices. By rotating through these, our scraper avoids "triggering" Pinterest's rate-limiting logic, allowing for reliable, high-volume data collection.

#### Best Practices for Large-Scale Extraction 💡

To maximize the efficiency and reliability of your scraping runs, follow these professional tips:

1. **Batching**: Don't run 1,000 separate actor runs for 1,000 usernames. Instead, run a single actor with a list of 1,000 usernames. This is more cost-effective and allows the actor to manage the proxy rotation more efficiently.
2. **Scheduling**: Use Apify's "Schedule" feature to run your scraper daily or weekly. This allows you to track metrics like `follower_count` and `pin_count` over time, giving you insight into growth trends.
3. **Integrating Webhooks**: Set up a webhook to send the data to a Google Sheet automatically every time the actor finishes. This creates a "set it and forget it" data pipeline.
4. **Data Security**: Always ensure you are storing and using the extracted data in compliance with your local laws (such as GDPR or CCPA).

#### Potential Limitations & Troubleshooting ❓

While our scraper is highly robust, there are a few things to keep in mind:

- **Private Profiles**: Some Pinterest users set their profiles to "Private". No scraper can access non-public data from these accounts.
- **Temporary Blocks**: If you see a series of "403 Forbidden" errors in your logs, it usually means your proxy pool is being heavily tested. The scraper will automatically attempt to rotate to a new IP, but if the issue persists, consider checking your Apify proxy settings.
- **Username Accuracy**: Ensure that the usernames you provide are exact handles (e.g., `wholefoods`, not `Whole Foods Market`).

##### Frequently Asked Questions (FAQ)

**Q: Do I need a Pinterest account to use this?**
A: No. Our scraper works by accessing publicly available data, so no login or account is required on your part.

**Q: How many profiles can I scrape per minute?**
A: This depends on your proxy capacity, but typically you can process several hundred profiles per minute without issue.

**Q: Is there any limit on the number of usernames in a single run?**
A: There is no hard limit from the actor's side. However, for extremely large lists (e.g., 50,000+), we recommend breaking them into smaller batches of 5,000 to 10,000 for better management.

#### Integrating with Your Tech Stack 🔄

One of the greatest strengths of our Pinterest Scraper is its ability to live within your existing ecosystem.

##### API First Approach

Since the actor is hosted on Apify, you can start, stop, and retrieve data from it using a simple REST API. This means you can build your own custom dashboard that shows Pinterest follower growth by calling our actor in the background.

##### Webhooks and Automation

- **Slack/Discord**: Receive a notification when a major competitor's profile is scraped.
- **Zapier/Make**: Automatically send any profile with over 100k followers to your "Lead Generation" CRM.
- **Cloud Storage**: Save your results directly to AWS S3 or Google Cloud Storage for long-term data archival.

#### Continuous Updates and Support 🛠️

We are committed to maintaining this as the #1 Pinterest Profile Scraper. We continuously monitor Pinterest's frontend changes and update the actor to ensure it never breaks.

##### Roadmap for Future Features:

- **Board Extraction**: Detailed metadata for every board on a profile.
- **Pin Sentiment Analysis**: Using AI to analyze the descriptions of a user's pins.
- **Visual Similarity Search**: Finding profiles that "look" like a target profile.

#### Conclusion: Data-Driven Pinterest Success 🏆

The difference between successful brands on Pinterest and those that struggle is often just a matter of data. By having access to current, accurate, and deep profile metadata, you can make informed decisions that drive real business results.

Stop guessing. Stop wrestling with complicated APIs. Start using the professional's choice for Pinterest data extraction. Run the **Pinterest Profile Scraper** today and unlock the true potential of your visual social strategy. 👑

***

**SEO Optimized Tags**: Pinterest Scraper, Pinterest Data, Social Media Mining, Pinterest Influencer Analytics, Competitor Research Tool, Pinterest Verified Merchant Data, Apify Scraping Actor, Pinterest Profile Metadata, Lead Generation Pinterest, Web Scraping Python, Business Intelligence Pinterest.

***

#### Technical Specifications Summary

- **Runtime**: Python 3.11+
- **Architecture**: Asynchronous I/O (`httpx` / `requests` / `asyncio`)
- **Proxy**: Full Residential Support
- **Output**: JSON, CSV, XLSX, XML, RSS
- **Storage**: Apify Key-Value Store & Dataset

***

Copyright © 2026. Built with ❤️ by the Scraping Experts for the Global Marketing Community.

***

\[Disclaimer: This tool is intended for ethical data collection purposes. Users must comply with Pinterest's Terms of Service and all applicable data privacy regulations.]

***

##### Detailed Extraction Guide (Expanded) 📚

To reach the depth of insight required for modern data science, we've included an even more detailed look at how to interpret the data you'll receive from this scraper.

###### Interpreting 'Last Pin Save Time'

This field is more than just a timestamp. It is the heartbeat of a Pinterest profile. A profile with 1M followers but a `last_pin_save_time` from 2022 is a "ghost profile." Marketing to these users or partnering with these creators is often a waste of resources. By filtering for active users (saved within the last 7 days), you ensure your marketing spend is going toward engaged audiences.

###### The Power of 'SEO Description'

Pinterest generates this description based on the user's most active boards and most frequent keywords. If you are trying to optimize your own profile, don't just guess which keywords to use. Scrape the top 50 creators in your niche, aggregate their `seo_description` fields, and use a word-frequency analysis to find the "hidden" keywords that Pinterest's algorithm values most.

###### Verified Merchant vs Verified Identity

Understanding the difference is key. A `verified_merchant` has a direct connection to a product feed and is actively selling. A `verified_identity` might just be a celebrity or a high-profile brand. If your goal is e-commerce partnerships, focus exclusively on the `is_verified_merchant` tag. It's the gold standard for commercial intent on Pinterest.

***

##### Troubleshooting Guide (Deep Dive) 🔧

**Unexpected Empty Fields**: Occasionaly, Pinterest may return `null` for certain secondary fields like `about` or `website_url`. This is typically because the user has simply not filled out those parts of their profile. Our scraper is designed to handle these null values gracefully without crashing the run.

**Authentication Errors**: If you find that every single request is failing, it's possible that Pinterest has temporarily blacklisted a specific proxy range. Try switching your proxy settings from "Automatic" to a specific geographic region (e.g., "United States") within the Apify proxy configuration to refresh your IP pool.

**Dataset Not Updating**: Ensure that you are looking at the "Dataset" associated with the *current* run. Every time you click "Start", a new dataset is created. If you have an automation set up, make sure it's pointing to the most recent run ID.

***

##### Final Thoughts on Scalability 🚀

As your business grows, so will your data needs. This actor is designed to grow with you. Whether you're checking 5 usernames once a month or 500,000 usernames every single day, the underlying architecture remains stable and cost-effective. We invite you to test the limits of what's possible with Pinterest data.

Thank you for choosing the most powerful Pinterest Profile Scraper on the market. We can't wait to see what you build with it!

***

\[End of Documentation]

***

##### Appendices

###### Appendix A: Sample JSON Output Details

Every item in your dataset will follow a predictable structure. This allows you to write automated scripts (in Python, R, or Node.js) that process the data instantly upon completion.

###### Appendix B: Glossary of Terms

- **Actor**: A cloud program running on the Apify platform.
- **Dataset**: A permanent storage for the results of your scraper.
- **Proxy**: A middle-man server that hides your real IP address to prevent blocking.
- **Residential Proxy**: A proxy that uses an IP address provided by an ISP to a homeowner.

***

##### Support Contact Info

If you need any custom modifications or have a high-volume enterprise requirement, please contact us through the Apify platform's support channels or directly via the "Issues" tab on this Actor. We typically respond within 24 hours.

***

\[Page Limit Reached - Document End]

# Actor input Schema

## `usernames` (type: `array`):

List of Pinterest usernames to scrape.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "usernames": [
    "wholefoods"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "usernames": [
        "wholefoods"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/pinterest-user-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 = {
    "usernames": ["wholefoods"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/pinterest-user-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 '{
  "usernames": [
    "wholefoods"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapers-hub/pinterest-user-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest User Scraper",
        "description": "📌 Pinterest User Scraper extracts public Pinterest profiles—usernames, bios, followers, boards, pins, outbound links & engagement. 🔍 Export CSV/JSON for marketing research, influencer discovery, competitor analysis, and growth automation. 🚀",
        "version": "0.1",
        "x-build-id": "xWSTJhdLiNAfEKFdo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~pinterest-user-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-pinterest-user-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/scrapers-hub~pinterest-user-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-pinterest-user-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/scrapers-hub~pinterest-user-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-pinterest-user-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "List of Pinterest usernames to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
