# Competitor Hiring Surge & Freeze Watch - Hiring Freeze Tracker (`dominvo/competitor-hiring-surge-freeze-watch`) Actor

Competitor hiring tracker and hiring freeze tracker for LinkedIn: get alerted which rival companies ramped up, froze, or pulled back hiring since the last check, with the job openings and closures behind each verdict. Saves a baseline per company and diffs every run for what changed.

- **URL**: https://apify.com/dominvo/competitor-hiring-surge-freeze-watch.md
- **Developed by:** [Domin Vo](https://apify.com/dominvo) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job posting checkeds

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/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.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

## Competitor Hiring Surge & Freeze Watch

A competitor hiring tracker and hiring freeze tracker for LinkedIn: watch a named set of rivals and get a surge, freeze, or pullback verdict with the roles behind it.

### Which of your competitors ramped up or froze hiring since last week?

One row per company you watch, with a `surge`, `freeze`, or `pullback` verdict, the count of roles opened and closed, and the job IDs behind each call. The Actor saves a baseline for each company, then compares every run against it — so you find out *what changed*, not just which roles are live today.

### When an MCP agent should use this

- "Which of my competitors ramped up hiring since last week?"
- "Tell me which rival companies froze hiring this month."
- "Watch Stripe, Adyen, and Checkout.com for a hiring surge."
- "Has anyone on my watchlist quietly pulled back their open roles?"

### When to use something else

| You want | Use instead |
|---|---|
| Which roles changed their salary bands | `Salary Band Change Alerts` |
| Which roles have been open unusually long | `Stale Job & Time-to-Fill Watch` |
| A one-off list of every job live right now | a raw LinkedIn job scraper |

### How it works

1. **Collect** — fetches the live LinkedIn postings for each watched company, optionally scoped by role keywords and location.
2. **Snapshot & diff** — compares against your saved baseline for this `monitorId`.
3. **Classify** — groups the opened and closed roles by company and applies a deterministic surge / freeze / pullback rule.
4. **Emit** — writes export-ready rows (JSON / CSV / XLSX) and updates the snapshot.

### Inputs

| Field | Required | Example |
|---|---|---|
| `companies` | yes | `["Stripe","Adyen","Checkout.com"]` |
| `keywords` | no | `["engineer","product manager"]` |
| `location` | no | `"United States"` |
| `monitorId` | no | `"fintech-rivals"` |
| `mode` | no | `"check_for_changes"` (default) or `"reset_baseline"` |

**Baseline run:**

```json
{ "companies": ["Stripe","Adyen"], "keywords": ["engineer"], "location": "United States", "monitorId": "fintech-rivals", "mode": "reset_baseline" }
````

**Refresh run (the recurring job):**

```json
{ "companies": ["Stripe","Adyen"], "keywords": ["engineer"], "location": "United States", "monitorId": "fintech-rivals", "mode": "check_for_changes" }
```

### Example output

A detected change:

```json
{
  "companyName": "Stripe",
  "changeType": "surge",
  "openedCount": 14,
  "closedCount": 1,
  "openedJobIds": ["3901234567","3901234999"],
  "closedJobIds": ["3899111222"],
  "evidence": ["14 new roles opened vs 2 last check","1 role closed"],
  "sourceUrls": ["https://www.linkedin.com/jobs/view/3901234567/"],
  "snapshotDate": "2026-06-04"
}
```

### Modes

- `check_for_changes` *(default)* — compare against the baseline and return which companies surged, froze, or pulled back hiring. Auto-creates the baseline on the first run, so use this almost every time.
- `reset_baseline` — save a fresh starting point and report nothing. Use only to re-baseline after you intentionally changed the companies or keywords you watch.

### Billing

| Event | Price | When |
|---|---:|---|
| `job-checked` | `$0.005` | One job posting is checked against the baseline and contributes to a company verdict (both modes). |

The first 10 job checks per run are free.

### FAQ

**Is this a hiring-trends or recruitment-market-intelligence tool?**

It's the change-monitoring layer for the competitors *you* name — a focused hiring trends alert, not a broad market report. It watches your specific company list and tells you which ones surged, froze, or pulled back hiring since the last check, which is the slice of recruitment market intelligence most teams actually act on.

**How is this different from a LinkedIn jobs scraper?**

A raw scraper lists the roles live today. It can't tell you what changed without a snapshot you saved last week, re-fetched, and diffed. This Actor owns that cross-run baseline and the per-company surge/freeze rule, so one call returns the verdict instead of thousands of raw rows.

**Can I use it as a headcount tracker or buying-intent signal?**

Yes — as a directional headcount tracker, a sustained hiring surge on a target account is an early buying-intent signal, and a freeze or pullback is an early read on a rival stalling. You get that job-posting signal before headcount changes show up anywhere public.

**Which companies are hiring right now — can it answer that?**

For your watchlist, yes: each run shows which of them opened or closed roles. For a one-off "who's hiring" list across the whole market, use a raw LinkedIn job scraper instead.

### Limits & support

- LinkedIn postings only — ATS and career-site sources aren't covered.
- It does not score ghost or fake jobs, detect salary-band changes, or measure how long roles stay open — see the sibling Actors above.
- The first run on a new `monitorId` is a baseline; the surge/freeze verdict begins on the next run.
- A failed fetch is reported clearly, never silently treated as "no changes".

# Actor input Schema

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

The competitor or target company names to track on LinkedIn. Each run compares their live postings to the saved baseline.

## `keywords` (type: `array`):

Optional job-title keywords to scope the watch (e.g. only engineering roles). Leave empty to track all roles.

## `location` (type: `string`):

Optional location filter applied to the job search (country, region, or city).

## `monitorId` (type: `string`):

A stable label for this watchlist so its baseline is kept separate from your other monitors. Reuse the same value every run to keep comparing the same set.

## `mode` (type: `string`):

Select the buyer outcome. check\_for\_changes (default) compares against the saved baseline and returns which companies surged, froze, or pulled back hiring since the last check — use this almost every time; it auto-creates the baseline on the first run. reset\_baseline saves a fresh starting point and reports nothing — use only to re-baseline after you intentionally changed the companies or keywords you watch.

## Actor input object example

```json
{
  "companies": [
    "Stripe",
    "Adyen",
    "Checkout.com"
  ],
  "keywords": [
    "engineer",
    "product manager"
  ],
  "location": "United States",
  "monitorId": "fintech-rivals",
  "mode": "check_for_changes"
}
```

# 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 = {
    "companies": [
        "Stripe",
        "Adyen",
        "Checkout.com"
    ],
    "keywords": [
        "engineer",
        "product manager"
    ],
    "location": "United States",
    "monitorId": "fintech-rivals",
    "mode": "check_for_changes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dominvo/competitor-hiring-surge-freeze-watch").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": [
        "Stripe",
        "Adyen",
        "Checkout.com",
    ],
    "keywords": [
        "engineer",
        "product manager",
    ],
    "location": "United States",
    "monitorId": "fintech-rivals",
    "mode": "check_for_changes",
}

# Run the Actor and wait for it to finish
run = client.actor("dominvo/competitor-hiring-surge-freeze-watch").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 '{
  "companies": [
    "Stripe",
    "Adyen",
    "Checkout.com"
  ],
  "keywords": [
    "engineer",
    "product manager"
  ],
  "location": "United States",
  "monitorId": "fintech-rivals",
  "mode": "check_for_changes"
}' |
apify call dominvo/competitor-hiring-surge-freeze-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dominvo/competitor-hiring-surge-freeze-watch",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Hiring Surge & Freeze Watch - Hiring Freeze Tracker",
        "description": "Competitor hiring tracker and hiring freeze tracker for LinkedIn: get alerted which rival companies ramped up, froze, or pulled back hiring since the last check, with the job openings and closures behind each verdict. Saves a baseline per company and diffs every run for what changed.",
        "version": "0.1",
        "x-build-id": "OzNqGRLNzfWfOr7EA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dominvo~competitor-hiring-surge-freeze-watch/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dominvo-competitor-hiring-surge-freeze-watch",
                "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/dominvo~competitor-hiring-surge-freeze-watch/runs": {
            "post": {
                "operationId": "runs-sync-dominvo-competitor-hiring-surge-freeze-watch",
                "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/dominvo~competitor-hiring-surge-freeze-watch/run-sync": {
            "post": {
                "operationId": "run-sync-dominvo-competitor-hiring-surge-freeze-watch",
                "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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies to watch",
                        "type": "array",
                        "description": "The competitor or target company names to track on LinkedIn. Each run compares their live postings to the saved baseline.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Role keywords",
                        "type": "array",
                        "description": "Optional job-title keywords to scope the watch (e.g. only engineering roles). Leave empty to track all roles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location filter applied to the job search (country, region, or city)."
                    },
                    "monitorId": {
                        "title": "Monitor ID",
                        "type": "string",
                        "description": "A stable label for this watchlist so its baseline is kept separate from your other monitors. Reuse the same value every run to keep comparing the same set."
                    },
                    "mode": {
                        "title": "What to do",
                        "enum": [
                            "check_for_changes",
                            "reset_baseline"
                        ],
                        "type": "string",
                        "description": "Select the buyer outcome. check_for_changes (default) compares against the saved baseline and returns which companies surged, froze, or pulled back hiring since the last check — use this almost every time; it auto-creates the baseline on the first run. reset_baseline saves a fresh starting point and reports nothing — use only to re-baseline after you intentionally changed the companies or keywords you watch.",
                        "default": "check_for_changes"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```