# Pinterest Profile Scraper – Extract Public Profile Data (`scrapeberry/pinterest-profile-scraper`) Actor

Pinterest Profile Scraper extracts public profile data — username, name, bio, followers, following, boards, pins, monthly views, reach, website, verification status and profile images — as fast, structured JSON for lead generation, market research, analytics and data pipelines.

- **URL**: https://apify.com/scrapeberry/pinterest-profile-scraper.md
- **Developed by:** [Scrapeberry](https://apify.com/scrapeberry) (community)
- **Stats:** 66 total users, 66 monthly users, 97.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 profile scrapeds

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

Pinterest Profile Scraper extracts **public Pinterest profile data** — username, name, bio, followers, following, boards, pins, profile URL, website, verification status, and profile images — as fast, structured JSON. Every request hits Pinterest's servers **live**; there is no cached or stored data, so you always get the freshest possible snapshot. It is a no-browser **Pinterest API alternative** built for lead generation, market research, analytics, and data pipelines: paste usernames in, get clean records out, one per profile, with no coding required.

### What does the Pinterest Profile Scraper do?

This Pinterest user scraper fetches the public profile page data of any Pinterest account and returns it as a normalized JSON record — 18 fields per profile, including monthly views, reach, avatar and cover image. There is no browser rendering, no login, and no Pinterest API key required: the Pinterest profile extractor reads only what a logged-out visitor sees.

- **Bulk scraping** — one username per line, hundreds or thousands at a time.
- **Clean schema** — consistent, documented field names; the same shape every run.
- **Fast** — under a second per profile; plain HTTP, no browser.
- **Resilient** — automatic session handling, exponential backoff, rate-limit awareness.
- **Apify Proxy with sticky sessions** — reliable access at scale; residential fallback in one click.
- **Fair billing** — pay only for profiles actually delivered. Expect two small charges per profile because every scrape is live (no cache): a **$2 per 1,000** scraping fee plus a tiny platform data-processing fee. Failed lookups are returned as error items **at no charge**.

### What data can this Pinterest scraper extract?

| Field | Type | Description |
|---|---|---|
| `id` | string | Unique Pinterest profile ID |
| `username` | string | Pinterest handle |
| `full_name` | string | Display name |
| `bio` | string | Profile bio / description |
| `profile_url` | string | Public profile URL |
| `website_url` | string | External website (if set) |
| `followers_count` | number | Followers |
| `following_count` | number | Accounts followed |
| `boards_count` | number | Boards |
| `pins_count` | number | Pins |
| `views_count` | number | Monthly profile views |
| `reach_count` | number | Monthly profile reach |
| `created_at` | date | Account creation date (ISO 8601) |
| `last_activity_at` | date | Most recent pin save (ISO 8601) |
| `is_verified` | boolean | Verified account badge |
| `is_business_account` | boolean | Business / partner account |
| `profile_image` | string | Avatar URL (highest resolution available) |
| `cover_image` | string | Profile cover image URL (original size) |

### Input

See the **Input tab** for the full form. Key options:

- **Usernames** — one Pinterest username per line (`@` optional). This is the only required field.
- **Max profiles** — safety cap per run (default 1,000).
- **Concurrency** — parallel requests, 1–50 (default 5).
- **Proxy configuration** — Apify Proxy with a sticky session (default). Switch **Residential** on if datacenter IPs get throttled.

### Output

The dataset contains one item per username. Failed lookups (private, renamed, or nonexistent accounts) return transparent, **uncharged** error items:

```json
{ "username": "nonexistentuserxyz123", "status": "error", "error": "Profile not found or private" }
```

The run's **OUTPUT** key summarizes totals: requested, scraped, failed, and charged counts.

### Example

Real output for `@pinterest` — every field returned by this Pinterest public profile scraper:

```json
{
  "id": "424605208526455283",
  "username": "pinterest",
  "full_name": "Pinterest",
  "bio": "Find your reason to go offline. 📌",
  "profile_url": "https://www.pinterest.com/pinterest/",
  "website_url": "http://www.pinterest.com",
  "followers_count": 6263031,
  "following_count": 395,
  "boards_count": 133,
  "pins_count": 96098,
  "views_count": 10000001,
  "reach_count": 10000001,
  "created_at": "2012-08-16T06:25:03.000Z",
  "last_activity_at": "2026-09-09T19:54:12.000Z",
  "is_verified": false,
  "is_business_account": true,
  "profile_image": "https://i.pinimg.com/280x280_RS/1c/b5/61/1cb561c8e7b9c709f78d110a4b5f0863.jpg",
  "cover_image": "https://i.pinimg.com/originals/9e/8e/87/9e8e87f41ca425a3adefc66ddb01a9b3.jpg",
  "status": "success"
}
```

Download the dataset as **JSON, HTML, CSV, or Excel** for spreadsheets, BI tools, or direct pipeline ingestion.

### Pricing — how much does it cost to scrape Pinterest profiles?

This Pinterest profile extractor uses **pay-per-event** pricing. Because every request is made **live against Pinterest's servers in real-time** (there is no cached or stored data), you will see two small charges per successfully delivered profile on your invoice:

| Charge | Amount | Why |
|---|---|---|
| **Profile scraped** | **$2 per 1,000 profiles** ($0.002 each) | The main scraping fee — charged only for successfully delivered profiles. |
| **Result** (dataset item) | **$0.01 per 1,000 profiles** ($0.00001 each) | Platform data-processing/storage fee charged by Apify for every item written to the dataset. |
| **Actor start** | $0.05 per 1,000 starts (default) | Fixed per-run start fee; Apify covers the first 5 seconds of compute. |

**Total cost:** roughly **$2.01 per 1,000 profiles** delivered.

Failed lookups (private, renamed, or nonexistent accounts) are returned as error items **at no charge** — you pay nothing for those.

A 10,000-profile run costs about **$20.10** plus a few cents of platform usage. New Apify accounts include free platform credit — enough to scrape thousands of profiles while evaluating the actor.

### Performance

- **~1 second per profile** at default concurrency 5 on plain HTTP (no browser).
- A 1,000-profile run typically finishes in **5–10 minutes**; raise concurrency to 10–20 for bulk jobs.
- Built-in rate-limit awareness backs off automatically on throttling — lower concurrency if you see it.

### Use cases

- **Lead generation** — build prospect lists of active Pinterest creators and brands with public websites.
- **Influencer marketing** — filter creators by followers, monthly views and reach, activity (`last_activity_at`), and business-account status.
- **Market research & competitor tracking** — monitor rival brands' follower growth and content volume over time with scheduled runs.
- **Analytics & data pipelines** — normalized JSON/CSV drops straight into spreadsheets, BI dashboards, or ETL jobs.
- **Pinterest data extraction at scale** — thousands of profiles per run via the Apify API.

### API usage

Run the Pinterest user scraper programmatically — see the **API tab** for copy-paste snippets. Node.js example with the [Apify SDK](https://docs.apify.com/sdk/js/):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('scrapeberry/pinterest-profile-scraper').call({
    usernames: ['pinterest', 'etsy'],
    maxProfiles: 100,
    concurrency: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Or schedule a recurring run from the actor page to turn the dataset into a follower-growth tracker.

### FAQ and disclaimers

**Is the data public?** Yes — the actor reads only what any logged-out visitor sees. It does not log in, access private accounts, or extract private personal data such as emails, phone numbers, or precise locations.

> Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

**Why did a profile fail?** The account is private, was renamed, or no longer exists — you are not charged for it. If *all* profiles fail, Pinterest may be throttling your proxy: lower concurrency or switch to residential proxies.

Found an issue or have an idea? Open a ticket in the **Issues tab** — feedback shapes the roadmap.

# Actor input Schema

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

Pinterest usernames, account IDs, or profile URLs — one per line (with or without @).

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

Maximum number of profiles to scrape in this run (safety cap).

## `concurrency` (type: `integer`):

Parallel profile requests (1-50). Higher is faster but may trigger Pinterest rate limits.

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

Apify Proxy with a sticky session (recommended). Residential recommended if datacenter IPs get blocked.

## Actor input object example

```json
{
  "usernames": [
    "pinterest"
  ],
  "maxProfiles": 1000,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `scraped` (type: `string`):

Successful profiles out of the total requested; only successful profiles are billed.

## `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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeberry/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"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapeberry/pinterest-profile-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "pinterest"
  ]
}' |
apify call scrapeberry/pinterest-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapeberry/pinterest-profile-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oyEmxGAf6bQhqngaA/builds/qkGGbXdBCtjos8r3F/openapi.json