# LinkedIn Hiring Signals - Company Hiring Intelligence & Intent (`centorprat/linkedin-hiring-signals-intelligence`) Actor

Company hiring intelligence from public LinkedIn data: hiring momentum, department and seniority mix, leadership hires, new markets, buying-intent signals, and (deep) tech stack, salary bands and hard-to-fill roles from job descriptions. No login or cookies.

- **URL**: https://apify.com/centorprat/linkedin-hiring-signals-intelligence.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $34.00 / 1,000 company analyzeds

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

## LinkedIn Hiring Signals — Company Hiring Intelligence & Buying Intent

Turn a list of companies into hiring intelligence you can act on. For each company you get:

- its LinkedIn facts
- how fast it is hiring right now (postings in the last 7 / 30 days, relative to headcount)
- where the hiring is concentrated (department and seniority mix)
- leadership openings (new leaders bring new budgets)
- which new countries it's hiring in
- **buying-intent signals** mapped to what vendors sell, plus your own keyword signals

Turn on deep mode to also get the company's **tech stack from its job descriptions**, salary bands, applicant counts, hard-to-fill roles and compliance / IPO-readiness signals.

It reads public LinkedIn pages: **no login, no cookies, no paid scraper behind it.** It uses company and job data only and never reads personal profiles. Agent-callable.

Built for B2B sales and SDR teams (prospect companies showing intent), recruiters and staffing agencies (who's hiring what, and what's hard to fill), and investors/analysts (growth signals).

### Tiers

- **Hiring brief (default):**
  - open roles found and postings in the last 7 / 30 days
  - roles per 1,000 employees, plus a hiring-momentum label and intensity score
  - department and seniority mix, leadership openings
  - top locations, countries and remote share
  - buying-intent signals and keyword signals
  - the 12 most recent roles
- **Deep job-description analysis (`deepAnalysis: true`):** reads the most recent postings in full.
  - tech stack by category (languages, cloud, data, AI, CRM/GTM, security, ERP, devtools…)
  - salary bands by department and currency
  - salary-transparency share and average applicants
  - hard-to-fill roles (open 3+ weeks with fewer than 25 applicants)
  - compliance signals (SOC 2, ISO 27001, HIPAA, PCI, GDPR, FedRAMP, SOX/IPO)

### What makes it useful

| Signal | Why it matters |
|---|---|
| **Momentum vs company size** | 40 new roles at a 500-person company and at a 50,000-person company mean very different things. Postings per 1k employees normalise that. Labels: `surging` · `active` · `steady` · `slow` · `hiring-pause-signals` · `no-open-roles-found`. |
| **Department mix** | A company putting 40% of its openings into Sales is in a revenue push. Heavy Support hiring means it's scaling customer volume. |
| **Leadership openings** | A new VP/Head/Director usually arrives with a mandate, a budget, and vendor reviews. |
| **New markets** | Hiring outside the HQ country = international expansion (local vendors, localisation, legal, payroll). |
| **Buying-intent signals** | Department surges and title or description evidence are mapped to vendor categories: sales team expansion, support scaling, security investment, data platform build-out, AI initiative, recruiting ramp, finance & IPO readiness, Salesforce ecosystem, marketing build-out, engineering scale-up. Each comes with **evidence** and *what it signals*. |
| **Your keywords** | `intentKeywords: ["snowflake", "soc 2"]` counts open roles that mention what *you* sell. That is the most direct buying signal there is. |
| **Tech stack (deep)** | Job descriptions reveal the tools a team actually uses, which is technographics without guesswork. |

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `companies` | array of strings | ✅\* | LinkedIn company URLs (exact match), company names or website domains. |
| `intentKeywords` | array of strings | | Products/skills you sell into; reported per company. |
| `datasetId` | dataset | ✅\* | …or read companies from a lead-list dataset. |
| `maxJobsPerCompany` | integer | | Open jobs read per company (default 50). |
| `deepAnalysis` | boolean | | Job-description analysis add-on (default off). |
| `jobDetailsSampled` | integer | | Postings read in full in deep mode (default 20). |
| `maxCompanies` | integer | | Cap per run (default 20). |
| `webhookUrl` | string | | POST the briefs here as JSON. |

\* provide `companies` or `datasetId`. For an exact match, use the LinkedIn company URL. A domain input is accepted only when the company's LinkedIn website matches it.

**Example input**

```json
{ "companies": ["https://www.linkedin.com/company/stripe", "notion.com", "HubSpot"], "intentKeywords": ["salesforce", "snowflake"], "deepAnalysis": true }
```

### Output

One brief per company. **Example** (real run, trimmed):

```json
{
  "companyName": "Notion",
  "website": "https://notion.com",
  "industry": "Software Development",
  "sizeBand": "501-1,000 employees",
  "employeesOnLinkedIn": 7211,
  "openRolesFound": 50,
  "postedLast7Days": 22,
  "postedLast30Days": 48,
  "rolesPostedPer1kEmployees30d": 6.7,
  "hiringMomentum": "surging",
  "departments": [{"department": "Sales", "roles": 16, "pct": 32}, {"department": "Engineering", "roles": 15, "pct": 30}],
  "leadershipRoles": ["Head of Sales Recruiting, AMER"],
  "countries": [{"country": "United States", "roles": 37}, {"country": "Ireland", "roles": 7}, {"country": "South Korea", "roles": 4}],
  "intentSignals": [
    {"topic": "Sales team expansion", "strength": "medium", "evidence": ["16 Sales roles (32% of openings)"],
     "whatItSignals": "sales engagement, data/intent providers, sales enablement, CRM seats"}
  ],
  "topTechnologies": [{"tech": "typescript", "roles": 2}, {"tech": "react", "roles": 2}, {"tech": "aws", "roles": 2}, {"tech": "postgres", "roles": 2}],
  "salaryBands": [{"department": "Engineering", "currency": "USD", "roles": 2, "medianMin": 150000, "medianMax": 200000}],
  "avgApplicants": 139,
  "complianceSignals": ["GDPR", "SOX"],
  "summary": "Notion - 501-1,000 employees - 50 open roles found (22 in last 7d, 48 in last 30d, 6.7 per 1k employees) - top: Sales - 1 leadership opening(s) - intent: Sales team expansion, ... -> surging"
}
```

### Use cases

- **Intent-based prospecting:** find accounts expanding the team your product serves, or hiring for the tool you replace.
- **Account research:** a one-call brief before an SDR touches an account.
- **Recruiting & staffing:** who's hiring what, where, and which roles are hard to fill.
- **Competitive / investor research:** growth vs. slowdown, new markets, new leadership, IPO-readiness hires.
- **AI agents:** a structured hiring brief + one-line `summary` per company.

### Instant HTTP endpoint (Standby) - call it like a tool

Besides normal runs, this Actor answers HTTP requests directly. There's no run to start or poll; the JSON comes back in the same request, which is what an AI agent wants mid-task:

```bash
curl "https://centorprat--linkedin-hiring-signals-intelligence.apify.actor/?companies=https://www.linkedin.com/company/stripe&maxJobsPerCompany=30" -H "Authorization: Bearer <APIFY_TOKEN>"
curl -X POST "https://centorprat--linkedin-hiring-signals-intelligence.apify.actor/" -H "Authorization: Bearer <APIFY_TOKEN>" \
     -H "Content-Type: application/json" -d '{"companies": ["notion.com", "HubSpot"], "intentKeywords": ["salesforce"], "deepAnalysis": true}'
```

Query parameters and the POST body take the same fields as the normal input. One company returns the brief; several return `{count, results}`. Pricing is the same pay-per-event, charged per request; errors aren't charged.

### For AI agents / MCP

```
https://mcp.apify.com/?tools=actors,docs,centorprat/linkedin-hiring-signals-intelligence
```

Loads as `centorprat--linkedin-hiring-signals-intelligence`. Claude Code:

```
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors centorprat/linkedin-hiring-signals-intelligence
```

### FAQ

**Do I need a LinkedIn account or cookies?** No. It reads LinkedIn's public company pages and public job search, the same pages anyone can open logged out.

**Does it collect personal data?** No. It reads company and job-posting data only. It never visits personal profiles and never outputs names of people.

**How many jobs does it see?** What LinkedIn's public job search returns for the company, worldwide, up to `maxJobsPerCompany`. `openRolesCapped: true` means there are more. Very large employers can have thousands; the recent-posting counts are then lower bounds.

**How is momentum calculated?** From each posting's date: new roles in the last 7 and 30 days, also relative to the company's LinkedIn employee count.

**Why "intent signals"?** Hiring reveals budget before anything else does: a company hiring SDRs is about to buy sales tools, and one hiring a "SOC 2 compliance lead" is about to buy GRC software. Each signal lists its evidence.

**How fast?** Around 10–30 s per company for the brief. Deep mode reads postings one by one and is best used in batch / webhook runs.

**Cost?** Pay-per-event: one event per company analysed, plus one per company when deep analysis runs. There's no underlying scraper bill.

### Data & attribution

Public LinkedIn company pages and job postings. These are signals for prospecting and research, not guarantees. Counts reflect what LinkedIn's public job search shows at run time.

### Related actors

- [Company Hiring Monitor](https://apify.com/centorprat/company-hiring-monitor): every open role straight from the company's own careers board (Workday, Greenhouse, Lever, Ashby...), plus new/closed-role monitoring.
- [Google Maps Leads & Website Audit](https://apify.com/centorprat/google-maps-leads-website-audit)
- [Shopify Store Leads & App Audit](https://apify.com/centorprat/shopify-store-leads-app-audit)

# Actor input Schema

## `companies` (type: `array`):

LinkedIn company URLs (exact), company names or website domains (e.g. "https://www.linkedin.com/company/stripe", "HubSpot", "notion.com"). One brief per company.

## `intentKeywords` (type: `array`):

Products, tools or skills YOU sell into (e.g. "salesforce", "snowflake", "soc 2", "kubernetes"). Reports how many open roles mention each - a vendor-specific buying signal. Deep mode also searches job descriptions.

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

Read companies from another dataset (e.g. a lead list) - uses the 'linkedinUrl' / 'companyUrl' / 'website' / 'domain' / 'companyName' field.

## `maxJobsPerCompany` (type: `integer`):

How many of the company's open LinkedIn jobs to analyse (most companies have fewer).

## `deepAnalysis` (type: `boolean`):

Also read the most recent job postings in full: tech stack (technographics), salary bands, applicant counts, hard-to-fill roles, compliance / IPO-readiness signals, LinkedIn seniority and job function. Adds time. Off by default.

## `jobDetailsSampled` (type: `integer`):

When deep analysis is on, how many of the most recent postings per company to read in full.

## `maxCompanies` (type: `integer`):

Cap how many companies to analyse this run.

## `webhookUrl` (type: `string`):

If set, the finished briefs are POSTed here as JSON when the run completes.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/hubspot"
  ],
  "maxJobsPerCompany": 50,
  "deepAnalysis": false,
  "jobDetailsSampled": 20,
  "maxCompanies": 20
}
```

# Actor output Schema

## `companies` (type: `string`):

One brief per company: LinkedIn company facts, open roles found, postings in the last 7/30 days, roles per 1k employees, hiring momentum + intensity score, department and seniority mix, leadership openings, locations/countries/remote share, buying-intent signals, keyword signals, sample roles and (deep) tech stack, salary bands, applicants, hard-to-fill roles and compliance signals.

# 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 = {
    "companies": [
        "https://www.linkedin.com/company/hubspot"
    ],
    "maxCompanies": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/linkedin-hiring-signals-intelligence").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 = {
    "companies": ["https://www.linkedin.com/company/hubspot"],
    "maxCompanies": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/linkedin-hiring-signals-intelligence").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 '{
  "companies": [
    "https://www.linkedin.com/company/hubspot"
  ],
  "maxCompanies": 20
}' |
apify call centorprat/linkedin-hiring-signals-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/linkedin-hiring-signals-intelligence"
        }
    }
}
```

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/O1EtS9ZIW8qtPTqSr/builds/2VdTExDEHBQuacaim/openapi.json