# LinkedIn Company Hiring Signal Tracker (`scrapemint/linkedin-company-hiring-tracker`) Actor

One row per company per run: total open roles on LinkedIn, broken down by seniority, function, and location, plus the change since the last run. A buying signal feed for B2B sales, recruiters, and analysts. No cookie, no login. JSON. Pay per company.

- **URL**: https://apify.com/scrapemint/linkedin-company-hiring-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Company Hiring Signal Tracker and Export Tool

Paste a list of LinkedIn company URLs and get one hiring signal row per company. Total open roles, broken down by seniority, function, and location, the date of the newest role, and the change since the last run when you schedule it. Output as JSON, CSV, or Excel. No cookie, no login.

Built for B2B sales teams, recruiters, equity and PE analysts, and competitive intelligence people who treat a hiring spike as a buying signal and want it as data, not a dashboard they pay a seat for.

---

### Who uses this hiring tracker

```mermaid
flowchart TD
    A[B2B sales] -->|Company opened 40 roles<br/>budget and growth signal| D[Hiring Signal<br/>Row]
    B[Recruiters] -->|Competitor talent demand<br/>by function| D
    C[PE and equity analysts] -->|Headcount trajectory<br/>quarter over quarter| D
    E[Competitive intel] -->|Where a rival is<br/>investing headcount| D
    D --> F[Outreach trigger]
    D --> G[Talent market map]
    D --> H[Diligence note]
````

| Role | What this tracker unlocks |
|---|---|
| **B2B sales** | A hiring ramp is budget plus growth, the cleanest time to reach out |
| **Recruiter** | Where a competitor is opening roles, by function and seniority |
| **PE or equity analyst** | Headcount trajectory of a target across scheduled runs |
| **Competitive intel** | Which function a rival is staffing up tells you their next move |
| **Founder** | Watch the companies in your space ramp or slow in one feed |

***

### How the hiring tracker works

```mermaid
flowchart LR
    A[Company URL] --> B[Resolve numeric<br/>organization id]
    B --> C[Public jobs list<br/>filtered to that company]
    C --> D[Walk 25 at a time]
    D --> E[Aggregate one row]
    E --> F[Compare to last run]
    F --> G[(Hiring signal row)]
```

The actor resolves each company page to its numeric organization id, then walks the public job list filtered to that company, twenty five roles at a time. It counts every open role and buckets each by seniority, function, and location from the title and location text. With change tracking on, it stores the count between runs, so a scheduled run reports how many roles the company added or cut since last time. That velocity is the whole point.

This reads only the public job endpoint LinkedIn serves without a login. It is not a job board scraper for job seekers. It is a per company signal for people who sell, recruit, or invest.

***

### Job feed vs hiring signal

```mermaid
flowchart LR
    subgraph Feed[Per job scrapers]
        A1[One row per job]
        A2[For job seekers]
        A3[You aggregate yourself]
    end
    subgraph Signal[This actor]
        B1[One row per company]
        B2[For sellers and analysts]
        B3[Change since last run]
    end
    Feed -.-> X[Pick based on<br/>what you need]
    Signal --> X
```

| Feature | Per job scraper | This actor |
|---|---|---|
| Output unit | One row per job | One row per company |
| Built for | Job seekers, aggregators | Sales, recruiting, analysts |
| Velocity | You compute it | Reported per scheduled run |
| Breakdown | You group later | Seniority, function, location ready |
| Pricing | Pay per job | Pay per company, first 3 per run free |

Pair this with Scrapemint LinkedIn Hiring Tracker and Salary Intelligence when you want the individual roles behind a signal.

***

### Quick start

Track three companies once:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~linkedin-company-hiring-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyUrls": [
      "https://www.linkedin.com/company/anthropicresearch/",
      "https://www.linkedin.com/company/stripe/",
      "https://www.linkedin.com/company/databricks/"
    ]
  }'
```

Watch only engineering hiring at one company on a daily schedule:

```json
{
  "companyUrls": ["https://www.linkedin.com/company/databricks/"],
  "roleKeyword": "engineer",
  "trackDeltas": true,
  "maxRolesScanPerCompany": 1000
}
```

Run it on the Apify Scheduler daily and the delta field fills in from the second run on.

***

### What one company record looks like

```json
{
  "company": "Anthropic",
  "companySlug": "anthropicresearch",
  "companyId": "74126343",
  "companyUrl": "https://www.linkedin.com/company/anthropicresearch/",
  "totalOpenRoles": 312,
  "previousTotal": 280,
  "delta": 32,
  "deltaPct": 11.4,
  "hiringTrend": "ramping",
  "bySeniority": { "senior": 110, "mid": 96, "staff": 41, "director": 22 },
  "byFunction": { "engineering": 140, "sales": 38, "operations": 27 },
  "topLocations": [
    { "location": "San Francisco, CA", "count": 121 },
    { "location": "Remote", "count": 64 }
  ],
  "newestRolePostedAt": "2026-05-17",
  "sampleTitles": ["Staff Software Engineer", "Recruiter, Technical"],
  "scrapedAt": "2026-05-18T19:30:00.000Z"
}
```

`delta`, `previousTotal`, and `deltaPct` are null on the first run and fill in from the second scheduled run on.

***

### Pricing

First 3 companies per run are free. After that you pay per company tracked, breakdown and change figure included. No seat licenses. Tracking 100 companies a day lands around $3 a day on the Apify free plan.

***

### FAQ

**How is this different from a LinkedIn jobs scraper?**
A jobs scraper gives one row per job for job seekers. This gives one row per company for people who sell, recruit, or invest, with the count already bucketed and the change since last run.

**Do I need a LinkedIn login or cookie?**
No. The actor resolves the public company page and reads the public jobs endpoint. No session, no Sales Navigator seat.

**How do I get the change figure?**
Keep change tracking on and run the actor on the Apify Scheduler. The first run sets a baseline. Every run after reports the delta versus the previous run.

**Will it count every open role?**
It walks the public list up to the scan cap you set. Raise the cap for very large employers. The row flags when the cap was hit so you know the count is a floor.

**What company input formats work?**
A LinkedIn company URL like `linkedin.com/company/{slug}`, or the raw numeric organization id for advanced use.

**Can I track only one function?**
Yes. Set a role keyword like `engineer` or `sales` and only matching titles are counted.

**Is this legal?**
The company page and the jobs endpoint are public surfaces LinkedIn serves without a login. Use the output in line with your own policies and applicable law.

***

### Related actors by Scrapemint

- **LinkedIn Hiring Tracker and Salary Intelligence** for the individual roles behind a signal
- **LinkedIn Company Employees Scraper** for org wide prospecting
- **LinkedIn Company Profile Scraper** for firmographics on a flagged company
- **Lead Enrichment Pipeline** to push a ramping company into outreach
- **LinkedIn Profile Scraper** for the hiring manager behind a role

Stack these to go from a hiring spike to an enriched account plan.

# Actor input Schema

## `companyUrls` (type: `array`):

LinkedIn company page URLs, or raw numeric organization IDs. Examples: 'https://www.linkedin.com/company/stripe/', 'https://www.linkedin.com/company/anthropicresearch/', '74126343'.

## `maxRolesScanPerCompany` (type: `integer`):

Pagination cap. The actor walks the company's public job list 25 at a time up to this many roles, then reports the total it counted. Raise it for very large employers.

## `roleKeyword` (type: `string`):

Optional. Only count roles whose title contains this text, for example 'engineer' or 'sales'. Leave blank to count every open role.

## `trackDeltas` (type: `boolean`):

Store each company's count between runs so a scheduled run reports the change versus the previous run. The hiring velocity is the whole point of this actor.

## `topLocations` (type: `integer`):

How many of the busiest hiring locations to include in the per company breakdown.

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

Apify proxy. The public jobs endpoint is light, but residential improves reliability at volume.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/anthropicresearch/"
  ],
  "maxRolesScanPerCompany": 300,
  "roleKeyword": "",
  "trackDeltas": true,
  "topLocations": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "companyUrls": [
        "https://www.linkedin.com/company/anthropicresearch/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/linkedin-company-hiring-tracker").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 = {
    "companyUrls": ["https://www.linkedin.com/company/anthropicresearch/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/linkedin-company-hiring-tracker").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 '{
  "companyUrls": [
    "https://www.linkedin.com/company/anthropicresearch/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapemint/linkedin-company-hiring-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Hiring Signal Tracker",
        "description": "One row per company per run: total open roles on LinkedIn, broken down by seniority, function, and location, plus the change since the last run. A buying signal feed for B2B sales, recruiters, and analysts. No cookie, no login. JSON. Pay per company.",
        "version": "0.1",
        "x-build-id": "sWtbjxd7CRgmBZ5mR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~linkedin-company-hiring-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-linkedin-company-hiring-tracker",
                "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/scrapemint~linkedin-company-hiring-tracker/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-linkedin-company-hiring-tracker",
                "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/scrapemint~linkedin-company-hiring-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-linkedin-company-hiring-tracker",
                "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": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company URLs or numeric IDs",
                        "type": "array",
                        "description": "LinkedIn company page URLs, or raw numeric organization IDs. Examples: 'https://www.linkedin.com/company/stripe/', 'https://www.linkedin.com/company/anthropicresearch/', '74126343'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRolesScanPerCompany": {
                        "title": "Max roles to scan per company",
                        "minimum": 25,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "Pagination cap. The actor walks the company's public job list 25 at a time up to this many roles, then reports the total it counted. Raise it for very large employers.",
                        "default": 300
                    },
                    "roleKeyword": {
                        "title": "Restrict to roles matching",
                        "type": "string",
                        "description": "Optional. Only count roles whose title contains this text, for example 'engineer' or 'sales'. Leave blank to count every open role.",
                        "default": ""
                    },
                    "trackDeltas": {
                        "title": "Track change since last run",
                        "type": "boolean",
                        "description": "Store each company's count between runs so a scheduled run reports the change versus the previous run. The hiring velocity is the whole point of this actor.",
                        "default": true
                    },
                    "topLocations": {
                        "title": "Top locations to include",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many of the busiest hiring locations to include in the per company breakdown.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. The public jobs endpoint is light, but residential improves reliability at volume.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```