# LinkedIn Jobs Scraper - Global Listings, Salary & Skills (`thirdwatch/linkedin-jobs-scraper`) Actor

Scrape LinkedIn public job listings worldwide. Extract title, company, location, salary, description, skills, experience level, job type. Fast and full scrape modes. 30+ countries, 100+ cities. No login needed.

- **URL**: https://apify.com/thirdwatch/linkedin-jobs-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Other
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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 Jobs Scraper - Global Listings, Salary & Skills

> Scrape thousands of public job listings from LinkedIn -- the world's largest professional network with 1B+ members.

### What you get

LinkedIn hosts 20M+ active job postings across 200+ countries. Extract job titles, companies, locations, parsed salary ranges, skills, full descriptions, experience levels, and direct apply links. No LinkedIn account needed.

Try it free -- click **Start** in the Input tab.

### Why scrape LinkedIn Jobs?

Whether you're building a job aggregator, tracking hiring trends, benchmarking salaries, or powering a recruitment tool -- LinkedIn is the most comprehensive global source. This scraper accesses only public job listing pages.

**Use cases:**
- Job aggregation and board platforms
- Salary benchmarking and compensation analytics
- Hiring trend analysis by role, company, and region
- Competitor hiring intelligence
- Recruitment automation and lead generation
- Academic research on labor markets

### Output fields

| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company_name` | Hiring company |
| `location` | Job location |
| `salary_raw` | Salary as displayed |
| `salary_min` | Parsed minimum salary |
| `salary_max` | Parsed maximum salary |
| `salary_currency` | Currency code |
| `salary_period` | Pay period (yearly, monthly, hourly) |
| `experience_level` | Required experience level |
| `job_type` | Full-time, Part-time, Contract, etc. |
| `industry` | Company industry |
| `skills` | Required skills (Full mode) |
| `description` | Full job description (Full mode) |
| `applicant_count` | Number of applicants |
| `is_easy_apply` | Whether Easy Apply is available |
| `posted_at` | Posting date |
| `apply_url` | LinkedIn job URL |

### Example output

```json
{
    "title": "Software Engineer",
    "company_name": "Google",
    "location": "San Francisco, CA",
    "salary_raw": "$150,000 - $200,000/yr",
    "salary_min": 150000,
    "salary_max": 200000,
    "salary_currency": "USD",
    "salary_period": "yearly",
    "experience_level": "Mid-Senior level",
    "job_type": "Full-time",
    "industry": "Technology, Information and Internet",
    "skills": ["Python", "Java", "AWS"],
    "description": "We are looking for a talented Software Engineer to join...",
    "applicant_count": "200+ applicants",
    "is_easy_apply": true,
    "posted_at": "2026-04-05",
    "apply_url": "https://www.linkedin.com/jobs/view/123456/"
}
````

### Input parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `queries` | Yes | Job search keywords (e.g., "software engineer", "data scientist") |
| `location` | No | City or country (e.g., "San Francisco", "India") |
| `country` | No | Country filter: US, UK, India, Canada, etc. |
| `companyName` | No | Filter by company (e.g., "Google", "Netflix") |
| `maxResultsPerQuery` | No | Max jobs per query (default: 25) |
| `maxPages` | No | Search result pages per query (default: 1) |
| `scrapeMode` | No | "fast" (cards only) or "full" (with descriptions/salary/skills) |
| `datePosted` | No | Filter: past 24h, past week, past month |
| `jobType` | No | Filter: Full-time, Part-time, Contract, Temporary, Internship |
| `experienceLevel` | No | Filter: Internship through Executive |

### Scrape modes

#### Fast mode (default)

Extracts data from search result cards only. Gets: title, company, location, posted date, apply URL. Best for bulk job listing collection.

#### Full mode

Visits each job's detail page. Gets: full description, salary, experience level, job type, skills, industry, applicant count. Best for complete job data analysis.

### Pricing

| Mode | Jobs | Cost |
|------|------|------|
| Fast | 100 | ~$0.05 |
| Fast | 1,000 | ~$0.50 |
| Full | 100 | ~$0.20 |
| Full | 1,000 | ~$2.00 |

Pay-per-result pricing at $0.005 per job. Volume discounts available.

### Supported locations

**Countries (20+):** United States, United Kingdom, India, Canada, Australia, Germany, France, Netherlands, Singapore, UAE, Japan, Brazil, Ireland, Sweden, Switzerland, Spain, Italy, Israel, South Korea, Mexico

**Cities (100+):** San Francisco, New York, London, Berlin, Paris, Amsterdam, Toronto, Sydney, Singapore, Dubai, Tokyo, Bangalore, Mumbai, and many more.

### Tips

- **Use Fast mode first** -- preview results cheaply before switching to Full mode
- **One query at a time** -- keep queries focused for best results
- **Filter by date** -- `pastWeek` finds fresh listings and reduces noise
- **Company filter** -- add `companyName` to monitor specific employer hiring
- **Use the Apify scheduler** to run daily and track new listings automatically

### FAQ

**Do I need a LinkedIn account?**
No. The scraper accesses only publicly visible job listing pages.

**Why are some fields empty in Fast mode?**
Fast mode only reads search result cards. Salary, skills, and description require Full mode.

**What if I get blocked?**
The actor includes rate limiting by default. If you see failures, reduce `maxPages` or add delays between runs.

### Related Actors

- [Naukri.com Jobs Scraper](https://apify.com/thirdwatch/naukri-jobs-scraper) -- India jobs with descriptions, salary, ratings
- [Indeed.com Jobs Scraper](https://apify.com/thirdwatch/indeed-jobs-scraper) -- Global job listings with 22 fields
- [CutShort Tech Jobs Scraper](https://apify.com/thirdwatch/cutshort-jobs-scraper) -- India tech jobs, salary, skills

### Changelog

- **v1.0** -- Initial release with Fast/Full modes, 20+ countries, salary parsing, skills extraction

# Actor input Schema

## `queries` (type: `array`):

Job search keywords (e.g., 'software engineer', 'data scientist', 'product manager'). Each query produces a separate LinkedIn search.

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

Location to search in. Use a city name (e.g., 'San Francisco', 'London', 'Bangalore'), a country name (e.g., 'United States', 'India'), or leave empty for worldwide results.

## `country` (type: `string`):

Filter by country using LinkedIn geoId. Select a country or leave empty to use the location field instead.

## `companyName` (type: `string`):

Filter by specific company name (e.g., 'Google', 'Netflix'). Appended to search keywords.

## `maxResultsPerQuery` (type: `integer`):

Maximum job listings to extract per query. LinkedIn shows ~25 per page.

## `maxPages` (type: `integer`):

Number of search result pages to scrape per query. Each page has ~25 jobs. Keep low to manage costs.

## `scrapeMode` (type: `string`):

HTTP (recommended, cheapest): Fastest and most affordable (~$0.10/1K). Full: Comprehensive extraction with fallback (~$0.50-2/1K). Fast: Search cards only, no descriptions.

## `datePosted` (type: `string`):

Filter by when jobs were posted.

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

Filter by employment type.

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

Filter by experience level.

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

IPs

## Actor input object example

```json
{
  "queries": [
    "software engineer"
  ],
  "location": "",
  "country": "",
  "companyName": "",
  "maxResultsPerQuery": 25,
  "maxPages": 1,
  "scrapeMode": "http",
  "datePosted": "",
  "jobType": "",
  "experienceLevel": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "queries": [
        "software engineer"
    ],
    "location": "",
    "maxResultsPerQuery": 25,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/linkedin-jobs-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 = {
    "queries": ["software engineer"],
    "location": "",
    "maxResultsPerQuery": 25,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/linkedin-jobs-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 '{
  "queries": [
    "software engineer"
  ],
  "location": "",
  "maxResultsPerQuery": 25,
  "maxPages": 1
}' |
apify call thirdwatch/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper - Global Listings, Salary & Skills",
        "description": "Scrape LinkedIn public job listings worldwide. Extract title, company, location, salary, description, skills, experience level, job type. Fast and full scrape modes. 30+ countries, 100+ cities. No login needed.",
        "version": "1.1",
        "x-build-id": "vEhX7xl1a8Xik4BME"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-linkedin-jobs-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/thirdwatch~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-linkedin-jobs-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/thirdwatch~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-linkedin-jobs-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Job Search Queries",
                        "type": "array",
                        "description": "Job search keywords (e.g., 'software engineer', 'data scientist', 'product manager'). Each query produces a separate LinkedIn search.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search in. Use a city name (e.g., 'San Francisco', 'London', 'Bangalore'), a country name (e.g., 'United States', 'India'), or leave empty for worldwide results.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country Filter",
                        "enum": [
                            "",
                            "us",
                            "uk",
                            "india",
                            "canada",
                            "australia",
                            "germany",
                            "france",
                            "netherlands",
                            "singapore",
                            "uae",
                            "japan",
                            "brazil",
                            "ireland",
                            "sweden",
                            "switzerland",
                            "spain",
                            "italy",
                            "israel",
                            "south_korea",
                            "mexico"
                        ],
                        "type": "string",
                        "description": "Filter by country using LinkedIn geoId. Select a country or leave empty to use the location field instead.",
                        "default": ""
                    },
                    "companyName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Filter by specific company name (e.g., 'Google', 'Netflix'). Appended to search keywords.",
                        "default": ""
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum job listings to extract per query. LinkedIn shows ~25 per page.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of search result pages to scrape per query. Each page has ~25 jobs. Keep low to manage costs.",
                        "default": 1
                    },
                    "scrapeMode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "http",
                            "full",
                            "fast"
                        ],
                        "type": "string",
                        "description": "HTTP (recommended, cheapest): Fastest and most affordable (~$0.10/1K). Full: Comprehensive extraction with fallback (~$0.50-2/1K). Fast: Search cards only, no descriptions.",
                        "default": "http"
                    },
                    "datePosted": {
                        "title": "Date Posted Filter",
                        "enum": [
                            "",
                            "past24h",
                            "pastWeek",
                            "pastMonth"
                        ],
                        "type": "string",
                        "description": "Filter by when jobs were posted.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job Type Filter",
                        "enum": [
                            "",
                            "F",
                            "P",
                            "C",
                            "T",
                            "I"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience Level Filter",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6"
                        ],
                        "type": "string",
                        "description": "Filter by experience level.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "IPs",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
