# Pinterest Brand Presence Mapper - Followers for Clay (`mambalabs/pinterest-brand-presence-mapper`) Actor

Resolves a company domain to its Pinterest business account and returns exact follower, pin and board counts plus activity recency. Built to join a company level ecommerce profile on company\_domain. Flat, Clay ready.

- **URL**: https://apify.com/mambalabs/pinterest-brand-presence-mapper.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.45 / 1,000 company checkeds

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 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

### 🔎 What can Pinterest Brand Presence Mapper do?

Give it a company domain and it returns that company's Pinterest business account with **exact** follower, pin and board counts, its claimed website, verified merchant status and how recently it pinned.

### 💡 Why use Pinterest Brand Presence Mapper?

**The counts are exact.** Pinterest serves real integers, so unlike Instagram, TikTok, YouTube, Threads and Facebook, these numbers can be summed across a target list without summing the platform's rounding.

**Board count is the better activity signal.** Followers are a vanity metric on every platform. Boards are curation work, and a consumer brand with thirty boards is investing in Pinterest in a way that one with three thousand followers and two boards is not.

**It refuses to report a stranger's account as yours.** This matters more on Pinterest than anywhere else in this family, because handles here are rarely the domain stem. Guessing `pinterest.com/stripe` for stripe.com returns a real, active account with 35 followers, 117 pins and 30 boards, belonging to a private individual named Debra Rotz. This actor reports `identity_mismatch` and no counts. A tool without that check would publish her numbers under Stripe's domain.

**It joins cleanly with company level ecommerce data.** Identity columns use the fleet's standard spelling and every count is an integer, so a join on `company_domain` needs no cleaning step.

#### 🧭 Why identity checking matters so much here

Pinterest usernames are rarely the domain stem, and B2B homepages declare Pinterest even less often than they declare TikTok. So the guess route gets used a lot, and the guess route is where wrong accounts come from.

Every account found by guessing or by search is checked against the company before its numbers ship, using two signals the guess did not choose: the account's own display name, and the website it claims. When neither corroborates, the row reports `identity_mismatch`, keeps the URL so a human can check the call, and returns no counts.

### 📋 What data can Pinterest Brand Presence Mapper extract?

| Field | Type | Meaning |
|---|---|---|
| `degraded` | boolean | True when this row could not be produced normally, for example the company site was unreachable and no discovery could run. A degraded row is never charged. |
| `degradation_reason` | string | null | Why the row is degraded, in plain words. Null on a normal row. |
| `company_domain` | string | null | The company domain this row is about, normalized. Null when only a handle or a name was supplied. This is the join key across the whole Mamba Labs fleet. |
| `company_name` | string | null | The company name as supplied or derived. Improves search accuracy and is what the identity gate matches against. |
| `pinterest_url` | string | null | Canonical Pinterest profile URL, or null when no trustworthy account was found. |
| `pinterest_handle` | string | null | The resolved Pinterest username. |
| `pinterest_followers` | integer | null | Exact follower count. Pinterest serves the real integer, so this number can be summed across a list, unlike Instagram, TikTok, YouTube, Threads and Facebook. |
| `pinterest_followers_exact` | boolean | null | Always true when a count was returned. Pinterest does not round. |
| `pinterest_following` | integer | null | How many accounts this account follows. |
| `pinterest_pin_count` | integer | null | Total pins on the account. Zero is a real answer and means a claimed but unused account. |
| `pinterest_board_count` | integer | null | Total boards on the account. For a consumer brand this is a better activity signal than follower count: boards are curation effort and followers are not. |
| `pinterest_display_name` | string | null | The account display name. This is what the identity gate checks against, and on this platform it does real work. |
| `pinterest_about` | string | null | The account about text. |
| `pinterest_website` | string | null | The website the account links to. When its host is the company domain, the account is provably this company's and needed no guessing. |
| `pinterest_verified_merchant` | boolean | null | True when Pinterest marks the account as a verified merchant, which is a real commerce signal rather than a vanity badge. |
| `pinterest_last_pin_at` | string | null | When the account last saved a pin, where the page declares it. An account with boards and no recent pins is dormant. |
| `pinterest_discovery` | string | null | How the account was found: input\_handle, homepage\_sameas, homepage\_link, search or pattern\_guess. Treat pattern\_guess with particular suspicion on Pinterest: see Known limits. |
| `pinterest_status` | string | ok, not\_found, not\_extractable, blocked, identity\_mismatch, auth\_failed or skipped. identity\_mismatch is more common here than anywhere else in this actor family and it is the actor working correctly. |
| `run_date` | string | ISO 8601 timestamp of this run. Social counts move, so a row without a date is a number with no shelf life. |

`pinterest_website` is the strongest field on the row for verification. When its host equals your `company_domain`, the account is provably the company's own.

### 🛠️ How to find a company's Pinterest account

1. Put a company domain in `company_domain`.
2. Add `company_name`. On this platform it does more work than anywhere else, because it is what the identity gate checks a guessed account against.
3. If you already know the handle, put it in `handle`. That skips discovery and the identity risk with it.
4. For a list, pass an array of objects.

#### 🧪 Using it in Clay

Add an **Enrichment > Apify** column, map `company_domain`.

This actor pays off on consumer and ecommerce brands and returns `not_found` on most pure B2B software companies, which is correct rather than a failure. Gate the column on your ICP so you are not spending credits establishing that a devtools company has no Pinterest.

### 💵 How much does it cost?

Pay per event. You are charged for output, never for input.

| Event | Fires when | Price |
|---|---|---|
| `company-checked` | Once per company for which the discovery cascade completed and a non degraded row was produced, whether or not a Pinterest profile was found. Does not fire on a degraded row, because on a degraded row no discovery was performed. | $0.0035 |
| `profile-resolved` | Once per company whose candidate Pinterest URL passed the identity gate. Fires on the validation work, not on a populated count. A candidate dropped as an impersonator does not charge: the work was done and the honest answer is that there is no such profile. | $0.0030 |
| `follower-count-extracted` | Once per company where a numeric follower count was read off the public page. Does not fire on not\_extractable, blocked, identity\_mismatch or url only runs. | $0.0025 |

An `identity_mismatch` row charges `company-checked` and `profile-resolved`, because a candidate was found, fetched and validated, and the answer is that it was not this company. It does not charge the extraction event.

**What the same coverage costs bought a la carte:** There is no Pinterest company presence actor on the Apify Store that accepts a company domain. Pinterest scrapers on the Store take a username or a board URL and return pins, which is content rather than company presence. There is no like for like price, so this follows the family's own three event shape.

### ⌨️ Input

| Field | Type | Required | Meaning |
|---|---|---|---|
| `company_domain` | string | no | Bare company domain, for example shopify.com. Supply this or a handle. With a domain the actor runs full discovery; with a handle it skips straight to the fetch. |
| `company_name` | string | no | Optional. Improves search accuracy and is what the identity gate checks a discovered profile against, so supplying it reduces wrong matches. |
| `handle` | string | no | Optional. The Pinterest username from pinterest.com/<handle>. Supplying it skips discovery and, more importantly, skips the identity risk: Pinterest handles are rarely the domain stem. |
| `includeFollowerCounts` | string | no | When "true" (default) the profile page is fetched and the counts are extracted. Set "false" to resolve the profile URL only, which is cheaper and needs no proxy. Sent as a string for Clay compatibility. |
| `skipCache` | string | no | When "false" (default) a successful lookup is cached for seven days and reused. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility. |

```json
{
  "company_domain": "shopify.com",
  "company_name": "Shopify"
}
```

### 📤 Output

One flat, snake\_case row per company. No nested objects, so it drops straight
into Clay, a spreadsheet or a warehouse table without a flattening step.

```json
{
  "degraded": false,
  "degradation_reason": null,
  "company_domain": "shopify.com",
  "company_name": "Shopify",
  "pinterest_url": "https://www.pinterest.com/shopify/",
  "pinterest_handle": "shopify",
  "pinterest_followers": 123456,
  "pinterest_followers_exact": true,
  "pinterest_following": 52,
  "pinterest_pin_count": 117,
  "pinterest_board_count": 30,
  "pinterest_display_name": "Shopify",
  "pinterest_about": "The entrepreneurship company.",
  "pinterest_website": "https://www.shopify.com",
  "pinterest_verified_merchant": true,
  "pinterest_last_pin_at": "2026-07-14T00:00:00.000Z",
  "pinterest_discovery": "homepage_link",
  "pinterest_status": "ok",
  "run_date": "2026-08-22T09:00:00.000Z"
}
```

#### false versus null, and why the difference matters

`false` means we looked and the answer is no. `null` means we could not look,
or the platform withheld it. They are never interchangeable in this output. If
you filter for companies with no presence on this platform, filter on `false`,
because `null` rows are unknown rather than absent and including them will
overstate your list.

### 💡 Tips

- **Check `pinterest_website` first.** It is the cheapest confirmation that the row is right.
- **Compare `pinterest_board_count`, not followers,** when you are ranking brands by Pinterest investment.
- **Filter out `pattern_guess` rows** if a wrong match would be costly, even though they are gated.
- **`not_found` on a B2B software company is the correct answer,** not a coverage gap.

### ⚠️ Known limits

- **Discovery is genuinely hard here.** Pinterest handles are rarely the domain stem and few B2B homepages declare a Pinterest link. Expect `not_found` and `identity_mismatch` more often than on LinkedIn or YouTube.
- **The page is heavy,** 1.4 MB, second only to YouTube in this family. Cheap in money over datacenter routing, not fast.
- **No pins, no boards content, no pin engagement.** Account level presence and counts only.
- **A personal account can look exactly like a brand account.** That is why the identity gate exists and why `identity_mismatch` is a status you will see.
- **Follower counts are a public vanity metric,** a proxy for reach rather than a measurement of it.

### ❓ FAQ

**Why do I get `identity_mismatch` so often on Pinterest?**
Because Pinterest handles rarely match domain stems, so the actor has to guess more often, and a guess frequently lands on a real account belonging to somebody else. Reporting the mismatch is the actor working correctly.

**Are the counts exact?**
Yes. Pinterest serves real integers.

**Why does a B2B company return `not_found`?**
Because it probably has no Pinterest account. That is a real answer.

**Does this need a Pinterest login or API key?**
No.

**Can I pass a handle instead of a domain?**
Yes, in `handle`, and on this platform it is the safest input.

### 🧩 Want other GTM data?

Mamba Labs builds a fleet of GTM enrichment actors that share one flat,
Clay-ready output convention, so their rows join on `company_domain` with no
cleaning step:

- **Company Firmographic Enricher** headcount, industry, location and revenue band from a domain, joins on `company_domain`.
- **Domain to LinkedIn URL Resolver** the company LinkedIn URL for domains where the social mapper found none.
- **GTM Hiring Signal Scraper** open go to market roles, which is the buying signal a follower count is a proxy for.
- **Company Social Presence Mapper** every platform in one row when you want breadth rather than depth on one network.

Full fleet: [apify.com/mambalabs](https://apify.com/mambalabs)

### 🆘 Support

Issues, field requests and bug reports: open an issue on the actor's Issues tab.
Mamba Labs reads every one.

# Actor input Schema

## `company_domain` (type: `string`):

Bare company domain, for example shopify.com. Supply this or a handle. With a domain the actor runs full discovery; with a handle it skips straight to the fetch.

## `company_name` (type: `string`):

Optional. Improves search accuracy and is what the identity gate checks a discovered profile against, so supplying it reduces wrong matches.

## `handle` (type: `string`):

Optional. The Pinterest username from pinterest.com/<handle>. Supplying it skips discovery and, more importantly, skips the identity risk: Pinterest handles are rarely the domain stem.

## `includeFollowerCounts` (type: `string`):

When "true" (default) the profile page is fetched and the counts are extracted. Set "false" to resolve the profile URL only, which is cheaper and needs no proxy. Sent as a string for Clay compatibility.

## `skipCache` (type: `string`):

When "false" (default) a successful lookup is cached for seven days and reused. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility.

## `source_tag` (type: `string`):

Internal attribution tag set by Mamba Labs on published task examples. Not required, and nothing depends on it. Leave it empty.

## Actor input object example

```json
{
  "company_domain": "shopify.com",
  "company_name": "Shopify",
  "includeFollowerCounts": "true",
  "skipCache": "false"
}
```

# Actor output Schema

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

Dataset of one flat row per company, with per platform status so a blocked fetch never reads as a zero.

# 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 = {
    "company_domain": "shopify.com",
    "company_name": "Shopify",
    "handle": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/pinterest-brand-presence-mapper").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 = {
    "company_domain": "shopify.com",
    "company_name": "Shopify",
    "handle": "",
}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/pinterest-brand-presence-mapper").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 '{
  "company_domain": "shopify.com",
  "company_name": "Shopify",
  "handle": ""
}' |
apify call mambalabs/pinterest-brand-presence-mapper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mambalabs/pinterest-brand-presence-mapper"
        }
    }
}

```

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/d1HvjZfKhgvWsoEwn/builds/I8eJgmtuZ1OVdETe2/openapi.json