# LinkedIn Jobs Scraper — Job Postings API, No Login | $0.50/1k (`glasswing/linkedin-jobs-scraper`) Actor

Scrape LinkedIn job postings without an account: title, company, location, date posted, salary, seniority, employment type, industries, applicants and the full description. Keyword, location, company and date filters.

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

## Pricing

from $0.50 / 1,000 results

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 does LinkedIn Jobs Scraper do?

Get LinkedIn job postings as clean spreadsheet rows: job title, company, company page and logo, location, the date the job was posted, the pay range when the employer published one (parsed into `salaryMin` and `salaryMax`), seniority, employment type, job function, industries, applicant count, Easy Apply, and the full job description as plain text.

Type a keyword and a location - `software engineer` in `United States`, `nurse` in `United Kingdom` - or paste a LinkedIn job-search URL straight from your browser, and **scrape LinkedIn jobs** into JSON, CSV or Excel, or read them from the Apify API. It works as a practical **LinkedIn jobs API** for job boards, recruiters, analysts and AI agents: no LinkedIn account, no login, no cookies, nothing to install.

It reads only LinkedIn's **public job postings**, the same pages LinkedIn shows to anyone who is not signed in. It never logs in and never touches member profiles. It does not collect recruiter names, "meet the hiring team" cards, emails or phone numbers.

**$0.50 per 1,000 jobs** plus $0.005 per run, platform compute and proxy included. A 1,000-job run with full descriptions costs about $0.51.

### Use cases for this LinkedIn jobs scraper

- **Job board or aggregator.** Schedule one search per keyword and city every morning with **Date posted = Past 24 hours**, and publish fresh postings with the full `descriptionText`, `employmentType` and `seniority`.
- **Recruitment agency.** Find the companies hiring for the roles you place: filter on `companyName`, `location` and `postedAt`, and see how many people applied (`applicantCount`) before you call.
- **Sales prospecting.** A company hiring five data engineers is buying data tools. Search by role and group the rows by `companyName` and `companyUrl` to build an account list with real hiring intent.
- **Labour-market and salary research.** `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` are parsed from LinkedIn's pay range, so you can chart pay by role, country or `industries`.
- **Job seekers and career tools.** Pull every entry-level posting for a skill from the past week into a spreadsheet and track what you applied to.
- **AI agents and automations.** Call it with `{"keywords": ["python developer"], "locations": ["Berlin"]}` from an MCP client, n8n, Make or Zapier and get structured rows back.

### What data can LinkedIn Jobs Scraper extract?

One row per job posting. A job found by several of your searches is returned once (de-duplicated by `jobId`). The **Overview** table shows `title`, `companyName`, `location`, `postedAt`, `salaryText`, `employmentType`, `seniority`, `applicantCount`, `url`, `companyUrl`, `searchKeyword`, `status` and `error`.

**Job and company**

| Field | Type | Description |
|---|---|---|
| `jobId` | string | LinkedIn's numeric job id, e.g. `4454133738`. |
| `url` | string | Public job page, `https://www.linkedin.com/jobs/view/<jobId>/`. |
| `title` | string | Job title as posted. |
| `companyName` | string | Hiring company. |
| `companyUrl` | string | The company's LinkedIn page. |
| `companyLogo` | string | Company logo image URL. |
| `location` | string | Location as LinkedIn writes it: city, region, country or metro area. |
| `workplaceType` | string | `Remote` or `Hybrid`, only when LinkedIn writes it into the location; LinkedIn's public job pages have no workplace-type field, so it is usually absent. |

**Date, pay and applicants**

| Field | Type | Description |
|---|---|---|
| `postedAt` | string | Posting date, ISO 8601 (LinkedIn gives the day, so the time is midnight UTC). |
| `postedText` | string | LinkedIn's relative time, e.g. `2 weeks ago`. |
| `salaryText` | string | Pay range exactly as shown, e.g. `$117,000.00/yr - $234,000.00/yr`. Only when the employer published one. |
| `salaryMin` / `salaryMax` | number | The range parsed to numbers. |
| `salaryCurrency` | string | ISO currency code: `USD`, `EUR`, `GBP`, `CAD`, `INR`, ... |
| `salaryPeriod` | string | `hour`, `day`, `week`, `month` or `year`. |
| `applicantsText` | string | e.g. `Over 200 applicants`, `Be among the first 25 applicants`. |
| `applicantCount` | integer | The number in `applicantsText` (`Over 200` = 200). |
| `benefits` | array | LinkedIn's highlights on the search card, e.g. `Actively Hiring`. |

**Job details** (with **Fetch full job details** on, the default)

| Field | Type | Description |
|---|---|---|
| `descriptionText` | string | Full description as plain text, paragraphs and bullet points on their own lines. |
| `descriptionHtml` | string | The same as HTML, only with **Also keep the description as HTML**. |
| `seniority` | string | e.g. `Entry level`, `Mid-Senior level`, `Director`. |
| `employmentType` | string | e.g. `Full-time`, `Part-time`, `Contract`. |
| `jobFunction` | string | e.g. `Engineering and Information Technology`. |
| `industries` | string | The company's industries as LinkedIn lists them. |
| `easyApply` | boolean | `true` = LinkedIn Easy Apply, `false` = apply on the company's site. |
| `isClosed` | boolean | `true` when LinkedIn says the job no longer accepts applications. |
| `applyUrl` | string | External apply link, only on the few postings where LinkedIn shows it without sign-in. |
| `descriptionError` | string | Why the details of this job could not be read; the row still has the search-card data. |

**Search and row status**

| Field | Type | Description |
|---|---|---|
| `searchKeyword` | string | Keyword of the search that found the job. |
| `searchLocation` | string | Location of that search. |
| `status` | string | `ok`, `not_found` or `error` (below). |
| `error` | string | Reason when `status` is not `ok`. |
| `scrapedAt` | string | ISO 8601 time the row was written. |

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | A job posting. | Yes |
| `not_found` | LinkedIn answered, but has nothing: a search with no jobs, a deleted posting, a company name LinkedIn does not know. | No |
| `error` | LinkedIn could not be read after retries. `error` says why. | No |

A run whose only rows are `not_found` ends as **Succeeded**: "no jobs for this search" is an answer, not a failure.

### How to scrape LinkedIn jobs

1. Open the Actor and click **Try for free**.
2. Type one or more **Job titles or keywords** and **Locations** - or paste LinkedIn job-search URLs into **LinkedIn job-search URLs**.
3. Optional: pick filters (**Date posted**, **Experience level**, **Job type**) or restrict to companies by name or id.
4. Set **Maximum results** (the default 20 shows you the output in seconds).
5. Click **Start**, then open the **Output** tab or export the dataset as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl) or add a **Schedule**.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array of strings | - | Job titles or keywords; each one is a separate search. |
| `locations` | array of strings | - | Countries, regions or cities; each is searched separately. Empty = worldwide. |
| `startUrls` | array of strings | one example search | LinkedIn job-search URLs (all filters kept), job URLs or job ids. The example is skipped as soon as you fill in keywords, locations or companies. |
| `datePosted` | string | `any` | `1h`, `24h`, `week`, `month` or `any`. |
| `experienceLevel` | array | all | `internship`, `entry`, `associate`, `mid-senior`, `director`, `executive`. Checked on every job's page (see below). |
| `jobType` | array | all | `full-time`, `part-time`, `contract`, `temporary`, `internship`, `volunteer`, `other`. Checked on every job's page. |
| `companyNames` | array of strings | - | Only jobs at these companies, matched to their LinkedIn page by name. |
| `companyIds` | array of strings | - | LinkedIn company ids (the `f_C` value in a search URL). |
| `geoId` | string | - | LinkedIn's place id, for ambiguous place names. |
| `fetchDescription` | boolean | `true` | Full job details (one extra request per job). `false` = search-card data only, much faster. |
| `includeDescriptionHtml` | boolean | `false` | Also return the description as HTML. |
| `maxItems` | integer | `20` | Stop after this many jobs across all searches. |
| `maxItemsPerSearch` | integer | - | Cap per single search, so one broad search cannot use up `maxItems`. |
| `proxyConfiguration` | object | Apify Proxy on | Datacenter proxy (included). Residential proxies are not needed. |

Filters apply to every search, pasted URLs included. `keyword`, `location` and `query` are accepted as aliases, which helps AI agents.

**How the filters work.** LinkedIn's logged-out search applies the date and company filters itself. It ignores experience level and job type (we measured identical results with and without them), so the Actor reads each job's own "Seniority level" and "Employment type" and saves only the jobs that match; the ones that do not match are never saved or billed. When you pick exactly one level or type, its words (e.g. `entry level`, `part-time`) are also added to your keyword search so that LinkedIn ranks matching jobs first; `searchKeyword` still shows your own keyword. That takes one job-page request per job checked, so filtered runs are slower. Remote/hybrid and salary filters are not offered because LinkedIn ignores them and its public job pages do not show the workplace type; you can add `remote` to your keywords, and filter on `salaryMin` in the output.

Example input:

```json
{
    "keywords": ["data analyst", "data engineer"],
    "locations": ["United States", "Canada"],
    "datePosted": "week",
    "experienceLevel": ["entry", "associate"],
    "maxItems": 500,
    "maxItemsPerSearch": 125
}
```

### Output

A real row from a platform run (description shortened):

```json
{
    "url": "https://www.linkedin.com/jobs/view/4454133738/",
    "status": "ok",
    "jobId": "4454133738",
    "title": "(USA) Senior, Software Engineer",
    "companyName": "Walmart",
    "companyUrl": "https://www.linkedin.com/company/walmart",
    "companyLogo": "https://media.licdn.com/dms/image/v2/D560BAQHZkPdlecGssw/company-logo_100_100/company-logo_100_100/0/1736779000209/walmart_logo?e=2147483647&v=beta&t=tWcWIFSyHtICTzTLIPiYeKCp21XucI-HWijZdWwYR-A",
    "location": "Sunnyvale, CA",
    "postedAt": "2026-09-11T00:00:00.000Z",
    "postedText": "2 weeks ago",
    "benefits": ["Actively Hiring"],
    "applicantsText": "101 applicants",
    "applicantCount": 101,
    "seniority": "Not Applicable",
    "employmentType": "Full-time",
    "jobFunction": "Engineering and Information Technology",
    "industries": "Retail",
    "salaryText": "$117,000.00/yr - $234,000.00/yr",
    "salaryMin": 117000,
    "salaryMax": 234000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "easyApply": false,
    "descriptionText": "Position Summary...\n\nWhat you'll do...\n\nRole summary:\n\nAs a Senior Software Engineer, you will lead the delivery of scoped features and solutions by collaborating with cross-functional teams ...",
    "searchKeyword": "software engineer",
    "searchLocation": "United States",
    "scrapedAt": "2026-09-27T23:34:53.593Z"
}
```

A search with no jobs, and a company name LinkedIn does not know, look like this (free):

```json
{
    "url": "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search?keywords=astronaut&location=Vatican+City&f_TPR=r3600&start=0",
    "status": "not_found",
    "error": "No results for this page",
    "scrapedAt": "2026-09-28T00:10:04.221Z"
}
```

### Speed and reliability (real runs)

All numbers are from runs on the Apify platform at the default 1,024 MB, with the default datacenter proxy.

| Run | Jobs | Time | Requests | Failed |
|---|---|---|---|---|
| Default input (no arguments), 6 staging runs | 20 | 5-18 s | 22 | 0 |
| 3 US keyword searches, full details | 300 | 79 s | 345 | 0 |
| 12 searches in 12 countries (US, UK, DE, IN, CA, AU, FR, NL, BR, SG, ES, PL), full details | 1,188 | 6 min 11 s | 1,308 | 0 (99.9% on the first attempt) |

With **Fetch full job details** off, a run needs one request per 10 jobs instead of one per job. LinkedIn throttles busy IP addresses; the Actor retries a throttled request from a fresh IP, so throttling costs seconds, not rows.

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

Pay per event, platform compute and proxy included:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Result (`status: ok` job) | $0.0005 per job ($0.50 per 1,000) |

Examples: the default 20-job run costs $0.015; 1,000 jobs cost $0.505; 10,000 jobs $5.005. Rows with status `not_found` or `error` are never billed. Cap spending with **Maximum results** and the run's **Max total charge**; the Actor stops cleanly when either is reached.

### Tips

- **More than 1,000 jobs for one query:** LinkedIn serves at most 1,000 results per search. Split it: several locations (states or cities instead of a country), several related keywords, or **Date posted = Past 24 hours** on a daily schedule.
- Put several keywords and locations into one run instead of many small runs; you pay the start fee once, and duplicates across searches are removed for you.
- Use `maxItemsPerSearch` to spread `maxItems` evenly over your searches.
- For exact companies use `companyIds`; `companyNames` takes LinkedIn's best match for the name (check `companyName` in the output).

### Limitations

- LinkedIn serves at most 1,000 jobs per search (see Tips).
- LinkedIn does not return "no results" for a keyword it does not recognise; it shows related jobs instead. `searchKeyword` tells you which search found each row.
- Pay ranges exist only where the employer published one (about one job in ten in our test runs, more in the US, UK and EU).
- Most external apply links are behind LinkedIn's sign-in, so `applyUrl` is usually empty; `easyApply` tells you how to apply.
- `postedAt` has day precision. Jobs requested by URL (not found through a search) have `postedText` only.
- LinkedIn's logged-out search ignores the workplace-type (remote/hybrid), salary, Easy Apply and "under 10 applicants" filters, so they are not offered. Experience level and job type are checked on each job page instead, which costs one request per job checked.
- If an experience-level or job-type filter matches none of the jobs checked (up to 20 per requested result), the run ends without results and is marked failed.
- Member data is out of scope: no recruiter names, profiles, emails or phone numbers.

### FAQ

**Do I need a LinkedIn account, cookies or a proxy?** No. The Actor reads LinkedIn's public job pages without logging in; the datacenter proxy it uses is included in the price.

**Is it legal to scrape LinkedIn jobs?** It collects only job postings that LinkedIn publishes to anonymous visitors, and no member data. You are responsible for how you use the data; read the notice below and LinkedIn's terms.

**Why did I get fewer rows than Maximum results?** Your searches had fewer jobs, jobs repeated across searches (each is returned once), or a per-search cap or the run's charge limit was reached. The run log says which.

**Can an AI agent call it?** Yes. With no input at all it returns 20 software engineer jobs in the United States in seconds. Agents can pass `keywords`/`keyword`, `locations`/`location` or `query` as plain strings, and every row says whether it is data (`ok`), an empty answer (`not_found`) or a failure (`error`).

**How fresh is the data?** Every run reads LinkedIn live; nothing is cached. Use **Date posted = Past hour / 24 hours** for a feed of new postings.

**Does it get the company's website, size or employees?** No, only what the job posting shows: company name, LinkedIn page and logo.

### Related Actors

- [ATS Jobs: Workday, Greenhouse, Lever, BambooHR](https://apify.com/glasswing/ats-jobs-scraper) - use it to read postings straight from a company's own applicant-tracking system.
- [Dice Jobs Scraper](https://apify.com/glasswing/dice-jobs-scraper) - use it for US tech and IT job-board listings instead of LinkedIn.
- [Workable Jobs Scraper](https://apify.com/glasswing/workable-jobs-scraper) - use it for roles hosted on company Workable career pages.
- [XING Jobs Scraper](https://apify.com/glasswing/xing-jobs-scraper) - use it for Germany, Austria and Switzerland listings.
- [LinkedIn Jobs Scraper — Hiring Leads with Emails](https://apify.com/glasswing/linkedin-leads) - use it when you need recruiter or hiring-manager contact emails, not just the postings.

### Legal and data-protection notice

This Actor extracts only job postings that LinkedIn publishes publicly to visitors who are not signed in. It does not log in, does not work around access controls, and does not extract member data such as names, profile links, e-mail addresses or phone numbers. Job descriptions are written by employers and can still mention a contact person; personal data is protected by the GDPR in the European Union and by other laws worldwide, so do not use such data without a legitimate reason. You are responsible for complying with LinkedIn's terms of service and applicable law when you use the extracted data.

This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by LinkedIn Corporation. LinkedIn is a trademark of LinkedIn Corporation; all trademarks belong to their respective owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/glasswing/linkedin-jobs-scraper/changelog.md

# Actor input Schema

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

What you would type into LinkedIn's job search, one per line (e.g. `software engineer`, `registered nurse`, `sales manager`). Each keyword is a separate search in every location below; a job found by several searches is returned once. Leave empty to list every job in the locations.

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

Where to search, one per line, the way you would type it on LinkedIn: a country (`United States`, `Germany`), a region (`California, United States`) or a city (`London, England, United Kingdom`, `Berlin`). Each location is searched separately. Empty = worldwide.

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

Search result pages copied from your browser (https://www.linkedin.com/jobs/search/?keywords=...\&location=...), from any country site; every filter in the URL is kept. Job pages (https://www.linkedin.com/jobs/view/...) and bare job ids work too. The example is skipped automatically as soon as you fill in keywords, locations or companies.

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

Only jobs posted within this time. Applies to every search, pasted URLs included.

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

LinkedIn's experience levels (the job page's "Seniority level"). Pick one or more; empty = all. LinkedIn's logged-out search does not apply this filter itself, so every job's page is checked and only matching jobs are saved (jobs that do not match are free). Needs the job details, which are then fetched even with the details switch off. With exactly one level chosen, its words (e.g. `entry level`) are added to the keyword search so LinkedIn ranks matching jobs first.

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

Employment types (the job page's "Employment type"). Pick one or more; empty = all. Checked on every job's page like Experience level: only matching jobs are saved and billed. With exactly one type chosen, its word (e.g. `part-time`) is added to the keyword search.

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

Only jobs at these companies, one name per line (e.g. `Google`, `Microsoft`). Each name is matched to its LinkedIn company page (an exact name match first, else LinkedIn's top suggestion) and searched separately with your keywords and locations. A name LinkedIn does not know returns one free `not_found` row.

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

Numeric LinkedIn company ids (the `f_C` value in a LinkedIn search URL, e.g. `1441` for Google). Each id is searched separately with your keywords and locations.

## `geoId` (type: `string`):

LinkedIn's numeric place id (the `geoId` value in a LinkedIn search URL, e.g. `103644278` = United States). Use it when a location name is ambiguous; it applies to every keyword search.

## `fetchDescription` (type: `boolean`):

On (default): one extra request per job adds the full description, seniority, employment type, job function, industries, applicant count, salary range (when LinkedIn shows it), Easy Apply and closed flags. Off: search-card data only (title, company, location, date, logo), about 10x fewer requests and faster.

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

Adds `descriptionHtml` (LinkedIn's formatted description) next to the plain-text `descriptionText`. Only with full job details on.

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

Stop after this many jobs have been saved, across all searches. Each saved job with status `ok` is one billable result. LinkedIn serves at most 1,000 jobs per search, so split big pulls by location, keyword or date posted.

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

Optional cap for each single search (one keyword in one location, or one pasted URL), so one broad search cannot use up Maximum results. Empty = no per-search cap (LinkedIn's own limit is 1,000).

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

Apify Proxy (datacenter) spreads the requests over many IPs so LinkedIn does not throttle the run. Residential proxies are not needed.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States"
  ],
  "datePosted": "any",
  "fetchDescription": true,
  "includeDescriptionHtml": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/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 = {
    "startUrls": ["https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/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 '{
  "startUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call glasswing/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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