# LinkedIn Jobs Report: Who's Hiring, Salaries & Applicants (`precious_bathmat/linkedin-jobs-report`) Actor

LinkedIn jobs market report for any role and location: which companies are hiring most, seniority and job-type mix, how many applicants each role has, how fresh the postings are, and salaries where stated. Every job and a hiring-leads list as CSV. No login, no cookies, no proxy.

- **URL**: https://apify.com/precious\_bathmat/linkedin-jobs-report.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 search reports

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/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 Jobs Report: Who's Hiring, Salaries & Applicants

A **LinkedIn jobs market report** for any role and location: **which companies are hiring most**, the seniority and job-type mix, **how many people are applying**, how fresh the postings are, and **what the jobs pay** where the posting says. Every job and a **hiring-leads list of companies** come with it as CSV.

Other LinkedIn job scrapers return rows of postings. This one also tells you what the rows mean: one report per search, ready to compare roles and cities side by side.

No login, no cookies, no proxy: it reads LinkedIn's public job search, the same one anyone sees without an account.

### What does this do?

For each job title and location you give, it collects the matching jobs, opens each job's public page, and rolls them up:

```
data engineer · United States · posted in the past week · 100 jobs

 80 companies hiring            13% posted in the last 24 hours
 11% under 25 applicants        46% over 200 applicants
 51 jobs state pay              median $126,500 to $163,700 a year

 top hirers      NinjaOne 2 · Deloitte 2 · Zeta Global 2 · Accenture Federal Services 2 · …
 least crowded   Senior Data Engineer, Zeta Global, Nashville · first 25 applicants
                 Data Engineer III, Deloitte, Arlington · first 25 applicants
```

### Who is it for?

- **Recruiters and staffing agencies**: find the companies hiring most for a role, straight into a leads list
- **Sales teams selling to employers**: hiring is a buying signal; the leads file ranks companies by open roles
- **Job seekers**: see pay ranges and which roles still have few applicants, and apply there first
- **HR and compensation teams**: benchmark posted salaries and the seniority mix for a role and city
- **Analysts and researchers**: a repeatable weekly snapshot of a job market

### What data do you get?

**One report per search:**

| Field | What it tells you |
|---|---|
| `jobsCollected`, `companiesHiring` | How big the market is right now |
| `topCompanies` | The companies with the most openings, with titles, locations and newest posting |
| `postedLast24hPercent`, `postedLast7dPercent`, `medianPostingAgeDays` | How fresh the postings are |
| `applicantsUnder25Percent`, `applicantsOver200Percent` | How crowded the roles are |
| `lowCompetitionJobs` | The ten roles with the fewest applicants, newest first |
| `jobsWithSalary`, `medianSalaryMin`, `medianSalaryMax`, `medianSalaryMid` | Posted pay, with its currency and period |
| `seniorityMix`, `employmentTypeMix`, `topJobFunctions`, `topIndustries` | What kind of roles these are |
| `topLocations`, `remoteMentionPercent`, `activelyHiringPercent` | Where, and how actively |

**Every job** (CSV and JSON): title, company and company page, location, posting date, seniority, employment type, job function, industry, applicant count, salary with the exact text it came from, and a link. **Hiring leads** (CSV): every company, most openings first.

### Example: four searches, September 2026

Live runs on 24 September 2026, jobs posted in the past week, 100 per search:

| Search | Jobs | Companies | Under 25 applicants | Over 200 | Median posted pay |
|---|---|---|---|---|---|
| **Data engineer, United States** | 100 | 80 | 11% | **46%** | $126,500 to $163,700 a year (51 jobs) |
| **Registered nurse, United States** | 100 | 73 | **100%** | 0% | $41 to $59 an hour (29 jobs) |
| **Software engineer, London** | 100 | 75 | 13% | 23% | £70,000 to £90,000 a year (20 jobs) |
| **Software engineer, Nairobi** | 38 | 15 | 13% | 16% | not stated |

The two US rows show why applicant counts matter. **Almost half of data engineering jobs had over 200 applicants within days; every single nursing job was still under 25.** Nairobi shows the other thing a report catches: only 38 postings in a week, and 17 of them came from one employer.

All four searches: 338 jobs read, no throttling, no failures.

### How it works, and what it does not do

- **Public search only.** It reads what LinkedIn shows without an account: up to about 1,000 jobs per search, newest and most relevant first. Reports describe the jobs collected, not every job on LinkedIn.
- **Applicant counts are LinkedIn's own public captions**: an exact number up to 200, "over 200" above that, and "among the first 25" for new or quiet postings.
- **Salary comes from the job description.** LinkedIn's public pages rarely show a pay field, so pay is read from the description when it states a range next to a pay word ("salary", "compensation", "base", "pay range"…). Every job keeps the exact text it came from in `salaryText`, and `$5M Series A`-style figures are never counted. Many postings, especially outside the US and UK, state no pay at all.
- **Steady, not fast.** Each job's page is read at about one request a second, because LinkedIn refuses bursts. 100 jobs with details take about two minutes; switch off "Read each job's page" for a fast cards-only run.
- **No personal data.** No recruiter, poster or applicant names are collected.

### Pricing

**$0.03 per search report** and **$0.002 per job** (only when jobs are switched on).

A 100-job search with every job costs **$0.23**. The four searches above cost **$0.80** with all 338 jobs, or **$0.12** for the reports alone.

### Input

| Field | Meaning |
|---|---|
| **Job titles or keywords** | What to search; each keyword runs in each location |
| **Locations** | Countries, states or cities, as you would type them into LinkedIn |
| **Posted within** | Past 24 hours, week, month, or any time |
| **Workplace** | On-site, remote, hybrid, or any |
| **Experience levels**, **Job types** | Optional filters, the same as LinkedIn's |
| **Jobs per search** | 10 to 1,000 |
| **Read each job's page** | Adds seniority, applicants and pay; off for a fast run |
| **Include full job descriptions** | Adds the text of each posting |
| **Also return every job** | Adds the jobs and hiring-leads files |

### Integrations

Reports export to JSON, CSV, Excel and Google Sheets, or feed a CRM or dashboard through the Apify API, webhooks, Make, Zapier and n8n. Schedule it weekly to track who is hiring in your market and how pay moves.

# Actor input Schema

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

What to search for, as you would type it into LinkedIn, e.g. "data engineer", "nurse", "account executive". Each keyword is searched in each location.

## `locations` (type: `array`):

Countries, states or cities, e.g. "United States", "Texas, United States", "London, England, United Kingdom", "Germany".

## `postedWithin` (type: `string`):

Only jobs posted in this window. A week is a good default for a current picture.

## `workplace` (type: `string`):

On-site, remote or hybrid roles only, or all of them.

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

Leave empty for every level.

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

Leave empty for every type.

## `maxJobsPerSearch` (type: `integer`):

How many jobs each report is built from. LinkedIn's public search goes up to about 1,000. Each job's page is read at a steady pace, so 100 jobs take about two minutes.

## `includeDetails` (type: `boolean`):

Adds seniority, employment type, job function, industry, applicant count and salary (when the description states one). Switch off for a faster, cards-only run.

## `includeDescription` (type: `boolean`):

Adds the full description text to each job. Makes the files much larger.

## `includeJobs` (type: `boolean`):

Saves every job, and a hiring-leads list of companies, as CSV and JSON next to the reports. Charged per job.

## Actor input object example

```json
{
  "keywords": [
    "data engineer"
  ],
  "locations": [
    "United States"
  ],
  "postedWithin": "week",
  "workplace": "any",
  "maxJobsPerSearch": 100,
  "includeDetails": true,
  "includeDescription": false,
  "includeJobs": true
}
```

# Actor output Schema

## `reports` (type: `string`):

One row per keyword and location: who is hiring, levels, applicants, freshness and pay.

## `companiesCsv` (type: `string`):

Every company hiring in these searches, with openings, titles, locations and newest posting.

## `jobsCsv` (type: `string`):

Every job behind the reports, one per row.

## `jobsJson` (type: `string`):

The same jobs as JSON.

## `summary` (type: `string`):

Counts, any search that returned nothing, and the limits of the data.

# 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 = {
    "keywords": [
        "data engineer"
    ],
    "locations": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/linkedin-jobs-report").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 = {
    "keywords": ["data engineer"],
    "locations": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("precious_bathmat/linkedin-jobs-report").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 '{
  "keywords": [
    "data engineer"
  ],
  "locations": [
    "United States"
  ]
}' |
apify call precious_bathmat/linkedin-jobs-report --silent --output-dataset

```

## MCP server setup

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

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/EACG0wycyRkJPaxbg/builds/NjScBE1RBpLvoD32X/openapi.json