# LinkedIn Jobs Scraper · No Login · $0.2/1k (`alfalfa/linkedin-jobs-scraper`) Actor

LinkedIn jobs scraper: search public jobs by keyword, location, date, company or URL; export full description, salary, applicants and poster to Excel, CSV or JSON. No login. $0.20/1k jobs on Business or $0.30/1k on Free; platform usage included, no start fee.

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

## Pricing

from $0.20 / 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 (No Login)

Search **public LinkedIn job postings** by keyword, location, date, company or a LinkedIn URL and get every job as a clean record: title, company with logo and page URL, location, posting date, salary when shown, applicant count, the full description, seniority, employment type, job function, industries and the recruiter who posted it. No LinkedIn account, login or cookies needed. **Same field names as the most used LinkedIn jobs Actor** at **$0.30 per 1,000 jobs**, with **no start fee** and **job details included**.

Export to JSON, CSV or Excel, read the dataset through the API, or run it on a schedule from n8n, Make or Zapier.

Narrow a search down before anything is saved: **title words to keep or skip** (`titleInclude`, `titleExclude`), **company names** (`companyNames`), your own **posting window in hours** (`postedWithinHours`), and every job says whether it is **Easy Apply or an external application** (`applyType`).

### What you can do with LinkedIn job data

- **Job boards and aggregators**: pull new postings for a niche or a city every morning and publish them.
- **Lead generation**: a company hiring for a role is a company buying what that role needs. Get the companies, the roles and the recruiter names for a territory in one table.
- **Salary and market research**: titles, seniority, employment types and posted salaries across thousands of postings.
- **Recruiting**: track which competitors are hiring, where, and how many applicants each posting has.
- **Job search automation**: filter by keyword, title words, company, date and Easy Apply, push matches to a spreadsheet or a chat alert.

### What data do you get

| Field | Example |
|---|---|
| `id`, `link`, `title` | `4463607193`, the job URL, `Brand Manager, Foodservice` |
| `companyName`, `companyLinkedinUrl`, `companyLogo` | `Libbey`, the company page, logo URL |
| `location`, `postedAt`, `postedAgo` | `Toledo, OH`, `2026-09-04`, `6 days ago` |
| `salaryInfo`, `benefits` | `["$85,000.00", "$110,000.00"]`, `["Actively Hiring"]` |
| `applicantsCount`, `applicantsText` | `71`, `71 applicants` (`<25` when LinkedIn only says "be among the first 25", `>200` for "over 200") |
| `descriptionHtml`, `descriptionText` | the full posting |
| `seniorityLevel`, `employmentType`, `jobFunction`, `industries` | `Mid-Senior level`, `Full-time`, `Marketing and Sales`, `Manufacturing` |
| `jobPosterName`, `jobPosterTitle`, `jobPosterProfileUrl`, `jobPosterPhoto` | the recruiter when the posting shows one |
| `applyType` | `EASY_APPLY` (applications on LinkedIn) or `EXTERNAL` (the company's own site) |
| `applyUrl`, `inputUrl` | external apply link when exposed, the search or URL the job came from |

### How to scrape LinkedIn jobs

1. Type **Keywords** and a **Location**, pick **Date posted**, or paste LinkedIn search URLs and job URLs into **LinkedIn URLs**.
2. Narrow it down if you like: **Title must contain** / **Title must not contain**, **Company names**, **Posted within the last N hours**.
3. Set **Max jobs per search** and keep **Include job details** on for the full description, the criteria and the apply type.
4. Click **Start**. Jobs stream into the dataset as they are found; export as JSON, CSV or Excel, or read them through the API.

### Filter by job title

`titleInclude` keeps only jobs whose title contains at least one of the given words or phrases; `titleExclude` drops jobs whose title contains any of them. Matching is case-insensitive and on any part of the title, so `engineer` also matches *Engineering Manager* and `senior` matches *Senior Data Engineer*. Filtered-out jobs are never saved or charged, and the search keeps reading result pages until **Max jobs per search** matching jobs are found or the results end. The run log and the status show how many were filtered out.

```json
{
  "keywords": "data engineer",
  "location": "Berlin",
  "titleInclude": ["data engineer", "data platform"],
  "titleExclude": ["senior", "lead", "praktikant", "werkstudent"],
  "maxJobs": 100
}
```

The filters apply to search results (keywords, location, company or a pasted search URL). Single job URLs are always saved.

### Search by company name

`companyNames` takes plain company names. Each one is looked up on LinkedIn and used when a company of that name exists; the log says which (`company "Microsoft" -> id 1035 (Microsoft)`). A name with no match, including a misspelling, is skipped with a note. If none of the names is found, the search does not run, so you never pay for other companies' jobs. Combine it with `companyIds` when you know the numeric IDs, or with `keywords` and `location` to search inside those companies.

```json
{
  "companyNames": ["Microsoft", "Siemens Healthineers"],
  "keywords": "engineer",
  "maxJobs": 200
}
```

### Only the newest postings

`postedWithinHours` sets your own posting window instead of the four presets of **Date posted**: `6` for a run every six hours, `24` for a daily run, `72` for the last three days, up to `8760` (a year). It overrides **Date posted** when both are set.

### Easy Apply or external application

Every job with details carries `applyType`: `EASY_APPLY` when applications are taken on LinkedIn, `EXTERNAL` when the posting sends applicants to the company's site. It is `null` when the posting no longer shows an apply button (applications closed) or when **Include job details** is off. To get only Easy Apply jobs, switch **Easy Apply only** on; to get only external ones, filter the dataset by `applyType`.

### Input

| Field | Type | Description |
|---|---|---|
| `keywords` | string | Job title, skill or free text. |
| `location` | string | City, region or country as typed on LinkedIn. |
| `datePosted` | `anyTime` / `past24Hours` / `pastWeek` / `pastMonth` | Posting window. |
| `postedWithinHours` | integer | Your own posting window in hours; overrides `datePosted`. |
| `maxJobs` | integer | Max jobs per search or URL (default 100). LinkedIn returns at most 1,000 per search. `limitPerSource` and `rows` are accepted too. |
| `scrapeDetails` | boolean | Open each job for description, criteria, applicants, salary, poster, apply type (default on). |
| `startUrls` | array | LinkedIn search URLs (filters in the URL are kept) or job URLs. |
| `companyNames` | array of strings | Company names; each is looked up on LinkedIn, the best match is used. |
| `companyIds` | array of strings | Numeric company IDs (`f_C=` in a search URL). |
| `titleInclude` | array of strings | Keep only titles containing at least one of these words or phrases (case-insensitive). |
| `titleExclude` | array of strings | Skip titles containing any of these words or phrases (case-insensitive). |
| `experienceLevel`, `jobType`, `workplaceType` | arrays | Passed to LinkedIn; applied only where LinkedIn's search still supports these filters. |
| `easyApply`, `under10Applicants` | boolean | Easy Apply only; fewer than 10 applicants only. |
| `sortBy` | `relevance` / `date` | LinkedIn's order or newest first. |
| `geoId`, `distance` | string, integer | Precise location ID and radius in miles. |
| `maxConcurrency` | integer | Searches in parallel (default 5). |
| `proxyConfiguration` | object | Residential proxies by default, included in the price. |

Example:

```json
{
  "keywords": "data engineer",
  "location": "Berlin",
  "datePosted": "pastWeek",
  "maxJobs": 200,
  "scrapeDetails": true
}
```

### Output

One record per job (trimmed):

```json
{
  "id": "4463607193",
  "link": "https://www.linkedin.com/jobs/view/4463607193",
  "title": "Brand Manager, Foodservice",
  "companyName": "Libbey",
  "companyLinkedinUrl": "https://www.linkedin.com/company/libbey",
  "companyLogo": "https://media.licdn.com/dms/image/v2/...",
  "location": "Toledo, OH",
  "postedAt": "2026-09-04",
  "postedAgo": "6 days ago",
  "salaryInfo": [],
  "benefits": [],
  "applicantsCount": "<25",
  "applicantsText": "Be among the first 25 applicants",
  "descriptionText": "The Brand Manager, Foodservice is responsible for ...",
  "descriptionHtml": "<p><strong>Summary</strong></p><p>The Brand Manager ...",
  "seniorityLevel": "Not Applicable",
  "employmentType": "Full-time",
  "jobFunction": "Marketing and Sales",
  "industries": "Manufacturing",
  "jobPosterName": null,
  "applyType": "EXTERNAL",
  "applyUrl": "",
  "inputUrl": "https://www.linkedin.com/jobs/search?keywords=marketing+manager&location=United+States"
}
```

### Pricing

**$0.30 per 1,000 jobs** ($0.0003 per job), **no start fee**, details included, platform usage and residential proxies included. You pay only for records written to the dataset. Set the maximum budget per run in the Actor settings; the scraper stops when it is reached and never overshoots.

**Final price.** The per-job price is everything you pay: platform usage is included, there is no start fee and no per-run minimum. Some listings on the Store show a lower number and add platform usage on top; here the number on the listing is the number on your bill.

| Monthly spend | Jobs |
|---|---|
| $5, which is what the free plan includes | about 16,700 |
| $49 | about 163,300 |
| $499 | about 1,663,300 |

For comparison, the most used LinkedIn jobs Actor charges $2 per 1,000 jobs on the free plan and $1 on paid plans.

### Switching from another LinkedIn jobs Actor

Field names follow the most used one (`id`, `link`, `title`, `companyName`, `companyLinkedinUrl`, `companyLogo`, `location`, `salaryInfo`, `postedAt`, `benefits`, `descriptionHtml`, `descriptionText`, `applicantsCount`, `applyUrl`, `jobPosterName`, `jobPosterTitle`, `jobPosterPhoto`, `jobPosterProfileUrl`, `seniorityLevel`, `employmentType`, `jobFunction`, `industries`), and its `urls`, `keywords`, `location`, `geoId`, `distance`, `datePosted`, `companyIds`, `under10Applicants` and `limitPerSource` inputs are understood. Company enrichment (employee count, website) is not included yet.

### Limitations

- Only what LinkedIn shows a visitor without an account: public job postings. Nothing that needs a login.
- LinkedIn returns at most 1,000 jobs per search. For more, split by location, date window or company.
- LinkedIn has retired several classic filters (experience level, job type, workplace) for many searches; they are passed along and applied when LinkedIn honours them. Date, Easy Apply, under-10-applicants and company filters work.
- `applyUrl` is usually empty: LinkedIn hides the external apply link behind a login for most postings. `applyType` still tells Easy Apply from external applications, and the job URL in `link` always works.
- Title filters look at the title only, not at the description; `companyNames` uses LinkedIn's best match for a name, so check the log line or use `companyIds` for an exact company.

### FAQ

#### Do I need a LinkedIn account?

No. The scraper reads the public job pages that LinkedIn shows to anyone. Nothing is posted, no account of yours is used.

#### How fast is it?

About 100 jobs with full details in a minute; five times faster with details off.

#### Can I run it every day and get only new jobs?

Yes. Set *Date posted* to *Past 24 hours* (or `postedWithinHours` to match any other schedule, e.g. `6`) and schedule the run; each run returns only the new postings.

#### Is scraping LinkedIn jobs legal?

Job postings are public data companies publish to be found. Reading public pages without an account is generally legal (the hiQ v. LinkedIn rulings in the US), but you are responsible for how you use the data; respect privacy laws for the recruiter names. This Actor is not affiliated with LinkedIn or Microsoft.

### Use it from n8n, Make, Zapier or an AI agent

- **n8n, Make, Zapier**: add the Apify node, pick `alfalfa/linkedin-jobs-scraper`, paste the JSON input above and read the run's dataset in the next step. See the [Apify integrations docs](https://docs.apify.com/platform/integrations).
- **Daily Google Sheets tracker**: schedule a run with `postedWithinHours: 36` once every 24 hours, then use the Apify node's **Get items** operation on the run's `defaultDatasetId`. In Google Sheets, use **Append or update row** and match the `id` column. The overlap catches postings near the schedule boundary while the sheet keeps one row per job. A job returned again on a later run is still a new billed Actor result.
- **AI agents and MCP**: connect the Apify MCP server with this Actor as a tool, `https://mcp.apify.com/?tools=alfalfa/linkedin-jobs-scraper`. See [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).
- **API and scheduling**: every run is available through the [Apify API](https://docs.apify.com/api/v2); schedules, webhooks and exports are built in.

### Examples you can run in one click

Each example opens with its input already filled in and a sample of the results, so you can change any field and run it right away.

- [Export LinkedIn jobs to CSV](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-jobs-export-csv)
- [LinkedIn Easy Apply jobs](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-easy-apply-jobs)
- [LinkedIn job postings for lead generation](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-job-postings-for-lead-generation)
- [LinkedIn jobs API](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-jobs-api)
- [LinkedIn jobs by keyword](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-jobs-by-keyword)
- [LinkedIn jobs to Google Sheets](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-jobs-to-google-sheets)
- [LinkedIn jobs under 10 applicants](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/linkedin-jobs-under-10-applicants)
- [Remote jobs on LinkedIn](https://apify.com/alfalfa/linkedin-jobs-scraper/examples/remote-linkedin-jobs)

Need something the examples do not cover? Every field is on the Input tab, and any example input works unchanged in an API call or an n8n, Make or Zapier workflow.

### Was this useful?

If this Actor saved you time, a short review on its Store page helps others find it and tells me what to improve next. Missing a field or stuck on an input? Open an Issue on the Actor page; issues are answered within a day.

### More scrapers by Alfalfa

| Actor | What it does | Price |
|---|---|---|
| [Facebook Ads Library Scraper](https://apify.com/alfalfa/facebook-ads-library-scraper) | ads from the Meta Ad Library with creatives, dates, platforms and EU reach | $0.45 per 1,000 ads |
| [Google Ads Transparency Scraper](https://apify.com/alfalfa/google-ads-transparency-scraper) | every Google ad of an advertiser or website domain with format, dates, regions, previews and YouTube video ids | $0.30 per 1,000 ads |
| [Google Maps Scraper](https://apify.com/alfalfa/google-maps-scraper) | places from any search and location with address, phone, website, rating and hours, plus reviews and website emails | $0.07 per 1,000 places |
| [LinkedIn Company Scraper](https://apify.com/alfalfa/linkedin-company-scraper) | LinkedIn company pages from URLs, names, websites or a filtered keyword search with size, employee count, followers, offices and recent posts | $1 per 1,000 companies |
| [Amazon Product Scraper](https://apify.com/alfalfa/amazon-product-scraper) | products from searches, Best Sellers lists and ASINs in 22 Amazon stores with price, rating, BSR and details | $0.28 per 1,000 products |
| [YouTube Scraper](https://apify.com/alfalfa/youtube-scraper) | videos of a search, channel, playlist or URL list with views, likes, date, tags, plus transcripts and comments; no API key | $0.50 per 1,000 rows |
| [YouTube Transcript Scraper](https://apify.com/alfalfa/youtube-transcript-scraper) | transcripts only: the subtitles of videos, channels, playlists or searches as timed segments, plain text, SRT or WebVTT | $0.09 per 1,000 transcripts |
| [Facebook Posts Scraper](https://apify.com/alfalfa/facebook-posts-scraper) | posts of any public page or profile | $2 per 1,000 posts |
| [Facebook Comments Scraper](https://apify.com/alfalfa/facebook-comments-scraper) | comments and replies of any public post | $0.30 per 1,000 comments |
| [Facebook Pages Scraper](https://apify.com/alfalfa/facebook-pages-scraper) | page details with email, phone, address | from $2.50 per 1,000 pages |
| [Facebook Events Scraper](https://apify.com/alfalfa/facebook-events-scraper) | events by search, city, page or URL | $3 per 1,000 events |

### Not working?

Open an issue in the **Issues** tab with your input and the run ID. LinkedIn changes its pages now and then; fixes usually ship within a day.

# Changelog

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

# Actor input Schema

## `keywords` (type: `string`):

Job title, skill or free text, as you would type it on LinkedIn: <code>data engineer</code>, <code>marketing manager remote</code>.

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

City, region or country as you would type it on LinkedIn: <code>United States</code>, <code>London, United Kingdom</code>, <code>Berlin</code>.

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

Only jobs posted within this window.

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

Your own posting window in hours, e.g. <code>6</code> for a run every six hours or <code>48</code> for two days. Overrides <b>Date posted</b> when set.

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

Maximum jobs per search or start URL. LinkedIn shows at most 1,000 results per search; split broad searches by location or date to get more. <code>limitPerSource</code> and <code>rows</code> are accepted as aliases.

## `scrapeDetails` (type: `boolean`):

Open every job page for the full description, seniority, employment type, job function, industries, applicant count, salary when shown and the job poster. One extra request per job, no surcharge. Off = list fields only (title, company, location, date), about five times faster.

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

LinkedIn job search URLs copied from your browser (<code>linkedin.com/jobs/search?keywords=...\&location=...</code>, filters in the URL are kept) or single job URLs (<code>linkedin.com/jobs/view/1234567890</code>). Each URL is one task on top of the search above.

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

Restrict the search to these companies by name, e.g. <code>Microsoft</code>, <code>Siemens Healthineers</code>. Each name is looked up on LinkedIn and used only when a company of that name exists (the log shows which); names that are not found or misspelled are skipped. For exact control use <b>Company IDs</b> instead.

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

Numeric LinkedIn company IDs to restrict the search to, e.g. <code>1441</code> for Google (the <code>f_C=</code> value in a search URL).

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

Keep only jobs whose title contains at least one of these words or phrases, e.g. <code>python</code>, <code>data engineer</code>. Case-insensitive, so <code>engineer</code> also matches <code>Engineering</code>. Applies to search results before a job is saved: filtered-out jobs are not charged, and the search reads more pages until <b>Max jobs per search</b> matching jobs are found.

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

Skip jobs whose title contains any of these words or phrases, e.g. <code>senior</code>, <code>intern</code>, <code>manager</code>. Case-insensitive. Filtered-out jobs are not saved and not charged.

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

LinkedIn applies this filter only where its search still supports it; results may ignore it.

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

LinkedIn applies this filter only where its search still supports it; results may ignore it.

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

On-site, remote or hybrid. LinkedIn applies this filter only where its search still supports it.

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

Only jobs with LinkedIn's Easy Apply.

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

Only jobs with fewer than 10 applicants so far.

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

LinkedIn's relevance order or newest first.

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

Optional numeric geoId from a LinkedIn search URL for a precise location; overrides the location text.

## `distance` (type: `integer`):

Search radius around the location, in miles.

## `maxConcurrency` (type: `integer`):

Searches run in parallel (default 5). Pages of one search are always read in order.

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

Residential proxies are included in the price per job. Leave the default unless you want your own proxy servers.

## Actor input object example

```json
{
  "keywords": "marketing manager",
  "location": "United States",
  "datePosted": "pastWeek",
  "maxJobs": 100,
  "scrapeDetails": true,
  "experienceLevel": [],
  "jobType": [],
  "workplaceType": [],
  "easyApply": false,
  "under10Applicants": false,
  "sortBy": "relevance",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped jobs as JSON. Append ?format=csv for CSV.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": "marketing manager",
    "location": "United States",
    "datePosted": "pastWeek",
    "maxJobs": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": "marketing manager",
    "location": "United States",
    "datePosted": "pastWeek",
    "maxJobs": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": "marketing manager",
  "location": "United States",
  "datePosted": "pastWeek",
  "maxJobs": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call alfalfa/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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