# Buying Committee Map - Buyers, Champions, Blockers by Domain (`b2bdata/buying-committee-map`) Actor

Buying committee map by company domain: pick a buyer type, get the likely economic buyer, champions, evaluators, blockers and influencers per company with title, department and profile URL. Roles are guessed from titles. Free plan: 100 domains per run. Pay per member, empty lookups free. No login.

- **URL**: https://apify.com/b2bdata/buying-committee-map.md
- **Developed by:** [Open Enrich](https://apify.com/b2bdata) (community)
- **Categories:** Lead generation, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 committee member delivereds

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

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

## Buying Committee Map - Buyers, Champions, Blockers by Domain

Buying committee map by company domain: give a list of company domains and the team that buys your product, get the likely buying committee for each company, one row per person: economic buyer, champion, evaluator, blocker or influencer, with title, department, seniority, location and profile URL. The role is a guess from the job title, never a fact. No login, no cookies, no start fee. You pay only for a member row you receive.

**No login | Domains, URLs or emails in | One person per row | Role by team and seniority | Unknown domains = free | JSON/CSV export**

> **Domains in, committee out.** An account list tells you who the company is. This tells you who to talk to inside it: the leader of the team that owns your budget, the directors and managers who would run the evaluation, and the people in security, legal, finance and procurement who can slow a deal down. It does not return email addresses; for those chain it with [email-finder](https://apify.com/b2bdata/email-finder).

[See all actors by b2bdata](https://apify.com/b2bdata)

***

### 💳 Pricing and plans

One event, `committee-member`, charged once per person row delivered. Prices per 1,000 members (set on the Pricing tab):

| Event | When it is charged | Free plan | Gold plan |
|---|---|---|---|
| `committee-member` | A committee member row is delivered to your dataset | $1.896 | $1.396 |

Bronze and Silver prices are on the Pricing tab. Higher Apify plans only lower the price. Empty runs, unknown domains, domains with fewer than two matching people, failed lookups, unreadable entries and notices are free, and there is no start fee.

**Plan-credit math.** The free plan's $5 monthly credit covers about 2,630 members at the Free price, which is about 330 committees of 8.

#### Success-only billing

You are charged only for a member row you receive. A domain with no company on file, or with no likely committee members, gets one free notice row (`reason: "unknown_domain"` or `"no_committee"`). A domain where only one person matched is not a committee: it gets a free `thin_committee` notice and nothing is charged. A hosting or platform domain shared by too many companies gets a free notice (`domain_too_broad`). An entry that is not a domain, a repeat, or a lookup that fails is listed in `MISSES` with its position and a reason and costs nothing. If any of the four lookups for a domain fails, nothing is delivered or charged for that domain, so you never pay for a committee with a missing part.

#### The free plan

Free Apify accounts get up to 100 domains looked up per run, and as many runs as their Apify credit covers. Nothing is stored on our side. When a list is longer, the first 100 valid domains are looked up and one free notice row (`reason: "free_plan_limit"`) says how many were not looked up; they are not charged. Run again with the rest, or use a paid Apify plan for no per-run limit.

#### Keep a run small while you test

`maxPeoplePerDomain` (default 8, maximum 30) sets the committee size. `limit` (default 100, maximum 10,000) caps the whole run. Try one domain, read the rows, then scale up.

***

### ⚡ Why this buying committee actor?

- **Start from the domain.** `stripe.com`, `https://www.stripe.com/about` and `jane@stripe.com` all become `stripe.com`. No company-name matching and no LinkedIn URL needed.
- **Pick the buyer type once.** `buyerType` says which team buys your product: it, security, marketing, sales, finance, hr, engineering, data or operations. The roles follow from it.
- **Roles, not a flat list.** A plain employee list gives you 100 names. This gives you about 8 with a reason to call each one.
- **Every role has a stated basis.** `roleBasis` says in words why the person got the role.
- **Success-only, no start fee.** Unknown domains, thin committees, bad entries, repeats and notices are free.

***

### 🎯 Use cases: who to approach inside a target account

- **ABM account planning.** For each target account, get the people to multi-thread.
- **Security and compliance reviews.** List the blockers at an account before the deal reaches procurement.
- **Champion hunting.** Directors and managers in the team that owns your use case.
- **Agent workflows.** An AI agent holds company domains and needs a short, role-labelled list of people per account in one call.

***

### 🚀 Quick start: a committee for a list of domains

#### 1. One domain, a security product

```json
{ "items": ["stripe.com"], "buyerType": "security", "maxPeoplePerDomain": 8 }
```

#### 2. A list of accounts, a marketing tool

```json
{ "items": ["openai.com", "https://www.microsoft.com/en-us/about", "shopify.com"], "buyerType": "marketing", "maxPeoplePerDomain": 10, "limit": 30 }
```

Each entry becomes its bare domain before the lookup.

***

### ⚙️ Inputs

| Key | Type | Default | What it does |
|---|---|---|---|
| `items` | array of strings | required | Company domains, website URLs or email addresses. A company name is not a domain and is listed in `MISSES` as `invalid_domain`. The same domain written twice is looked up once. Free plan: 100 domains per run. |
| `buyerType` | string | `it` | The team that buys your product: `it`, `security`, `marketing`, `sales`, `finance`, `hr`, `engineering`, `data`, `operations`. Any other value stops the run with a message. |
| `maxPeoplePerDomain` | integer | 8 | Committee size per domain. Maximum 30. |
| `limit` | integer | 100 | Most people delivered in the whole run, which also caps what is charged. Maximum 10,000. Domains not reached are listed in `MISSES`. |
| `includeAudit` | boolean | false | Adds an `audit` object to each row. |

Any other field stops the run before a lookup with `remove unsupported fields: ...`. Nothing is charged.

***

### 🧭 How roles are assigned (a documented heuristic)

The role comes from two things in the job title: the team and the seniority. It is a rule of thumb, not knowledge of how any company really decides.

| `committeeRole` | Who gets it | Share of `maxPeoplePerDomain` |
|---|---|---|
| `economic_buyer` | C-level or VP whose title names the buyer team | 25% |
| `champion` | Director whose title names the buyer team | up to 40% together with evaluators |
| `evaluator` | Manager whose title names the buyer team | (see above) |
| `blocker` | C-level, VP or director in security, legal (incl. compliance and privacy), finance or procurement, except the buyer team | 25% |
| `influencer` | C-level, VP or director in IT, engineering, data or operations, except the buyer team | everything left |

Rows come in that order. If a band finds fewer people than its share, the next bands get the room. Teams inside a band take turns, so blockers show legal and finance, not three finance titles.

**The team (`department`) is read from keywords in the title:** security, legal, finance, procurement, hr, marketing, sales, data, it, engineering, operations, executive, other. A title that names two teams ("Director of Engineering, Head of Compliance") gets the first team in that list, which is the order above.

***

### 📤 Output

One result row per person. Rows for one domain stay together in the order above, domains keep input order. Empty values are left out.

| Key | Type | Meaning, and when it is missing |
|---|---|---|
| `companyDomain` | string | The domain from your entry, cleaned |
| `committeeRole` | string | `economic_buyer`, `champion`, `evaluator`, `blocker` or `influencer` |
| `roleBasis` | string | Why this role, in words. Always ends with "Guess from the title." |
| `fullName`, `firstName`, `lastName` | string | The person's name |
| `jobTitle` | string | Title of the position this row comes from |
| `seniority` | string | `cxo`, `vp`, `director` or `manager`, grouped from the title |
| `department` | string | The team read from title keywords |
| `headline` | string | The profile headline. Missing when the person has none |
| `location` | string | Place on the profile |
| `country` | string | Two-letter country code |
| `startYear` | integer | Year the person started the position. Missing when it is not on file |
| `connections` | integer | Connection count on the profile |
| `hasWorkEmail` | boolean | An address on another domain is on record. Missing when that could not be checked |
| `hasPersonalEmail` | boolean | A personal mailbox is on record. Missing when that could not be checked |
| `lowSignal` | boolean | `true` for a thin profile: under 10 connections and no start year. These sort last inside their role |
| `profileUrl` | string | Public profile URL |
| `slug` | string | Profile slug |
| `updatedAt` | string | When the profile was last refreshed in the data |
| `audit` | object | Only with `includeAudit`: `requestIds`, `inputRaw`, `buyerType` |

Example output (the shape is real, the values are illustrative):

```json
{
  "companyDomain": "stripe.com",
  "committeeRole": "economic_buyer",
  "roleBasis": "C-level title in security; same team as the security buyer. Guess from the title.",
  "fullName": "Ann Example",
  "firstName": "Ann",
  "lastName": "Example",
  "jobTitle": "Chief Information Security Officer",
  "seniority": "cxo",
  "department": "security",
  "headline": "Security leader",
  "location": "Dublin, Ireland",
  "country": "IE",
  "startYear": 2021,
  "connections": 1523,
  "hasWorkEmail": true,
  "hasPersonalEmail": false,
  "lowSignal": false,
  "profileUrl": "https://linkedin.com/in/ann-example",
  "slug": "ann-example",
  "updatedAt": "2025-01-02T03:04:05Z"
}
```

#### How to read the rows

- **A role is a guess.** Titles are not org charts. A CTO can own the security budget and a CISO can report to the CFO. Check `jobTitle` before you act on a role.
- **Who is on the list.** People the data holds as currently working at the companies that declare the domain. A domain can declare more than one company, and all of them are included.
- **Precision of the team.** Titles that only say "Head of IT" or "VP, Technology" can be missed or land in a neighbouring team. Odd titles ("Chief Kitchen Engineer") can pass as a team leader. Employer brand roles read as marketing.
- **Recall.** Each of the four lookups reads the first 40 matching titles. A very large company can have more people in a role than are shown; the order inside a role is the order of the data, with thin profiles last.
- **One person once.** A person with several positions, or one profile stored twice, is delivered once per run. If the same person is found at two domains in your list, the row stays with the first domain.
- **Email flags are not emails.** `hasWorkEmail: true` means an address is on record, not that we return it.
- **Pace.** Four lookups per domain at about one a second: about four seconds per domain, so 100 domains take about seven minutes.

#### Other records in the run

- **`MISSES`** (key-value store): `[{index, input, reason}]` for every entry without a result row. Reasons: `unknown_domain`, `no_committee`, `thin_committee`, `domain_too_broad`, `invalid_domain`, `duplicate_input` (the same domain as an earlier entry; `duplicateOf` names it), `not_looked_up_limit` (the run `limit` was reached first), or `Upstream HTTP <code>`.
- **`errors-buying-committee-map`** (key-value store): the lookups that failed for a technical reason, so you can re-run only those domains.
- **`RUN_SUMMARY`**: counts (requested, valid, looked up, people delivered) and, per domain, how many people were delivered per role.
- **Notice rows** (`type: "notice"`) appear for a domain with no data, a thin committee, a platform domain, a free-plan list longer than 100 (`free_plan_limit`), a reached `limit` (`limit_reached`), a reached spend limit (`charge_limit_reached`) or invalid input (`invalid-input`). Notices are never charged.

#### What is NOT returned

- Email addresses or phone numbers (use [email-finder](https://apify.com/b2bdata/email-finder))
- The real reporting lines, budgets or deal roles inside a company
- Work history, skills or education (use [linkedin-profile-by-url](https://apify.com/b2bdata/linkedin-profile-by-url))
- Company details such as industry or size

***

### 🛡️ Reliable results

**Our data promise.** We work to keep the data current, and we stand behind it. If a person has moved on, a company is missing or a row looks wrong, open the Issues tab with your run link. We review every report and sort it out with you, case by case.

- **No data is free and visible.** Every domain without a row is in `MISSES` with its position and a reason and is never charged.
- **No half committees.** If a lookup fails, nothing is delivered or charged for that domain.
- **Repeats are charged once.** The same domain written twice, or the same person found twice, is one row.
- **Typos fail early.** An unsupported input field, a bad buyer type or a limit above its maximum stops the run before any charge.

***

### 🤖 For AI agents (MCP)

This actor runs through the Apify MCP server. Prompt to copy:

> "Use b2bdata/buying-committee-map with items=\["stripe.com"], buyerType="security" and maxPeoplePerDomain=8. Return committeeRole, fullName, jobTitle and profileUrl."

**When to use it.** You hold company domains and need a short, role-labelled list of people to approach at each.
**When not to.** You need a full employee list (use b2bdata/people-at-company), email addresses (use b2bdata/email-finder) or a full profile (use b2bdata/linkedin-profile-by-url).
**Input contract.** `items` array of domains, URLs or emails; optional `buyerType` (default `it`), `maxPeoplePerDomain` 1-30 (default 8), `limit` 1-10,000 (default 100).
**Output contract.** One row per person with `companyDomain`, `committeeRole`, `fullName`, `jobTitle`, `department`, `profileUrl`. Roles are a documented title heuristic. Domains without data are a free notice row and listed in `MISSES`.
**Smoke test.** `maxPeoplePerDomain: 3` on a well-known domain returns up to three rows.
**Error cases.** `No valid domains` means no entry was a domain. `remove unsupported fields`, a bad `buyerType` or a bad number ends the run SUCCEEDED with one free `invalid-input` notice row and nothing charged.

***

### 🔌 Integrations: send results anywhere

1. **API.** Fetch rows from the run's default dataset: `GET /v2/datasets/{datasetId}/items?format=csv`.
2. **Webhook** on run success to push rows to your own endpoint.
3. **n8n, Make, Zapier.** Use the native Apify nodes: run the actor, then read the dataset.
4. **Google Sheets, Airtable, HubSpot, Salesforce, Clay.** Join on `companyDomain` and map `committeeRole`, `fullName`, `jobTitle` and `profileUrl` to contact fields.

***

### 🕐 Schedule examples

- **Weekly account refresh.** A schedule with a saved task that points at your target-account list.
- **New-account mapping.** A webhook from your CRM starts a run with the new domains.

***

### 🔗 Related actors

- `b2bdata/people-at-company`: every employee of a company domain, one row per person. [Open](https://apify.com/b2bdata/people-at-company)
- `b2bdata/email-finder`: a work email for a person at a domain. [Open](https://apify.com/b2bdata/email-finder)
- `b2bdata/headcount-by-department`: how many people a company has per team. [Open](https://apify.com/b2bdata/headcount-by-department)
- `b2bdata/linkedin-people-search`: search people across companies by title and location. [Open](https://apify.com/b2bdata/linkedin-people-search)

[See all actors by b2bdata](https://apify.com/b2bdata)

***

### ❓ FAQ

#### Data and coverage

**How do I find the buying committee of a company from its domain?**
Put the domain in `items`, set `buyerType` to the team that buys your product, and run. You get about eight people, each with a committee role.

**How is the committee role decided?**
From the job title: the team (security, finance and so on) and the seniority (C-level or VP, director, manager). The table under "How roles are assigned" lists every rule. It is a guess.

**Why did I get fewer people than my committee size?**
A company may have no one with a matching title, or the data may hold few people for it. Unused room moves to later roles. A domain with fewer than two matching people returns a free `thin_committee` notice instead of rows.

**Why is a domain missing from the results?**
It is in `MISSES` with a reason: no company on file, no matching people, a thin committee, a platform domain shared by many companies, a failed lookup or an entry that was not a domain.

**Do I get email addresses?**
No. `hasWorkEmail` and `hasPersonalEmail` say whether an address is on record. Use `b2bdata/email-finder` to find one.

**Do I need a LinkedIn account or cookies?**
No. It is a lookup without login, cookies or an account to ban.

#### Pricing

**What do I pay when a domain has no data?**
Nothing. There is no start fee, and unknown domains, thin committees, bad entries, repeats and notices are free.

***

### 🛟 Support

Use the **Issues** tab on this actor's Apify page for bugs, questions and feature requests. We answer within 48 hours on working days. Please include the run ID and the input you used. Published on Apify by b2bdata. Not affiliated with, endorsed by, or sponsored by any company or person named in the examples above.

# Changelog

This Actor's version history is a separate document: https://apify.com/b2bdata/buying-committee-map/changelog.md

# Actor input Schema

## `items` (type: `array`):

Company domains to map a buying committee for. Example: \["stripe.com", "https://www.openai.com/about", "jane@microsoft.com"]. A website URL or an email address is reduced to its domain; a company name is not a domain and is listed in the MISSES record as invalid_domain. Each domain is looked up once. A domain with no company on file, or too few matching people, returns one free notice row. Free plan: 100 domains per run.

## `buyerType` (type: `string`):

The team that owns the purchase of your product. The economic buyer and the champions are looked for in this team; blockers (security, legal, finance, procurement) and influencers (IT, engineering, data, operations) in the other teams. Default it.

## `maxPeoplePerDomain` (type: `integer`):

Most people delivered for one domain: about 25% economic buyers, 40% champions and evaluators, 25% blockers, the rest influencers. A person is delivered once. Default 8, maximum 30.

## `limit` (type: `integer`):

Most people delivered in the whole run, which also caps what is charged. Domains not reached are listed in MISSES and are not charged. Default 100, maximum 10000.

## `includeAudit` (type: `boolean`):

Adds requestIds, inputRaw and buyerType to each row under audit. Omit for clean rows.

## Actor input object example

```json
{
  "items": [
    "stripe.com"
  ],
  "buyerType": "it",
  "maxPeoplePerDomain": 8,
  "limit": 100,
  "includeAudit": false
}
```

# Actor output Schema

## `members` (type: `string`):

One row per person: committee role, name, title, department, seniority, company domain and profile URL

## `summary` (type: `string`):

Counts, members per role and domain, and stop reason for this run

# 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 = {
    "items": [
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2bdata/buying-committee-map").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 = { "items": ["stripe.com"] }

# Run the Actor and wait for it to finish
run = client.actor("b2bdata/buying-committee-map").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 '{
  "items": [
    "stripe.com"
  ]
}' |
apify call b2bdata/buying-committee-map --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2bdata/buying-committee-map"
        }
    }
}
```

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/TNHV5DBLoXKuvfu28/builds/wF1A1vmAcVIdTP3fs/openapi.json