# LinkedIn Jobs Scraper ($0.09/1K): Jobs, Salaries, No Login (`tsutseisoftware/linkedin-jobs-scraper`) Actor

Scrape public LinkedIn job ads without login: title, company, place, date, insights; with job details the description, seniority, employment type, industry, applicants and salary as numbers. Monitoring of new and removed jobs, notifications, hiring signals, market summary. Unofficial.

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

## Pricing

from $0.05 / 1,000 jobs

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

Learn more: https://docs.apify.com/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: Jobs, Salaries & Hiring Signals, No Login

Get public job ads from **LinkedIn Jobs** as clean, ready-to-use data, **without a LinkedIn account, cookies or login**. Search by **keyword**, **location** (city, region or country, with a **radius**), **date posted** (past 24 hours, week, month or any number of hours), **company** (by name, ID or company page), **Easy Apply** and **under 10 applicants**, or paste any LinkedIn job search, job or company URL. Every job comes with its title, company and company page, place (city, region, country), posting date and LinkedIn's insights; with **Job details** also the **full description**, **seniority level**, **employment type**, **industry**, **number of applicants**, whether you apply on LinkedIn or on the employer's site, and the **salary the ad states, as numbers**.

**$0.09 per 1 000 jobs**, $0.25 with the full description and details. No proxy setup and no extra platform costs.

Built for **recruiters, sales teams looking for companies that hire, job boards, labour-market analysts and job seekers**: schedule it daily in monitoring mode and get only jobs that are **new or changed**, plus, if you want, the jobs that **were closed or taken down**, straight to Slack, Discord, Telegram, WhatsApp or your webhook.

### Why use this LinkedIn jobs scraper?

- 💰 **Salaries as numbers.** When the ad states a pay range (US pay-transparency ads, UK and EU ads), you get `salaryMin`, `salaryMax`, currency, period and a **yearly figure** to compare, with the sentence it came from. In our test 86 % of software jobs in New York had one.
- 🔎 **Every filter LinkedIn's public search still has** (filtered-out jobs cost nothing): keywords, location, radius, date posted (also any number of hours, e.g. the last hour for an hourly feed), company, Easy Apply, under 10 applicants.
- 🎯 **Exact filters LinkedIn no longer offers:** employment type, experience level, industry, recruiting agencies out, only jobs with a salary, at most N applicants (checked on each job page), plus title, company and place filters.
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`, `changedFields`), optionally with **removed jobs** (`expired` or `noLongerMatches`, with `daysOnline`). Unchanged jobs are free.
- 📈 **Hiring signals and a free market summary:** how many positions a company has open, days online, hard to fill, reposts of the same position; every run saves salary quartiles by country, seniority, employment type and industry, top companies, cities and industries.
- 🧩 **Keyword match for job seekers:** give your skills ("Python", "TypeScript|TS") and every job gets `matchedKeywords`, `missingKeywords` and a 0-100 `keywordMatchScore`.
- 🔒 **Privacy first.** Only the company is returned, never the job poster, the hiring team or anybody else the job page shows; e-mails and phone numbers are removed from the descriptions.

#### How it compares with other LinkedIn job scrapers

An honest comparison with the LinkedIn job scrapers most used in the Store (checked 2026-11-16), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keywords, locations, date posted, company, Easy Apply, under 10 applicants, URLs | yes | yes |
| Any number of hours for "date posted", radius, company pages as input | yes | some |
| Employment type and experience level filters that really apply | yes, checked on each job | rarely (added to the search words, or not at all) |
| Salary as numbers with currency, period and a yearly figure | yes | as text, or numbers for some |
| Monitoring of new, changed and removed jobs, notifications | yes | rarely (only "new" or none) |
| Hiring signals, market summary, keyword match score | yes | rarely |
| Names and profiles of job posters and recruiters | never (privacy) | returned by most |
| Company profile (size, followers, website) | not yet | some |
| Price per 1 000 jobs with descriptions (Free plan) | $0.25 | $0.35 to $2.00 at most others |

### What data can you get?

| Group | Fields |
|---|---|
| Job | `id`, `url`, `title`, `postedAt`, `postedAgo`, `isNew`, `insights` (e.g. "Actively Hiring", "Be an early applicant"), `workplaceType` |
| Company | `company`, `companyUrl`, `companyLogo`; with Job details also `companyId` and `isAgency` |
| Place | `location`, `city`, `region`, `country`, `countryCode` |
| Salary | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salarySource`, `salaryYearlyMin`, `salaryYearlyMax` |
| With Job details | `description` (text, Markdown or HTML), `seniorityLevel`, `employmentType`, `industries`, `applicants`, `applicantsText`, `applyOnLinkedIn`, `jobPosterShown`, `isClosed` |
| Hiring signals (option) | `companyOpenPositions`, `daysOnline`, `hardToFill`, `isRepost`, `repostOf`, `repostCount` |
| Keyword match (option) | `matchedKeywords`, `missingKeywords`, `keywordMatchScore` |
| Monitoring | `changeType`, `changedFields`, `firstSeenAt`, `removedAt`, `removedReason` |
| Search | `searchKeywords`, `searchLocation`, `sourceUrl`, `scrapedAt` |

**Fill rates** (measured 2026-11-16 on 110 jobs: software jobs in New York, Python developer jobs in Germany, nurse jobs in the United Kingdom): title, company, place and date 100 %, country 95 to 100 %, insights 60 to 90 %. With Job details: description, seniority level, employment type and industry 100 %, number of applicants 15 to 86 % (LinkedIn shows "Be among the first 25 applicants" for the rest), **salary 86 % in New York, 27 % in the UK and 7 % in Germany** (only salaries the ad states). `workplaceType` only when the title or place says so (0 to 2 %).

**Export:** download the jobs as Excel, CSV or JSON from the Output tab, or turn on **Extra export formats** for a printable HTML report (the main columns, to print, save as PDF or send) or a Markdown table of the same jobs (a big run makes a big file).

### How to scrape LinkedIn jobs

1. Open the actor and type one or more **Search keywords** (e.g. `python developer`) and **Locations** (e.g. `Germany`, `Berlin`, `United States`).
2. Pick **Date posted** and the other filters you need.
3. Set **Max jobs** (20 for a quick test) and turn on **Job details** if you need the description, seniority, applicants and salary.
4. Click **Start** and download the dataset as **JSON, CSV, Excel, XML or HTML**, or read it through the Apify API.
5. To watch a search, turn on **Monitoring: only new or changed jobs** and schedule the actor daily.

### Use cases

#### Python developer jobs in Germany posted this week

```json
{
  "searchQueries": ["python developer"],
  "locations": ["Germany"],
  "postedWithin": "pastWeek",
  "maxItems": 200
}
```

#### Senior software jobs in New York with salaries

```json
{
  "searchQueries": ["software engineer"],
  "locations": ["New York"],
  "includeDetails": true,
  "experienceLevels": ["MID_SENIOR", "DIRECTOR"],
  "onlyWithSalary": true,
  "maxItems": 100
}
```

#### New jobs of a few companies every morning, to Slack

```json
{
  "companyNames": ["Google", "Microsoft", "Siemens"],
  "locations": ["Germany"],
  "postedWithin": "past24Hours",
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "big-tech-germany",
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### Companies that are hiring: lead list for sales

```json
{
  "searchQueries": ["data engineer"],
  "locations": ["United Kingdom"],
  "postedWithin": "pastMonth",
  "includeHiringSignals": true,
  "includeDetails": true,
  "excludeAgencies": true,
  "maxItems": 500
}
```

#### Jobs that fit your skills

```json
{
  "searchQueries": ["backend developer"],
  "locations": ["Berlin"],
  "includeDetails": true,
  "matchKeywords": ["Python", "Django", "PostgreSQL|Postgres", "Kubernetes|k8s"],
  "maxItems": 100
}
```

#### A search, a job or a company from the website

Paste a job search from LinkedIn (its keywords, location, radius, date posted, company, Easy Apply and under-10-applicants filters are used), a job URL or a company page (every open job of that company) into **LinkedIn URLs**.

```json
{
  "startUrls": [
    { "url": "https://www.linkedin.com/jobs/search/?keywords=python&location=Germany&f_TPR=r604800" },
    { "url": "https://www.linkedin.com/jobs/view/4477761949" },
    { "url": "https://www.linkedin.com/company/google" }
  ],
  "maxItems": 100
}
```

#### Monitoring mode

The actor remembers the jobs of earlier runs with the same **Monitoring: key** and saves only jobs that are new or whose title, company, place or shown salary changed. Unchanged jobs are not saved and not charged; every search page read in this mode (up to 10 jobs) is a small "Monitoring page" charge. With **Monitoring: include removed jobs**, jobs of earlier runs that are no longer in the results come as rows with `changeType: "removed"` and `removedReason` `expired` (closed or taken down) or `noLongerMatches` (still open, no longer in the search). They are checked only when every search of the run was read to its end. Combine monitoring with **Date posted** (e.g. past week) for a cheap daily feed.

#### Market summary (SUMMARY)

Every run saves a free summary to the key-value store (record `SUMMARY`): jobs matched, share with a salary, yearly salary quartiles per currency (overall, by country, seniority level, employment type and industry), top companies, cities, countries, industries, seniority levels, employment types, workplace types, the share of recruiting agencies and of jobs you apply for on LinkedIn, and the median number of applicants.

### How much does it cost to scrape LinkedIn jobs?

Pay per event; the prices are also on the **Pricing** tab. Platform costs are included.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.09 / 1 000** (Bronze $0.09, Silver $0.07, Gold and higher $0.05) | every saved row |
| Job details | $0.16 / 1 000 | a saved job whose description and details were read (**Job details** on) |
| Actor start | $0.003 per run | once per run |
| Hiring signals | $0.10 / 1 000 | a saved job with hiring signals (**Hiring signals** on) |
| Monitoring page | $0.20 / 1 000 pages | monitoring mode: every search page read (up to 10 jobs), so unchanged jobs cost little |
| Extra page | $0.25 / 1 000 pages | pages beyond what the saved jobs explain: a search that finds nothing, search pages and job pages a filter rejects, URLs of closed jobs, second attempts. If the saved jobs don't cover a run's cost (e.g. a run that waits long because the website delays answers), the difference is charged as extra pages; the log says how many. A normal run pays nothing or very little here. |
| Notification | $0.0002 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.005 | under 10 s |
| 1 000 jobs | $0.09 | about 3 minutes |
| 1 000 jobs with Job details | $0.25 | about 30 minutes |
| Daily monitoring of a search with 300 jobs, 20 new, with details | $0.01 | about 1 minute |

You can set a maximum cost per run; the actor stops when it is reached.

### Input example

```json
{
  "searchQueries": ["data analyst"],
  "locations": ["London"],
  "radiusMiles": 25,
  "postedWithin": "pastWeek",
  "includeDetails": true,
  "employmentTypes": ["FULL_TIME"],
  "maxItems": 50,
  "descriptionFormat": "markdown"
}
```

### Output example

```json
{
  "id": "4434138603",
  "source": "linkedin.com",
  "url": "https://www.linkedin.com/jobs/view/4434138603",
  "title": "Software Engineer, New Grad",
  "company": "Palantir Technologies",
  "companyId": "20708",
  "companyUrl": "https://www.linkedin.com/company/palantir-technologies",
  "location": "New York, NY",
  "city": "New York",
  "region": "NY",
  "country": "United States",
  "countryCode": "US",
  "workplaceType": null,
  "postedAt": "2026-11-15",
  "postedAgo": "16 hours ago",
  "isNew": true,
  "insights": ["Actively Hiring"],
  "salaryText": "The estimated salary range for this position is estimated to be $145,000 - $155,000/year.",
  "salaryMin": 145000,
  "salaryMax": 155000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salarySource": "description",
  "salaryYearlyMin": 145000,
  "salaryYearlyMax": 155000,
  "description": "A World-Changing Company\n\nPalantir builds the world’s leading software for data-driven decisions…",
  "seniorityLevel": "Not Applicable",
  "employmentType": "Full-time",
  "industries": "Software Development",
  "isAgency": false,
  "applicants": 200,
  "applicantsText": "Over 200 applicants",
  "applyOnLinkedIn": false,
  "jobPosterShown": false,
  "isClosed": false,
  "detailScraped": true,
  "searchKeywords": "software engineer",
  "searchLocation": "New York, New York, United States",
  "scrapedAt": "2026-11-16T10:00:00Z",
  "changeType": null
}
```

### Limitations

- **LinkedIn shows at most 1 000 jobs of one search.** The status message says when a search had more; split it by location, keywords or **Date posted** to get the rest.
- LinkedIn's public search ranks by relevance and also returns related jobs (a search for a rare word still returns jobs). Use **Title must contain** to keep only what you want.
- LinkedIn's public search no longer filters by employment type, experience level, workplace type, industry or salary. The actor checks employment type, experience level, industry and salary on each job page (with **Job details**), so job pages that don't match are read and charged as extra pages. **Workplace type** only adds words to your search.
- Salaries come from the ad's own text (rarely from the search) and are only as good as the ad: a range for several locations or levels is returned as its lowest and highest amount, in the currency of the job's country when the ad states several. Earnings prospects ("OTE", "realistic earnings in year 3") and one-off amounts (bonuses, home-office budgets) are left out.
- A few jobs of a search are already closed; with **Job details** they are skipped and counted in the status.
- Company profiles (size, followers, website) are not included yet.
- Free text may mention a person by name (e.g. "you will report to …"); e-mails and phone numbers are removed. The job poster and hiring team are never returned.
- A request the website rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. The actor never solves challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/linkedin-jobs-scraper").call(run_input={
    "searchQueries": ["machine learning engineer"], "locations": ["United States"],
    "postedWithin": "pastWeek", "includeDetails": True, "maxItems": 100,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["company"], job["salaryMin"], job["salaryMax"], job["salaryCurrency"], job["url"])
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["salary"]["byCurrency"], summary["topCompanies"][:10])
```

**Compact output** keeps the core fields (title, company, place, country, workplace type, date, salary, URL) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"Nothing to search"**: add search keywords, a location, a company or a LinkedIn URL.
- **"LinkedIn does not know the location …"**: use a city, region or country as LinkedIn suggests it when you type it on the website (e.g. `Berlin`, `Greater London`, `United States`).
- **"LinkedIn does not know the company …"**: check the name as LinkedIn writes it, or use the company ID (a run with **Company names** logs the IDs it found).
- **"… need the job page: turn on Job details"**: employment type, experience level, industry, salary and applicant filters work only with **Job details**.
- **"the website shows at most 1 000 jobs of a search"**: narrow the search with a location, keywords or **Date posted**.
- **"Your maximum cost per run … does not cover the start of the run"**: raise the maximum cost per run in the run options.
- **"LinkedIn is rejecting requests"**: try again later, and keep the proxy setting at its default.
- **"the residential proxy costs more than the run earns"**: set **Proxy configuration** back to the default (no proxy); the actor doesn't need one.
- **"the website asked to slow down"**: LinkedIn limits how fast anyone reads it. The run waits a little, asks once more and reads the rest more slowly; this is normal (each extra request is a small "Extra page" charge). If a few pages could not be read, the status says so; run it again later for the rest.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### More job scrapers

Jobs from another source, with salaries and monitoring:

- [StepStone Scraper](https://apify.com/tsutseisoftware/stepstone-scraper): jobs from StepStone in Germany, Austria, Belgium and the Netherlands: salary as numbers, hiring signals, monitoring
- [SEEK Scraper](https://apify.com/tsutseisoftware/seek-scraper): jobs from SEEK in Australia and New Zealand: salary as numbers, past the 550-job limit, hiring signals, removed jobs
- [Welcome to the Jungle Scraper](https://apify.com/tsutseisoftware/welcome-to-the-jungle-scraper): jobs from Welcome to the Jungle in France, Europe and the US: salary as numbers, company profile, closed jobs, alerts
- [XING Jobs Scraper](https://apify.com/tsutseisoftware/xing-jobs-scraper): jobs from XING in Germany, Austria and Switzerland: full description, salary as numbers, past the 1,000-job limit, removed jobs, alerts
- [Arbeitsagentur Jobbörse Scraper](https://apify.com/tsutseisoftware/arbeitsagentur-scraper): jobs from the Jobbörse of the Bundesagentur für Arbeit, Germany's largest job board: salary as numbers, employer profiles, removed jobs, alerts
- [Career Site Job Search & Scraper](https://apify.com/tsutseisoftware/ats-jobs-scraper): jobs straight from company career sites on Greenhouse, Workday, Lever, Ashby and SmartRecruiters in any country, including the jobs that just closed

### FAQ

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

It reads only publicly available job ads, without logging in, at most 40 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It returns companies only, never the people a job page shows, and always removes e-mails and phone numbers from the texts. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (privacy laws, database rights and the website's terms). If in doubt, consult a lawyer. This actor is not affiliated with LinkedIn or Microsoft.

#### Why are there no recruiter names?

On purpose. Job posters and hiring teams are private persons; the actor returns the company that posts the job and tells you whether the job page shows a contact person (`jobPosterShown`), never who it is.

#### Is the salary the employer's?

Yes: only salaries the ad states (`salarySource` `description`) or the search shows (`listing`), never an estimate. Ads without a stated salary have empty salary fields.

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

No. The default setting works without a proxy, cookies or account and costs you nothing extra.

#### Can I use it from an AI agent or through MCP?

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as a LinkedIn Jobs API, LinkedIn job scraper, LinkedIn job postings export, LinkedIn jobs crawler or LinkedIn job search scraper.

# Actor input Schema

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

What to search for, as on LinkedIn Jobs (job title, skill, company…), e.g. "python developer", "registered nurse", "sales manager". Each keyword is one search, combined with every location. Leave empty to search by location and filters only.

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

City, region or country as you would type it on LinkedIn, e.g. "Berlin", "Greater London", "United States" (for remote jobs use "Workplace type"). Each location is combined with every keyword. Empty = worldwide. A location LinkedIn does not know is skipped and named in the status.

## `startUrls` (type: `array`):

Paste URLs from linkedin.com: a job search (https://www.linkedin.com/jobs/search/?keywords=python\&location=Germany\&f_TPR=r604800, its keywords, location, radius, date posted, company, Easy Apply and under-10-applicants filters are used), a job (https://www.linkedin.com/jobs/view/4477761949) or a company page (https://www.linkedin.com/company/google: every open job of that company). The filters below apply to search and company URLs too, unless the URL sets them.

## `companyNames` (type: `array`):

Only jobs of these companies, by name as on LinkedIn (e.g. "Google", "Siemens"). Each name is matched to its LinkedIn company page; the log says which one. Combined with the keywords and locations above.

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

Only jobs of these companies, by LinkedIn company ID (e.g. 1441 for Google; a run with "Company names" logs the IDs it found). Exact, faster than names.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit (every job of the searches, at most 1 000 per search as the website shows).

## `maxItemsPerSearch` (type: `integer`):

Maximum number of jobs saved from each search (keyword × location, URL or company), so one large search doesn't use up the whole Max jobs. 0 = no limit per search.

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

Only jobs posted in this period (the website's filter, filtered-out jobs cost nothing).

## `postedWithinHours` (type: `integer`):

Any period in hours instead of "Date posted", e.g. 1 for an hourly schedule or 48. Empty or 0 = "Date posted" applies.

## `radiusMiles` (type: `integer`):

With a city in "Locations": include jobs up to this distance, e.g. 10, 25 or 50 miles (LinkedIn works in miles; 25 miles is about 40 km). Empty or 0 = the website's default.

## `easyApply` (type: `boolean`):

Only jobs you can apply for on LinkedIn directly (Easy Apply).

## `under10Applicants` (type: `boolean`):

Only jobs with fewer than 10 applicants so far.

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

LinkedIn's public job search no longer filters by workplace type, so these words are added to your search keywords (LinkedIn then prefers such jobs). Not a guarantee: check "workplaceType" in the results (filled when the title or place says so).

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

Adds the full description (e-mails and phone numbers removed), seniority level, employment type, industry, the number of applicants, whether you apply on LinkedIn or on the employer's site, the company ID and the salary the ad states (as numbers). Extra charge "Job details": $0.16 per 1 000 jobs with details. Off = what the search shows (title, company, place, date, insights).

## `descriptionFormat` (type: `string`):

With "Job details": format of the description, plain text, Markdown (good for AI agents and Notion) or simple HTML.

## `descriptionMaxLength` (type: `integer`):

With "Job details": cut the description after about this many characters (0 = full description). Smaller rows for spreadsheets and AI agents.

## `titleInclude` (type: `array`):

Keep only jobs whose title contains at least one of these words or phrases (case doesn't matter). Checked before the job page is read; skipped jobs are not charged, but a narrow filter over a large search reads many search pages, which count as extra pages when they save nothing.

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

Skip jobs whose title contains any of these words or phrases, e.g. "Senior", "Intern".

## `companyExclude` (type: `array`):

Skip jobs of companies whose name contains any of these texts.

## `locationExclude` (type: `array`):

Skip jobs whose place contains any of these texts, e.g. "Munich" in a search of Germany.

## `skipJobIds` (type: `array`):

Job IDs (the number at the end of a job URL) you already have; they are not saved again.

## `employmentTypes` (type: `array`):

Only jobs of these employment types, checked exactly on each job page (LinkedIn's public search no longer filters it). Needs "Job details". Each job page read for a job that doesn't match is a small "Extra page" charge.

## `experienceLevels` (type: `array`):

Only jobs of these seniority levels, checked exactly on each job page. Needs "Job details"; non-matching job pages are a small "Extra page" charge.

## `industries` (type: `array`):

Only jobs whose industry contains one of these texts, e.g. "Software Development", "Hospitals", "Financial Services". Needs "Job details".

## `excludeIndustries` (type: `array`):

Skip jobs whose industry contains any of these texts. Needs "Job details".

## `excludeAgencies` (type: `boolean`):

Skip jobs posted by staffing and recruiting agencies (by the industry of the company). Needs "Job details".

## `onlyWithSalary` (type: `boolean`):

Skip jobs that state no salary amount. Needs "Job details".

## `maxApplicants` (type: `integer`):

Skip jobs that show more applicants than this (jobs that show no number are kept). Needs "Job details". Empty or 0 = no limit.

## `includeHiringSignals` (type: `boolean`):

Adds to every job how many open positions its company has in the results (companyOpenPositions), days online (daysOnline) and hardToFill; with monitoring also reposts of the same position under a new job ID (isRepost, repostOf, repostCount). At no extra run time; $0.10 per 1 000 jobs that got the signals (the "Hiring signals" event).

## `matchKeywords` (type: `array`):

Free: your skills or must-haves, each with other spellings after "|", e.g. "Python", "TypeScript|TS", "Kubernetes|k8s". Every job gets matchedKeywords, missingKeywords and keywordMatchScore (0-100), from the title and, with "Job details", the description.

## `compactOutput` (type: `boolean`):

Only the core fields (title, company, place, country, workplace type, date, salary, URL) plus the fields of the options you turned on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, company, place or shown salary changed since the previous run with the same Monitoring key. Unchanged jobs are free; every search page read in this mode (up to 10 jobs) is the "Monitoring page" event ($0.20 per 1 000 pages). Tip: combine with "Date posted" for a cheap daily feed.

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched search (e.g. "python-berlin"). Empty = "default". The value is stored encrypted.

## `includeRemovedJobs` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return jobs of earlier runs that are no longer in the results, as rows with changeType "removed" and removedReason "expired" (closed or taken down) or "noLongerMatches" (still open but no longer in the search), with daysOnline. Each one is checked; checked only when every search was read to its end. A removed job is a saved row.

## `telegramBotToken` (type: `string`):

After each run, send the saved jobs (in monitoring mode only the new, changed and removed ones) to Telegram, Slack, Discord, WhatsApp or your webhook: title, company, place, salary and link. A run that sent its notification is the "Notification" event ($0.0002 per run). Token of your bot from @BotFather.

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n…): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

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

No proxy by default: the website answers the platform's servers directly, so you pay nothing for a proxy. Change it only if the website starts rejecting requests. A residential proxy is not needed and makes runs with Job details dearer.

## `exportFormats` (type: `array`):

Off by default. Printable HTML report: the results as a clean, branded table with the main columns, made for printing, saving as PDF or sending to someone; for working with the data use Excel or CSV, which have every field. Markdown table: the same columns as text for AI tools, docs or GitHub. The Output tab links the files. Each file has the overview columns of every saved row and nothing is left out, so a run with tens of thousands of rows makes a file of tens of MB that can be slow to open; for big runs use the dataset or its Excel export. Excel (XLSX), CSV and JSON are always in the Output tab and under Export, at no extra cost.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "python developer"
  ],
  "locations": [
    "Germany"
  ],
  "maxItems": 20,
  "maxItemsPerSearch": 0,
  "postedWithin": "any",
  "easyApply": false,
  "under10Applicants": false,
  "includeDetails": false,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "excludeAgencies": false,
  "onlyWithSalary": false,
  "includeHiringSignals": false,
  "compactOutput": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "exportFormats": [],
  "sendErrorReports": true
}
```

# Actor output Schema

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

The saved jobs (one row per job), in the run's default dataset.

## `summary` (type: `string`):

Free summary of the jobs the run found: yearly salary quartiles per currency (by country, seniority, employment type and industry), top companies, cities, countries, industries, seniority levels, employment types, workplace types, recruiting agencies and applicants.

## `excel` (type: `string`):

All saved rows as an Excel file, with every field.

## `htmlReport` (type: `string`):

The saved rows with the main columns as a clean table to print, save as PDF or send; only when "Extra export formats" includes it. Excel has every field.

## `markdown` (type: `string`):

The saved rows as a Markdown table, handy for AI tools, docs and GitHub; only when "Extra export formats" includes Markdown.

# 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": [
        "python developer"
    ],
    "locations": [
        "Germany"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/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 '{
  "searchQueries": [
    "python developer"
  ],
  "locations": [
    "Germany"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/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/YLnVxkyGDtbJt6Urf/builds/BoosHSQtujMEzqAMZ/openapi.json
