# LinkedIn Jobs Scraper: Public Job Listings, No Login (`subimpact/linkedin-jobs-api`) Actor

Scrape public LinkedIn job listings by keyword and location: title, company, location, posting date, plus optional full description, seniority, employment type and applicant count. No login.

- **URL**: https://apify.com/subimpact/linkedin-jobs-api.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 96.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 job listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Jobs Scraper: Public Job Listings, No Login

Search public LinkedIn job listings by keyword and location and get one clean row per job: title, company, location, posting date, salary when LinkedIn shows it on the card, the full description, criteria, applicant count and the apply type. No login, no cookies, no browser.

### What it does

- Runs your keyword and location searches against LinkedIn's logged-out public job pages.
- Returns one dataset row per unique job id. The same job found by two searches is delivered once.
- Reads the cards LinkedIn shows publicly: title, company, company page, location, posting date and age, salary text when shown, and badges such as Actively Hiring.
- Optionally fetches each job's public detail page for the full description (text and HTML), seniority level, employment type, job function, industries, applicant count and the apply type (`offsite` or `easy_apply`).
- When LinkedIn shows the external apply link to a logged-out visitor, which is rare, the row also carries the decoded `applyUrl` and, for a known host, the `atsPlatform`: Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Personio or UKG.
- Fetches detail pages concurrently (`detailConcurrency`, default 6, up to 10) while still pushing and charging rows one at a time, in listing order.
- Applies LinkedIn's own filters: posted within 24 hours, week or month, on-site, remote or hybrid, full-time, part-time, contract, temporary or internship, experience level, and newest first.
- Pushes each row as soon as it is ready and charges only after the row is in the dataset. Error rows are free.
- Accepts LinkedIn search URLs copied from a browser, so filters you set in the LinkedIn UI carry over.

Public job listings only: the Actor reads the same pages a logged-out visitor sees. It does not log in, does not use cookies, does not open profiles and does not collect people data. Recruiter and poster names are never extracted, even when LinkedIn shows them.

### Input

Two equivalent ways to define searches. The prefilled form input is also a working API input:

```json
{
  "searches": [
    { "keywords": "data engineer", "location": "Malaysia" }
  ],
  "maxJobsPerSearch": 20,
  "maxTotalJobs": 20,
  "includeDetails": true
}
```

Or paste LinkedIn search URLs, including any filters you set on the LinkedIn site:

```json
{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=data%20engineer&location=Malaysia&f_TPR=r604800&f_WT=2&sortBy=DD"
  ],
  "maxJobsPerSearch": 20,
  "maxTotalJobs": 20
}
```

An empty input `{}` runs the prefilled demo search (`data engineer` in `Malaysia`), 10 jobs, without details. It costs a fraction of a cent.

| Input | Type | Default | What it does |
| --- | --- | --- | --- |
| `searches` | array of objects | none | Keyword and location pairs, for example `{"keywords":"software engineer","location":"Singapore"}`. Location may be empty. |
| `searchUrls` | array of strings | none | LinkedIn jobs search URLs. `keywords`, `location` and the `f_TPR`, `f_WT`, `f_JT`, `f_E`, `sortBy` and `geoId` parameters are read from the URL. |
| `maxJobsPerSearch` | integer | `50` | Delivered jobs per search, 1 to 1000. LinkedIn stops returning cards around `start=990`, so about 1,000 is the practical ceiling per search. |
| `maxTotalJobs` | integer | `200` | Global cap for the run. This is the hard cost ceiling. `0` means no limit. |
| `includeDetails` | boolean | `false` | Fetch each job's public detail page. Adds one request and the `job-details` event per job. |
| `detailConcurrency` | integer | `6` | Detail pages fetched in parallel, 1 to 10. Rows are still delivered and charged one at a time, in listing order. Higher is faster; lower is gentler on LinkedIn. |
| `postedWithin` | select | `any` | `any`, `24h`, `week` or `month`, sent as LinkedIn's `f_TPR`. |
| `workplaceType` | multi-select | empty | `onsite`, `remote`, `hybrid`, sent as `f_WT`. |
| `jobType` | multi-select | empty | `full-time`, `part-time`, `contract`, `temporary`, `internship`, sent as `f_JT`. |
| `experienceLevel` | multi-select | empty | `internship`, `entry`, `associate`, `mid-senior`, `director`, `executive`, sent as `f_E`. |
| `sortByDate` | boolean | `false` | Newest first, sent as `sortBy=DD`. |
| `proxyCountry` | string | `US` | Two-letter country for the residential proxy session, for example `US` or `MY`. |

Rules for mixed input: use `searches` or `searchUrls`, not both (`searches` wins if both are given). A filter in a pasted URL wins over the run-level filter of the same name. One unreadable entry becomes its own free error row and the rest of the run continues; the run fails only when nothing at all could be processed. Blank lines are ignored.

There is no input for cookies, credentials or a LinkedIn account, because the Actor never uses them.

### Output

One dataset row per unique job id, plus free error rows. Fields:

| Field | Example | Notes |
| --- | --- | --- |
| `jobId` | `4385043644` | LinkedIn posting id. |
| `jobUrl` | `https://www.linkedin.com/jobs/view/4385043644` | Public job page. |
| `title` | `AI & Data - Data Engineer, Senior Associate` | Job title. |
| `companyName` | `EY` | Hiring company. |
| `companyUrl` | `https://uk.linkedin.com/company/ernstandyoung` | LinkedIn company page when the card shows one, tracking parameters removed. |
| `location` | `Kuala Lumpur, Federal Territory of Kuala Lumpur, Malaysia` | As published by the employer. |
| `postedAt` | `2026-11-06` | Posting date from the card's `datetime` attribute. |
| `postedText` | `1 day ago` | Relative age exactly as shown. |
| `salaryText` | `null` | Salary text when LinkedIn shows one on the card. |
| `isPromoted` | `false` | True when the card is marked promoted. |
| `benefits` | `["Actively Hiring"]` | Badge texts on the card, null when none. |
| `searchKeywords` | `data engineer` | Search that produced the row. |
| `searchLocation` | `Malaysia` | Location of that search. |
| `scrapedAt` | `2026-11-08T09:15:00.000Z` | When the search page was fetched. |
| `error` | `null` | Reason on error rows, null on job rows. |
| `inputValue` | `null` | Raw search entry on error rows only. |
| `descriptionText` | `The opportunity ...` | Full plain-text description, requires `includeDetails`. |
| `descriptionHtml` | `<p><strong>The opportunity</strong> ...` | Full HTML description, requires `includeDetails`. |
| `seniorityLevel` | `Mid-Senior level` | LinkedIn criteria, when shown. |
| `employmentType` | `Full-time` | LinkedIn criteria, when shown. |
| `jobFunction` | `null` | LinkedIn criteria, when shown. Some postings omit it. |
| `industries` | `Professional Services` | LinkedIn criteria, when shown. |
| `applicantsText` | `Over 200 applicants` | Applicant caption exactly as shown. |
| `applyUrl` | `null` | Filled only when LinkedIn shows the external apply link to logged-out visitors (rare); `applyType` tells offsite from Easy Apply. |
| `applyType` | `offsite` | `offsite`, `easy_apply` or `unknown`. The reliable signal for how a posting is applied to; it is set on every detail page. |
| `atsPlatform` | `null` | Filled only when a visible `applyUrl` points at Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Personio or UKG. |

Example row with details, values from a real public posting scraped on 2026-11-08 (description shortened here):

```json
{
  "jobId": "4385043644",
  "jobUrl": "https://www.linkedin.com/jobs/view/4385043644",
  "title": "AI & Data - Data Engineer, Senior Associate",
  "companyName": "EY",
  "companyUrl": "https://uk.linkedin.com/company/ernstandyoung",
  "location": "Kuala Lumpur, Federal Territory of Kuala Lumpur, Malaysia",
  "postedAt": "2026-11-06",
  "postedText": "1 day ago",
  "salaryText": null,
  "isPromoted": false,
  "benefits": ["Actively Hiring"],
  "searchKeywords": "data engineer",
  "searchLocation": "Malaysia",
  "scrapedAt": "2026-11-08T09:15:00.000Z",
  "error": null,
  "inputValue": null,
  "descriptionText": "The opportunity\nEY AI & Data is the data and advanced analytics capability within EY Asia-Pacific ...",
  "descriptionHtml": "<strong>The opportunity <br><br></strong>EY AI & Data is the data and advanced analytics capability ...",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": null,
  "industries": "Professional Services",
  "applicantsText": "Over 200 applicants",
  "applyUrl": null,
  "applyType": "offsite",
  "atsPlatform": null
}
```

A search with no results returns no rows and is reported in the run summary. A search that fails after retries returns one error row (`error` explains why, job fields are null) and is never charged. The run summary with counters and byte usage is stored in the key-value store as `OUTPUT`.

### Pricing

- **`job`: per delivered listing row.** Per 1,000 jobs: $0.50 Free plan, $0.40 Bronze, $0.30 Silver, $0.25 Gold and above.
- **`job-details`: extra per row delivered with details.** Per 1,000 jobs: $1.20 Free, $1.00 Bronze, $0.80 Silver, $0.70 Gold and above. A details run is therefore $1.70 per 1,000 jobs on the Free plan and $0.95 on Gold.
- The `job` event is charged only after the row has been pushed to the dataset. `job-details` is charged only for a row that actually carries the detail fields.
- Error rows, empty searches and failed pushes are free.
- **Platform usage is included in the price.** That includes the Apify residential proxy traffic the run needs.

A demo run (`{}`) is 10 jobs without details: about $0.005 of job charges. `maxTotalJobs` is the hard ceiling: set it to the number of rows you are willing to pay for.

### How this compares

List prices per 1,000 jobs (Free plan / Gold plan), checked 8 November 2026. All five include platform usage in the price.

| Actor | Free plan | Gold | Notes |
| --- | --- | --- | --- |
| **This actor** | $0.50 ($1.70 with details) | $0.25 ($0.95 with details) | Pay per delivered row, no start fee |
| curious_coder/linkedin-jobs-scraper | $2.00 | $1.00 | Per item |
| valig/linkedin-jobs-scraper | $0.40 | $0.28 | Per item, plus a start fee |
| bebity/linkedin-jobs-scraper | $1.50 | $1.00 | Per item, company add-ons extra |
| cheap_scraper/linkedin-job-scraper | $0.70 | $0.35 | Per item, plus a $0.005 start fee |

### Limits and things to know

- **Public pages only.** The Actor uses LinkedIn's logged-out guest endpoints. It cannot see anything a visitor without an account cannot see.
- **10 cards per page.** LinkedIn's guest search returns 10 job cards per request and stops around `start=990`, so one search yields at most about 1,000 jobs. Add more searches for more coverage.
- **Residential proxy is required.** LinkedIn throttles datacenter IPs immediately. The Actor always runs through Apify's RESIDENTIAL proxy, with a fresh session on every retry (429, 999, 403, an anti-bot challenge page or an empty page), up to 4 attempts per URL. A retry that switches session only pauses 150 to 400 ms, because the new exit IP does not inherit the throttle; a 5xx response or a timeout keeps the longer exponential backoff. It never falls back to a direct connection.
- **Details cost one extra request per job.** That is about 63 KB per job against about 29 KB per page of 10 cards, so leaving `includeDetails` off is the cheaper way to build large lists. With details on, detail pages are fetched `detailConcurrency` at a time (6 by default), which is the main speed lever.
- **A stop is exact.** `maxTotalJobs`, `maxJobsPerSearch` and the platform charge limit stop the run before another row is pushed or charged, and no detail page is fetched for a job that will not be delivered.
- **Offsite apply URLs are rarely visible.** Logged-out detail pages usually keep the offsite target behind a sign-in modal while still marking the apply type as `offsite`. In that case `applyUrl` and `atsPlatform` are null. `applyType` is the reliable field: it reports `offsite` or `easy_apply` on every detail page. Expect `applyUrl` to be null on most or all rows.
- **Salary is only there when LinkedIn shows it.** The card has to carry the salary itself; most postings do not, so `salaryText` is often null.
- **Filters are LinkedIn's.** Some filters are applied by LinkedIn itself. If a filter is ignored for a market, the returned listings reflect that, and the Actor does not add its own client-side filter that would hide data.
- **Criteria can be missing.** Not every posting publishes job function or salary. Missing values are null.
- **No people data.** No profiles, no employee lists, no recruiter names, no contact details.
- **Limits in the Actor:** 1,000 jobs per search, 2,000 jobs per run, 45 second request timeout, 4 attempts per URL, 3 concurrent searches, 10 concurrent detail fetches, 256 MB memory.

### FAQ

**Do I need a LinkedIn account or cookies?**
No. The Actor only reads public, logged-out job listings. There is no login step and no cookie input.

**Public job listings only: no login, no personal profiles.**
Correct. Job postings and the companies behind them only. No profiles, no connections, no employee or recruiter data.

**How do I get remote jobs?**
Set `workplaceType` to `["remote"]`, or paste a LinkedIn search URL that carries `f_WT=2`.

**Why is `applyUrl` null on some rows?**
Usually because LinkedIn keeps the offsite target behind a sign-in modal for logged-out visitors, which is the common case. The apply type is still reported (`offsite` or `easy_apply`). Only when a detail page does expose the target is it decoded to the employer or ATS URL and the ATS platform detected.

**Can I monitor new postings?**
Yes. Run the Actor on a schedule with `postedWithin` set to `24h` and deduplicate downstream on `jobId`. This Actor does not keep state between runs.

**Can I cap spending?**
Yes. `maxTotalJobs` is the hard row cap, and the run also stops cleanly if the platform charge limit is reached.

**Why did a search return zero rows?**
Either LinkedIn had no matches, or the request was throttled after all retries. Throttled and failed searches produce a free error row with the reason, so the dataset always explains itself.

### How it works

The Actor sends plain HTTP GET requests through Apify's RESIDENTIAL proxy to LinkedIn's public guest endpoints: `seeMoreJobPostings/search` for the cards and `jobPosting/<id>` for the optional details. Responses are parsed with string matching, not a browser, so the default 256 MB memory is enough. Every response is checked before it is sold: an anti-bot challenge, an unexpected page or a failed charge becomes a retry or a free error row, never a paid row.

### Responsible use

This Actor collects publicly visible job listings for recruitment, market research, job-board aggregation and similar legitimate uses. Respect LinkedIn's terms and the laws that apply to you, keep request volumes reasonable, and do not use the data to contact or profile candidates. Job ads go stale quickly: confirm details with the employer before acting on them.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

## `searches` (type: `array`):

Keyword and location pairs. Each pair is one LinkedIn job search. Example: \[{"keywords":"data engineer","location":"Malaysia"}]. Use either this or searchUrls. With neither, the prefilled demo search runs and nothing else.

## `searchUrls` (type: `array`):

LinkedIn jobs search URLs copied from your browser, for example https://www.linkedin.com/jobs/search/?keywords=data%20engineer\&location=Malaysia\&f_WT=2. keywords, location and the f_TPR, f_WT, f_JT, f_E, sortBy and geoId filters are read from the URL. Use either this or searches.

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

Cap on delivered jobs per search (1 to 1000). LinkedIn's guest endpoint stops returning cards around start=990, so a search yields at most about 1,000 jobs.

## `maxTotalJobs` (type: `integer`):

Global cap across every search in one run. This is the hard cost ceiling. Set 0 for no limit.

## `includeDetails` (type: `boolean`):

Fetch each job's public detail page for the full description, seniority level, employment type, job function, industries, applicant count and the apply type. Adds one request and one extra charge per job.

## `detailConcurrency` (type: `integer`):

How many detail pages to fetch in parallel when includeDetails is on. Rows are still delivered and charged one at a time, in listing order. Higher is faster, lower is gentler on LinkedIn.

## `postedWithin` (type: `string`):

Keep jobs posted in the last 24 hours, week or month. LinkedIn applies this as the f_TPR filter.

## `workplaceType` (type: `array`):

On-site, remote or hybrid. Leave empty for all.

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

Full-time, part-time, contract, temporary or internship. Leave empty for all.

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

Internship through executive. Leave empty for all.

## `sortByDate` (type: `boolean`):

Ask LinkedIn to sort by posting date instead of relevance.

## `proxyCountry` (type: `string`):

Two-letter country for the residential proxy session, for example US or MY. LinkedIn throttles datacenter IPs, so the Actor always runs through Apify residential proxy.

## Actor input object example

```json
{
  "searches": [
    {
      "keywords": "data engineer",
      "location": "Malaysia"
    }
  ],
  "maxJobsPerSearch": 20,
  "maxTotalJobs": 50,
  "includeDetails": false,
  "detailConcurrency": 6,
  "postedWithin": "any",
  "sortByDate": false,
  "proxyCountry": "US"
}
```

# Actor output Schema

## `jobs` (type: `string`):

One dataset item per unique job id: title, company, location, posting date, salary, search that found it, and with includeDetails the description, criteria, applicant count and apply link.

## `runSummary` (type: `string`):

Counters for the run: delivered jobs, jobs with details, duplicates skipped, free error rows, requests and bytes downloaded.

# 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 = {
    "searches": [
        {
            "keywords": "data engineer",
            "location": "Malaysia"
        }
    ],
    "maxJobsPerSearch": 20,
    "maxTotalJobs": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/linkedin-jobs-api").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 = {
    "searches": [{
            "keywords": "data engineer",
            "location": "Malaysia",
        }],
    "maxJobsPerSearch": 20,
    "maxTotalJobs": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/linkedin-jobs-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    {
      "keywords": "data engineer",
      "location": "Malaysia"
    }
  ],
  "maxJobsPerSearch": 20,
  "maxTotalJobs": 50
}' |
apify call subimpact/linkedin-jobs-api --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tPwtNDsstxkfKhume/builds/ij1nFW6Sn09ry6dyl/openapi.json
