# LinkedIn Job Scraper (`scraptivo/linkedin-job-scraper`) Actor

Scrape LinkedIn job postings with advanced filters including location, time range, job type, experience level, and work type.

- **URL**: https://apify.com/scraptivo/linkedin-job-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper** collects job postings from LinkedIn and turns them into structured data for hiring research, recruitment analytics, and automated job alerts. Provide a keyword or job title, add optional filters for location, posting date, job type, experience level, and work arrangement, then export title, company, location, skills, description, and application details to JSON, CSV, or Excel. Use it to monitor hiring trends, build job databases, and track competitor recruitment. Pricing starts at $1 per 1,000 jobs.

### What can you automate with LinkedIn Job Scraper?

- **Build targeted job databases** — search by keyword, location, and filters to compile lists of matching postings for analysis or lead generation.
- **Monitor hiring trends** — track which companies are hiring, which roles are in demand, and how job markets shift over time.
- **Power recruitment workflows** — feed structured job data into your ATS, CRM, or dashboards to streamline candidate sourcing.
- **Analyze competitors** — see what roles rivals are hiring for as a signal of growth areas and technology investment.
- **Automate job alerts** — schedule recurring scrapes and export fresh listings without manual searching.
- **Enrich with company data** — optionally scrape each company's LinkedIn page for description, follower count, and specialties.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Recruitment & staffing agencies | Build filtered, candidate-ready job pipelines to source roles and clients faster. |
| Market researchers | Analyze skill demand, hiring volume, and salary signals across industries and regions. |
| HR & talent intelligence teams | Monitor competitor hiring and workforce changes over time. |
| Sales & marketing teams | Identify fast-growing companies by their open roles and hiring velocity. |

### What data can you collect from LinkedIn?

| Data group | Example fields | How it helps |
|---|---|---|
| Job identity | `title`, `jobId`, `url`, `description` | Identify and open each posting directly. |
| Company & employer | `companyName`, `companyUrl`, `companyLogo`, `industry` | Understand who is hiring and their sector. |
| Location & timing | `location`, `city`, `country`, `latitude`, `longitude`, `datePosted`, `validThrough` | Filter by geography and freshness. |
| Requirements | `employmentType`, `monthsOfExperience`, `educationLevel`, `skills` | Match roles to candidate profiles. |

### How to use LinkedIn Job Scraper

1. Open the actor in your Apify console.
2. Enter one or more search queries, such as "Python Developer" or "Data Scientist".
3. Add optional filters for location, time range, job type, experience level, and remote work.
4. Run the actor.
5. Export the dataset to JSON, CSV, or Excel, or read it through the API.

```json
{
  "searchQueries": ["Python Developer"],
  "locations": ["Germany"],
  "timeRange": "any",
  "maxItems": 30,
  "extractCompanyDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example workflow

#### Build a weekly list of new developer roles

1. Run a "Python Developer" search for Germany every Monday.
2. Keep postings from the past week that match your required experience level.
3. Send new records to Google Sheets or a CRM.
4. Deduplicate using the stable `jobId` or `url` field.

### Automate and integrate your results

Schedule the actor from the Scheduler tab — a daily cadence suits fast-moving job boards, while weekly is enough for trend reports. Attach a webhook to trigger a downstream pipeline when each run completes, and export to Google Sheets, Make, Zapier, Slack, or a database. For recurring pipelines, call the actor through the Apify API:

```shell
curl -X POST "https://api.apify.com/v2/acts/scraptivo/linkedin-job-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["Python Developer"], "locations": ["Germany"], "maxItems": 30}'
```

When merging multiple runs, deduplicate on the `jobId` field to keep one record per posting.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|
| `searchQueries` | array | No | `[]` | Keywords or job titles to search. |
| `startUrls` | array | No | `[]` | Direct LinkedIn job search URLs; overrides `searchQueries`. |
| `locations` | array | No | `[]` | Location names applied to all search queries. |
| `timeRange` | string | No | `any` | Posting date: `any`, `past24Hours`, `pastWeek`, `pastMonth`. |
| `jobType` | array | No | `[]` | `fullTime`, `partTime`, `contract`, `temporary`, `internship`, `volunteer`. |
| `experienceLevel` | array | No | `[]` | `internship`, `entryLevel`, `associate`, `midSenior`, `director`, `executive`. |
| `remote` | array | No | `[]` | `onSite`, `remote`, `hybrid`. |
| `maxItems` | integer | No | `0` | Maximum postings to scrape (0 = unlimited). |
| `extractCompanyDetails` | boolean | No | `false` | Also scrape each company's LinkedIn page. |
| `maxConcurrency` | integer | No | `5` | Parallel detail page fetches (1–20). |
| `proxyConfiguration` | object | No | residential | Proxy settings for anti-bot protection. |

#### Which `timeRange` value should I use?

`past24Hours` returns only very fresh postings, `pastWeek` covers most active hiring, and `pastMonth` captures a broader picture. `any` removes the date filter entirely.

### Output example

```json
{
  "jobId": "4412111373",
  "title": "Python Developer",
  "companyName": "DATAGROUP",
  "companyUrl": "https://de.linkedin.com/company/datagroup-se",
  "location": "Krakau, Saxony-Anhalt, Germany",
  "city": "Krakau",
  "country": "DE",
  "datePosted": "2026-05-08T13:38:46.000Z",
  "validThrough": "2026-11-04T13:38:46.000Z",
  "employmentType": "FULL_TIME",
  "industry": "IT-Dienstleistungen und IT-Beratung",
  "educationLevel": "bachelor degree",
  "skills": "",
  "description": "Design and implement robust, scalable Python components...",
  "url": "https://de.linkedin.com/jobs/view/python-developer-at-datagroup-4412111373"
}
```

### How much does it cost to scrape LinkedIn?

The actor bills per job: **$1 per 1,000 jobs** scraped. Each posting written to the dataset counts as one result. A small run of 1,000 postings costs $1; a larger run of 10,000 postings costs $10. Use `maxItems` to cap output and control spend. In addition to the per-job fee, Apify bills separately for compute and residential proxy usage, which your plan's free monthly units offset.

### Reliability and responsible use

The actor uses Apify residential proxies by default and retries failed requests to handle LinkedIn's anti-bot measures. Some fields are conditional — `monthsOfExperience` or `skills` can be empty when LinkedIn does not publish them, and `latitude`/`longitude` are only present when coordinates are available. It scrapes only publicly visible job postings. You are responsible for complying with LinkedIn's terms and applicable laws when storing or using the data.

### Frequently asked questions

#### Can I scrape specific job types or experience levels?

Yes. Set `jobType`, `experienceLevel`, and `remote` arrays to filter results. Leave any of them empty to include all values.

#### Can I schedule LinkedIn Job Scraper to run automatically?

Yes. Use the Scheduler tab to run it daily or weekly, or trigger scheduled runs through the API with a cron expression.

#### What counts as one result?

Each job posting written to the dataset is one billable result, charged at $1 per 1,000 jobs.

#### Why are some fields empty?

LinkedIn omits optional fields such as skills or months of experience for some postings. Fields that are not published on the page return empty rather than failing the run.

#### Do I need to extract company details?

Only if you want richer employer data. `extractCompanyDetails` fetches each company's LinkedIn page and adds fields like description and follower count, at the cost of extra detail-page requests.

### Related Scraptivo automations

- **[LinkedIn Company Scraper](https://apify.com/scraptivo/linkedin-company-scraper)** — pull company profiles to complement your job data.
- **[LinkedIn Scraper](https://apify.com/scraptivo/linkedin-scraper)** — collect LinkedIn profile data for candidate and lead sourcing.
- **[Trustpilot Reviews Scraper](https://apify.com/scraptivo/trustpilot-reviews-scraper)** — check employer reputation alongside hiring activity.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, a sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords or job titles to search for (e.g. 'Python Developer', 'Data Scientist'). Each query produces a separate search.

## `startUrls` (type: `array`):

Direct LinkedIn job search URLs. Overrides searchQueries when provided.

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

Location names to filter jobs (e.g. 'Germany', 'United States', 'London'). Applied to all search queries.

## `timeRange` (type: `string`):

Filter jobs by posting date.

## `jobType` (type: `array`):

Filter by employment type. Leave empty for all types.

## `experienceLevel` (type: `array`):

Filter by required experience level. Leave empty for all levels.

## `remote` (type: `array`):

Filter by work arrangement. Leave empty for all types.

## `maxItems` (type: `integer`):

Maximum number of job postings to scrape. 0 = unlimited.

## `extractCompanyDetails` (type: `boolean`):

When enabled, also scrapes each company's LinkedIn page for full company details (description, followers, specialties, etc.) and appends them to the output.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel detail page fetches. Higher values increase speed but may trigger rate limiting. Recommended: 3-10.

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

Proxy settings for anti-bot protection.

## Actor input object example

```json
{
  "searchQueries": [
    "Python Developer"
  ],
  "startUrls": [],
  "locations": [],
  "timeRange": "any",
  "jobType": [],
  "experienceLevel": [],
  "remote": [],
  "maxItems": 10,
  "extractCompanyDetails": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchQueries": [
        "Python Developer"
    ],
    "startUrls": [],
    "locations": [],
    "maxItems": 10,
    "extractCompanyDetails": false,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/linkedin-job-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 = {
    "searchQueries": ["Python Developer"],
    "startUrls": [],
    "locations": [],
    "maxItems": 10,
    "extractCompanyDetails": False,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/linkedin-job-scraper").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 '{
  "searchQueries": [
    "Python Developer"
  ],
  "startUrls": [],
  "locations": [],
  "maxItems": 10,
  "extractCompanyDetails": false,
  "maxConcurrency": 5
}' |
apify call scraptivo/linkedin-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/v931fP2on3hO9cRZj/builds/mv9IpSVB7LYXhBnic/openapi.json