# LinkedIn Job Market Trend Intelligence (`scrapemint/linkedin-job-market-trend-scraper`) Actor

One row per job market query per run: total open roles on LinkedIn for a keyword, location, and filter set, with a seniority and function breakdown and the change since the last run. A labor market index for analysts and planners. No cookie. JSON. Pay per query.

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

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Job Market Trend Intelligence and Labor Index Export

Define the job market segments you care about and get one trend row per segment. Total open roles on LinkedIn for a keyword, location, and filter set, a seniority and function split, and the change since the last run when you schedule it. Output as JSON, CSV, or Excel. No cookie, no login.

Built for labor market analysts, economists, workforce planners, talent acquisition strategists, and macro and equity researchers who treat job posting volume as a leading indicator and want it as a clean time series, not a dashboard seat.

---

### Who uses this job market tracker

```mermaid
flowchart TD
    A[Labor analysts] -->|Demand for a role<br/>by region over time| D[Job Market<br/>Trend Row]
    B[Economists] -->|Posting volume as a<br/>leading indicator| D
    C[TA strategists] -->|Where to open reqs<br/>and where it is hot| D
    E[Equity research] -->|Sector hiring as a<br/>read on growth| D
    D --> F[Time series]
    D --> G[Region heat map]
    D --> H[Sector read]
````

| Role | What this tracker unlocks |
|---|---|
| **Labor analyst** | Demand for a role across regions as a clean weekly series |
| **Economist** | Job posting volume, a known leading indicator, without a data vendor |
| **TA strategist** | Where a skill is hot and where it has cooled before you open reqs |
| **Equity or macro researcher** | Sector hiring as a read on growth between earnings |
| **Workforce planner** | Supply pressure on a role by market over time |

***

### How the trend tracker works

```mermaid
flowchart LR
    A[Keyword x location<br/>x filter] --> B[Public jobs<br/>search page]
    B --> C[Read total<br/>result count]
    B --> D[Sample role cards]
    C --> E[One trend row]
    D --> E
    E --> F[Compare to last run]
    F --> G[(Time series)]
```

For each keyword and location pair, plus any experience, type, remote, or recency filter, the actor reads the public jobs search page and pulls the total result count LinkedIn shows in the header. It also samples the rendered role cards to add a seniority and function split. With change tracking on, it stores the count between runs, so a scheduled run reports how the segment moved since last time. That movement is the whole point.

This reads only the public jobs search page LinkedIn serves without a login. It is not a per job intelligence and not a per company tracker. It is a market level index.

***

### Three jobs lenses

```mermaid
flowchart LR
    A[Per job] --> X[Pick the unit<br/>you need]
    B[Per company] --> X
    C[Per market] --> X
```

| Actor | Output unit | Built for |
|---|---|---|
| LinkedIn Hiring Tracker and Salary Intelligence | One row per job | Recruiters, comp researchers |
| LinkedIn Company Hiring Signal Tracker | One row per company | Sales, talent intel |
| **This actor** | One row per market segment | Analysts, economists, planners |

Run all three when you need the macro trend, the companies driving it, and the roles behind it.

***

### Quick start

Track three role markets in the US once:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~linkedin-job-market-trend-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["data engineer", "registered nurse", "product manager"],
    "locations": ["United States"]
  }'
```

Track one skill across three regions, remote only, on a weekly schedule:

```json
{
  "keywords": ["machine learning engineer"],
  "locations": ["United States", "Germany", "India"],
  "remoteFilter": "remote",
  "trackDeltas": true
}
```

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

***

### What one trend record looks like

```json
{
  "keyword": "data engineer",
  "location": "Germany",
  "filters": { "remoteFilter": "remote", "postedSince": null },
  "totalJobs": 6000,
  "totalJobsText": "6,000+",
  "isApproximate": true,
  "previousTotal": 5600,
  "delta": 400,
  "deltaPct": 7.1,
  "trend": "growing",
  "sampleSize": 56,
  "bySeniority": { "senior": 21, "mid": 19, "lead": 8 },
  "byFunction": { "engineering": 33, "data": 18 },
  "scrapedAt": "2026-05-18T19:30:00.000Z"
}
```

LinkedIn reports large counts rounded with a plus, so `isApproximate` flags when the count is a floor. `delta`, `previousTotal`, and `deltaPct` are null on the first run and fill in from the second scheduled run on.

***

### Pricing

First 5 queries per run are free. After that you pay per query tracked, breakdown and change figure included. No seat licenses. Tracking 50 segments daily lands well under $1 a day on the Apify free plan.

***

### FAQ

**How is this different from a LinkedIn jobs intelligence?**
A jobs intelligence returns one row per job. This returns one row per market segment, the total count with a seniority and function split, and the change since last run. It is a labor index, not a job feed.

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

**Why is the count rounded?**
LinkedIn rounds large result counts and adds a plus, so the number is a reliable floor. The actor flags this with `isApproximate` and the trend still tracks cleanly run over run.

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

**Can I track a 24 hour new postings rate?**
Yes. Set posted since to past 24 hours and run daily for a clean new-postings velocity per segment.

**Is this legal?**
The jobs search page is a public surface LinkedIn serves without a login. Use the output in line with your own policies and applicable law.

***

### Related actors by Scrapemint

- **LinkedIn Hiring Tracker and Salary Intelligence** for the individual roles behind a trend
- **LinkedIn Company Hiring Signal Tracker** for the companies driving a trend
- **Indeed Jobs Intelligence** to triangulate the same market on a second source
- **Lead Enrichment Pipeline** to act on a heating segment
- **Glassdoor Company Salary Intelligence** to pair demand with pay

Stack these to turn a market signal into a hiring or investment decision.

# Actor input Schema

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

Role or skill terms to track. Each keyword is crossed with each location. Examples: 'data engineer', 'registered nurse', 'product manager'.

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

Locations to track. Leave empty for worldwide. Examples: 'United States', 'Germany', 'Remote', 'London'.

## `experienceLevel` (type: `string`):

Optional LinkedIn experience filter applied to every query.

## `jobType` (type: `string`):

Optional employment type filter applied to every query.

## `remoteFilter` (type: `string`):

Optional on-site, remote, or hybrid filter applied to every query.

## `postedSince` (type: `string`):

Optional recency filter. Tracking a 24 hour window run daily gives a clean new-postings velocity.

## `includeBreakdown` (type: `boolean`):

Parse the sample of role cards LinkedIn renders to add a seniority and function split per query. Adds no extra request.

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

Store each query's count between runs so a scheduled run reports the change versus the previous run. The trend is the whole point.

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

Apify proxy. The public jobs search page is light; residential improves reliability at volume.

## Actor input object example

```json
{
  "keywords": [
    "data engineer",
    "product manager"
  ],
  "locations": [
    "United States"
  ],
  "experienceLevel": "",
  "jobType": "",
  "remoteFilter": "",
  "postedSince": "",
  "includeBreakdown": true,
  "trackDeltas": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "data engineer",
        "product manager"
    ],
    "locations": [
        "United States"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/linkedin-job-market-trend-scraper").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",
        "product manager",
    ],
    "locations": ["United States"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/linkedin-job-market-trend-scraper").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 '{
  "keywords": [
    "data engineer",
    "product manager"
  ],
  "locations": [
    "United States"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapemint/linkedin-job-market-trend-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Job Market Trend Intelligence",
        "description": "One row per job market query per run: total open roles on LinkedIn for a keyword, location, and filter set, with a seniority and function breakdown and the change since the last run. A labor market index for analysts and planners. No cookie. JSON. Pay per query.",
        "version": "0.1",
        "x-build-id": "nZyAfDspSOruiTUBV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~linkedin-job-market-trend-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-linkedin-job-market-trend-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~linkedin-job-market-trend-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-linkedin-job-market-trend-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~linkedin-job-market-trend-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-linkedin-job-market-trend-scraper",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Role or skill terms to track. Each keyword is crossed with each location. Examples: 'data engineer', 'registered nurse', 'product manager'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to track. Leave empty for worldwide. Examples: 'United States', 'Germany', 'Remote', 'London'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "",
                            "internship",
                            "entry",
                            "associate",
                            "mid-senior",
                            "director",
                            "executive"
                        ],
                        "type": "string",
                        "description": "Optional LinkedIn experience filter applied to every query.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Optional employment type filter applied to every query.",
                        "default": ""
                    },
                    "remoteFilter": {
                        "title": "Remote type",
                        "enum": [
                            "",
                            "onsite",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Optional on-site, remote, or hybrid filter applied to every query.",
                        "default": ""
                    },
                    "postedSince": {
                        "title": "Posted since",
                        "enum": [
                            "",
                            "1d",
                            "1w",
                            "1m"
                        ],
                        "type": "string",
                        "description": "Optional recency filter. Tracking a 24 hour window run daily gives a clean new-postings velocity.",
                        "default": ""
                    },
                    "includeBreakdown": {
                        "title": "Include seniority and function breakdown",
                        "type": "boolean",
                        "description": "Parse the sample of role cards LinkedIn renders to add a seniority and function split per query. Adds no extra request.",
                        "default": true
                    },
                    "trackDeltas": {
                        "title": "Track change since last run",
                        "type": "boolean",
                        "description": "Store each query's count between runs so a scheduled run reports the change versus the previous run. The trend is the whole point.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. The public jobs search page is light; residential improves reliability at volume.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```