# Company Team Page Scraper: Names & Job Titles from Websites (`steadyline/website-team-extractor`) Actor

Give it company websites, get the people each company publishes on its Team, About, Leadership and Board pages: name, job title, department, source page, plus LinkedIn/profile links and emails only when listed. One row per person, robots.txt respected, no LinkedIn scraping. By Steadyline Data.

- **URL**: https://apify.com/steadyline/website-team-extractor.md
- **Developed by:** [Steadyline Data](https://apify.com/steadyline) (community)
- **Categories:** Lead generation, Business, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 person founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Company Team Page Scraper: names & job titles from About, Team and Leadership pages

Give it a list of company websites. For each one it finds the company's own **Team, About, Leadership, People, Staff, Management and Board** pages and returns the **people the company publishes there**: name, job title, department or group, and the exact page each person came from. It also returns a LinkedIn or profile link, or a business email, **but only when the company's page lists it next to that person**. You get one row per person, ready for a CRM or spreadsheet.

- **Company-owned pages only.** No LinkedIn scraping, no search engines, no third-party people databases or data brokers.
- **No guessing.** Titles are copied as published. Emails are never constructed (no `first.last@` patterns).
- **Respects robots.txt.** Pages disallowed for our crawler are skipped.
- **Small footprint.** No headless browser, 8 pages per site by default (max 25), pages within a site fetched one at a time.
- **Pairs with [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor)**: that tool returns a company's emails, phones and social links; this one returns its **named people and titles**.

### Use cases

- **Account-based prospecting:** turn a list of target domains into the founders, executives and department heads each company lists publicly.
- **CRM enrichment:** add decision makers and their titles to company records in HubSpot, Salesforce or Pipedrive, with the source page for every row.
- **Org-chart and leadership monitoring:** run on a schedule and diff the results to spot new executives, departures and title changes.
- **Board and governance research:** pull directors and officers from board and governance pages of companies, nonprofits and associations.
- **Investor, partner and vendor due diligence:** see who runs a company before a call, straight from its own website.
- **Agency and recruiter research:** find the head of marketing, engineering or people at each account.

### How it works

1. Reads the URL you give (a homepage, a bare domain or a direct team page).
2. Follows same-site links that look like Team / Leadership / People / Staff / Board / Management / About / Impressum pages, best matches first. If the site links none (for example, a menu built with JavaScript), it tries a few common paths such as `/team`, `/leadership` and `/about`.
3. Extracts people from common layouts: card grids, heading + title pairs, lists, definition lists, tables, "Name, Title" lines, staff directories, schema.org `Person` JSON-LD and microdata, and plain name lists under a "Board of Directors" heading.
4. Skips non-people such as navigation, "Join the team" banners, job listings and customer testimonials. On pages that are not about the team (homepages, product pages) it only keeps structured data and clearly labelled leadership sections.
5. Deduplicates each person per site. If the same person appears with a second title, it goes in `otherTitles`.

### Input

```json
{
  "startUrls": ["hubspot.com", "https://about.gitlab.com/company/team/e-group/"],
  "followTeamPages": true,
  "maxPagesPerSite": 8,
  "includeStartPage": true,
  "maxPeoplePerSite": 200
}
```

| Field | Default | Notes |
|---|---|---|
| `startUrls` | – | Homepages, bare domains or team page URLs. One site per entry. |
| `followTeamPages` | `true` | Follow same-site team/about/leadership/people/staff/board links. |
| `maxPagesPerSite` | 8 | 1–25, including the start page. Failed pages are not counted. |
| `includeStartPage` | `true` | Turn off to use the start page only for finding links. |
| `maxPeoplePerSite` | 200 | Caps rows and `person-found` charges per site. Set to 10–25 for "mostly leadership". |
| `maxConcurrency` | 5 | Sites processed in parallel. |

### Output sample

One row per person:

```json
{
  "site": "https://www.acme-example.com",
  "status": "ok",
  "name": "Jane Example",
  "title": "Co-founder & CEO",
  "department": "Leadership",
  "sourceUrl": "https://www.acme-example.com/company/leadership",
  "linkedin": "https://www.linkedin.com/in/jane-example",
  "profileUrl": "https://www.acme-example.com/company/leadership/jane-example",
  "publicListedEmail": null,
  "otherTitles": ["Board Member"],
  "extraction": "card",
  "peopleOnSite": 14,
  "pagesScanned": 5,
  "startUrl": "https://acme-example.com",
  "scannedUrls": ["https://www.acme-example.com/", "https://www.acme-example.com/company/leadership"],
  "skippedByRobots": []
}
```

- `title` is `null` when the page lists a name without a role (for example, a plain list of board members). `department` then usually holds the group heading, such as "Board of Directors".
- `linkedin`, `profileUrl` and `publicListedEmail` are filled **only** when that link or address appears next to the person on the company's page.
- `extraction` tells you how the person was found: `card`, `card-title-first`, `inline`, `name-list`, `json-ld` or `microdata`.

Sites without people still get a row, so you can see every miss:

| `status` | Meaning | Charged? |
|---|---|---|
| `ok` | People found (one row per person) | `site-scanned` once + `person-found` per row |
| `no-people-found` | Site scanned, no published people found | `site-scanned` only |
| `unreachable` | Site down, DNS error, HTTP error or not HTML | No |
| `blocked-by-robots` | robots.txt disallows every page we needed | No |
| `invalid-url` | Input is not a usable URL | No |

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `site-scanned` | $0.001 | Once per website that was reached and scanned |
| `person-found` | $0.004 | Per named person returned (deduplicated per site) |

Invalid URLs, duplicates, unreachable sites and sites fully blocked by robots.txt are **never charged**. `maxPeoplePerSite` caps the per-person charge for each site.

**Cost example:** 1,000 company websites, where about 60% publish a team page with about 12 people each, gives roughly 7,200 people: 1,000 × $0.001 + 7,200 × $0.004 = **about $29.80**. With `maxPeoplePerSite` set to 10, the same mix is about $25.00 for 1,000 sites. Platform usage is included.

### Use it from AI agents (MCP), Zapier, Make, n8n or the API

**AI agents (Claude, Cursor, VS Code, ChatGPT and other MCP clients).** Add Apify's hosted MCP server with just this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steadyline/website-team-extractor"
    }
  }
}
```

Sign in with Apify (OAuth) on first connect, or add an `Authorization: Bearer <APIFY_TOKEN>` header. Then ask your agent, for example:

> Use steadyline/website-team-extractor to list the leadership team (name, title, source page) of these 15 company websites, and return a table grouped by company.

The agent sees this Actor's input schema and output fields, so it can call it without extra prompting. Agents that use the general Apify MCP server can also find it with `search-actors`.

This Actor uses pay-per-event pricing with limited permissions, so it can also be run through Apify's agentic payments (no Apify account needed for the agent). See the [Apify docs](https://docs.apify.com/platform/integrations/mcp#agentic-payments).

**Zapier, Make and n8n.** Use the official Apify app: Zapier "Run Actor" action, Make "Run an Actor" module, or the n8n Apify node. Choose `steadyline/website-team-extractor`, paste the input below, then use "Get dataset items" (or the run's dataset) to send people to Google Sheets, Slack, a CRM or a database.

**API (any language).** Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyline~website-team-extractor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["hubspot.com", "mozilla.org/en-US/about/leadership/"], "maxPagesPerSite": 8, "maxPeoplePerSite": 50}'
```

Or with the Python client (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("steadyline/website-team-extractor").call(run_input={"startUrls": ["hubspot.com"], "maxPeoplePerSite": 50})
for person in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(person.get("name"), "|", person.get("title"), "|", person.get("sourceUrl"))
```

### Works well with other Steadyline Data tools

- **Who + how to reach the company:** run this Actor for named people and titles, and [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor) for the company's public emails, phones and social links. About $0.031 per site combined at 7 people per site.
- **Fresh funding, then the team:** take new companies from [Recently Funded Companies (SEC Form D)](https://apify.com/steadyline/sec-form-d-funded-companies), then pull their leadership with this Actor.
- **Tech-targeted lists:** filter domains with [Tech Stack Detector](https://apify.com/steadyline/tech-stack-detector), then run this Actor on the matches.

### FAQ

**Does it scrape LinkedIn?**
No. It never visits LinkedIn, search engines or people-data providers. A LinkedIn URL is returned only when the company's own page links it next to that person.

**Does it find email addresses?**
Only addresses that the company's page publishes next to that person (`publicListedEmail`). It does not guess or construct emails. For company-level contact points, use [Website Contact Scraper](https://apify.com/steadyline/website-contact-extractor).

**Why did a site return `no-people-found`?**
Usually the team is only shown after JavaScript runs, inside images, or the site has no team page. These sites cost $0.001 (the scan was done) and are listed so you can see the miss.

**Can I give it a direct team page?**
Yes. A deep URL such as `https://example.com/about/leadership` is scanned first, and linked sub-pages (for example, separate board or executive pages) are followed.

**How accurate is it?**
On company sites that render their team in HTML, it finds most listed people with their titles. Department labels are best-effort, taken from the nearest section heading. See Limits below.

**Can I run it on a schedule?** Yes. Create an Apify Schedule (or a saved Task with a schedule) and connect a webhook or integration to receive results.

**Need a feature or found a bug?** Open an issue on the Issues tab of this page or email hello@steadylinedata.com. Built and maintained by **Steadyline Data**.

### Acceptable use, privacy and GDPR

This tool collects **business roles that organizations publish about their own people** on their own public websites: names, job titles and links the company chose to show. It does not collect home addresses, personal phone numbers or private data, and it does not log in anywhere.

- Names and titles of identifiable people are personal data under GDPR, UK GDPR, CCPA and similar laws. **You are responsible for having a lawful basis** (for example, legitimate interest with a documented balancing test) to store or contact them, for honoring opt-outs and data-subject requests, and for following anti-spam laws (CAN-SPAM, PECR, ePrivacy, CASL).
- Only supply websites you have a legitimate reason to process, and follow each site's terms of use.
- The output is **not a consumer report**. Do not use it for decisions about credit, employment, insurance, housing or any other FCRA-covered purpose, or for harassment, surveillance or reselling personal data.

Steadyline Data provides this tool as is and does not give legal advice.

### Limits

- Teams rendered only by JavaScript (no HTML fallback), shown in images or behind logins are not found.
- Pages in other languages are supported for common layouts. The site's language prefix (`/fr/`, `/de/`) is kept, so other language versions are not scanned twice.
- Department is taken from the nearest section heading and can be imprecise on long pages.
- Very large staff directories split across many pages are limited by `maxPagesPerSite` (max 25).

# Actor input Schema

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

Company homepages, bare domains (acme.com) or a direct team page URL. One site per entry. Duplicates are merged; invalid URLs are reported and never charged.

## `followTeamPages` (type: `boolean`):

Follow links that look like Team, About, Leadership, People, Staff, Board or Management pages on the same site (best ones first). If the site links none, a few common paths such as /team and /about are tried.

## `maxPagesPerSite` (type: `integer`):

Includes the start page. Pages that fail to load are not counted.

## `includeStartPage` (type: `boolean`):

Turn off to use the start page only for finding team links (useful when homepages show customer testimonials).

## `maxPeoplePerSite` (type: `integer`):

Caps rows (and person-found charges) per site. Set to e.g. 10 to get mostly the leadership listed first.

## `respectRobotsTxt` (type: `boolean`):

Always on; pages disallowed by robots.txt are skipped.

## `maxConcurrency` (type: `integer`):

Sites processed in parallel (pages within a site are fetched one at a time).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.hubspot.com/company/management",
    "https://about.gitlab.com/company/team/e-group/"
  ],
  "followTeamPages": true,
  "maxPagesPerSite": 8,
  "includeStartPage": true,
  "maxPeoplePerSite": 200,
  "respectRobotsTxt": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `people` (type: `string`):

One row per person found (plus one row per site with no people or errors).

## `sites` (type: `string`):

Status and pages scanned per row.

# 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": [
        "https://www.hubspot.com/company/management",
        "https://about.gitlab.com/company/team/e-group/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyline/website-team-extractor").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": [
        "https://www.hubspot.com/company/management",
        "https://about.gitlab.com/company/team/e-group/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steadyline/website-team-extractor").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": [
    "https://www.hubspot.com/company/management",
    "https://about.gitlab.com/company/team/e-group/"
  ]
}' |
apify call steadyline/website-team-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyline/website-team-extractor"
        }
    }
}
```

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/zgdC5aoqCNGMK19Ux/builds/LcaegKzXYVHHPHDjH/openapi.json
