# LinkedIn Job Scraper (`data_minds/lnkedin-job-scraper`) Actor

Scrape public LinkedIn jobs with no login, cookies or API key. Get title, company, location, salary, workplace type, applicants, recruiter, skills and full description from search links, job links or titles. Bulk input, filters, auto proxy fallback. Export JSON, CSV or Excel.

- **URL**: https://apify.com/data_minds/lnkedin-job-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Job Scraper** is an Apify Actor that extracts public job listings from LinkedIn: title, company, location, pay, workplace type, applicants, recruiter, skills and full description. Paste search links, job links or company links, or type job titles and places, and export JSON, CSV or Excel. No login needed. **From $1.50 per 1,000 jobs on the Gold plan.** [🚀 Try it free](https://apify.com/data_minds/lnkedin-job-scraper)

### What can LinkedIn Job Scraper do?

Use it as a LinkedIn job extractor and LinkedIn job posting scraper. It also works as a LinkedIn jobs API alternative and a LinkedIn job scraper without cookies, with API access, schedules, webhooks and integrations.

- ✅ **Bulk LinkedIn job scraper** - search links, job links, company links, job ids, titles and places in one run.
- 🎯 **Filters checked on every job** - job type, experience level, workplace type, industry, minimum salary and description words.
- 💰 **Pay with its source** - salary text, min, max, currency and period, plus whether LinkedIn or the description supplied it.
- 👥 **Honest applicant numbers** - a job applicants count plus a flag when LinkedIn only says "over N applicants".
- 🧠 **Description insights** - skills, minimum years of experience, visa sponsorship and contact e-mails found in the text, which helps you find visa sponsorship jobs.
- 🔄 **Only new jobs** - pass yesterday's job ids in a skip list to receive just the new postings.
- ⚡ **Live results** - each job is saved to the dataset as soon as it is ready.
- 🔌 **Export and integrations** - JSON, CSV, Excel, API, schedules and webhooks.

#### What data can I extract from LinkedIn?

| Field | Description |
|---|---|
| 🆔 `id`, `jobUrl` | LinkedIn job id and the public link to the posting. |
| 💼 `title` | Job title. |
| 🏢 `companyName`, `companyUrl`, `companyId`, `companyLogo` | Employer name, public company page, company id and logo link. |
| 🌍 `location`, `city`, `region`, `country` | Location as written on the posting and its parts. |
| 🏠 `workplaceType`, `workplaceTypeSource` | Remote, Hybrid or On-site, and whether it came from the location, title or description. |
| 📝 `contractType`, `experienceLevel`, `industries` | Employment type, seniority level and industries from the job page. |
| 💵 `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salarySource` | Pay as written, parsed range, currency, period and where it was found. |
| 👥 `applicantsCount`, `applicantsIsLowerBound`, `applicantsText` | Number of applicants, a lower-bound flag and the text as shown. |
| ⚡ `applyType`, `jobState` | EASY_APPLY or EXTERNAL, and LISTED or CLOSED. |
| 📅 `postedAt`, `postedTimeAgo` | Posting date and the age as shown. |
| 🎁 `benefits` | Benefit labels shown on the search card. |
| 📄 `descriptionText` | Full job description as plain text. |
| 👤 `recruiterName`, `recruiterHeadline`, `recruiterProfileUrl`, `recruiterPhoto` | Recruiter shown on the posting, when the poster enabled it. |
| 🧠 `skills`, `yearsExperienceMin`, `visaSponsorship`, `contactEmails` | Insights found in the description. |
| 🔎 `searchKeyword`, `searchLocation`, `scrapedAt`, `error` | Which search found the job, collection time, and a read error when one happened. |

Fields LinkedIn does not show for a job are empty. Only public job data is collected, with no private profile data.

### What can you do with the data from LinkedIn?

**🎯 Job market research and competitor hiring tracking**

1. Add job titles to `keywords` and places to `locations`.
2. Set `postedWithin` to `30d`, and set `experienceLevels` to Entry level for entry level jobs data.
3. Filter `workplaceTypes` to Remote for remote jobs data, or compare remote, hybrid or on-site jobs, then export to Excel.

**💰 Salary benchmarking with a LinkedIn salary scraper**

1. Turn on `requireSalary` or set `salaryMin`.
2. Run your titles per city and export CSV.
3. Compare `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` across roles.

**🤝 Recruiting lead lists**

1. List employers in `companies`.
2. Keep `fullDetails` on to get each LinkedIn recruiter contact, with name and headline.
3. Send the Recruiter view to your CRM.

**🔔 Job alerts for new postings**

1. Schedule a daily run with `postedWithin` set to `24h` to get LinkedIn jobs posted today.
2. Put the ids you already have into `skipJobIds`.
3. Send only new jobs to your team through a webhook.

**🤖 Skills demand analysis and AI datasets**

1. Keep `extractInsights` on.
2. Export `skills` and `descriptionText`.
3. Feed the job descriptions for AI pipelines into an LLM or vector store.

### How do I use LinkedIn Job Scraper?

Here is how to use Apify to scrape LinkedIn jobs in a few clicks.

1. Open **LinkedIn Job Scraper** on Apify and click **Try for free**.
2. Paste LinkedIn links into **LinkedIn links or job ids**, or add **Job titles or keywords** and **Locations**.
3. Choose **Posted within** and set **Max jobs**.
4. Add filters such as companies, job types, experience levels or workplace types.
5. Click **Start** and watch jobs arrive in the Output tab.
6. Open the **Dataset** tab and export as JSON, CSV or Excel, or read the rows through the API.

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

LinkedIn Job Scraper uses pay-per-event pricing: you pay for each job saved to the dataset, and Apify platform usage is billed in addition. Jobs removed by your filters are not saved and not charged. The price per job depends on your Apify plan:

| Plan | Price per job | Per 1,000 jobs |
|---|---|---|
| 🆓 Free | $0.002 | $2.00 |
| 🥉 Bronze | $0.0018 | $1.80 |
| 🥈 Silver | $0.0016 | $1.60 |
| 🥇 Gold | $0.0015 | $1.50 |

Each run also has an Actor start event of $0.00005 per GB of memory, minimum one event. The default memory is 1,024 MB (1 GB), so one start event of $0.00005 is charged. Worked example: 500 jobs on the Silver plan cost 500 x $0.0016 = $0.80, plus the $0.00005 start event and platform usage.

#### Is scraping LinkedIn free?

You pay per saved job on every plan, starting at $0.002 per job on the Free plan, so the default 10 jobs cost $0.02. Platform usage is billed in addition. Set **Max jobs** to control the size of a run, or set a maximum spend per run in Apify, and the Actor stops cleanly when it is reached.

#### How much does LinkedIn Job Scraper cost per 1,000 results?

One result is one saved job. A thousand jobs cost $2.00 on the Free plan, $1.80 on Bronze, $1.60 on Silver and $1.50 on Gold, plus the $0.00005 start event and platform usage. Jobs kept without full details because the job page could not be read are saved and charged like any other job.

### Input

Give the Actor at least one of: links, job titles, locations or companies. Links, titles and places can be combined, and **Max jobs** caps the total across all searches. Common alternative key names used by other LinkedIn job Actors, such as `query`, `location`, `startUrls` and `jobsToFetch`, are also accepted.

| Field | Type | Required | Description | Default / example |
|---|---|---|---|---|
| `urls` | array | one of urls, keywords, locations, companies | LinkedIn job-search links, job links, company links or job ids. Duplicates are removed. | `[]` |
| `keywords` | array | see above | Job titles or skills, one per line. Boolean search works, for example `"data engineer" OR "data scientist" NOT intern`. | `[]` |
| `locations` | array | see above | City, region or country. Empty means worldwide. An unknown place is skipped with a warning. | `[]` |
| `postedWithin` | string | no | `any`, `1h`, `6h`, `12h`, `24h`, `3d`, `7d`, `30d`; other values such as `36` (hours) or `2w` can be typed. | `any` |
| `maxJobs` | integer | no | Total jobs to save across all searches. `0` means no cap. LinkedIn shows up to about 1,000 jobs per search. | `10` |
| `fullDetails` | boolean | no | On: open every job for description, applicants, seniority, employment type, industry, recruiter and pay. Off: fast mode with title, company, location and date. Turned on automatically when a filter needs the job page. | `true` |
| `extractInsights` | boolean | no | Add skills, minimum years of experience, visa sponsorship and contact e-mails. | `true` |
| `companies` | array | no | Only jobs from these employers: names, company links or numeric company ids. | `[]` |
| `excludeCompanies` | array | no | Drop jobs from these employers. | `[]` |
| `jobTypes` | array | no | Full-time, Part-time, Contract, Temporary, Internship, Volunteer. | `[]` |
| `experienceLevels` | array | no | Internship, Entry level, Associate, Mid-Senior level, Director, Executive. | `[]` |
| `workplaceTypes` | array | no | Remote, Hybrid, On-site. | `[]` |
| `industries` | array | no | Keep jobs whose industry contains one of these words, for example Software Development. | `[]` |
| `salaryMin` | number | no | Minimum yearly pay; hourly and monthly pay is converted. Jobs without pay are dropped when set. | none |
| `easyApply` | boolean | no | Only Easy Apply jobs you can apply to directly on LinkedIn. | `false` |
| `under10Applicants` | boolean | no | Only jobs with fewer than 10 applicants. | `false` |
| `titleInclude` / `titleExclude` | array | no | Keep jobs whose title contains one of these words, or drop jobs whose title contains one. | `[]` |
| `skipJobIds` | array | no | Job ids you already have, to receive only new jobs. | `[]` |
| `sortBy` | string | no | `relevance` or `newest` (orders the jobs of each results page by posting date). | `relevance` |
| `descriptionInclude` / `descriptionExclude` | array | no | Keep jobs whose description contains one of these words, or drop jobs that contain one. | `[]` |
| `requireSalary` | boolean | no | Drop jobs that show no salary information. | `false` |
| `salaryFromDescription` | boolean | no | When LinkedIn shows no salary, read a pay range written in the description. | `true` |
| `maxScanned` | integer | no | With content filters, stop a search after examining this many jobs (1 to 20,000). | `3000` |
| `concurrency` | integer | no | Job pages opened at the same time (1 to 8). Higher is faster but more likely to be rate-limited. | `4` |
| `maxRetries` | integer | no | Retries per failed request (0 to 10). | `5` |
| `requestGap` | number | no | Seconds between requests (0 to 10). The pause grows automatically when LinkedIn slows the run down. | `0.6` |
| `proxyConfiguration` | object | no | Optional connection settings. Leave the default for automatic behavior. | `{"useApifyProxy": false}` |

Example input:

```json
{
  "urls": [
    "https://www.linkedin.com/jobs/search/?keywords=python%20developer&location=Berlin%2C%20Germany"
  ],
  "keywords": ["data engineer"],
  "locations": ["London, United Kingdom"],
  "postedWithin": "7d",
  "maxJobs": 50,
  "workplaceTypes": ["Hybrid"],
  "salaryFromDescription": true
}
```

### Output

Each job is one row in the Apify Dataset, saved as soon as it is ready. Export as JSON, CSV, Excel, XML or HTML from the Dataset tab or through the API. The Output tab shows ten tables (views): overview, company, location, salary, job details, applicants, recruiter, skills and insights, description, and search info.

```json
{
  "id": "1234567890",
  "jobUrl": "https://www.example.com/jobs/view/1234567890",
  "title": "Senior Python Developer",
  "companyName": "Example Company",
  "companyUrl": "https://www.example.com/company/example-company",
  "companyId": "1000000",
  "companyLogo": "https://www.example.com/logo.png",
  "location": "Berlin, Berlin, Germany",
  "city": "Berlin",
  "region": "Berlin",
  "country": "Germany",
  "workplaceType": "Hybrid",
  "workplaceTypeSource": "description",
  "contractType": "Full-time",
  "experienceLevel": "Mid-Senior level",
  "industries": "Software Development",
  "salary": "EUR 80,000/yr - EUR 100,000/yr",
  "salaryMin": 80000,
  "salaryMax": 100000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salarySource": "linkedin",
  "applicantsCount": 61,
  "applicantsIsLowerBound": false,
  "applicantsText": "61 applicants",
  "applyType": "EASY_APPLY",
  "jobState": "LISTED",
  "postedAt": "2026-10-09",
  "postedTimeAgo": "2 days ago",
  "benefits": ["Actively Hiring"],
  "descriptionText": "Example description of the role...",
  "recruiterName": "Jane Example",
  "recruiterHeadline": "Talent Acquisition",
  "recruiterProfileUrl": "https://www.example.com/in/jane-example",
  "recruiterPhoto": "https://www.example.com/photo.jpg",
  "skills": ["Python", "AWS"],
  "yearsExperienceMin": 5,
  "visaSponsorship": null,
  "contactEmails": [],
  "searchKeyword": "python developer",
  "searchLocation": "Berlin, Germany",
  "scrapedAt": "2026-10-11T19:58:58Z"
}
```

When a run finishes, a `SUMMARY` record in the key-value store holds the counts of the run: `jobsSaved`, `jobsBilled`, `searches`, `filteredOut`, `detailFailed`, `removedBeforeDetail`, `warnings` and `durationSeconds`, among others.

#### Notes and limitations

- `error` appears only when a job page could not be read; that row keeps the search-card data only.
- With `extractInsights` off, the fields `skills`, `yearsExperienceMin`, `visaSponsorship` and `contactEmails` are not included.
- `applicantsCount` stays empty when LinkedIn only shows a ceiling such as "first 25 applicants".
- `workplaceType` is worked out from the location, title and description, so it can be empty when the posting does not say.
- `salaryCurrency` is set only when it is unambiguous.
- A few filters inside pasted search links are not supported and are ignored with a warning.
- Job type, level, workplace, industry and pay filters are checked job by job, so rare values take longer.

### FAQ

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

LinkedIn Job Scraper collects only public job listings that any visitor can see, with no login. Laws and site terms differ by country and use, and personal data such as recruiter names may fall under privacy rules. Read [Apify's guide on web scraping legality](https://blog.apify.com/is-web-scraping-legal/). This is not legal advice.

#### Do I need a LinkedIn account, cookies or an API key to scrape jobs?

No. The Actor needs no LinkedIn account, cookies or API key, and it never asks for your LinkedIn login. You only need an Apify account to run it. Add links, or job titles and locations, then press Start. The rows contain public job data only.

#### How many LinkedIn jobs can I get per run?

Set the total with Max jobs, from 1 up to 100,000, or use 0 for no cap. LinkedIn shows up to about 1,000 jobs per search, so for larger collections combine several keywords, locations or companies. The default is 10 jobs, which suits a quick test run.

#### Can I export LinkedIn jobs to Excel, CSV or JSON?

Yes. Open the Dataset tab after the run and choose Excel, CSV, JSON, XML or HTML. The ten views, such as salary or recruiter, can be exported separately. You can also download the same rows through the Apify API, or send them to Google Sheets with an integration.

#### Can I schedule runs or use webhooks and integrations?

Yes. Use Apify schedules to run the Actor daily or hourly, and webhooks to notify your tools when a run finishes. Combine a schedule with the skip list of job ids and you receive only new postings each time. Apify also offers integrations with tools such as Make, so a LinkedIn job scraper n8n workflow is easy to build.

#### Can I use LinkedIn Job Scraper with the Apify API or an MCP server?

Yes. Every Actor can be started, scheduled and read through the Apify API, and AI agents can call it through Apify's MCP server, for example from a LinkedIn job scraper Python script. The API tab of this Actor shows ready-made examples, and the full reference is in the [Apify API documentation](https://docs.apify.com/api/v2).

#### Why am I getting fewer jobs than expected?

Common causes are strict filters, a short posted-within window, a Max jobs cap, or a location LinkedIn did not recognise, which is skipped with a warning. Check the run log and the filteredOut counts in the SUMMARY record. Loosen the filters or raise the scan budget, then run again.

#### LinkedIn Job Scraper not working?

First read the run log, which explains most problems in plain words, such as LinkedIn limiting requests. Wait a few minutes and run again with a lower parallel connections value. If it still fails, open the Issues tab of this Actor and include your run link and a short description of the input.

### Related Actors

| Actor | Use it to |
|---|---|
| 🔗 [Indeed Job Scraper](https://apify.com/data_minds/indeed-job-scraper) | Collect job postings from Indeed's country sites using search links or job titles. |
| 🔗 [Workday Jobs Scraper](https://apify.com/data_minds/workday-jobs-scraper) | Scrape jobs from any Workday careers portal with titles, salaries, descriptions and skills. |
| 🔗 [LinkedIn Ads Library Scraper](https://apify.com/data_minds/linkedin-ads-library-scraper) | Extract LinkedIn ad copy, creatives, advertisers and run dates for competitor analysis. |

For job board scraping beyond LinkedIn, use the sibling Actors above, and browse the public job search on [LinkedIn](https://www.linkedin.com/jobs/) to compare with your results.

### Support and disclaimer

Found a bug or need a feature? Open an issue in the **Issues** tab. For custom solutions, integrations or questions, contact hello.dataminds@gmail.com. LinkedIn Job Scraper is independent and not affiliated with LinkedIn; trademarks belong to their owners. It collects publicly available data, and you are responsible for complying with applicable laws and the site's terms.

*Last updated: 2026-10-18*

# Actor input Schema

## `urls` (type: `array`):

Paste one or more LinkedIn job-search links, job links (linkedin.com/jobs/view/…), company links or plain job ids. Bulk input is supported and duplicates are removed. Search links keep their keywords, place and posted-date settings. Leave empty to search with the job titles and locations below.

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

Job titles or skills, one per line, e.g. python developer. Boolean search works, e.g. "data engineer" OR "data scientist" NOT intern. Each one is combined with every location below.

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

City, region or country, e.g. Berlin, Germany. Leave empty to search worldwide. A place LinkedIn does not recognise is skipped with a warning instead of searching somewhere else.

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

Only jobs posted within this time. Other values such as 36 (hours) or 2w can be typed in.

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

Total number of jobs to save across all searches (0 = no cap; LinkedIn shows up to about 1,000 per search).

## `fullDetails` (type: `boolean`):

On: open every job for description, applicants, seniority, employment type, industry, recruiter and pay. Off: fast mode with title, company, location and date only (turned on automatically when a filter needs the job page).

## `extractInsights` (type: `boolean`):

Add skills, minimum years of experience, visa sponsorship and contact e-mails found in the job description.

## `companies` (type: `array`):

Only jobs from these employers. Company names, LinkedIn company links or numeric company ids.

## `excludeCompanies` (type: `array`):

Drop jobs from these employers (company names).

## `jobTypes` (type: `array`):

Keep only these employment types. Each job is checked against its own page when that page can be read.

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

Keep only these seniority levels. Each job is checked against its own page when that page can be read.

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

Keep only remote, hybrid or on-site jobs. The workplace type is worked out from the location, title and description, and the output says which one it came from.

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

Keep only jobs whose industry contains one of these words, e.g. Software Development.

## `salaryMin` (type: `number`):

Keep only jobs paying at least this per year (hourly and monthly pay is converted). Jobs with no pay information are dropped when this is set.

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

Only jobs you can apply to directly on LinkedIn.

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

Only jobs with fewer than 10 applicants.

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

Keep a job only if its title contains at least one of these words or phrases.

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

Drop a job if its title contains any of these words or phrases, e.g. intern.

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

Job ids you already have. Pass yesterday's ids to receive only new jobs.

## `sortBy` (type: `string`):

Relevance keeps LinkedIn's order. Newest orders the jobs of each results page by posting date.

## `descriptionInclude` (type: `array`):

Keep a job only if its description contains at least one of these words.

## `descriptionExclude` (type: `array`):

Drop a job if its description contains any of these words.

## `requireSalary` (type: `boolean`):

Drop jobs that show no salary information.

## `salaryFromDescription` (type: `boolean`):

When LinkedIn shows no salary, look for a pay range written in the job description. The output says where each salary came from.

## `maxScanned` (type: `integer`):

With job type, level, workplace, industry, salary or description filters, stop a search after examining this many jobs.

## `concurrency` (type: `integer`):

How many job pages are opened at the same time (1-8). Higher is faster but more likely to be rate-limited.

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

How many times a failed request is retried before it is given up.

## `requestGap` (type: `number`):

Seconds between requests, with random variation. The pause grows automatically when LinkedIn slows the run down.

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

Optional connection settings. Leave the default and the run adapts its connection automatically if LinkedIn limits requests.

## Actor input object example

```json
{
  "urls": [
    "https://www.linkedin.com/jobs/search/?keywords=python%20developer&location=Berlin%2C%20Germany"
  ],
  "keywords": [],
  "locations": [],
  "postedWithin": "any",
  "maxJobs": 10,
  "fullDetails": true,
  "extractInsights": true,
  "companies": [],
  "excludeCompanies": [],
  "jobTypes": [],
  "experienceLevels": [],
  "workplaceTypes": [],
  "industries": [],
  "easyApply": false,
  "under10Applicants": false,
  "titleInclude": [],
  "titleExclude": [],
  "skipJobIds": [],
  "sortBy": "relevance",
  "descriptionInclude": [],
  "descriptionExclude": [],
  "requireSalary": false,
  "salaryFromDescription": true,
  "maxScanned": 3000,
  "concurrency": 4,
  "maxRetries": 5,
  "requestGap": 0.6,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

One line per job.

## `company` (type: `string`):

Employer data.

## `location` (type: `string`):

City, region, country and workplace type.

## `salary` (type: `string`):

Pay range, currency, period and benefits.

## `details` (type: `string`):

Employment type, seniority, industry, status and apply type.

## `applicants` (type: `string`):

Applicant counts and posting time.

## `recruiter` (type: `string`):

Recruiter shown on the posting.

## `insights` (type: `string`):

Skills, experience, visa and e-mails found in the description.

## `description` (type: `string`):

Full job description text.

## `search` (type: `string`):

Which search found each job, when, and any read error.

## `summaryFile` (type: `string`):

SUMMARY file with the counts of this run.

# 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 = {
    "urls": [
        "https://www.linkedin.com/jobs/search/?keywords=python%20developer&location=Berlin%2C%20Germany"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "urls": ["https://www.linkedin.com/jobs/search/?keywords=python%20developer&location=Berlin%2C%20Germany"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/lnkedin-job-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 '{
  "urls": [
    "https://www.linkedin.com/jobs/search/?keywords=python%20developer&location=Berlin%2C%20Germany"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_minds/lnkedin-job-scraper --silent --output-dataset

```

## MCP server setup

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