# LinkedIn Job Scraper - Public Jobs, No Login (`nezha/linkedin-job-scraper`) Actor

Scrape public LinkedIn job search results without login and export job title, company, location, salary, job description, apply URL, seniority, employment type, industry, and application count fields.

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

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## LinkedIn Job Scraper - Public Jobs, No Login

Extract public LinkedIn job search results without a LinkedIn login. Provide keywords, location, company filters, date filters, work arrangement, job type, and seniority filters, then export structured job records to an Apify dataset.

### What This Actor Extracts

This Actor opens LinkedIn public guest job endpoints and saves job records with:

- job title, job URL, and LinkedIn job ID
- company name, company URL, and optional company ID lookup
- job location, published time, application count, salary, benefits
- employment type, seniority level, industries, job function
- job description text and optional description HTML
- apply type and apply URL

### Quick Start

1. Add one or more values to **Keywords**.
2. Set **Location**, for example `Los Angeles Metropolitan Area`.
3. Keep **Max Jobs** small for your first run, such as `20`.
4. Keep **Max Concurrency** around `2-4` and **Delay Between Requests** above zero.
5. Run the Actor and export the dataset as CSV, Excel, JSON, or via API.

### Example Input

```json
{
  "MainKeys": ["Controller"],
  "Location": "Los Angeles Metropolitan Area",
  "Published_at": "Past week",
  "Remote_or_OnSite": ["Remote", "Hybrid"],
  "Job_Type": ["Full time"],
  "Experience_Level": ["Entry level", "Associate"],
  "maxItems": 20,
  "maxListPages": 5,
  "maxConcurrency": 3,
  "maxRetries": 3,
  "requestDelaySecs": 2,
  "includeDescriptionHtml": true,
  "includeNoResultRecords": true,
  "resolveCompanyIds": true
}
````

### Output Preview

| title | companyName | location | publishedAt | contractType | jobUrl |
| --- | --- | --- | --- | --- | --- |
| Controller | Example Company | Los Angeles, CA | 1 week ago | Full-time | https://www.linkedin.com/jobs/view/... |

### Stability Recommendations

Public LinkedIn pages can throttle aggressive traffic. The Actor is configured for stability rather than maximum speed:

- low default concurrency
- request delay with random jitter
- session and cookie persistence
- retries and failed request records
- basic detection for rate-limit, sign-in, verification, and blocked pages

Use Apify Proxy when you need consistent network routing, and start with small test runs before increasing `maxItems`.

### Notes

This Actor works with public LinkedIn job pages that are available without login. It does not log into LinkedIn, bypass access controls, or solve verification challenges.

# Actor input Schema

## `MainKeys` (type: `array`):

Job keywords to search on LinkedIn public jobs, for example Controller, Python Engineer, Sales Manager, or Data Analyst.

## `Location` (type: `string`):

LinkedIn location text. The Actor resolves it through LinkedIn's public GEO typeahead when possible. Empty input defaults to United States.

## `Company_Title` (type: `array`):

Optional LinkedIn company names. The Actor resolves each name through LinkedIn's public COMPANY typeahead and applies the resulting f\_C filter.

## `Company_ID` (type: `array`):

Optional LinkedIn company IDs. Use this when you already know the exact f\_C values and want to avoid company-name lookup.

## `Published_at` (type: `string`):

Optional LinkedIn date filter. It maps to f\_TPR in LinkedIn public job search.

## `Remote_or_OnSite` (type: `array`):

Optional work arrangement filters. Supported values: Remote, On site, Hybrid. They map to LinkedIn f\_WT values.

## `Job_Type` (type: `array`):

Optional job type filters. Supported values: Full time, Part time, Contract, Temporary, Volunteer. They map to LinkedIn f\_JT values.

## `Experience_Level` (type: `array`):

Optional seniority filters. Supported values: Internship, Entry level, Associate, Mid Senior level, Director. They map to LinkedIn f\_E values.

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

Maximum number of job records to save in one run.

## `maxListPages` (type: `integer`):

Maximum LinkedIn search result pages to scan per keyword. Each public list page usually contains up to 10 jobs.

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

Concurrent HTTP requests. Keep this low for public LinkedIn pages; 2-4 is usually a safer range than high parallelism.

## `maxRetries` (type: `integer`):

How many times to retry a failed list or detail request before storing it in FAILED\_REQUESTS.

## `requestDelaySecs` (type: `integer`):

Polite delay before each HTTP request. The Actor also adds a small random jitter.

## `includeDescriptionHtml` (type: `boolean`):

Store the job description HTML in descriptionHtml. Disable to reduce dataset size.

## `includeNoResultRecords` (type: `boolean`):

When enabled, a keyword/location with no first-page matches saves one empty row with error\_message set.

## `resolveCompanyIds` (type: `boolean`):

When enabled, each detail record attempts to resolve the company ID by company name. Disable for fewer auxiliary requests.

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

Optional Apify proxy configuration. Use stable country/session settings and modest concurrency for more reliable public LinkedIn runs.

## Actor input object example

```json
{
  "MainKeys": [
    "Controller"
  ],
  "Location": "Los Angeles Metropolitan Area",
  "Published_at": "Past week",
  "maxItems": 100,
  "maxListPages": 100,
  "maxConcurrency": 3,
  "maxRetries": 3,
  "requestDelaySecs": 2,
  "includeDescriptionHtml": true,
  "includeNoResultRecords": true,
  "resolveCompanyIds": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured public LinkedIn job records.

## `outputSummary` (type: `string`):

Input settings, request settings, and crawl statistics.

## `failedRequests` (type: `string`):

List or detail requests that failed after retries.

# 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 = {
    "MainKeys": [
        "Controller"
    ],
    "Location": "Los Angeles Metropolitan Area"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nezha/linkedin-job-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "MainKeys": ["Controller"],
    "Location": "Los Angeles Metropolitan Area",
}

# Run the Actor and wait for it to finish
run = client.actor("nezha/linkedin-job-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 '{
  "MainKeys": [
    "Controller"
  ],
  "Location": "Los Angeles Metropolitan Area"
}' |
apify call nezha/linkedin-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Job Scraper - Public Jobs, No Login",
        "description": "Scrape public LinkedIn job search results without login and export job title, company, location, salary, job description, apply URL, seniority, employment type, industry, and application count fields.",
        "version": "0.1",
        "x-build-id": "La0pc6gVWZaN2Aom1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nezha~linkedin-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nezha-linkedin-job-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/nezha~linkedin-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nezha-linkedin-job-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/nezha~linkedin-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nezha-linkedin-job-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": [
                    "MainKeys"
                ],
                "properties": {
                    "MainKeys": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job keywords to search on LinkedIn public jobs, for example Controller, Python Engineer, Sales Manager, or Data Analyst.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "Location": {
                        "title": "Location",
                        "type": "string",
                        "description": "LinkedIn location text. The Actor resolves it through LinkedIn's public GEO typeahead when possible. Empty input defaults to United States."
                    },
                    "Company_Title": {
                        "title": "Company Names",
                        "type": "array",
                        "description": "Optional LinkedIn company names. The Actor resolves each name through LinkedIn's public COMPANY typeahead and applies the resulting f_C filter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "Company_ID": {
                        "title": "Company IDs",
                        "type": "array",
                        "description": "Optional LinkedIn company IDs. Use this when you already know the exact f_C values and want to avoid company-name lookup.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "Published_at": {
                        "title": "Published At",
                        "enum": [
                            "Any time",
                            "Past month",
                            "Past week",
                            "Past 24 hours"
                        ],
                        "type": "string",
                        "description": "Optional LinkedIn date filter. It maps to f_TPR in LinkedIn public job search.",
                        "default": "Past week"
                    },
                    "Remote_or_OnSite": {
                        "title": "Remote or On-site",
                        "type": "array",
                        "description": "Optional work arrangement filters. Supported values: Remote, On site, Hybrid. They map to LinkedIn f_WT values.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "Job_Type": {
                        "title": "Job Type",
                        "type": "array",
                        "description": "Optional job type filters. Supported values: Full time, Part time, Contract, Temporary, Volunteer. They map to LinkedIn f_JT values.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "Experience_Level": {
                        "title": "Experience Level",
                        "type": "array",
                        "description": "Optional seniority filters. Supported values: Internship, Entry level, Associate, Mid Senior level, Director. They map to LinkedIn f_E values.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job records to save in one run.",
                        "default": 100
                    },
                    "maxListPages": {
                        "title": "Max List Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum LinkedIn search result pages to scan per keyword. Each public list page usually contains up to 10 jobs.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Concurrent HTTP requests. Keep this low for public LinkedIn pages; 2-4 is usually a safer range than high parallelism.",
                        "default": 3
                    },
                    "maxRetries": {
                        "title": "Retries Per Request",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed list or detail request before storing it in FAILED_REQUESTS.",
                        "default": 3
                    },
                    "requestDelaySecs": {
                        "title": "Delay Between Requests",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Polite delay before each HTTP request. The Actor also adds a small random jitter.",
                        "default": 2
                    },
                    "includeDescriptionHtml": {
                        "title": "Include Description HTML",
                        "type": "boolean",
                        "description": "Store the job description HTML in descriptionHtml. Disable to reduce dataset size.",
                        "default": true
                    },
                    "includeNoResultRecords": {
                        "title": "Save No-result Rows",
                        "type": "boolean",
                        "description": "When enabled, a keyword/location with no first-page matches saves one empty row with error_message set.",
                        "default": true
                    },
                    "resolveCompanyIds": {
                        "title": "Resolve Company IDs",
                        "type": "boolean",
                        "description": "When enabled, each detail record attempts to resolve the company ID by company name. Disable for fewer auxiliary requests.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Use stable country/session settings and modest concurrency for more reliable public LinkedIn runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
