# Pinterest Profile Scraper - Creator Analytics (`benthepythondev/pinterest-profile-scraper`) Actor

Scrape public Pinterest profiles with creator names, bios, websites, follower and following counts, pins, boards, verification status and profile images.

- **URL**: https://apify.com/benthepythondev/pinterest-profile-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 - Creator Analytics and Public Profile Data

Collect structured information from public Pinterest creator and business profiles without copying profile pages by hand. Pinterest Profile Scraper accepts usernames, @handles, or profile URLs and returns the public name, bio, website, follower and following counts, pin and board counts, verification status, profile image, cover image, and account metadata.

The Actor is built for creator research, influencer discovery, brand monitoring, partnership qualification, market analysis, and repeatable social-media datasets. Results are stored in the Apify default dataset and can be exported to JSON, CSV, Excel, XML, or RSS. You can also call the Actor through the Apify API or connect runs to Make, Zapier, n8n, webhooks, Google Sheets, Airtable, or your own database.

### What can Pinterest Profile Scraper collect?

- Public Pinterest username and account ID.
- Display name and public biography.
- Claimed website URL when available.
- Profile and cover image URLs.
- Follower and following counts.
- Published pin and board counts.
- Account creation timestamp when Pinterest exposes it.
- Verified identity and verified merchant indicators.
- Partner, private-profile, and domain-verification flags.
- Canonical Pinterest profile URL.
- A UTC scrape timestamp for historical comparisons.

No Pinterest login or user account cookie is required. The Actor processes only the public profiles you supply and fails clearly when none of them can be retrieved.

### Who is it for?

#### Influencer and creator research

Build a comparable table of public Pinterest creators for a niche. Use `followers`, `pins`, `boards`, `about`, and `website_url` as starting points for a human qualification process. A follower count alone does not prove audience quality or partnership fit, so combine the output with content review and your own due diligence.

#### Brand and competitor monitoring

Track public profile metrics for brands, publishers, retailers, and competitors. Scheduled runs can reveal changes in follower counts, profile copy, website links, verification, and publishing volume.

#### Agency prospect research

Agencies can enrich a manually selected list of Pinterest accounts with public profile information. Website and domain-verification fields can help route profiles into research segments, but the Actor does not infer email addresses or consent to contact.

#### Dataset enrichment

If you already have Pinterest usernames from search results, campaign reports, or customer-provided lists, use this Actor to append current profile-level fields. Pair it with Pinterest Search Scraper when you need both discovery and profile enrichment.

#### Academic and market analysis

Create repeatable snapshots of public Pinterest profiles for aggregate research. Store the scrape timestamp and document your sampling method so later comparisons remain interpretable.

### Input

Provide one or more usernames, handles, or full Pinterest profile URLs.

```json
{
  "usernames": [
    "pinterest",
    "https://www.pinterest.com/etsy/",
    "@wholefoods"
  ],
  "maxProfiles": 10
}
````

#### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `usernames` | array of strings | Pinterest usernames, @handles, or full profile URLs. Default: `pinterest`. |
| `maxProfiles` | integer | Maximum supplied profiles processed in one run. Default: 10. Maximum: 100. |

Duplicate handles are processed once. URL prefixes, a trailing slash, and a leading `@` are normalized automatically.

### Output

Each dataset item represents one public Pinterest profile.

```json
{
  "id": "1234567890",
  "username": "examplecreator",
  "full_name": "Example Creator",
  "about": "Practical design ideas for small spaces.",
  "profile_url": "https://www.pinterest.com/examplecreator/",
  "website_url": "https://example.com",
  "profile_image_url": "https://i.pinimg.com/280x280_RS/example.jpg",
  "cover_image_url": "https://i.pinimg.com/originals/cover.jpg",
  "followers": 128400,
  "following": 612,
  "pins": 9840,
  "boards": 146,
  "created_at": "2014-03-18T10:22:31",
  "is_verified": true,
  "is_verified_merchant": false,
  "is_partner": false,
  "is_private": false,
  "domain_verified": true,
  "scraped_at": "2026-07-11T10:00:00+00:00"
}
```

Pinterest does not expose every field for every profile. Personal accounts, merchants, creators, partners, older accounts, and region-specific pages may contain different metadata. The Actor returns missing fields as `null` or `false` according to the public source; it does not fabricate values.

### Pricing

Pinterest Profile Scraper uses pay per event pricing:

- Actor start: $0.00005 per run.
- Result: $0.003 per profile saved to the default dataset.

A successful run with 10 profiles costs about $0.03005 in Actor charges, excluding ordinary Apify platform usage. A 100-profile run costs about $0.30005. You pay only for profiles actually saved. Invalid, unavailable, or private profiles that produce no row are not billed as dataset results.

### Run through the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/benthepythondev~pinterest-profile-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["pinterest","etsy"],"maxProfiles":2}'
```

Poll the returned run ID until it succeeds, then read the default dataset URL from the run object. For production integrations, keep your Apify token in a secret manager rather than hardcoding it in source control.

### Repeat-use workflows

#### Weekly profile monitor

Create an Apify schedule for a fixed list of profiles. Send each dataset to a database and compare `followers`, `following`, `pins`, `boards`, `about`, `website_url`, and verification flags with the previous snapshot.

#### Search-to-profile pipeline

Run Pinterest Search Scraper for target keywords, collect unique `pinner_username` values, review them, and pass the selected handles to this Actor. This separates broad discovery from profile-level enrichment and avoids repeatedly processing the same account.

#### Creator research sheet

Connect the dataset to Google Sheets through Make or Zapier. Add your own manual columns for niche fit, content quality, location, contact status, and campaign notes. Public metrics should support, not replace, human judgment.

#### Change alerts

Use n8n or a webhook to flag large follower-count changes, a new website URL, a rewritten bio, or a newly verified profile. Add thresholds to avoid alerts for ordinary small fluctuations.

### Reliability and technical approach

The Actor loads each public profile with a Chrome-compatible HTTP client and reads Pinterest's embedded server-side profile state. This is faster and less expensive than running a full browser. Requests use bounded retries and timeouts. Handles are normalized and deduplicated before collection. A run with zero valid profiles fails explicitly instead of appearing successful with an empty dataset, which makes schedules and alerts easier to monitor.

The implementation does not require residential proxies, third-party unblocker credits, or a Pinterest API key. Pinterest can change its public pages, so production users should monitor run health. When reporting a failure, include the Apify run ID and an example public handle that can be reproduced.

### Data quality notes

- Follower, following, pin, and board counts reflect the public values available at scrape time.
- A verified or merchant flag should not be treated as legal identity verification for your own compliance process.
- A website URL may redirect or change after collection; validate it before using it operationally.
- Private, deleted, restricted, misspelled, or unavailable profiles may be skipped.
- Account metrics can vary between page versions or Pinterest experiments.

### Responsible use

Use this Actor only for lawful collection and processing of public data. Follow Pinterest's terms, privacy and marketing laws, intellectual-property rules, and your organization's compliance requirements. Do not use the output for harassment, sensitive profiling, automated spam, identity resolution, or outreach without a lawful basis. The presence of a public website or profile does not itself establish consent for commercial contact.

Pinterest is a trademark of its owner. This independent Actor is not affiliated with, sponsored by, or endorsed by Pinterest.

### Frequently asked questions

#### Can it scrape private profiles?

No. It is intended for publicly accessible profiles and does not log into Pinterest or bypass account privacy controls.

#### Does it collect pins from each profile?

This Actor focuses on profile-level fields. Use Pinterest Search Scraper for pin discovery. A dedicated board or profile-pin workflow can be evaluated separately when a stable public data path exists.

#### Can I submit full URLs?

Yes. Full profile URLs, usernames, and @handles are normalized into Pinterest usernames.

#### Why is a profile missing?

The handle may be misspelled, private, deleted, restricted, regionally unavailable, or temporarily absent from Pinterest's public page state.

#### Can I export to Excel?

Yes. Open the default dataset after the run and choose Excel, CSV, JSON, XML, or another supported Apify export format.

### You might also like

- [Pinterest Search Scraper](https://apify.com/benthepythondev/pinterest-search-scraper) for keyword-based pin and creator discovery.
- [Instagram Intelligence Scraper](https://apify.com/benthepythondev/instagram-intelligence-scraper) for public Instagram account research.
- [TikTok Profile Scraper](https://apify.com/benthepythondev/tiktok-profile-scraper) for public TikTok creator metrics.
- [YouTube Channel Intelligence](https://apify.com/benthepythondev/youtube-channel-intelligence) for channel-level YouTube research.

### Support and reviews

For support, open an issue on the Actor page with the run ID, a redacted input, and the expected behavior. This makes the report reproducible without exposing your full research list. If Pinterest Profile Scraper is useful in your workflow, please leave an honest Apify Store review. Reviews help other users compare tools and show which improvements matter most.

**Keywords:** Pinterest profile scraper, Pinterest creator analytics, Pinterest follower scraper, Pinterest account data, Pinterest influencer research, Pinterest business profile, Pinterest profile API, creator discovery, social media monitoring, public profile dataset.

# Actor input Schema

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

Public Pinterest usernames, @handles, or full profile URLs.

## `maxProfiles` (type: `integer`):

Maximum number of supplied profiles processed in one run.

## Actor input object example

```json
{
  "usernames": [
    "pinterest",
    "etsy"
  ],
  "maxProfiles": 10
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "usernames": [
        "pinterest",
        "etsy"
    ],
    "maxProfiles": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/pinterest-profile-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": [
        "pinterest",
        "etsy",
    ],
    "maxProfiles": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/pinterest-profile-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": [
    "pinterest",
    "etsy"
  ],
  "maxProfiles": 10
}' |
apify call benthepythondev/pinterest-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Profile Scraper - Creator Analytics",
        "description": "Scrape public Pinterest profiles with creator names, bios, websites, follower and following counts, pins, boards, verification status and profile images.",
        "version": "1.0",
        "x-build-id": "hoeYqH3OB0CRB88Kb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~pinterest-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-pinterest-profile-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/benthepythondev~pinterest-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-pinterest-profile-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/benthepythondev~pinterest-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-pinterest-profile-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": {
                    "usernames": {
                        "title": "Pinterest usernames or profile URLs",
                        "type": "array",
                        "description": "Public Pinterest usernames, @handles, or full profile URLs.",
                        "default": [
                            "pinterest"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of supplied profiles processed in one run.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
