# LinkedIn Jobs Scraper · No Cookies · $1/1k ✅ (`linkedintel/linkedin-jobs-scraper`) Actor

Search and extract LinkedIn job listings — title, company, location, salary, posting date, application URL. No cookies, no login. $1/1k pay-per-result.

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

## Pricing

$2.50 / 1,000 job listing extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## LinkedIn Jobs Scraper · No Cookies · $1/1k

Search and extract structured LinkedIn job listings — by keyword, by location, by full search URL — without cookies, without a login, without a session. Pay only for the jobs you actually receive.

**$0.001 per job extracted ($1 per 1,000 results).**

---

### What you get

Each job is returned as a flat JSON record with the following fields:

| Field | Type | Notes |
| --- | --- | --- |
| `jobId` | string | LinkedIn job posting ID |
| `jobUrn` | string | LinkedIn URN |
| `jobUrl` | string | Canonical `linkedin.com/jobs/view/{id}` URL |
| `title` | string | Job title |
| `jobFunction` | string | When upstream surfaces it |
| `employmentType` | string | Full-time, Part-time, Contract, Internship, Temporary |
| `companyName` | string | Hiring company |
| `companyId` | string | LinkedIn company ID |
| `companyUrl` | string | Company LinkedIn URL |
| `companyLogoUrl` | string | Logo CDN URL |
| `locationCity` | string | Parsed from the location string |
| `locationCountry` | string | Parsed from the location string |
| `locationFull` | string | Raw location text |
| `isRemote` | boolean | True if remote-friendly |
| `workplaceType` | string | `remote` / `hybrid` / `onsite` |
| `listedAt` | string | ISO 8601 timestamp |
| `expiresAt` | string | ISO 8601 timestamp (when available) |
| `description` | string | Full job description text |
| `shortDescription` | string | First ~280 chars, whitespace-collapsed |
| `applicantCount` | integer | When LinkedIn exposes it |
| `seniorityLevel` | string | Entry / Associate / Mid-Senior / Director / Executive |
| `industry` | string | LinkedIn industry tag |
| `applyUrl` | string | External application URL (when not Easy Apply) |
| `easyApply` | boolean | True if LinkedIn Easy Apply is enabled |
| `benefitsList` | array | Surfaced benefits (when available) |
| `salaryMin` | number | Minimum compensation (when available) |
| `salaryMax` | number | Maximum compensation (when available) |
| `salaryCurrency` | string | ISO currency code |
| `salaryPeriod` | string | `YEARLY` / `MONTHLY` / `HOURLY` |
| `isPromoted` | boolean | True for sponsored postings |
| `insightText` | string | LinkedIn insight badge (e.g. "Be among the first 25 applicants") |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

A `summary` record is appended at the end of every run with per-query counts and overall totals.

---

### Pricing comparison

| Actor | Price | Cookies needed |
| --- | --- | --- |
| **This actor** | **$1.00 / 1k** | **No** |
| harvestapi/linkedin-job-search | $1.00 / 1k | No |
| bebity/linkedin-jobs-scraper | $5.00 / 1k | No |
| dev_fusion/linkedin-jobs-scraper | $3.00 / 1k | Yes (li_at) |
| voyager/linkedin-jobs-scraper | $4.00 / 1k | No |

You only pay for jobs returned. Empty result sets cost $0.

---

### Example searches

#### Recipe 1 — Remote SaaS engineering hiring

```json
{
  "searchQueries": ["Senior Backend Engineer SaaS", "Staff Software Engineer SaaS"],
  "workplaceTypeFilter": "remote",
  "maxJobsPerSearch": 200
}
````

#### Recipe 2 — US-only marketing leadership

```json
{
  "searchQueries": ["VP Marketing", "Head of Growth", "Marketing Director"],
  "countriesFilter": ["US"],
  "maxJobsPerSearch": 100
}
```

#### Recipe 3 — Easy Apply data science roles

```json
{
  "searchQueries": ["Data Scientist", "Machine Learning Engineer"],
  "easyApplyOnly": true,
  "maxJobsPerSearch": 50
}
```

#### Recipe 4 — Pull from a full LinkedIn URL

```json
{
  "searchQueries": [
    "https://www.linkedin.com/jobs/search/?keywords=Product%20Manager&location=Berlin&f_WT=2"
  ],
  "maxJobsPerSearch": 300
}
```

The actor parses `keywords`, `location`, `f_WT` (workplace type), and `f_AL` (Easy Apply) directly from LinkedIn search URLs.

***

### Output sample

```json
{
  "type": "jobResult",
  "searchQuery": "Senior Software Engineer remote",
  "jobId": "3938472841",
  "jobUrl": "https://www.linkedin.com/jobs/view/3938472841",
  "title": "Senior Software Engineer, Platform",
  "employmentType": "Full-time",
  "companyName": "Acme Corp",
  "companyUrl": "https://www.linkedin.com/company/acme-corp/",
  "companyLogoUrl": "https://media.licdn.com/...",
  "locationCity": "San Francisco",
  "locationCountry": "United States",
  "locationFull": "San Francisco, CA (Remote)",
  "isRemote": true,
  "workplaceType": "remote",
  "listedAt": "2025-05-12T14:33:00+00:00",
  "shortDescription": "We are looking for a Senior Software Engineer to join our Platform team…",
  "applicantCount": 47,
  "seniorityLevel": "Mid-Senior level",
  "easyApply": true,
  "scrapedAt": "2025-05-19T09:12:33+00:00"
}
```

***

### Compliance & trademark

This actor returns only publicly available job posting data — the same information any logged-out visitor would see when browsing the public job board. No login, no cookies, no LinkedIn session, no scraping of private profile data. Output is structured re-presentation of public data and is intended for lawful purposes such as labor-market research, recruitment intelligence, and competitive analysis.

LinkedIn is a registered trademark of LinkedIn Corporation. This actor is not affiliated with, sponsored by, or endorsed by LinkedIn. Users are responsible for ensuring their use of scraped data complies with applicable laws and LinkedIn's terms of service in their jurisdiction.

Pay-per-result pricing: the actor charges $0.001 per job listing returned. Failed runs and empty result sets are not billed.

# Actor input Schema

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

Job search keywords (e.g. 'Senior Software Engineer', 'Marketing Director Berlin') OR full LinkedIn job-search URLs.

## `countriesFilter` (type: `array`):

ISO 3166-1 alpha-2 country codes (e.g. 'US', 'GB', 'DE') to filter results.

## `workplaceTypeFilter` (type: `string`):

Filter by remote / hybrid / onsite / all.

## `easyApplyOnly` (type: `boolean`):

Return only jobs with LinkedIn Easy Apply enabled (skip external application URLs).

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

Hard cap on jobs returned per query.

## Actor input object example

```json
{
  "searchQueries": [
    "Senior Software Engineer remote"
  ],
  "countriesFilter": [],
  "workplaceTypeFilter": "all",
  "easyApplyOnly": false,
  "maxJobsPerSearch": 100
}
```

# 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": [
        "Senior Software Engineer remote"
    ],
    "countriesFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/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 = {
    "searchQueries": ["Senior Software Engineer remote"],
    "countriesFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/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 '{
  "searchQueries": [
    "Senior Software Engineer remote"
  ],
  "countriesFilter": []
}' |
apify call linkedintel/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper · No Cookies · $1/1k ✅",
        "description": "Search and extract LinkedIn job listings — title, company, location, salary, posting date, application URL. No cookies, no login. $1/1k pay-per-result.",
        "version": "1.0",
        "x-build-id": "XAJnPj4ige94T9ifW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-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/linkedintel~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-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/linkedintel~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Job search keywords (e.g. 'Senior Software Engineer', 'Marketing Director Berlin') OR full LinkedIn job-search URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countriesFilter": {
                        "title": "Countries (optional)",
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 country codes (e.g. 'US', 'GB', 'DE') to filter results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workplaceTypeFilter": {
                        "title": "Workplace type",
                        "enum": [
                            "all",
                            "remote",
                            "hybrid",
                            "onsite"
                        ],
                        "type": "string",
                        "description": "Filter by remote / hybrid / onsite / all.",
                        "default": "all"
                    },
                    "easyApplyOnly": {
                        "title": "Easy Apply only",
                        "type": "boolean",
                        "description": "Return only jobs with LinkedIn Easy Apply enabled (skip external application URLs).",
                        "default": false
                    },
                    "maxJobsPerSearch": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on jobs returned per query.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
