# LinkedIn Hiring Signals & Job Market Analyzer (`yowling_blade/linkedin-hiring-signals`) Actor

Cookie-free LinkedIn company hiring analysis and job-search datasets with normalized jobs, recency, role, location, seniority, and remote-work insights.

- **URL**: https://apify.com/yowling\_blade/linkedin-hiring-signals.md
- **Developed by:** [Chenglin Wei](https://apify.com/yowling_blade) (community)
- **Categories:** Jobs, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## LinkedIn Hiring Signals & Job Market Analyzer

Turn public LinkedIn company pages and LinkedIn job-search URLs into a clean job dataset and auditable hiring-market insights—without supplying a LinkedIn cookie, account, proxy, or third-party API key.

Use it for recruiting research, sales timing, competitive intelligence, consulting, investment research, and job-market analysis. The Actor returns public job listings only; it does not scrape people, emails, phone numbers, or candidate profiles.

### What you get

- One normalized dataset for both company and job-search inputs.
- Global deduplication by LinkedIn job ID.
- Company, role-family, seniority, employment-type, workplace, location, and posting-age distributions.
- Top hiring companies and 7-day/30-day recency counts.
- Predictable pay-per-event prices and hard owner/customer cost guards.
- Scheduling, API, export, MCP, and agent workflow compatibility through Apify.

### Quick start

```json
{
  "companyUrls": ["https://www.linkedin.com/company/apify"],
  "jobSearchUrls": ["https://www.linkedin.com/jobs/search?keywords=software%20engineer&location=United%20States"],
  "maxJobsPerInput": 25,
  "publishedWithin": "pastWeek",
  "sortBy": "recent",
  "workplaceType": "all"
}
````

At least one supported company URL or `/jobs/search` URL is required. Company filters apply only to `companyUrls`; filters already encoded in a job-search URL are preserved.

### Output

Each default-dataset item has a stable shape: job ID and URL, title, compact company fields, normalized location, posting time and age, derived seniority, employment type, role family, Easy Apply when available, and a compact source object. Unknown facts are `null` or `unknown`; they are never guessed.

The `OUTPUT` key-value record contains the run status, per-input returned/unique/duplicate counts, distributions, recency metrics, top companies, warnings, endpoint prices, Monid call/cost totals, Apify event counts, and effective customer charge.

### Pricing

This Actor uses Apify pay per event (PPE):

| Event | Price | Trigger |
|---|---:|---|
| `apify-actor-start` | $0.00005 | Actor start (Apify synthetic event). |
| `apify-default-dataset-item` | $0.00001 | One dataset row (Apify synthetic event). |
| `company-profile` | $0.03 | A company profile is retrieved and normalized. |
| `job-page` | $0.01 | A company-jobs or saved-search request succeeds. |
| `job-result` | $0.002 | One unique normalized job is accepted for output. |

A direct search returning 25 jobs costs about **$0.06030** including synthetic micro-events. A company analysis returning 25 jobs costs about **$0.09030**. With an 80% creator share, current Monid costs, and expected small-run compute below $0.001, the documented company example has an estimated contribution profit near $0.059 (about 65% of customer charges), while the direct-search example is higher margin. Provider failures do not create custom success charges. If the maximum Actor charge is reached, the run preserves the successfully charged prefix and reports `partial`.

### Partial results and safety

One failed input does not discard successful inputs. `OUTPUT.status` is `partial` when an invalid input, provider failure, or charge/cost limit affects only part of the run. The Actor inspects Monid endpoint contracts and current prices before spending, processes at most three inputs concurrently, and stops before the next paid request when the owner or customer limit cannot cover it.

### Responsible use

This Actor returns public company and job-listing data. It intentionally excludes personal profile scraping and contact enrichment. Users are responsible for complying with LinkedIn terms, privacy and employment laws, and anti-discrimination rules. Derived classifications are deterministic research heuristics and must not be the sole basis for an employment decision.

This Actor is independent and is not affiliated with, authorized by, or endorsed by LinkedIn or TikHub.

### Owner configuration

Customers never provide Monid credentials. The owner configures `MONID_API_KEY` and `MONID_WORKSPACE_ID` as encrypted Apify secrets, plus the three endpoint price ceilings and `MONID_MAX_RUN_COST_USD`. Secrets are never written to source, build arguments, logs, datasets, or `OUTPUT`.

# Actor input Schema

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

Up to 20 public LinkedIn company URLs.

## `jobSearchUrls` (type: `array`):

Up to 20 LinkedIn /jobs/search URLs. Existing search filters are preserved.

## `maxJobsPerInput` (type: `integer`):

Return at most this many normalized jobs for each company or job-search URL.

## `publishedWithin` (type: `string`):

Limit company-mode jobs to a publication window; job-search URLs keep their encoded filters.

## `sortBy` (type: `string`):

Order company-mode jobs by recency or relevance.

## `workplaceType` (type: `string`):

Optionally restrict company-mode jobs to on-site, remote, or hybrid roles.

## `experienceLevels` (type: `array`):

Optional LinkedIn experience-level filters for company-mode jobs.

## `jobTypes` (type: `array`):

Optional employment-type filters for company-mode jobs.

## `easyApplyOnly` (type: `boolean`):

When supported upstream, return only company-mode jobs marked Easy Apply.

## `under10ApplicantsOnly` (type: `boolean`):

When supported upstream, return only company-mode jobs showing fewer than ten applicants.

## `debug` (type: `boolean`):

Enable sanitized progress details without logging credentials or raw provider payloads.

## Actor input object example

```json
{
  "companyUrls": [],
  "jobSearchUrls": [],
  "maxJobsPerInput": 25,
  "publishedWithin": "pastWeek",
  "sortBy": "recent",
  "workplaceType": "all",
  "experienceLevels": [],
  "jobTypes": [],
  "easyApplyOnly": false,
  "under10ApplicantsOnly": false,
  "debug": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("yowling_blade/linkedin-hiring-signals").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("yowling_blade/linkedin-hiring-signals").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 '{}' |
apify call yowling_blade/linkedin-hiring-signals --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Hiring Signals & Job Market Analyzer",
        "description": "Cookie-free LinkedIn company hiring analysis and job-search datasets with normalized jobs, recency, role, location, seniority, and remote-work insights.",
        "version": "0.1",
        "x-build-id": "Z8e54BIQL2RAjhVQg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yowling_blade~linkedin-hiring-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yowling_blade-linkedin-hiring-signals",
                "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/yowling_blade~linkedin-hiring-signals/runs": {
            "post": {
                "operationId": "runs-sync-yowling_blade-linkedin-hiring-signals",
                "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/yowling_blade~linkedin-hiring-signals/run-sync": {
            "post": {
                "operationId": "run-sync-yowling_blade-linkedin-hiring-signals",
                "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",
                "properties": {
                    "companyUrls": {
                        "title": "LinkedIn company URLs",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Up to 20 public LinkedIn company URLs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "jobSearchUrls": {
                        "title": "LinkedIn job-search URLs",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Up to 20 LinkedIn /jobs/search URLs. Existing search filters are preserved.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxJobsPerInput": {
                        "title": "Maximum jobs per input",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Return at most this many normalized jobs for each company or job-search URL.",
                        "default": 25
                    },
                    "publishedWithin": {
                        "title": "Published within",
                        "enum": [
                            "anytime",
                            "past24Hours",
                            "pastWeek",
                            "pastMonth"
                        ],
                        "type": "string",
                        "description": "Limit company-mode jobs to a publication window; job-search URLs keep their encoded filters.",
                        "default": "pastWeek"
                    },
                    "sortBy": {
                        "title": "Sort company jobs",
                        "enum": [
                            "recent",
                            "relevant"
                        ],
                        "type": "string",
                        "description": "Order company-mode jobs by recency or relevance.",
                        "default": "recent"
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "enum": [
                            "all",
                            "onsite",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Optionally restrict company-mode jobs to on-site, remote, or hybrid roles.",
                        "default": "all"
                    },
                    "experienceLevels": {
                        "title": "Experience levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional LinkedIn experience-level filters for company-mode jobs.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entryLevel",
                                "associate",
                                "midSenior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-senior",
                                "Director",
                                "Executive"
                            ]
                        },
                        "default": []
                    },
                    "jobTypes": {
                        "title": "Job types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional employment-type filters for company-mode jobs.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fullTime",
                                "partTime",
                                "contract",
                                "temporary",
                                "volunteer",
                                "internship",
                                "other"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Volunteer",
                                "Internship",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "easyApplyOnly": {
                        "title": "Easy Apply only",
                        "type": "boolean",
                        "description": "When supported upstream, return only company-mode jobs marked Easy Apply.",
                        "default": false
                    },
                    "under10ApplicantsOnly": {
                        "title": "Under 10 applicants only",
                        "type": "boolean",
                        "description": "When supported upstream, return only company-mode jobs showing fewer than ten applicants.",
                        "default": false
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable sanitized progress details without logging credentials or raw provider payloads.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
