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

Pinterest Profile Scraper extracts public profile data from Pinterest. Collect boards, pins, descriptions, followers, following counts, and profile metadata. Ideal for market research, competitor analysis, trend tracking, and content strategy insights.

- **URL**: https://apify.com/scraper-engine/pinterest-profile-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 12 total users, 2 monthly users, 97.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Followers, Bio, Pins and Boards

Pinterest Profile Scraper returns structured Pinterest profile data for any public account by username or URL — follower, following, pin and board counts, bio, avatar and cover images, linked website and Instagram handle, verification and merchant flags, SEO metadata, and the account creation date as an absolute ISO-8601 timestamp. No Pinterest login or API key is required. Output lands in your Apify dataset as typed JSON, ready to query, export or feed to an LLM. Paste a list of usernames and run it below.

### 🧭 What is Pinterest Profile Scraper?

Pinterest Profile Scraper is an Apify Actor that fetches Pinterest's own public profile payload for any account you name and returns it as clean, typed JSON — no HTML parsing, no headless browser required on your end. It does not require a Pinterest account, login or cookie: Pinterest serves this data to any logged-out visitor, and the Actor reads the same guest surface. It's built for growth marketers, influencer researchers, brand-safety and lead-gen teams, and developers wiring Pinterest profile data into an app, spreadsheet or AI pipeline.

### 🔍 What Pinterest profile data is publicly available to scrape?

Pinterest publishes a full profile header — identity, counts, verification flags, images and SEO metadata — to any logged-out visitor; it does not publish follower/following member lists, email addresses, or shop/catalog data to guests at all.

| Data category | Publicly available (no login) | Restricted |
| --- | --- | --- |
| Profile identity — username, display name, bio | ✅ | — |
| Follower / following / pin / board counts | ✅ | Member **lists** (not counts) return HTTP 401 to a logged-out client |
| Verification & merchant flags | ✅ | — |
| Avatar & cover images | ✅ | — |
| SEO metadata (title, description, canonical domain) | ✅ | — |
| Account creation date & last pin-save time | ✅ | — |
| Linked website & Instagram handle | ✅ | — |
| Shop, product & catalog data | ❌ | Storefront routes return HTTP 401; the profile-tabs field never lists a Shop tab to guests |
| Email address | ❌ | Not present in any Pinterest profile surface, logged in or out |

Pinterest Profile Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 📊 What data can I extract with Pinterest Profile Scraper?

The Actor returns 40 profile data columns plus 5 run-bookkeeping columns on every row, grouped below by what they describe.

#### Identity, links & SEO fields

| Field | Description |
| --- | --- |
| `username` | The account's Pinterest handle |
| `profileUrl` | Canonical profile URL, built from `username` |
| `full_name` | Display name |
| `first_name` | Pinterest also returns the full display name here |
| `about` | Bio text |
| `website_url` | Linked external website, as entered by the account |
| `domain_url` | Bare domain parsed from `website_url` |
| `instagram_data` | Linked Instagram `{username, url}`, or `null` if none is linked |
| `seo_title` / `seo_description` | Meta title/description Pinterest generates for the profile page |
| `seo_canonical_domain` | The account's regional Pinterest domain (e.g. `www.pinterest.com`, `uk.pinterest.com`) |
| `eligible_profile_tabs` | Which profile tabs Pinterest serves to a guest — observed values are `Saved` and `Created` only |
| `id` / `node_id` | Pinterest's numeric user ID and its GraphQL node ID |

#### Counts, flags & verification

| Field | Description |
| --- | --- |
| `follower_count` / `following_count` | Follower and following counts |
| `pin_count` | Pins the account **created** — not pins it saved from others |
| `board_count` | Number of boards |
| `interest_following_count` | Interests the account follows |
| `domain_verified` / `is_primary_website_verified` | Website ownership verification flags |
| `is_verified_merchant` | Pinterest merchant verification badge |
| `is_inspirational_merchant` | Pinterest's inspirational-merchant flag |
| `is_partner` | Business/partner account flag |
| `partner` | Business-partner object when `is_partner` is true |
| `is_private_profile` | Private-account flag |
| `is_ads_only_profile` | Ads-only account flag |
| `is_gco_account` | Pinterest's "GCO" account-type flag |
| `indexed` | Whether Pinterest allows the profile to be search-indexed |
| `seo_noindex_reason` | Reason for de-indexing, when `indexed` is false (e.g. `owner_requested`) |
| `impressum_url` | EU legal-disclosure link, when the account has published one |
| `verified_identity` | Identity-verification object; empty on unverified accounts |

#### Media & timestamps

| Field | Description |
| --- | --- |
| `image_medium_url` / `image_xlarge_url` | Avatar image at two resolutions |
| `profile_cover_url` | Highest-resolution cover-image URL the Actor could extract from `profile_cover.images`; `null` on the small share of accounts with no cover image |
| `profile_cover` | The raw Pinterest cover object |
| `created_at` / `createdAtIso` | Account creation date — Pinterest's raw RFC-1123 string, and the same value converted to an absolute ISO-8601 UTC timestamp |
| `last_pin_save_time` / `lastPinSaveTimeIso` | Last pin-save activity, raw and ISO — a real recency signal |

Every row also carries 5 bookkeeping columns regardless of outcome: `input` (what you supplied), `dataSource` (which Pinterest surface answered — see *How it works* below), `errorReason` / `errorMessage` (null on a successful row), and `scrapedAt`.

#### 🤖 Add-on: Need additional Pinterest data?

This Actor covers the profile header only. For the pins and boards themselves — images, video variants, alt text, save counts, outbound links — pair it with **Pinterest Boards Scraper**. For Pinterest's ad creative library, use **Pinterest Ads Scraper**. Both are linked in Related scrapers below.

### ⚖️ How does Pinterest Profile Scraper differ from the official Pinterest API?

Pinterest's own API v5 is built to manage the app's own connected business account, not to look up arbitrary public profiles by username. Its `/v5/user_account` endpoint reads the account tied to the OAuth token that called it, and its OAuth scopes (`user_accounts:read`, `boards:read`, `pins:read`, `ads:read`, …) are all scoped to that same connected account (per Pinterest's own API v5 scope documentation, developers.pinterest.com, checked 2026-08-04). There is no published v5 endpoint that returns a third party's public profile by username.

| Feature | Pinterest API v5 | Pinterest Profile Scraper |
| --- | --- | --- |
| Access model | OAuth 2.0 app registration + user authorization | No login, no OAuth, no API key |
| Whose profile it returns | The token owner's own connected account | Any public profile, by username or URL |
| Approval process | Pinterest developer app review for production access | None — start from the Store listing |
| Setup time | Register app, get approved, implement OAuth | Paste usernames, click Start |
| Output | JSON via REST, scoped fields | JSON via Apify dataset, 40 profile fields + 5 bookkeeping |
| Rate handling | Governed by Pinterest's per-app API quotas | Bounded per target by the Actor's own retry policy — no quota to request or manage |

Use the official API if you're building a Pinterest business integration for your own connected account. Use Pinterest Profile Scraper when you need public data for accounts you don't own or control.

### ▶️ How to use Pinterest Profile Scraper

Run it from the Apify Console — no code required, and no Pinterest credentials to set up.

1. Open **Pinterest Profile Scraper** on the Apify Store and click **Try for free** (or **Run**, if you've already added it).
2. Provide `startUrls` — the only required input. Add a bare username, a full profile URL, or a board/tab URL under the profile; each entry resolves to one profile.
3. Optionally set `maxProfiles` to cap how many targets are processed, and `proxyConfiguration` if you want every request routed through Apify Proxy.
4. Click **Start** and watch results populate the dataset in real time.
5. Export results as JSON, CSV, Excel, or push them to Google Sheets straight from the Apify dataset — or pull them via the API.

#### Scaling to bulk profile extraction

`startUrls` is an array: add as many usernames or URLs as you need in one run, up to the `maxProfiles` ceiling (maximum 1000). There's no separate "bulk mode" — one run with a long list is the bulk path. For lists larger than 1000, split them across multiple runs (e.g. with the Apify API or a schedule).

### 💼 What can you do with Pinterest profile data?

- 🎯 **Influencer marketers** vetting creators use `follower_count`, `pin_count` and `is_verified_merchant` to shortlist accounts before outreach.
- 🏢 **Brand and competitor monitoring teams** track `board_count`, `pin_count` and `lastPinSaveTimeIso` over repeated runs to see which competitor accounts are actively posting.
- 📈 **Growth and lead-gen teams** use `website_url`, `domain_url` and `instagram_data` to build cross-platform contact lists from Pinterest bios.
- 🔍 **Brand-safety and compliance reviewers** use `is_partner`, `is_verified_merchant` and `seo_noindex_reason` to flag accounts worth a closer look.
- 🤖 **AI engineers** feed `about`, `full_name` and `seo_description` into a RAG pipeline or agent tool as grounded, structured context instead of scraping and parsing HTML themselves.

### 🚦 How does Pinterest Profile Scraper handle rate limits and blocking?

Each target gets up to 3 attempts against Pinterest's guest endpoint, with exponential backoff between attempts. A `404`/"User not found" response stops immediately rather than burning retries on a bad handle. Attempts are retried only on a defined set of retryable signals — HTTP 403, 408, 425, 429, 500, 502, 503 or 504, or a redirect to a `/login` or CAPTCHA URL — never on a substring match inside the page body, which is unreliable on Pinterest's bundled JavaScript. If the primary endpoint is exhausted, the Actor falls back to parsing the profile HTML, then to the page's `ld+json` block, before giving up on that target.

Whatever proxy you select in `proxyConfiguration` is used for **every** request in the run — there is no built-in proxy ladder and no silent fallback to a direct connection if the proxy fails; a broken proxy configuration surfaces as a run error instead of quietly returning empty rows. ⚠️ If a run scrapes zero profile rows across every valid target supplied, the Actor fails the run loudly with a non-zero exit instead of finishing green with an empty dataset — check the uncharged accounting rows for the typed `errorReason` on each target.

### ⬇️ Input

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `startUrls` | Yes | array of strings | One entry per profile: a bare username, a full profile URL, a regional-domain URL, or a board/tab URL beneath the profile root. Search phrases are not supported — anything that isn't a resolvable username produces an uncharged row with `errorReason: invalid_input`. | `"marthastewart"` |
| `maxProfiles` | No | integer (min 0, max 1000) | Hard cap on how many supplied targets are processed. Every charged row counts against it. `0` processes every target supplied. | `10` |
| `proxyConfiguration` | No | object (proxy editor) | Proxy used for every request in the run. Optional — Pinterest served this endpoint to a bare Apify datacenter IP in testing; turn on Apify Proxy if you see `blocked` accounting rows. | `{"useApifyProxy": false}` |

#### Example input

```json
{
  "startUrls": [
    "marthastewart",
    "https://www.pinterest.com/nike/",
    "https://au.pinterest.com/etsy/",
    "https://www.pinterest.com/marthastewart/holiday-recipes/",
    "https://www.pinterest.com/nike/_created/"
  ],
  "maxProfiles": 10,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### ⬆️ Output

Every run produces one dataset row per target — either a full profile row or an uncharged accounting row — with the same 45-column schema either way, so the dataset always stays rectangular. Export as JSON, CSV, Excel, XML, or RSS, or push to Google Sheets, directly from the Apify dataset.

#### Example output

A successfully scraped profile:

```json
{
  "username": "marthastewart",
  "profileUrl": "https://www.pinterest.com/marthastewart/",
  "full_name": "Martha Stewart",
  "first_name": "Martha Stewart",
  "about": "Daily recipes, crafts, and inspiration from Martha Stewart.",
  "follower_count": 1867921,
  "following_count": 322,
  "pin_count": 104880,
  "board_count": 174,
  "interest_following_count": 58,
  "website_url": "http://marthastewart.com/",
  "domain_url": "marthastewart.com",
  "domain_verified": true,
  "is_primary_website_verified": true,
  "impressum_url": null,
  "instagram_data": { "username": "marthastewart", "url": "https://www.instagram.com/marthastewart" },
  "verified_identity": {},
  "is_verified_merchant": false,
  "is_inspirational_merchant": false,
  "is_partner": true,
  "partner": { "id": "573812345", "type": "business" },
  "is_private_profile": false,
  "is_ads_only_profile": false,
  "is_gco_account": false,
  "indexed": true,
  "seo_noindex_reason": null,
  "seo_title": "Martha Stewart (marthastewart) - Profile | Pinterest",
  "seo_description": "Martha Stewart | Daily recipes, crafts, and inspiration.",
  "seo_canonical_domain": "www.pinterest.com",
  "image_medium_url": "https://i.pinimg.com/75x75_RS/marthastewart.jpg",
  "image_xlarge_url": "https://i.pinimg.com/280x280_RS/marthastewart.jpg",
  "profile_cover_url": "https://i.pinimg.com/originals/marthastewart-cover.jpg",
  "profile_cover": { "id": "cov_482166", "images": { "originals": { "url": "https://i.pinimg.com/originals/marthastewart-cover.jpg" } } },
  "eligible_profile_tabs": ["Saved", "Created"],
  "created_at": "Fri, 02 Nov 2012 14:19:50 +0000",
  "createdAtIso": "2012-11-02T14:19:50Z",
  "last_pin_save_time": "Mon, 20 Jul 2026 03:05:29 +0000",
  "lastPinSaveTimeIso": "2026-07-20T03:05:29Z",
  "id": "482166744999114406",
  "node_id": "VXNlcjo0ODIxNjY3NDQ5OTkxMTQ0MDY=",
  "input": "marthastewart",
  "dataSource": "user_resource_api",
  "errorReason": null,
  "errorMessage": null,
  "scrapedAt": "2026-08-04T09:00:00Z"
}
```

An uncharged accounting row for a target that produced no profile — same columns, data fields null, `errorReason` typed:

```json
{
  "username": null,
  "profileUrl": null,
  "full_name": null,
  "follower_count": null,
  "input": "home decor ideas",
  "dataSource": null,
  "errorReason": "invalid_input",
  "errorMessage": "not a Pinterest username: 'home decor ideas'",
  "scrapedAt": "2026-08-04T09:00:04Z"
}
```

### ⚙️ How does it work?

Pinterest Profile Scraper calls Pinterest's own guest `UserResource` endpoint — the same request the Pinterest.com front end makes to build a profile page — instead of rendering the page in a browser. That request goes through whatever proxy (or direct connection) you configured, with retries and backoff on blocking-shaped responses. If that endpoint is unavailable for a target, the Actor falls back to fetching the profile HTML and reading the same data object out of Pinterest's embedded page state, and as a last resort out of a `ld+json` block on the page. Every returned object's username is checked against what you asked for, so a mismatch is refused rather than emitted. Only data Pinterest already serves to a logged-out visitor is ever returned, and the output schema stays the same 45 columns regardless of which surface answered or how Pinterest's page markup changes.

### 🔌 Integrations

Pinterest Profile Scraper runs like any Apify Actor, so it works with the tools you already use to call Apify.

#### Calling Pinterest Profile Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("pinterest-profile-scraper").call(
    run_input={"startUrls": ["marthastewart", "nike"], "maxProfiles": 10}
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["username"], item["follower_count"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request to the Apify API.

#### No-code tools (n8n, Make)

In n8n, use the HTTP Request node (or the Apify node) pointed at the Actor's run endpoint, with your Apify API token in the header — the run's dataset items come back as JSON you can pipe into any downstream node. In Make, use the same pattern with an HTTP module calling the Apify REST API, or the dedicated Apify app if you already use it.

### 🛡️ Is it legal to scrape Pinterest profiles?

Scraping publicly available Pinterest profile data is generally legal — Pinterest Profile Scraper only returns what Pinterest already serves to any logged-out visitor, nothing behind a login wall. Because profile data (names, bios, images) can identify a real person, storing or processing it may fall under GDPR (EU) or CCPA (California) if you retain personal data — you'll need a lawful basis for collection and storage, and you should honor deletion/access requests where applicable. Respect Pinterest's own Terms of Service alongside any data-protection law that applies to your use case. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What Pinterest profile fields does Pinterest Profile Scraper return?

The core fields are `follower_count`, `following_count`, `pin_count`, `board_count` and `about` (bio), alongside verification flags, images and SEO metadata — see the full field tables above.

#### Does Pinterest Profile Scraper require a Pinterest account or login?

No. It reads Pinterest's guest profile endpoint, the same one served to a logged-out visitor. No Pinterest account, cookie or API key is used or accepted.

#### How many Pinterest profiles can I extract in one run?

As many as you list in `startUrls`, up to the `maxProfiles` cap — which itself tops out at 1000 per run. Set `maxProfiles` to `0` to process every target you supply.

#### What happens if a profile is private or doesn't exist?

A nonexistent username returns Pinterest's own "User not found" response and produces an uncharged accounting row with `errorReason: not_found`. A private profile still returns a complete, real header object from Pinterest's guest endpoint — it's emitted as a normal charged row with `is_private_profile` set, not as an error. The `private_profile` value exists in the Actor's set of error reasons but was not triggered on any profile observed during testing, since Pinterest's guest endpoint answers for private accounts too.

#### Can I scrape multiple Pinterest profiles at once?

Yes — `startUrls` is an array. List every username or URL you need and they're processed in one run, each producing its own row.

#### Does Pinterest Profile Scraper work with Claude, ChatGPT, and other AI agent tools?

It's callable as an HTTP endpoint by any agent framework that can call the Apify API — point your agent's tool-calling layer at the Actor's run endpoint and parse the JSON dataset it returns.

#### What happens if I need Pinterest board, pin or ad data instead of profile data?

Pinterest Profile Scraper returns the profile header only. For pins and boards, use Pinterest Boards Scraper; for ad creative data, use Pinterest Ads Scraper — both listed under Related scrapers below.

#### Does Pinterest Profile Scraper return data in a format LLMs can use directly?

Yes. Every field is a typed JSON primitive or nested object with a consistent name across runs — no HTML, no selectors to write. Pass rows directly to an LLM prompt, index them into a vector store, or hand them to an agent tool.

#### What happens when Pinterest changes its layout or anti-bot system?

The Actor is maintained and targets Pinterest's underlying JSON payload rather than page markup, so the output schema is designed to stay stable across front-end changes. No specific turnaround time for fixes is published.

#### Can I use Pinterest Profile Scraper without managing proxies or browser infrastructure?

Yes. There's no browser to run — requests go out via `curl_cffi`, not a headless browser — and a proxy is optional; Pinterest answered this endpoint from a bare Apify datacenter IP during testing. Turn on `proxyConfiguration` only if you see `blocked` accounting rows.

#### Which Pinterest profile fields work best for AI training data and RAG indexing?

For RAG, index `about` and `seo_description` — the free-text fields with the most semantic content. For structured training features, `follower_count`, `pin_count`, `board_count`, `is_verified_merchant` and `createdAtIso` return as consistent typed primitives across every row.

### 🔗 Related scrapers

| Scraper | What it extracts |
| --- | --- |
| Pinterest Boards Scraper | Every pin on a Pinterest board: image/video variants, alt text, save counts, outbound links, board and pinner metadata |
| Pinterest Ads Scraper | Pinterest's public Ads Library: advertiser names, ad creative images/video, targeting info |
| LinkedIn Profile Post Scraper | LinkedIn profile pages and the posts published on them |
| Twitter (X.com) Tweets & Profiles Scraper | Public X (Twitter) profile stats alongside post-level engagement metrics |

### 💬 Your feedback

Found a bug or missing a field? Let us know through the Issues tab on this Actor's Apify Store page — that feedback goes straight to the people who maintain it.

# Actor input Schema

## `startUrls` (type: `array`):

One entry per profile. Accepts a bare username (`marthastewart`), a profile URL (`https://www.pinterest.com/marthastewart/`), a regional domain (`https://au.pinterest.com/marthastewart/`), or any sub-path below the profile root — a board URL such as `https://www.pinterest.com/marthastewart/holiday-recipes/` and a tab URL such as `https://www.pinterest.com/nike/_created/` both resolve to the parent profile. Search phrases are NOT supported: this actor scrapes profiles you name, it does not discover them. Anything that is not a username produces an uncharged row with `errorReason: invalid_input`.

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

Hard cap on how many of the supplied targets are processed, so a long list cannot run away with your budget. Every charged row counts against it. Example: 40 URLs with maxProfiles=10 scrapes the first 10. Set 0 to scrape every target supplied.

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

Whatever you choose here is used for every request in the run — there is no hidden proxy ladder and no silent fallback to a direct connection. Pinterest served this endpoint to a bare Apify datacenter IP in testing, so a proxy is optional; switch Apify Proxy on if you see `blocked` accounting rows.

## Actor input object example

```json
{
  "startUrls": [
    "marthastewart",
    "nike"
  ],
  "maxProfiles": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

# 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 = {
    "startUrls": [
        "marthastewart",
        "nike"
    ],
    "maxProfiles": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = {
    "startUrls": [
        "marthastewart",
        "nike",
    ],
    "maxProfiles": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/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/iezyqCmvQlSteiCcg/builds/9FsJ3jnQu8rO59xNX/openapi.json