# B2B Talent Sourcing Brief — Recruiter Account Intel (`noniner/b2b-talent-sourcing-brief`) Actor

For each target company, a recruiter-ready brief: what they do, their tech stack, the roles they're hiring right now, talent signals and the best angle to pitch recruiting services — or to source talent from them.

- **URL**: https://apify.com/noniner/b2b-talent-sourcing-brief.md
- **Developed by:** [Fredrik Hansson](https://apify.com/noniner) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $250.00 / 1,000 company briefeds

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

## B2B Talent Sourcing Brief — Recruiter Account Intel

**Point it at a list of companies and get back a recruiter's cheat sheet for each one.** Give it the domains of the companies you want to pitch recruiting services to — or source talent from — and this Actor hands back a one-page **talent sourcing brief** per company: what they do, the tech they run on, the exact roles they're hiring for *right now*, the talent signals that matter, and the single sharpest angle to open the conversation.

You bring the target list. It hands back a ready-to-send recruiter brief.

***

### The flow

```
                            ┌─ firmographic organ ─ noniner/ai-company-enrichment
  domains                   │
 (stripe.com,   ──────────► ├─ technographic organ ─ noniner/b2b-tech-stack-detector  ──►  AI recruiter brief
  notion.so, …)             │                                                            (one page per company)
                            └─ hiring organ ────── noniner/career-site-jobs-api
```

1. **Paste the companies** you care about into `domains` — domains, website URLs or emails all work.
2. **The Actor fires three research organs once across the whole list**, indexes everything by company, and degrades gracefully if any organ comes back empty.
3. **An AI then writes one grounded brief per company** — tech stack, open roles, talent signals and the best way in — assembled into a clean markdown page you can paste straight into your CRM, a Slack message or an email.

***

### What you get per company

For every company, the Actor returns:

1. **`companyOverview` / `whatTheyDo` / `industry` / `sizeSignal`** — who they are, in plain English, grounded in firmographic data.
2. **`techStackSummary`** — the stack they run on (so you know which engineers to source), or `null` if nothing was detected.
3. **`currentHiring`** — a short summary of the roles they're hiring for *right now*, read directly from their live career site.
4. **`rolesInDemand`** — the actual open job titles (or tight title groups) they're recruiting for.
5. **`talentSignals`** — inferred signals like *"scaling engineering"*, *"hiring senior security"* or *"building a sales team"* — the stuff that tells you they need help.
6. **`bestPitchAngle`** — one sentence: exactly how a recruiting agency should pitch them (framed around your own offering if you provide one).
7. **`sourcingNotes`** — where and what kind of talent to source for them.
8. **`oneLineSummary`** — a crisp one-liner on the company and its hiring posture.
9. **`briefMarkdown`** — all of the above assembled into a clean, one-page markdown brief, ready to paste.

Everything is **grounded strictly in the research data** — the AI never invents roles, offices or numbers.

***

### Three ways people use it

- **Recruiting-agency business development** — build a prospecting list of companies that are *actively hiring in your specialism*, each with the best pitch angle already written. Stop cold-guessing which companies to pitch recruiting to; lead with the roles they can't fill.
- **Talent mapping** — profile a set of target companies to understand their tech stack and open roles, so you know **who to source and from where** — perfect for headhunting and passive-candidate research.
- **Staffing & market intel** — scan a whole category of companies for hiring intensity, role mix and talent signals to spot where demand is heating up and which accounts to prioritise.

Whether you're figuring out *which companies to pitch recruiting to*, doing sourcing research before a search mandate, or mapping a competitor's team as it scales — this packages the whole research step into one call.

***

### How the orchestration works

This Actor is an **orchestrator**: it runs proven public organs once across your list, then layers an AI synthesis on top.

| Organ | Actor | What it contributes |
|---|---|---|
| Firmographics | [`noniner/ai-company-enrichment`](https://apify.com/noniner/ai-company-enrichment) | What the company does, industry, size signal, offerings, target customers. |
| Technographics | [`noniner/b2b-tech-stack-detector`](https://apify.com/noniner/b2b-tech-stack-detector) | Detected technology stack + inferred engineering team signals. |
| Hiring | [`noniner/career-site-jobs-api`](https://apify.com/noniner/career-site-jobs-api) | Live open roles from the company's career site (Greenhouse, Lever, Ashby and more). |

Each organ is **best-effort**: if one returns nothing, the brief is still produced from whatever the others found, and `sourcesUsed` reflects exactly which organs contributed.

> **A note on the hiring organ:** open roles are read from public ATS boards (Greenhouse / Lever / Ashby). If a company hosts its careers page on an unsupported platform, no roles are matched — `currentHiring` says so, and the brief still ships from the firmographic + technographic + AI layers.

***

### Input

| Field | Type | Notes |
|---|---|---|
| `domains` | array | **Required.** Company domains, website URLs or emails — one per line. |
| `recruiterOffering` | string | Optional. What your recruiting / staffing agency offers. Frames `bestPitchAngle` and `sourcingNotes`. |
| `maxResults` | integer | Max companies to brief. Default `25`. One charge per company briefed. |
| `maxConcurrency` | integer | Companies synthesized in parallel. Default `3`. |
| `model` | string | OpenAI model. Default `gpt-4o-mini`. |
| `useEnrichment` | boolean | Call the firmographic organ. Default `true`. |
| `useTechStack` | boolean | Call the technographic organ. Default `true`. |
| `useHiring` | boolean | Call the hiring organ. Default `true`. |

#### Minimal input example

```json
{
  "domains": ["stripe.com", "notion.so"],
  "recruiterOffering": "We place senior backend and security engineers"
}
```

***

### Output example

```json
{
  "domain": "stripe.com",
  "companyName": "Stripe",
  "oneLineSummary": "Stripe is a global payments platform hiring heavily across engineering and security.",
  "companyOverview": "Stripe builds economic infrastructure for the internet, powering payments and financial tooling for millions of businesses worldwide.",
  "whatTheyDo": "Provides payment processing and financial APIs for online businesses.",
  "industry": "Financial technology / payments",
  "sizeSignal": "Large, late-stage global company",
  "techStackSummary": "Modern web stack with heavy backend and infrastructure investment.",
  "currentHiring": "Hiring across backend engineering, security and infrastructure, with several senior roles open.",
  "rolesInDemand": ["Software Engineer, Backend", "Security Engineer", "Infrastructure Engineer"],
  "talentSignals": ["Scaling engineering", "Hiring senior security", "Investing in infrastructure"],
  "bestPitchAngle": "Lead with your senior backend and security bench — Stripe has multiple open roles in exactly those functions.",
  "sourcingNotes": ["Source senior backend engineers with payments/fintech experience", "Target security engineers with cloud infra backgrounds"],
  "sourcesUsed": ["ai-company-enrichment", "b2b-tech-stack-detector", "career-site-jobs-api"],
  "briefMarkdown": "# Talent Sourcing Brief — Stripe\n**Domain:** stripe.com  ·  **Industry:** Financial technology / payments  ·  **Open roles:** 12\n\n_Stripe is a global payments platform hiring heavily across engineering and security._\n\n## Current hiring\nHiring across backend engineering, security and infrastructure…\n\n## Best pitch angle\n> Lead with your senior backend and security bench…"
}
```

***

### Pay-per-event pricing

This Actor uses **pay-per-event** billing with a single event:

| Event | Price | Charged when |
|---|---|---|
| `company-briefed` | **$0.25** | Once per company researched into a finished recruiter brief. This one charge **bundles up to three orchestrated sub-actor runs** (firmographic enrichment, technographic detection, hiring/career-site) **plus** the OpenAI synthesis. |

The Actor logs its OpenAI token usage and the estimated AI cost per company at the end of every run, so the event price always stays safely above the model cost.

***

### Setup

The AI synthesis calls the OpenAI API. Set the environment variable / secret **`OPENAI_API_KEY`** on the Actor. Without it, the organs still run but no brief is synthesized.

***

### Use it from an AI agent (Apify MCP server)

This Actor is available through the [Apify MCP server](https://mcp.apify.com), so AI agents (Claude, ChatGPT, or anything that speaks MCP) can call it as a tool — hand it a list of `domains` and your `recruiterOffering`, and read back a finished recruiter brief per company — with no custom integration code.

***

### Run it locally

```bash
npm install
## put your input in storage/key_value_stores/default/INPUT.json
export OPENAI_API_KEY=sk-...   # required for the AI brief
apify run -p
```

***

### Related actors

- [B2B Hiring Signal Tracker](https://apify.com/noniner/b2b-hiring-signal-tracker) — Track which companies are ramping up hiring, by function and over time.
- [Career Site Jobs API](https://apify.com/noniner/career-site-jobs-api) — Every open job from Greenhouse, Lever, Ashby, Workday and more in one clean schema.
- [B2B Tech Stack Detector](https://apify.com/noniner/b2b-tech-stack-detector) — Detect the technology stack behind any company's website.
- [B2B Account Brief](https://apify.com/noniner/b2b-account-brief) — The sales-facing sibling: a pre-call account brief for AEs instead of recruiters.

***

**Part of the [No Niner](https://noniner.io) toolkit** — no-code web scraping, enrichment & AI data tools, all pay-per-use. Browse the full set at **[noniner.io](https://noniner.io)**.

# Actor input Schema

## `domains` (type: `array`):

Company domains, website URLs or emails (the domain is extracted). One per line — these are the companies you want a talent-sourcing brief for.

## `datasetId` (type: `string`):

Optional. Read the domains from a previous Actor run's dataset — for no-code chaining via the Integrations tab.

## `datasetField` (type: `string`):

Which dataset field holds the domain/URL. Leave blank to auto-detect (domain, website, companyDomain, url, companyUrl).

## `recruiterOffering` (type: `string`):

Describe what your recruiting / staffing / talent-sourcing agency offers (e.g. 'We place senior backend and security engineers'). If set, the best pitch angle and sourcing notes are framed around how your service fits each company's hiring.

## `maxResults` (type: `integer`):

Max companies to brief. One pay-per-event charge per company briefed.

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

How many companies to synthesize in parallel in the AI brief stage.

## `model` (type: `string`):

Override the model (default gpt-4o-mini).

## `useEnrichment` (type: `boolean`):

Call noniner/ai-company-enrichment for firmographics (what they do, industry, size, offerings).

## `useTechStack` (type: `boolean`):

Call noniner/b2b-tech-stack-detector for the detected technology stack and team signals.

## `useHiring` (type: `boolean`):

Call noniner/career-site-jobs-api to read the open roles each company is hiring for right now (Greenhouse, Lever, Ashby and more).

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so"
  ],
  "maxResults": 25,
  "maxConcurrency": 3,
  "model": "gpt-4o-mini",
  "useEnrichment": true,
  "useTechStack": true,
  "useHiring": true
}
```

# Actor output Schema

## `briefs` (type: `string`):

All recruiter briefs in the default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "stripe.com",
        "notion.so"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("noniner/b2b-talent-sourcing-brief").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 = { "domains": [
        "stripe.com",
        "notion.so",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("noniner/b2b-talent-sourcing-brief").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 '{
  "domains": [
    "stripe.com",
    "notion.so"
  ]
}' |
apify call noniner/b2b-talent-sourcing-brief --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,noniner/b2b-talent-sourcing-brief"
        }
    }
}
```

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/LNVXwXY3u8sc4G32B/builds/BMq6kzspnzQVtnL36/openapi.json