# LinkedIn Jobs Scraper: Salaries, Remote, Full Descriptions (`tablewise/linkedin-jobs-scraper`) Actor

Scrape LinkedIn job postings without login: full description, salary (from LinkedIn or the job text), workplace type, seniority, employment type, industries, applicants and Easy Apply. Search by keyword and location or paste search URLs. Only-new-jobs mode for scheduled runs. CSV, Excel or API.

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

## Pricing

from $1.00 / 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.

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

### What is LinkedIn Jobs Scraper?

LinkedIn Jobs Scraper turns any LinkedIn job search into a table: one row per
job with the full description, the salary (from LinkedIn's pay box or read
from the job text), workplace type, seniority, employment type, industries,
number of applicants and whether you apply with Easy Apply or on the company
website. In our tests on Apify it returned 2,046 jobs from 9 searches in the
US, the UK and Spain, with no duplicates, for USD 0.001 per job.

Type job titles and locations, or paste LinkedIn job search URLs. It reads the
same public job pages that anyone sees without signing in: no LinkedIn
account, no cookies, no login. Export as JSON, CSV or Excel, or read the
results through the API.

### What you can do with it

- **Track who is hiring:** schedule a search for a role and a city and, with
  **Only new jobs since the last run**, get (and pay for) only the jobs you
  have not seen yet.
- **Benchmark salaries:** every salary comes with numeric `salary_min`,
  `salary_max`, currency and period, and says where it came from.
- **Build a job board or a job feed:** the columns are the same as our
  [Company Jobs Scraper](https://apify.com/tablewise/workday-greenhouse-lever-jobs-scraper)
  for Workday, Greenhouse, Lever and Ashby career sites, so both tables can
  be combined.
- **Find companies to sell to or recruit for:** who is hiring for what,
  with the company's LinkedIn page and how many people already applied.

### Use cases

Ready-to-run examples, with the input already filled in:

- [Scrape remote Python developer jobs from LinkedIn](https://apify.com/tablewise/linkedin-jobs-scraper/examples/remote-python-developer-jobs-linkedin):
  25 jobs from a search for remote Python developers in the United States, all
  with Remote in the title, with the full description.
- [Get data analyst jobs posted on LinkedIn in the last 24 hours](https://apify.com/tablewise/linkedin-jobs-scraper/examples/new-data-analyst-jobs-last-24-hours):
  data analyst jobs posted in London in the last 24 hours; schedule it daily for a fresh feed.

### Example output

Two real rows from our test run (the description is shortened here; you get
the full text).

```json
[
  {
    "platform": "linkedin",
    "job_id": "4473069977",
    "title": "Data Engineer",
    "company": "Humana",
    "company_url": "https://www.linkedin.com/company/humana",
    "location": "Louisville, KY",
    "workplace_type": "remote",
    "workplace_type_source": "description",
    "remote": true,
    "employment_type": "Full-time",
    "seniority": "Mid-Senior level",
    "industries": "Insurance",
    "salary": "Base pay range $97,900.00/yr - $133,500.00/yr",
    "salary_min": 97900,
    "salary_max": 133500,
    "salary_currency": "USD",
    "salary_period": "year",
    "salary_source": "linkedin",
    "posted_date": "2026-11-14",
    "posted_text": "1 day ago",
    "applicants_count": 200,
    "applicants_text": "Over 200 applicants",
    "easy_apply": false,
    "apply_on_company_site": true,
    "benefits": [
      "Actively Hiring"
    ],
    "url": "https://www.linkedin.com/jobs/view/4473069977/",
    "apply_url": "https://www.linkedin.com/jobs/view/4473069977/",
    "description": "Become a part of our caring community\n\nHumana is looking for a Data Engineer 2 to join our Fortune #40, Best Places to Work company and help us make a different as a help our members achieve their bes ...",
    "search": "data engineer in United States",
    "search_position": 61,
    "status": "ok",
    "status_message": null,
    "scraped_at": "2026-11-16T15:42:02Z"
  },
  {
    "platform": "linkedin",
    "job_id": "4425916223",
    "title": "Staff Data Engineer",
    "company": "Self Financial, Inc.",
    "company_url": "https://www.linkedin.com/company/self-financial",
    "location": "Austin, TX",
    "workplace_type": "hybrid",
    "workplace_type_source": "description",
    "remote": false,
    "employment_type": "Full-time",
    "seniority": "Mid-Senior level",
    "industries": "Financial Services",
    "salary": "$160,000 – $195,000",
    "salary_min": 160000,
    "salary_max": 195000,
    "salary_currency": "USD",
    "salary_period": "year",
    "salary_source": "description",
    "posted_date": "2026-06-08",
    "posted_text": "5 months ago",
    "applicants_count": 132,
    "applicants_text": "132 applicants",
    "easy_apply": false,
    "apply_on_company_site": true,
    "benefits": [],
    "url": "https://www.linkedin.com/jobs/view/4425916223/",
    "apply_url": "https://www.linkedin.com/jobs/view/4425916223/",
    "description": "About Self Financial\n\nSelf Financial is a venture-backed, high-growth FinTech company with a mission to increase economic inclusion and financial resilience by empowering people to build credit and bu ...",
    "search": "data engineer in United States",
    "search_position": 17,
    "status": "ok",
    "status_message": null,
    "scraped_at": "2026-11-16T15:39:29Z"
  }
]
```

| Field | What it is |
| --- | --- |
| `platform` | Always `linkedin` (same column as our Company Jobs Scraper) |
| `job_id` | LinkedIn job ID |
| `title`, `company`, `location` | As shown on LinkedIn |
| `company_url`, `company_logo` | The company's LinkedIn page and logo |
| `workplace_type` | `remote`, `hybrid` or `onsite`, read from the title, location or description; empty when the job does not say |
| `workplace_type_source` | Where `workplace_type` was read: `title_or_location` or `description` |
| `remote` | `true` when `workplace_type` is `remote`; empty when unknown |
| `employment_type` | Full-time, Part-time, Contract, Temporary, Internship... |
| `seniority` | Internship, Entry level, Associate, Mid-Senior level, Director, Executive or Not Applicable |
| `industries` | Industries of the job, as LinkedIn lists them |
| `salary` | Salary as written: from LinkedIn's pay box or, when the box is missing, from the description |
| `salary_min`, `salary_max` | The salary range as numbers (the same value twice for a single amount) |
| `salary_currency`, `salary_period` | `USD`, `EUR`, `GBP`...; `year`, `month`, `week`, `day` or `hour` (empty when the job does not say) |
| `salary_source` | `linkedin` (pay box) or `description` (job text) |
| `posted_date`, `posted_text` | Date posted (`YYYY-MM-DD`) and "2 days ago" as LinkedIn shows it |
| `applicants_count`, `applicants_text` | Number of applicants (a minimum for "Over 200 applicants"; empty for "Be among the first 25 applicants") and the text |
| `easy_apply` | `true` when you apply on LinkedIn with Easy Apply |
| `apply_on_company_site` | `true` when the Apply button sends you to the company website |
| `benefits` | LinkedIn badges on the card: "Actively Hiring", "Be an early applicant"... |
| `url`, `apply_url` | The LinkedIn job page |
| `description` | The full job description as plain text, with line breaks and bullet points |
| `search`, `search_position` | The search the job came from and its position in the results |
| `status`, `status_message` | `ok` for a job; for a search with no jobs, why (table below) |
| `scraped_at` | When the row was produced (UTC) |

You get one row per job. A search that gives no jobs adds one status row,
which is free:

| `status` | What it means | Charged? |
| --- | --- | --- |
| `ok` | A job | Yes |
| `no_results` | LinkedIn returned no new jobs for that search, or your title filters removed all of them | No |
| `blocked` | LinkedIn refused our requests for that search, also through the proxy | No |
| `error` | LinkedIn did not answer or answered with an error | No |
| `invalid_input` | The URL you pasted is not a LinkedIn job search | No |

### What it costs

| Event | Price |
| --- | --- |
| Actor start | USD 0.0005 per run |
| Job | USD 0.001 per job |

**Example:** 1,000 jobs = 0.0005 + 1,000 × 0.001 = USD 1.00.

Full details (description, salary, seniority, applicants) are included at
the same price. Jobs removed by your title filters, jobs repeated across
your searches and, with **Only new jobs since the last run**, jobs you
already got are not charged. Status rows are free. Use **Max jobs in total**
to cap the spend.

#### How many jobs can I get with the free plan?

Apify's free plan includes USD 5 of credit every month. Used only for this
Actor, that is about 4,990 jobs: for example, one run of 4,990 jobs =
0.0005 + 4,990 × 0.001 = USD 4.99.

### How to use it

1. In **Job titles or keywords** and **Locations**, type what you would type
   in LinkedIn's job search, one per line. Each keyword is searched in each
   location. Or paste LinkedIn job search URLs in **LinkedIn job search
   URLs**: their filters are kept.
2. Optional: **Date posted**, **Company IDs**, **Easy Apply only**,
   **Workplace type**, **Title must include** / **Title must not include**,
   **Max jobs per search** and **Max jobs in total**.
3. Click **Start** and download the results as JSON, CSV or Excel.

#### Input

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `keywords` | array | — | Job titles or keywords, one per line |
| `locations` | array | — | Countries, cities or regions, as you would type them on LinkedIn; empty for worldwide |
| `searchUrls` | array | — | LinkedIn job search URLs (`https://www.linkedin.com/jobs/search/?keywords=...`) |
| `datePosted` | string | `anyTime` | `past24Hours`, `pastWeek` or `pastMonth` |
| `companyIds` | array | — | LinkedIn numeric company IDs (the `f_C=` value of a search URL) |
| `easyApplyOnly` | boolean | `false` | Only Easy Apply jobs |
| `workplaceTypes` | array | — | `onsite`, `remote`, `hybrid`: passed to LinkedIn as a filter (LinkedIn may not apply it to every search) |
| `titleMustInclude` | array | — | Keep a job only if its title has all the words of one of these phrases |
| `titleExclude` | array | — | Skip a job if its title has all the words of one of these phrases |
| `maxJobsPerSearch` | integer | 100 | Jobs per search (LinkedIn shows at most about 1,000) |
| `maxJobs` | integer | 1000 | Jobs in the whole run |
| `fetchDetails` | boolean | `true` | Open each job for the full details; off: only the search card (title, company, location, date) |
| `onlyNewJobs` | boolean | `false` | Skip jobs already delivered to you in earlier runs with this option on |
| `stateStoreName` | string | `linkedin-jobs-seen` | Key-value store in your account that remembers those jobs (one name per scheduled search) |
| `delayBetweenRequests` | number | 1 | Seconds between two requests to LinkedIn |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Proxy used when LinkedIn rate-limits direct requests |

### Speed and reliability

Requests go one at a time with a pause between them. LinkedIn rate-limits
the shared IP addresses of cloud servers: in our tests it answered HTTP 429
to 13 to 15 % of the requests, sometimes from the first request of a run.
Each limited request is retried at once through the proxy (and the other
way round), and the pause grows a little while LinkedIn keeps limiting.

In our tests, 750 jobs from 3 searches in the US, with full details, took
47 minutes (about 16 jobs per minute); three runs at the same time did 13
to 16 jobs per minute each. Runs that Apify moved to another server, and a
run we aborted and resumed, continued where they stopped, without duplicate
rows or double charges and without going over **Max jobs per search**.

### Limits and known issues

- **About 1,000 jobs per search.** LinkedIn does not show more; split a big
  search by city or by date posted.
- **LinkedIn's search is fuzzy** (since August 2026): a search for "data
  engineer" also brings related titles. Use **Title must include** and
  **Title must not include**; filtered jobs are not charged.
- **No external application link.** The link to the company's application
  form is only shown to signed-in LinkedIn users, so `apply_url` is the
  LinkedIn job page and `apply_on_company_site` tells you that the job is
  applied for on the company website.
- **Workplace type is not a public field.** LinkedIn does not show it to
  visitors as data, so `workplace_type` is read from the title, location
  and description, only from clear phrases ("Work Arrangement: Hybrid",
  "fully remote position"); it was found on 15 to 38 % of the jobs in our
  tests. The **Workplace type** filter is passed to LinkedIn, which may not
  apply it.
- **Seniority** is what LinkedIn shows on the job page; many jobs say "Not
  Applicable".
- Job function and the name of the person who posted the job are not on the
  public job page.
- Applicants and "posted ago" change over time: they are what LinkedIn
  showed when the row was produced.

### FAQ

#### Do I need a LinkedIn account or cookies?

No. It reads the public job pages that anyone sees without signing in.
Nothing is done with an account, yours or anyone else's.

#### Is it legal to scrape LinkedIn jobs?

This Actor reads public job postings without logging in and without any
LinkedIn account. LinkedIn's User Agreement, which members accept when they
create an account, prohibits scraping. You are responsible for how you use
the data and for the law that applies to you. Job postings are published by
companies; if you store personal data that appears in a description, data
protection laws such as the GDPR apply. If you are not sure, ask a lawyer.

#### Why are some jobs not related to my keyword?

LinkedIn's job search returns related jobs too. Add the words that must be
in the title to **Title must include** (for example `data engineer`) and the
ones you do not want to **Title must not include** (for example `senior`).
Jobs removed this way are not charged.

#### Can I get only new jobs every day?

Yes. Turn on **Only new jobs since the last run** and schedule the Actor.
Each run skips the jobs it already delivered in earlier runs with the same
**Name of the store for seen jobs**, and you only pay for the new ones. Use a
different name for each scheduled search.

#### Can I run it from the API or from Python?

Yes: with the Apify API or the official Apify clients for Python and
JavaScript. This call runs the Actor and returns the rows when it finishes
(it waits up to 5 minutes; for longer runs, start the run and read its
dataset when it ends):

```bash
curl -X POST "https://api.apify.com/v2/acts/tablewise~linkedin-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["python developer"], "locations": ["United States"], "maxJobsPerSearch": 20}'
```

#### Can AI agents use it?

Yes. AI agents can find and run it through Apify's MCP server
(`https://mcp.apify.com`). Every output field has a description, so an agent
knows what each value means.

### Support

Found a problem? Open an issue on the Actor's **Issues** tab with the run ID
and we'll look into it.

### More Actors from the same developer

- [Company Jobs Scraper: Workday, Greenhouse, Lever & Ashby](https://apify.com/tablewise/workday-greenhouse-lever-jobs-scraper): every open job from company careers sites on those four platforms, with the same columns as this Actor.
- [LinkedIn Company Scraper](https://apify.com/tablewise/linkedin-company-scraper): size, industry, employees, website and offices of any LinkedIn company page.
- [Website Email & Contact Scraper](https://apify.com/tablewise/website-email-contact-scraper): emails, phones and social profiles from any list of websites.
- [Google Trends Scraper](https://apify.com/tablewise/google-trends-scraper): interest over time, interest by region and related queries for any keyword.
- [Semrush Domain Metrics Scraper](https://apify.com/tablewise/semrush-domain-metrics-scraper): Authority Score, backlinks, referring domains and traffic for any list of domains.
- [YouTube Transcript & Subtitles Scraper](https://apify.com/tablewise/youtube-transcript-scraper): the transcript of any YouTube video, Short or channel as text or SRT, with the video details.
- [Google Hotels Scraper](https://apify.com/tablewise/google-hotels-scraper): hotel prices for your dates, ratings and prices by booking site.
- [AliExpress Search Scraper](https://apify.com/tablewise/aliexpress-search-scraper): prices, discounts, ratings and units sold from any AliExpress search.
- [Amazon Best Sellers Scraper](https://apify.com/tablewise/amazon-bestsellers-scraper): the top 100 of any Amazon.com Best Sellers or Hot New Releases list.
- [Amazon Product Details Scraper](https://apify.com/tablewise/amazon-product-details-scraper): price, Best Sellers Rank, specs and images for any list of ASINs.
- [Tennis Results & Odds Scraper](https://apify.com/tablewise/tennis-results-scraper): ATP, WTA, Challenger and ITF results and fixtures with set scores and betting odds.

# Actor input Schema

## `keywords` (type: `array`):

What to search for, one per line (for example: data engineer, nurse, marketing manager). Each keyword is searched in each location below.

## `locations` (type: `array`):

Where to search, one per line, as you would type it on LinkedIn: a country (United States), a city (London, England, United Kingdom) or a region. Leave empty for worldwide.

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

Paste LinkedIn job search URLs (https://www.linkedin.com/jobs/search/?keywords=...). Their filters are kept as they are.

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

Only jobs posted within this window.

## `companyIds` (type: `array`):

LinkedIn numeric company IDs, to search only those companies (the f_C= value of a LinkedIn search URL).

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

Only jobs you can apply to on LinkedIn with Easy Apply.

## `workplaceTypes` (type: `array`):

Passed to LinkedIn as a search filter. LinkedIn may not apply it to every search; each row also has workplace_type, read from the job itself.

## `titleMustInclude` (type: `array`):

Keep a job only if its title contains all the words of at least one of these phrases (for example: data engineer). LinkedIn search also returns related jobs; filtered jobs are not charged.

## `titleExclude` (type: `array`):

Skip a job if its title contains all the words of one of these phrases (for example: senior, intern). Not charged.

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

Stops each search after this many jobs. LinkedIn shows at most about 1,000 jobs per search: split big searches by city.

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

Stops the run after this many jobs across all searches. Use it to cap the spend.

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

Opens each job to add the full description, seniority, employment type, industries, applicants, salary, Easy Apply and workplace type. Off: only the search card (title, company, location, date). Same price per job.

## `onlyNewJobs` (type: `boolean`):

Skips jobs this Actor already delivered to you in earlier runs with this option on (remembered in a key-value store in your own account). Skipped jobs are not charged. Useful for scheduled runs.

## `stateStoreName` (type: `string`):

Key-value store in your account that remembers the jobs already delivered. Use a different name per scheduled search.

## `delayBetweenRequests` (type: `number`):

Pause between two requests to LinkedIn. Requests go one at a time.

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

Requests go directly first. When LinkedIn rate-limits a request (HTTP 429), it is retried at once through this proxy, and the run keeps switching between direct and proxy as needed, slowing down a little each time (Apify datacenter proxy by default). You only pay for jobs delivered.

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "locations": [
    "United States"
  ],
  "datePosted": "anyTime",
  "easyApplyOnly": false,
  "maxJobsPerSearch": 20,
  "maxJobs": 1000,
  "fetchDetails": true,
  "onlyNewJobs": false,
  "stateStoreName": "linkedin-jobs-seen",
  "delayBetweenRequests": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per job, plus a status row for each search that gave no jobs.

# 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": [
        "python developer"
    ],
    "locations": [
        "United States"
    ],
    "maxJobsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tablewise/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": ["python developer"],
    "locations": ["United States"],
    "maxJobsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("tablewise/linkedin-jobs-scraper").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 '{
  "keywords": [
    "python developer"
  ],
  "locations": [
    "United States"
  ],
  "maxJobsPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tablewise/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/NtHYXSqVJhYkvB2oa/builds/be5h6PUbCNK7DzyyZ/openapi.json
