# LinkedIn Employee Scraper & MCP Connector (`techforce.global/linkedin-company-employees`) Actor

LinkedIn Employee Scraper: find any company's employees name, title, department, seniority & profile URL. No login needed. Auto-deliver to Slack, Notion, Airtable via MCP.

- **URL**: https://apify.com/techforce.global/linkedin-company-employees.md
- **Developed by:** [Techforce Global](https://apify.com/techforce.global) (community)
- **Categories:** Agents, Jobs, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.40 / 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.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### LinkedIn Employee Scraper & MCP Connector

Scrape **every employee at any company on LinkedIn** — name, job title, department, seniority level, location, and profile URL, all as structured JSON. **No LinkedIn login, no cookies, no manual searching profile by profile.**

Built for sales teams doing account mapping, recruiters sourcing candidates, and researchers mapping a competitor's headcount — anyone who needs a clean list of who works where, in minutes instead of an afternoon of manual LinkedIn searches.

> **Enter a company name → get its employees → deliver it straight into Slack, Notion, Airtable, Jira, or your CRM.**

---

### ⭐ Why This Actor?

- ✅ **Just enter a company name** — no LinkedIn account, cookies, or session tokens required
- ✅ **No LinkedIn login risk** — discovery runs entirely through public search-engine results, never LinkedIn's own site
- ✅ **Stealth headless browser** — Playwright Chromium with anti-detection args, routed through Brave Search, with automatic PoW-CAPTCHA handling
- ✅ **Exact or fuzzy company matching** — require the full company name as a phrase, or loosen it to catch formatting variations
- ✅ **Every employee is tagged**, not just named — department (Technology, Sales, Marketing, Finance, HR, Product, Operations, Legal, Business) and seniority level are attached automatically
- ✅ **Automatic dedupe** — the same person found via multiple search queries is only ever returned once
- ✅ **Deliver anywhere via MCP connectors** — push results straight into Slack, Notion, Airtable, Jira, GitHub, or any MCP-compatible tool
- ✅ **Also runs in Standby mode** — as an on-demand HTTP API for `company_name` lookups, not just batch runs

---

### 📝 Use Cases & ROI

| Use Case | Time Saved | What You Get |
| --- | --- | --- |
| **Sales prospecting / account mapping** | 2–4 hrs/account | A ready contact list at a target company, tagged by department |
| **Recruiting & talent sourcing** | 1–3 hrs/search | Current staff by department/seniority for sourcing or market mapping |
| **Org-chart & competitive research** | 2–4 hrs/company | A department and seniority breakdown of a competitor's headcount |
| **Lead routing into your CRM/CMS** | 1–2 hrs/batch | Auto-delivery into Slack/Notion/Airtable skips the manual export-import step |
| **M&A / due diligence** | 1–3 hrs/target | A fast read on team size and function mix at a target company |

---

### 🚀 How to Use

1. Open the Actor on Apify.
2. Enter **Company Name** exactly as it appears on LinkedIn (e.g. `Techforce Global`).
3. Set **Max Profiles** — free plan runs are capped at 2 profiles per run; paid plans can request up to 50.
4. Leave **Exact company match** ON to require the full company name as a phrase, or turn it OFF for a looser, any-order word match.
5. _(Optional)_ Under **Proxy**, keep the default Residential Apify Proxy — strongly recommended, since datacenter IPs are frequently blocked by search-engine anti-bot checks.
6. _(Optional)_ Under **Delivery**, pick an **MCP connector**, a delivery mode, the tool to call, and a message template to push results into another tool automatically.
7. Click **Run** — profiles stream into the dataset as they're found.
8. Download as JSON, CSV, or Excel — or let the connector deliver them into your tools automatically once the run finishes.

> 🌐 **Proxy**: requests run through **Apify Proxy** (Residential group recommended) — Brave Search is far more likely to block datacenter IPs.
> 💡 First time with a connector? Run once with a connector selected — the log prints the connector's available tool names, so you know what to put in **Connector tool name**.

---

### 🧩 Input Configuration

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `company_name` | String | ✔️ Yes | Exact company name to search for (e.g. `Techforce Global`) |
| `max_profiles` | Integer | Optional | Max unique profiles to collect (1–50). Default: `2`. Free plan capped at 2; paid plans up to 50 |
| `exact_company_match` | Boolean | Optional | ON (default): full company name must match as a phrase. OFF: looser, any-order word match |
| `proxyConfiguration` | Object | Optional | Proxy used for all Brave Search requests. Default: Residential Apify Proxy |
| `mcpConnector` | Connector | Optional | Deliver results into a connector you've authorized (Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible tool) |
| `deliveryMode` | Enum | Optional | `perProfile` (one call per person), `summary` (one combined call), or `none` (dataset only). Default: `perProfile` |
| `mcpTool` | String | Optional | Name of the tool to call on the connector (e.g. `send_message`, `create_page`) |
| `mcpArguments` | Object | Optional | Arguments passed to the connector tool; string values support `{placeholders}` |
| `mcpMessageTemplate` | String | Optional | Markdown template rendered per profile and exposed as `{message}` |
| `debug` | Boolean | Optional | Verbose logging of every candidate result and why it was kept or skipped. Default: `false` |

#### Example — Minimal run

```json
{
    "company_name": "Techforce Global",
    "max_profiles": 25
}
````

#### Example — Looser, fuzzy company matching

```json
{
    "company_name": "Techforce Global",
    "max_profiles": 25,
    "exact_company_match": false
}
```

#### Example — Deliver each employee to Slack

```json
{
    "company_name": "Techforce Global",
    "max_profiles": 25,
    "mcpConnector": "<your-slack-connector>",
    "deliveryMode": "perProfile",
    "mcpTool": "send_message",
    "mcpArguments": { "channel": "#leads", "text": "{message}" },
    "mcpMessageTemplate": "*{name}* — {title}\n{location}\n{linkedin_url}"
}
```

#### Example — Deliver one summary page to Notion

```json
{
    "company_name": "Techforce Global",
    "max_profiles": 25,
    "mcpConnector": "<your-notion-connector>",
    "deliveryMode": "summary",
    "mcpTool": "create_page",
    "mcpArguments": { "title": "Employees at {company}", "content": "{message}" }
}
```

#### Placeholders available in arguments / template

- **`perProfile` mode:** `{name}` · `{linkedin_url}` · `{location}` · `{title}` · `{headline}` · `{department}` · `{seniority}` · `{message}` (the rendered template for that profile)
- **`summary` mode:** `{message}` (every profile's rendered template, joined) · `{count}` · `{company}`

***

### 📦 Output Fields

| Field | Description |
| --- | --- |
| `name` | Employee's name |
| `linkedin_url` | Normalized, canonical LinkedIn profile URL |
| `location` | Best-effort location extracted from the search result |
| `title` | Best available role/title string |
| `headline` | Short snippet/headline text from the search result |
| `department` | One of: Technology, Business, Finance, Marketing, Sales, Product, Operations, HR, Legal, General |
| `seniority` | Senior IC / Mid-Level / Junior · Associate / Entry-Level · Intern / Unknown |
| `title_verified` | `true` if the title matched a known role keyword, `false` if accepted on company evidence alone (e.g. no headline set) |

#### Example Output

```json
{
    "name": "Jane Doe",
    "linkedin_url": "https://www.linkedin.com/in/janedoe",
    "location": "Bangalore",
    "title": "Software Engineer",
    "headline": "Software Engineer at Techforce Global",
    "department": "Technology",
    "seniority": "Senior IC",
    "title_verified": true
}
```

A run summary is also written to the key-value store under `OUTPUT`, with `company`, `total_found`, `delivered`, `status`, and `finished_at`.

> You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

***

### 🔌 Integrations & Delivery

Deliver scraped employees into any MCP connector you've authorized in Apify — no glue code, no webhooks:

- **Slack / Discord** — post a message per employee, or one summary digest to a channel
- **Notion** — create a page per employee, or one combined page
- **Airtable / Google Sheets** — append a structured row per employee
- **Jira / GitHub / Linear** — open a task per employee (e.g. for outreach or sourcing follow-up)
- …or any other MCP-compatible connector

Credentials stay private — delivery runs through the **Apify MCP Proxy**, so the Actor never sees your connector tokens. You can also consume the dataset directly via the **Apify API**, or wire it into **n8n, Zapier, and Make**.

> ⚙️ **Delivery modes:** `perProfile` sends one call per employee found — best for CRM/task-tracker style destinations; `summary` sends one call combining every profile — best for a Slack digest or a single Notion page; `none` saves to the dataset only. MCP delivery only runs on the Apify platform and never affects what's saved to the dataset.

***

### 🛠️ How It Works

`my_actor/main.py` reads the input, then for the given company:

1. **Query building** — the company name is combined with a broad `site:linkedin.com/in` search plus role-keyword groups (engineering, IT/admin, analyst, sales/account, HR/recruiting, associate/support), covering employees across every department in one run.
2. **Search** — each query runs through Brave Search (`search.brave.com`) via a headless, stealth-configured Playwright Chromium browser routed through Apify Proxy. If Brave's PoW CAPTCHA appears, the Actor attempts to auto-solve it before continuing.
3. **Parsing** — each result page is parsed with BeautifulSoup to pull the LinkedIn URL, title, and snippet for every `linkedin.com/in/` result.
4. **Company gate** — a result is kept only if the target company name appears in its title, snippet, or metadata, using exact-phrase or fuzzy word matching per your input.
5. **Role tagging** — the title/snippet is matched against a keyword list to assign a normalized title, department, and seniority level. Profiles with no listed title but strong company evidence are still kept, flagged as unverified.
6. **Dedupe & collect** — profiles are deduplicated by canonical LinkedIn URL until `max_profiles` is reached.
7. **Save & deliver** — every profile is pushed to the dataset, then optionally delivered to your chosen MCP connector.

> 🕒 **Standby mode:** the Actor also runs as an on-demand HTTP API, answering `GET /?company_name=<name>&max_profiles=<n>&exact_company_match=<bool>` with the same JSON shape, for instant lookups instead of a full batch run.

**Built with:** [Apify SDK for Python](https://docs.apify.com/sdk/python/) · [Playwright](https://playwright.dev/python/) · [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/) · [MCP](https://modelcontextprotocol.io/)

***

### 🆘 Support

For issues, custom scraping requests, or feature suggestions:

**Email**: bhavin.shah@techforceglobal.com

***

#### Need a Custom Pipeline?

Want multi-company batch runs, scheduled refreshes, deeper enrichment, or a full CRM/data-warehouse integration?

#### [📅 Book a Free 15-min Consultation](https://calendly.com/techforce-infotech-pvt-ltd/intro-meeting?month=2026-01)

***

Made with ❤️ by **[Techforce](https://www.techforceglobal.com)**
Specialists in High-Performance Web Scrapers and AI Automation.

***

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn. LinkedIn® is a trademark of LinkedIn Corporation; all trademarks are property of their respective owners. The Actor only reads publicly indexed search-engine results — it does not log into LinkedIn, use LinkedIn credentials or cookies, or scrape LinkedIn's site directly. Use the data responsibly and in compliance with LinkedIn's Terms of Service, applicable data protection laws (e.g. GDPR), and the terms of the platforms you operate on.

# Actor input Schema

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

Exact company name to search for.

## `max_profiles` (type: `integer`):

Maximum number of unique employee profiles to collect and save to dataset. Free plan is capped at 2 profiles per run; paid plans can request up to 50.

## `exact_company_match` (type: `boolean`):

When ON (recommended), only profiles whose company name matches the full phrase you entered are kept — e.g. 'Techforce Global' will NOT match 'TechForce Telecom', 'LER TechForce', or 'Global TechForce'. Turn OFF for a looser match that accepts any profile mentioning all the significant words of the company name (in any order).

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

Requests to Brave Search are routed through this proxy. Residential Apify Proxy is strongly recommended — datacenter IPs are frequently blocked by search-engine anti-bot checks. Leave at the default to use Apify Proxy automatically.

## `mcpConnector` (type: `string`):

Optionally deliver the found employees into a connector you have authorized — Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible connector. Leave empty to only save results to the dataset.

## `deliveryMode` (type: `string`):

How to deliver to the connector: 'perProfile' (one call per decision maker), 'summary' (one call with all profiles combined), or 'none' (save to dataset only).

## `mcpTool` (type: `string`):

Name of the tool to call on the connector (e.g. 'create\_page' for Notion, 'send\_message' for Slack, 'create\_issue' for Jira/GitHub). If unsure, run once with a connector selected — the log lists the connector's available tools.

## `mcpArguments` (type: `object`):

Arguments passed to the connector tool. String values support {placeholders} from each profile: {name}, {linkedin\_url}, {location}, {title}, {headline}, and {message} (the rendered template below). Example for Slack: {"channel": "#leads", "text": "{message}"}.

## `mcpMessageTemplate` (type: `string`):

Optional Markdown template rendered per profile and exposed as the {message} placeholder in the tool arguments. Example: '*{name}* — {title}\n{location}\n{linkedin\_url}'.

## `debug` (type: `boolean`):

Log every Google result the actor considers, and why it was kept or skipped (company mismatch, not a decision maker, duplicate). Turn this on if a run finds 0 profiles and you want to see why. Off by default — very verbose.

## Actor input object example

```json
{
  "company_name": "Techforce Global",
  "max_profiles": 2,
  "exact_company_match": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "deliveryMode": "perProfile",
  "mcpTool": "",
  "mcpArguments": {},
  "mcpMessageTemplate": "",
  "debug": false
}
```

# Actor output Schema

## `results` (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 = {
    "company_name": "Techforce Global",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("techforce.global/linkedin-company-employees").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_name": "Techforce Global",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("techforce.global/linkedin-company-employees").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 '{
  "company_name": "Techforce Global",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call techforce.global/linkedin-company-employees --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=techforce.global/linkedin-company-employees",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Employee Scraper & MCP Connector",
        "description": "LinkedIn Employee Scraper: find any company's employees name, title, department, seniority & profile URL. No login needed. Auto-deliver to Slack, Notion, Airtable via MCP.",
        "version": "0.0",
        "x-build-id": "2HLNtTtPRqrPJheNy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techforce.global~linkedin-company-employees/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techforce.global-linkedin-company-employees",
                "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/techforce.global~linkedin-company-employees/runs": {
            "post": {
                "operationId": "runs-sync-techforce.global-linkedin-company-employees",
                "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/techforce.global~linkedin-company-employees/run-sync": {
            "post": {
                "operationId": "run-sync-techforce.global-linkedin-company-employees",
                "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",
                "required": [
                    "company_name"
                ],
                "properties": {
                    "company_name": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Exact company name to search for."
                    },
                    "max_profiles": {
                        "title": "Max Profiles",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of unique employee profiles to collect and save to dataset. Free plan is capped at 2 profiles per run; paid plans can request up to 50.",
                        "default": 2
                    },
                    "exact_company_match": {
                        "title": "Exact company match",
                        "type": "boolean",
                        "description": "When ON (recommended), only profiles whose company name matches the full phrase you entered are kept — e.g. 'Techforce Global' will NOT match 'TechForce Telecom', 'LER TechForce', or 'Global TechForce'. Turn OFF for a looser match that accepts any profile mentioning all the significant words of the company name (in any order).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Requests to Brave Search are routed through this proxy. Residential Apify Proxy is strongly recommended — datacenter IPs are frequently blocked by search-engine anti-bot checks. Leave at the default to use Apify Proxy automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "mcpConnector": {
                        "title": "Deliver to (MCP connector)",
                        "type": "string",
                        "description": "Optionally deliver the found employees into a connector you have authorized — Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible connector. Leave empty to only save results to the dataset."
                    },
                    "deliveryMode": {
                        "title": "Delivery mode",
                        "enum": [
                            "perProfile",
                            "summary",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to deliver to the connector: 'perProfile' (one call per decision maker), 'summary' (one call with all profiles combined), or 'none' (save to dataset only).",
                        "default": "perProfile"
                    },
                    "mcpTool": {
                        "title": "Connector tool name",
                        "type": "string",
                        "description": "Name of the tool to call on the connector (e.g. 'create_page' for Notion, 'send_message' for Slack, 'create_issue' for Jira/GitHub). If unsure, run once with a connector selected — the log lists the connector's available tools.",
                        "default": ""
                    },
                    "mcpArguments": {
                        "title": "Connector tool arguments",
                        "type": "object",
                        "description": "Arguments passed to the connector tool. String values support {placeholders} from each profile: {name}, {linkedin_url}, {location}, {title}, {headline}, and {message} (the rendered template below). Example for Slack: {\"channel\": \"#leads\", \"text\": \"{message}\"}.",
                        "default": {}
                    },
                    "mcpMessageTemplate": {
                        "title": "Message template",
                        "type": "string",
                        "description": "Optional Markdown template rendered per profile and exposed as the {message} placeholder in the tool arguments. Example: '*{name}* — {title}\\n{location}\\n{linkedin_url}'.",
                        "default": ""
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Log every Google result the actor considers, and why it was kept or skipped (company mismatch, not a decision maker, duplicate). Turn this on if a run finds 0 profiles and you want to see why. Off by default — very verbose.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
