# LinkedIn Change Monitor (`openactor/linkedin-change-monitor`) Actor

Track new, removed, and changed jobs at any company on LinkedIn. Build recurring hiring intelligence, recruiting signals, and competitor hiring alerts with persistent history.

- **URL**: https://apify.com/openactor/linkedin-change-monitor.md
- **Developed by:** [OpenActor](https://apify.com/openactor) (community)
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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.

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 Change Monitor

Track hiring changes at specific LinkedIn companies across scheduled Apify runs.

Add public LinkedIn company URLs, choose a watchlist name, and receive structured signals when jobs are added, removed, or changed. The Actor monitors public job information only and does not require LinkedIn cookies, login credentials, candidate profiles, or automated outreach.

### Quick start

Paste this into the Apify input editor:

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/openai/",
    "https://www.linkedin.com/company/anthropic/"
  ],
  "watchlistName": "ai-companies",
  "includeInitialSnapshot": false,
  "maxSignalsPerCompany": 100,
  "filters": {
    "departments": ["Engineering", "Research"],
    "locations": ["San Francisco", "Remote"],
    "seniority": ["Senior", "Staff", "Director"],
    "keywords": ["machine learning", "safety"]
  }
}
```

The same example is available in [`examples/input.example.json`](examples/input.example.json).

### How monitoring works

On the first run, the Actor saves the current jobs as a baseline. On later runs, it compares the latest results with that baseline and returns only changes. After a successful check, it replaces the baseline with the latest data. If a company check fails, its previous baseline is preserved.

Your monitoring history is isolated by your Apify account, watchlist name, company URLs, and filters. Reuse the same values on scheduled runs to continue the same watchlist. Use a different `watchlistName` for a separate watchlist.

The Actor derives each company ID from the LinkedIn URL, so you do not need to provide internal IDs.

### Input fields

| Field | Required | Purpose |
|---|---|---|
| `companyUrls` | Yes | One or more exact public LinkedIn company URLs. Example: `https://www.linkedin.com/company/openai/`. |
| `watchlistName` | Yes | A simple name for the saved monitoring history. Example: `ai-companies`. |
| `includeInitialSnapshot` | No | Set `true` to output all jobs found on the first run. Default: `false`. |
| `maxSignalsPerCompany` | No | Maximum signals emitted for each company in one run. Default: `100`. |
| `filters.departments` | No | Keep only matching departments. Example: `Engineering`, `Research`. |
| `filters.locations` | No | Keep jobs whose location contains a listed value. Example: `San Francisco`, `Remote`. |
| `filters.seniority` | No | Keep matching seniority levels. Example: `Senior`, `Staff`, `Director`. |
| `filters.keywords` | No | Keep jobs whose title or department contains a listed term. Example: `machine learning`, `safety`. |

Omit `filters` to consider every job returned by the provider.

### Output signals

Each dataset item is one signal:

- `new_job`: a role appeared
- `removed_job`: a role disappeared after a confirmed provider response
- `changed_job`: a tracked role changed
- `initial_snapshot`: a job returned on the first run when enabled
- `no_change`: the company was checked successfully and nothing changed
- `provider_error`: the company could not be checked

The Actor also writes a `RUN_SUMMARY` key-value record with operational counts. Commercial provider costs are not included in that record; Apify calculates billing separately.

### HTTP API and live view

The Actor also supports Apify Standby mode. Use the generated **Endpoints** tab in Apify Console, or call the Standby URL with an Apify API token.

#### Health check

```bash
curl https://YOUR-STANDBY-URL.apify.actor/health \\
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### Run a monitor check

```bash
curl -X POST https://YOUR-STANDBY-URL.apify.actor/monitor \\
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \\
  -H "Content-Type: application/json" \\
  --data @examples/input.example.json
```

The response contains `signals` and `summary`. The request uses the same `watchlistName`, company URLs, filters, baseline storage, and pricing behavior as a normal Actor run.

### Pricing

| Charge | Price | When it applies |
|---|---:|---|
| Actor start | `$0.0005` per event | When a run starts; Apify can charge multiple events based on Actor memory |
| Result | `$0.0075` | For each signal written to the default dataset |
| Company record | `$0.02` | For each company that returns a successful provider response |
| Provider cost unit | `$0.001` | Internal usage-based provider charge calculated by the Actor |

For example, with the current 2 GB run setting, a run that starts and writes 25 signals has these configured event charges:

`(2 × $0.0005) + (25 × $0.0075) + (1 × $0.02) = $0.209`

The provider-cost event is charged in `$0.001` units after a successful provider run, based on the provider run's measured usage plus the configured margin. It is not included in `RUN_SUMMARY`; Apify shows the final billing total separately.

### Scheduling

Schedule the Actor to run repeatedly with the same `watchlistName`, company URLs, and filters. This turns the watchlist into a continuing hiring-change feed.

#### Schedule it in Apify Console

1. Run the Actor once from the Input tab and confirm that the input is correct.
2. Open **Schedules** in Apify Console and click **Create new**.
3. Give the schedule a name, such as `AI company hiring monitor`.
4. Set the frequency and timezone. Daily or weekly runs are usually suitable for hiring monitoring.
5. Click **Add**, choose this Actor, and paste the same JSON input used for the first run.
6. Check that the same `watchlistName`, `companyUrls`, and filters are included.
7. Save and enable the schedule.

Keep the same watchlist name and company URLs for every scheduled run. Changing them starts an isolated monitoring history. Results appear in the run's dataset, and the `RUN_SUMMARY` record is available in the run's key-value store.

Apify requires the Actor to have been run at least once before it can be scheduled. Schedules can be enabled or disabled from their detail page. See the [Apify scheduling guide](https://docs.apify.com/actors/running/schedules) for API and advanced scheduling options.

### Use cases

#### Recruiting and talent intelligence

Track when target companies open new roles, remove roles, or change job details. Recruiting teams can schedule daily checks and send the dataset signals into their CRM or talent workflow.

#### Sales and account prioritization

Use hiring activity as an indication that a company may be growing, entering a new market, or investing in a department. Filter by department, location, seniority, or keywords to focus on relevant accounts.

#### Competitive intelligence

Monitor competitors such as OpenAI, Anthropic, or other public LinkedIn company pages to identify changes in engineering, research, sales, or leadership hiring.

#### Market research

Build a recurring dataset of hiring signals across a group of companies, locations, or industries and analyze the changes over time.

### Integrations and workflow use cases

The main paid value is:

> A new job appeared at one of your target accounts, and your workflow was notified automatically.

The sections below describe the recommended path from recurring LinkedIn hiring monitoring to a connected recruiting, sales, or competitive-intelligence workflow.

#### Scheduled LinkedIn hiring monitoring

Schedules are the foundation of the workflow and are available directly in Apify. Run the Actor daily, weekly, or on a custom interval using the same company URLs, filters, and `watchlistName`. Each run compares the latest public LinkedIn jobs with the saved baseline and produces hiring-change signals.

This is useful for competitor hiring monitoring, recruiting research, and recurring account intelligence without manually starting every run.

#### Webhook notifications for hiring changes

A webhook integration would send a notification when the Actor detects a new, removed, or changed job. A receiving endpoint could route the signal to an internal application, automation platform, or alerting service.

The most useful event is a new job at a target account, because it can trigger an immediate follow-up while the hiring activity is current. The Actor currently exposes structured dataset results; webhook delivery is the next integration to add.

#### n8n LinkedIn hiring-monitor workflow

An n8n example would show how to run the Actor on a schedule, read the dataset output, filter for meaningful hiring signals, and route them to other business systems. For example, an n8n workflow could monitor OpenAI and Anthropic, keep only engineering roles, and send a notification when a new role appears.

This gives users a practical no-code or low-code template for building automated LinkedIn hiring alerts.

#### Slack hiring alerts

A Slack integration would turn a hiring signal into a message in a chosen channel. A recruiting team could receive new engineering roles in `#talent-intelligence`, while a sales team could receive hiring activity for target accounts in `#sales-signals`.

Each alert could include the company, signal type, job title, location, and LinkedIn job URL so users can act without opening the full dataset.

#### Google Sheets export for hiring research

A Google Sheets integration would append or update hiring signals in a shared spreadsheet. This is useful for teams that want a lightweight hiring tracker, account-research table, or historical view of job growth across companies.

The sheet could contain one row per signal with the company, job title, location, detected date, change type, and job URL.

#### MCP listing and examples

An MCP integration would make the Actor’s hiring signals available to compatible AI assistants and agent workflows. Users could ask questions such as “Which target accounts added engineering jobs this week?” and use the structured results as context for research or prioritization.

MCP examples should show how to discover the Actor, provide company URLs and filters, and interpret new, removed, changed, and no-change signals.

#### CRM enrichment from hiring signals

A CRM integration would use hiring activity to enrich company or account records. A new job could update an account’s hiring-signal field, create a research task, or help a sales team prioritize an account that is expanding.

The safest workflow is to send only meaningful changes to the CRM and include the source LinkedIn URL, detected date, job title, and location for review.

# Actor input Schema

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

Add one or more exact public LinkedIn company page URLs. Example: \["https://www.linkedin.com/company/openai/", "https://www.linkedin.com/company/anthropic/"].

## `watchlistName` (type: `string`):

A short name for this monitoring list. Example: ai-companies. Reuse the same name and company URLs on future runs to compare against the previous baseline.

## `includeInitialSnapshot` (type: `boolean`):

Set true to output all jobs found on the first run. Example: false saves the baseline quietly and reports only future changes.

## `maxSignalsPerCompany` (type: `integer`):

Maximum change records one company can produce in one run. Example: 100. Use a lower value to limit output volume.

## `filters` (type: `object`):

Optional filters that narrow which jobs are compared. Example values are shown below. Omit this section to consider every job returned by the provider.

## Actor input object example

```json
{
  "watchlistName": "ai-companies",
  "includeInitialSnapshot": false,
  "maxSignalsPerCompany": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing new, removed, changed, unchanged, or provider-error records.

## `runSummary` (type: `string`):

Key-value record with company, job, signal, and baseline counts.

## `runConsole` (type: `string`):

Console view for logs and run diagnostics.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("openactor/linkedin-change-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("openactor/linkedin-change-monitor").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 '{}' |
apify call openactor/linkedin-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openactor/linkedin-change-monitor"
        }
    }
}
```

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/kk8ogQvA4oRO4AhSh/builds/CSz5d4q8Xp8sv5MoY/openapi.json