# LinkedIn Jobs Scraper (`maged120/linkedin-jobs-scraper`) Actor

Search LinkedIn job listings by keyword, location, job type, and date. Collect titles, companies, locations, descriptions, seniority levels, and applicant counts.

- **URL**: https://apify.com/maged120/linkedin-jobs-scraper.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### What does LinkedIn Jobs Scraper do?

**LinkedIn Jobs Scraper** pulls job listings from [LinkedIn Jobs](https://www.linkedin.com/jobs/) — no account or login needed. Give it keywords and a location, and it returns structured data: job title, company, location, posting date, and a direct link to apply. Enable detailed mode to also get the full job description, seniority level, employment type, industry, and applicant count.

Run it on Apify to schedule daily searches, feed results into Google Sheets or your ATS, and export in JSON, CSV, or Excel.

### Why use LinkedIn Jobs Scraper?

- **Job market research** — track which roles and companies are hiring over time
- **Recruitment pipelines** — pull fresh listings into your internal tools automatically
- **Competitive intelligence** — see who competitors are hiring and how fast
- **Salary & location benchmarking** — build your own dataset for compensation analysis
- **Automated job alerts** — schedule runs and push results to Slack or email

### How to use LinkedIn Jobs Scraper

1. Click **Try for free** on the Actor page
2. Enter your **Keywords** — a job title, skill, or any search term (e.g. `Data Engineer`)
3. Set a **Location** — city, country, or `Remote`
4. Optionally filter by **Date Posted** or **Job Type**
5. Toggle **Fetch Job Details** on if you want descriptions and seniority data
6. Click **Start** — results appear in the **Output** tab within seconds
7. Export your dataset as JSON, CSV, or Excel

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` | string | `software engineer` | Job title, skill, or search term |
| `location` | string | `United States` | City, country, or `Remote` |
| `datePosted` | select | `any` | Any time, Past 24h, Past week, Past month |
| `jobType` | select | `any` | Full-time, Part-time, Contract, Internship, etc. |
| `maxJobs` | integer | `10` | How many listings to collect (up to 500) |
| `fetchDetails` | boolean | `true` | Include full description, seniority, industry, and applicant count |

### Output

Each result is a JSON object saved to the default dataset. Download in JSON, CSV, HTML, or Excel from the **Export** button.

```json
[
  {
    "title": "Senior Python Developer",
    "company": "Acme Corp",
    "location": "New York, NY",
    "seniorityLevel": "Mid-Senior level",
    "employmentType": "Full-time",
    "jobFunction": "Engineering and Information Technology",
    "industries": "Software Development",
    "applicantCount": "Over 200 applicants",
    "postedAt": "2024-01-15",
    "jobUrl": "https://www.linkedin.com/jobs/view/senior-python-developer-at-acme-corp-1234567890",
    "companyUrl": "https://www.linkedin.com/company/acme-corp",
    "description": "We're looking for a Senior Python Developer to join our platform team..."
  }
]
````

### Data fields

| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company` | Hiring company name |
| `location` | City, state, or Remote |
| `seniorityLevel` | Seniority level (when details enabled) |
| `employmentType` | Employment type (when details enabled) |
| `jobFunction` | Job function category (when details enabled) |
| `industries` | Industry (when details enabled) |
| `applicantCount` | Number of applicants (when details enabled) |
| `postedAt` | Date the listing was posted |
| `jobUrl` | Direct link to the LinkedIn listing |
| `companyUrl` | LinkedIn company page |
| `description` | Full job description text (when details enabled) |

### Cost

Pricing is pay-per-result — you only pay for what you collect. There's no subscription and no wasted spend on failed runs.

| | Per 1,000 listings | Per 1,000 with details |
|---|---|---|
| Free plan | $1.00 | $1.50 |
| Starter plan | $0.80 | $1.20 |
| Scale plan | $0.70 | $1.05 |
| Business plan | $0.50 | $0.75 |

A flat $0.05 start fee applies per run to cover initialization.

### Tips

- **Filter by date** — `pastWeek` or `past24h` keeps your dataset clean and avoids stale listings.
- **Schedule it** — set a daily run and always have fresh data without lifting a finger.
- **Pipe to Google Sheets** — the Apify integration syncs results automatically.
- **Combine with other Actors** — feed company URLs into a company enrichment Actor for deeper research.

### FAQ and support

**Do I need a LinkedIn account?**
No. The Actor works entirely with publicly visible listings — the same ones anyone can browse without logging in.

**Why did my run return fewer results than expected?**
There may not be enough matching listings for your filters, or LinkedIn throttled the search. Try broadening your keywords or removing the date filter.

**The Actor stopped before reaching my target count — why?**
LinkedIn may limit results for very broad searches. Try adding a more specific location or keyword to improve coverage.

**Found a bug or need a custom feature?**
Open an issue in the Issues tab. For a bespoke data solution, reach out via [apify.com/contact](https://apify.com/contact).

# Actor input Schema

## `keywords` (type: `string`):

Job title, skills, or keywords to search for (e.g. 'Python Developer', 'Data Scientist')

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

City, state, country, or 'Remote' (e.g. 'New York', 'United States', 'Remote')

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

Filter jobs by how recently they were posted

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

Filter by employment type

## `maxJobs` (type: `integer`):

Maximum number of job listings to scrape

## `fetchDetails` (type: `boolean`):

Include full job description, seniority level, employment type, job function, industries, and applicant count for each listing. Increases run time.

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

Proxy settings. Residential proxy is recommended to avoid LinkedIn rate limiting.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "location": "United States",
  "datePosted": "any",
  "jobType": "any",
  "maxJobs": 10,
  "fetchDetails": true,
  "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 = {
    "keywords": "software engineer",
    "location": "United States",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/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 = {
    "keywords": "software engineer",
    "location": "United States",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("maged120/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 '{
  "keywords": "software engineer",
  "location": "United States",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call maged120/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper",
        "description": "Search LinkedIn job listings by keyword, location, job type, and date. Collect titles, companies, locations, descriptions, seniority levels, and applicant counts.",
        "version": "0.1",
        "x-build-id": "NH99Q903Qs81C3FA4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maged120~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maged120-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/maged120~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maged120-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/maged120~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maged120-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title, skills, or keywords to search for (e.g. 'Python Developer', 'Data Scientist')",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, country, or 'Remote' (e.g. 'New York', 'United States', 'Remote')",
                        "default": "United States"
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "past24h",
                            "pastWeek",
                            "pastMonth"
                        ],
                        "type": "string",
                        "description": "Filter jobs by how recently they were posted",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "any",
                            "fullTime",
                            "partTime",
                            "contract",
                            "temporary",
                            "internship",
                            "volunteer"
                        ],
                        "type": "string",
                        "description": "Filter by employment type",
                        "default": "any"
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape",
                        "default": 10
                    },
                    "fetchDetails": {
                        "title": "Fetch Job Details",
                        "type": "boolean",
                        "description": "Include full job description, seniority level, employment type, job function, industries, and applicant count for each listing. Increases run time.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy is recommended to avoid LinkedIn rate limiting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
