# Pinterest Profile Scraper (`fetch_cat/pinterest-profile-scraper`) Actor

📌 Extract public Pinterest profile data: followers, pins, boards, websites, verification status, and recent pin previews from profile URLs or usernames.

- **URL**: https://apify.com/fetch\_cat/pinterest-profile-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Lead generation, E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 profile saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Extract public Pinterest profile details, follower counts, board previews, and recent pin previews from Pinterest creator or brand accounts.

Use this actor to monitor public Pinterest accounts for social media research, ecommerce trend tracking, influencer discovery, competitor analysis, and content planning.

### What does Pinterest Profile Scraper do?

Pinterest Profile Scraper turns public Pinterest profiles into structured data.

It accepts Pinterest profile URLs or usernames.

It returns one clean dataset item per profile.

Each item can include account metadata, public counters, boards, and recent pins.

You can export the results as JSON, CSV, Excel, XML, RSS, or HTML from Apify.

### Who is it for?

#### Marketers

Track brand profiles, creator accounts, and campaign inspiration accounts.

#### Ecommerce teams

Monitor public Pinterest activity for categories, seasonal boards, and product inspiration.

#### Trend researchers

Compare follower counts, board inventory, and recent visual topics across profiles.

#### Lead generation teams

Collect public profile facts for outreach lists and account qualification.

#### Agencies

Prepare account audits and competitive snapshots for clients.

### Why use this actor?

- 📌 Profile-focused output instead of broad mixed search results
- 📊 Public counters such as followers, following, pins, and boards
- 🧩 Optional nested board previews
- 🖼️ Optional recent pin previews with images and outbound links
- 🔁 Batch input by URL or username
- 📤 Export-ready dataset rows
- ⚙️ Works in Apify API, schedules, webhooks, and integrations

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Pinterest profile URLs | `profileUrls` | array, default `[{"url":"https://www.pinterest.com/pinterest/"},{"url":"https://www.pinterest.com/etsy/"}]` | Public Pinterest profile URLs to scrape. You can also use usernames below. |
| Pinterest usernames | `usernames` | array, default `["pinterest"]` | Pinterest usernames without the domain, for example pinterest or etsy. |
| Include board previews | `includeBoards` | boolean, default `true` | Return public board previews embedded on the profile page. |
| Maximum boards per profile | `maxBoardsPerProfile` | integer, default `10` | Limit how many board previews are stored for each profile. |
| Include recent pin previews | `includePins` | boolean, default `true` | Return recent public pin previews embedded on the profile page. |
| Maximum pins per profile | `maxPinsPerProfile` | integer, default `20` | Limit how many recent pin previews are stored for each profile. |
| Proxy configuration | `proxyConfiguration` | object, default `{"useApifyProxy":false}` | Runs use direct connections by default to keep costs low. Enable Apify Proxy, preferably Residential, only for higher-volume runs or when Pinterest rate-limits or blocks your traffic. |

### Output fields

| JSON key | Label | Type | Description |
| --- | --- | --- | --- |
| `profileUrl` | ProfileUrl | string | Output field for profileurl. |
| `username` | Username | string | Output field for username. |
| `fullName` | FullName | string | Output field for fullname. |
| `profileDescription` | ProfileDescription | string | Output field for profiledescription. |
| `website` | Website | string | Output field for website. |
| `imageUrl` | ImageUrl | string | Output field for imageurl. |
| `coverImageUrl` | CoverImageUrl | string | Output field for coverimageurl. |
| `verified` | Verified | boolean | Output field for verified. |
| `followerCount` | FollowerCount | integer | Output field for followercount. |
| `followingCount` | FollowingCount | integer | Output field for followingcount. |
| `pinCount` | PinCount | integer | Output field for pincount. |
| `boardCount` | BoardCount | integer | Output field for boardcount. |
| `monthlyViews` | MonthlyViews | integer | Output field for monthlyviews. |
| `boards` | Boards | array | Output field for boards. |
| `recentPins` | RecentPins | array | Output field for recentpins. |
| `scrapedAt` | ScrapedAt | string | Output field for scrapedat. |
| `error` | Error | string | Output field for error. |
### Board preview fields

Each board preview can include:

- `id`
- `name`
- `url`
- `description`
- `followerCount`
- `pinCount`
- `coverImageUrl`

### Recent pin preview fields

Each recent pin preview can include:

- `id`
- `title`
- `description`
- `pinUrl`
- `link`
- `imageUrl`
- `boardName`
- `boardUrl`
- `createdAt`
- `repinCount`
- `commentCount`

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Per Pinterest profile dataset item produced | $2.875 / 1,000 | $2.5 / 1,000 | $1.95 / 1,000 | $1.5 / 1,000 | $1 / 1,000 | $0.7 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use Pinterest Profile Scraper

1. Open the actor on Apify.
2. Add Pinterest profile URLs or usernames.
3. Choose whether to include board previews.
4. Choose whether to include recent pin previews.
5. Set small limits for your first run.
6. Click **Start**.
7. Open the dataset when the run finishes.
8. Export the data in your preferred format.

### Input options

#### Pinterest profile URLs

Add full public profile URLs.

Example:

```json
[
  { "url": "https://www.pinterest.com/pinterest/" },
  { "url": "https://www.pinterest.com/etsy/" }
]
````

#### Pinterest usernames

Add usernames without the domain.

Example:

```json
["pinterest", "etsy"]
```

#### Include board previews

Set `includeBoards` to `true` to return board previews.

Use `maxBoardsPerProfile` to limit nested board data.

#### Include recent pin previews

Set `includePins` to `true` to return recent pin previews.

Use `maxPinsPerProfile` to limit nested pin data.

#### Proxy configuration

Runs use direct connections by default to keep costs low.

For small tests, keep the no-proxy default settings.

Enable Apify Proxy, preferably Residential, only for higher-volume runs or if Pinterest rate-limits or blocks your traffic.

### Ready-to-run examples

- [Pinterest Profile Batch By Usernames](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-profile-batch-by-usernames)
- [Pinterest Kids Brand Profile Scraper](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-kids-brand-profile-scraper)
- [Pinterest Sportswear Profile Research](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-sportswear-profile-research)
- [Pinterest Tech Brand Profile Monitor](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-tech-brand-profile-monitor)
- [Pinterest Recent Pin Preview Extraction](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-recent-pin-preview-extraction)
- [Pinterest Board Preview Extraction](https://apify.com/fetch_cat/pinterest-profile-scraper/examples/pinterest-board-preview-extraction)

[View all ready-to-run examples](https://apify.com/fetch_cat/pinterest-profile-scraper/examples)

### Example input

```json
{
  "profileUrls": [
    { "url": "https://www.pinterest.com/pinterest/" }
  ],
  "usernames": ["etsy"],
  "includeBoards": true,
  "maxBoardsPerProfile": 10,
  "includePins": true,
  "maxPinsPerProfile": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output

```json
{
  "profileUrl": "https://www.pinterest.com/pinterest/",
  "username": "pinterest",
  "fullName": "Pinterest",
  "profileDescription": "Find your reason to go offline. 📌",
  "website": "http://www.pinterest.com",
  "verified": true,
  "followerCount": 6257074,
  "followingCount": 393,
  "pinCount": 95722,
  "boardCount": 123,
  "boards": [
    {
      "name": "Sporty chic soccer looks",
      "url": "https://www.pinterest.com/pinterest/sporty-chic-soccer-looks/"
    }
  ],
  "recentPins": [
    {
      "pinUrl": "https://www.pinterest.com/pin/424605071145314750/",
      "imageUrl": "https://i.pinimg.com/736x/example.jpg"
    }
  ],
  "scrapedAt": "2026-06-29T10:00:00.000Z"
}
```

### Tips for best results

- ✅ Use public profile URLs.
- ✅ Start with small profile batches.
- ✅ Keep board and pin limits reasonable.
- ✅ Use usernames for quick batch setup.
- ✅ Export JSON if you need nested boards and pins.
- ✅ Export CSV if you only need top-level profile fields.

### Common use cases

#### Creator discovery

Compare followers, boards, and recent visual activity across creator accounts.

#### Brand monitoring

Track public brand profiles and save snapshots over time.

#### Competitive research

Build a list of competitors and monitor profile-level changes.

#### Content planning

Review boards and recent pins to discover visual content themes.

#### Ecommerce research

Analyze product inspiration accounts, marketplace brands, and seasonal boards.

### Integrations

Use this actor with Apify integrations to automate Pinterest profile monitoring.

#### Google Sheets

Send profile rows to Google Sheets for campaign lists and team review.

#### Webhooks

Trigger a webhook when scheduled profile monitoring finishes.

#### Make

Route new datasets to CRM, enrichment, or alerting scenarios.

#### Zapier

Create lightweight workflows for saved profile snapshots.

#### Apify datasets

Query historical runs and compare account counters over time.

### API usage

Run Pinterest Profile Scraper from your own code with the Apify API.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "profileUrls": [
    {
      "url": "https://www.pinterest.com/pinterest/"
    },
    {
      "url": "https://www.pinterest.com/etsy/"
    }
  ],
  "usernames": [
    "pinterest"
  ],
  "includeBoards": true,
  "maxBoardsPerProfile": 10,
  "includePins": true
};

const run = await client.actor('fetch_cat/pinterest-profile-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/pinterest-profile-scraper").call(run_input={
  "profileUrls": [
    {
      "url": "https://www.pinterest.com/pinterest/"
    },
    {
      "url": "https://www.pinterest.com/etsy/"
    }
  ],
  "usernames": [
    "pinterest"
  ],
  "includeBoards": true,
  "maxBoardsPerProfile": 10,
  "includePins": true
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~pinterest-profile-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"profileUrls":[{"url":"https://www.pinterest.com/pinterest/"},{"url":"https://www.pinterest.com/etsy/"}],"usernames":["pinterest"],"includeBoards":true,"maxBoardsPerProfile":10,"includePins":true}'
```

### Use with AI agents via MCP

Pinterest Profile Scraper can be used by AI assistants through the hosted Apify MCP server.

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/pinterest-profile-scraper"
```

**Claude Desktop, Cursor, or VS Code JSON config**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/pinterest-profile-scraper"
    }
  }
}
```

**Example prompts**

- "Run Pinterest Profile Scraper with this input JSON and summarize the dataset."
- "Export the latest Pinterest Profile Scraper results to a table I can review."
- "Schedule this Actor for monitoring and tell me what changed between runs."

### Scheduling

Schedule this actor to run daily, weekly, or monthly.

Scheduled runs are useful for tracking follower count changes and profile activity snapshots.

Keep your profile list stable if you want simple time-series comparisons.

### Data quality notes

Pinterest controls what public data is visible on each profile.

Some profiles may expose fewer pins or boards than others.

Some counters can change between runs.

Private, removed, or unavailable profiles return an `error` field.

### Limits

The first version focuses on data visible from public profile pages.

It does not log in to Pinterest.

It does not scrape private boards.

It does not bypass profile privacy settings.

It does not guarantee historical data that is not visible on the profile.

### Troubleshooting

#### Why did a profile return an error?

The profile may not exist, may be private, may be unavailable in your region, or Pinterest may have temporarily limited the request.

Try the profile in a browser and verify that it is publicly visible.

#### Why are there fewer boards or pins than requested?

The limits cap the maximum number stored.

Pinterest may expose fewer previews on the public profile page.

#### Why is monthlyViews empty?

Pinterest does not always expose monthly views on every public profile.

When it is not visible, the actor returns `null`.

### Legality and responsible use

This actor extracts public Pinterest profile information.

You are responsible for using the data in compliance with applicable laws, Pinterest terms, and privacy rules.

Do not use scraped data for spam, harassment, or prohibited profiling.

If you store personal data, make sure you have a lawful basis and honor deletion requests.

### Related actors

- [Bilibili Video Search Scraper](https://apify.com/fetch_cat/bilibili-video-search-scraper)
- [Bluesky Profile Feed Scraper](https://apify.com/fetch_cat/bluesky-profile-feed-scraper)
- [Douyin Search Scraper](https://apify.com/fetch_cat/douyin-search-scraper)
- [Facebook Pages Scraper](https://apify.com/fetch_cat/facebook-pages-scraper)
- [Instagram Stories & Highlights Scraper](https://apify.com/fetch_cat/instagram-stories-highlights-scraper)

### FAQ

#### Can I scrape many profiles at once?

Yes. Add multiple URLs or usernames, then use sensible board and pin limits.

#### Can I scrape private Pinterest profiles?

No. This actor is for public profile data only.

#### Can I export nested boards and pins?

Yes. JSON exports preserve nested arrays best.

#### Can I monitor profiles over time?

Yes. Use Apify schedules and compare dataset exports between runs.

#### Does this actor require a Pinterest account?

No. It is designed for publicly visible profile data.

#### Can I use this in a workflow?

Yes. Use the API, webhooks, Google Sheets, Make, Zapier, or MCP.

### Support

Report bugs, wrong output, blocked runs, or missing fields from the Actor page. Include the Apify run ID or run URL, your input JSON, what you expected, what the Actor returned, and one reproducible public URL so the issue can be tested quickly.

# Actor input Schema

## `profileUrls` (type: `array`):

Public Pinterest profile URLs to scrape. You can also use usernames below.

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

Pinterest usernames without the domain, for example pinterest or etsy.

## `includeBoards` (type: `boolean`):

Return public board previews embedded on the profile page.

## `maxBoardsPerProfile` (type: `integer`):

Limit how many board previews are stored for each profile.

## `includePins` (type: `boolean`):

Return recent public pin previews embedded on the profile page.

## `maxPinsPerProfile` (type: `integer`):

Limit how many recent pin previews are stored for each profile.

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

Runs use direct connections by default to keep costs low. Enable Apify Proxy, preferably Residential, only for higher-volume runs or when Pinterest rate-limits or blocks your traffic.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://www.pinterest.com/pinterest/"
    },
    {
      "url": "https://www.pinterest.com/etsy/"
    }
  ],
  "usernames": [
    "pinterest"
  ],
  "includeBoards": true,
  "maxBoardsPerProfile": 10,
  "includePins": true,
  "maxPinsPerProfile": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "profileUrls": [
        {
            "url": "https://www.pinterest.com/pinterest/"
        },
        {
            "url": "https://www.pinterest.com/etsy/"
        }
    ],
    "usernames": [
        "pinterest"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "profileUrls": [
        { "url": "https://www.pinterest.com/pinterest/" },
        { "url": "https://www.pinterest.com/etsy/" },
    ],
    "usernames": ["pinterest"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "profileUrls": [
    {
      "url": "https://www.pinterest.com/pinterest/"
    },
    {
      "url": "https://www.pinterest.com/etsy/"
    }
  ],
  "usernames": [
    "pinterest"
  ]
}' |
apify call fetch_cat/pinterest-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Profile Scraper",
        "description": "📌 Extract public Pinterest profile data: followers, pins, boards, websites, verification status, and recent pin previews from profile URLs or usernames.",
        "version": "0.1",
        "x-build-id": "UJUmIVlvD5qOaxhWo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~pinterest-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~pinterest-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~pinterest-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": {
                    "profileUrls": {
                        "title": "Pinterest profile URLs",
                        "type": "array",
                        "description": "Public Pinterest profile URLs to scrape. You can also use usernames below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "usernames": {
                        "title": "Pinterest usernames",
                        "type": "array",
                        "description": "Pinterest usernames without the domain, for example pinterest or etsy.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeBoards": {
                        "title": "Include board previews",
                        "type": "boolean",
                        "description": "Return public board previews embedded on the profile page.",
                        "default": true
                    },
                    "maxBoardsPerProfile": {
                        "title": "Maximum boards per profile",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit how many board previews are stored for each profile.",
                        "default": 10
                    },
                    "includePins": {
                        "title": "Include recent pin previews",
                        "type": "boolean",
                        "description": "Return recent public pin previews embedded on the profile page.",
                        "default": true
                    },
                    "maxPinsPerProfile": {
                        "title": "Maximum pins per profile",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit how many recent pin previews are stored for each profile.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Runs use direct connections by default to keep costs low. Enable Apify Proxy, preferably Residential, only for higher-volume runs or when Pinterest rate-limits or blocks your traffic.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
