# LinkedIn Jobs Scraper (`crawlix/linkedin-jobs-scraper`) Actor

LinkedIn Jobs Scraper searches and extracts job postings by keywords, location, and company filter. Scrape job title, company, location, salary, employment type, seniority, applicants, description, and direct apply link into clean Excel, CSV, or JSON.

- **URL**: https://apify.com/crawlix/linkedin-jobs-scraper.md
- **Developed by:** [Crawlix](https://apify.com/crawlix) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 94.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job scrapeds

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

The **LinkedIn Jobs Scraper** extracts verified public job postings and hiring opportunities directly from LinkedIn without requiring an account, login credentials, or cookies. Search by job keywords, roles, technologies, or skills across any global location, apply targeted filters for employers, posting dates, Easy Apply, or under 10 applicants, and collect complete job records with titles, companies, locations, compensation, and optional deep enrichment (full job descriptions, seniority levels, employment types, job functions, industries, and direct apply links).

Use it as an automated recruiting intelligence pipeline, a job board aggregator, a market salary tracker, or a lead generator for staffing agencies directly exporting into Excel, CSV, or JSON formats.

***

### Overview & Core Capabilities: LinkedIn Jobs Scraper

The **LinkedIn Jobs Scraper** is built for high-throughput, structured extraction of LinkedIn job listings. Instead of manually searching through pagination, copying job cards, and clicking into individual openings to view descriptions, this actor automates search execution, pagination up to the 1,000-job platform guest ceiling, and optional full-page detail enrichment in a single resilient run.

#### What This LinkedIn Jobs Scraper Extracts:

- **Core Search Tracking**: Search keyword query, search location, and targeted company name/ID.
- **Job Identifiers & Links**: Unique job ID, canonical LinkedIn job URN, direct LinkedIn job URL, and external direct apply URL.
- **Role & Employer Metadata**: Job title, hiring company name, numeric company ID, company profile URL, and office/workplace location.
- **Publication & Timing**: Exact publication ISO timestamp (`posted_date`) and relative posting time (`posted_time_ago`, e.g. "2 hours ago", "3 days ago").
- **Compensation & Badges**: Listed salary ranges, hourly rates, or benefit compensation tags, actively hiring badges, and Easy Apply flags.
- **Candidate Intelligence**: Number of applicants who have applied (`applicants_count`, e.g. "Under 10 applicants", "45 applicants").
- **Deep Role Attributes (with `scrape_job_details` enabled)**: Seniority level (Entry level, Mid-Senior level, Director, etc.), employment type (Full-time, Part-time, Contract, etc.), job functions, industry categories, clean plain-text description, and formatted description HTML.

Whether you execute the **LinkedIn Jobs Scraper** for one-off career research or integrate it into recurring enterprise talent ETL pipelines, every output row adheres to a clean, standardized schema with a custom overview table view ready for immediate analysis.

***

### Practical Use Cases & Applications

Talent acquisition teams, recruitment agencies, market researchers, and software engineers rely on the **LinkedIn Jobs Scraper** for critical data workflows:

1. **Job Board Aggregation & Career Portals**: Populate custom vertical job boards or niche career sites with real-time job listings filtered by role, skill, or location.
2. **Competitive Talent & Hiring Intelligence**: Track hiring patterns, team expansions, and in-demand tech stacks across rival companies in real time.
3. **Staffing Agency Lead Generation**: Identify companies that are actively hiring or listings with under 10 applicants to reach out to hiring managers before roles are filled.
4. **Labor Market & Compensation Research**: Analyze salary distributions, geographic hiring trends, remote work availability, and seniority distributions across industries.
5. **Job Search Automation & Candidate Alerts**: Set up scheduled scrapers to deliver freshly posted openings (past 24 hours or past week) directly into Slack, email, or a database.
6. **Skills & Tech Stack Trend Analysis**: Aggregate thousands of job descriptions to discover trending programming languages, frameworks, certifications, and required qualifications.

***

### Input Parameters & Configuration Reference

The **LinkedIn Jobs Scraper** accepts the following parameters:

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keywords` | Array of Strings | `["Python Developer"]` | Job titles, keywords, skills, or role queries to search for (e.g. `["Data Engineer", "DevOps Engineer"]`). |
| `location` | String | `"Worldwide"` | Name of a single city, state, country, or region (e.g. `"United States"`, `"London"`, `"Germany"`). Only 1 location is allowed per run. No need to provide both Location and Geo ID; entering either will work. If both are given, Geo ID takes priority. Must be valid, otherwise falls back to Worldwide. |
| `geo_id` | String | `""` | Optional single numeric LinkedIn Geo ID (e.g. `"103644278"` for United States, `"102257491"` for London). **Recommended for the highest success rate**. Only 1 Geo ID is allowed per run. When provided, it takes priority over Location name. If incorrect or yields no results, falls back to Location name. If both are invalid, defaults to Worldwide. |
| `companies` | Array of Strings | `[]` | Optional company names, handles, or URLs to restrict searches to specific employers (e.g. `["Google", "https://www.linkedin.com/company/apple"]`). When provided, only jobs from these companies will be collected. |
| `max_jobs` ($) | Integer | `50` | Maximum number of job postings to scrape per keyword (up to 1,000 max). Collecting jobs incurs a fee of $0.002 per job saved. |
| `jobs_date_posted` | Select | `"all"` | Filter jobs by publication timeframe: `"all"`, `"past_month"`, `"past_week"`, or `"past_24_hours"`. Free to use with no extra fee. |
| `jobs_under_10_applicants` | Boolean | `false` | When enabled, only returns job postings that currently have fewer than 10 applicants (`f_EA=true`). Note: Major companies (like Apple, Google, Microsoft) receive applicants very quickly; if you get 0 results when searching specific top employers, turn this filter off. Free to use with no extra fee. |
| `jobs_easy_apply` | Boolean | `false` | When enabled, only returns jobs that feature 1-click LinkedIn Easy Apply. **Important Tip**: Many companies (especially major tech firms and large corporations like Apple, Google, Microsoft, Amazon) do **not** support Easy Apply and require direct career site applications. If this filter is enabled for such companies, the search may return 0 results. It is safest to keep this filter turned off when targeting specific corporate employers. |
| `scrape_job_details` | Boolean | `true` | Enabled by default. Visits each job page to enrich records with full descriptions, seniority level, employment type, job functions, industries, and apply URLs. Free to use with no extra fee. |
| `proxyCountry` | Select | `"US"` | **Residential Proxy Country**. Select from the 158+ residential proxy country option list. Sets the regional exit country your run connects from using residential proxies. Pick the country closest to your target market. |
| `proxy_configuration` | Object | `{ "useApifyProxy": true }` | Proxy configuration options. Residential proxies are automatically managed. |

***

### Location Targeting Guide: Geo ID vs. Location Name

To target job postings in a specific geographic area, you can provide either a **Location Name** or a **Geo ID**:

#### 1. Single Input Rule

- **Only 1 location or 1 Geo ID is allowed per run**: You can only specify a single location or single Geo ID at a time. Multiple locations or multiple Geo IDs (such as lists or comma-separated names) are **not accepted**.

#### 2. No Need to Provide Both

- Providing either a **Location Name** OR a **Geo ID** will work seamlessly. You do **not** need to input both.

#### 3. Priority & Automatic Fallback Hierarchy

If you provide both, or if an input is invalid, the actor executes the following intelligent hierarchy:

1. **Geo ID Takes Priority**: When both `geo_id` and `location` are entered, the actor prioritizes the exact numeric Geo ID.
2. **Fallback to Location Name**: If the provided Geo ID is incorrect, invalid, or yields zero job results on LinkedIn, the scraper automatically falls back to searching using your Location name input instead.
3. **Safe Fallback to Worldwide**: You must provide a valid Geo ID or a correctly spelled Location name. If both the Geo ID and Location name are incorrect, unresolvable, or return no results, the scraper cleanly and safely defaults to searching **Worldwide**.

> \[!TIP]
>
> ### Pro-Tip: Use Geo ID for the Highest Success Rate & Accuracy
>
> Using the exact **Geo ID** directly gives the **best chance and highest success rate** compared to using a free-text location name. If you know the numeric Geo ID for your desired city, state, or country (e.g. `103644278` for United States, `102257491` for Greater London, `106779217` for Bangladesh, `101282230` for Germany), entering it directly in the **Geo ID** field ensures maximum pinpoint accuracy without geographic ambiguity.

***

### Pay-Per-Event (PPE) Pricing Model

The **LinkedIn Jobs Scraper** features a simple, transparent pricing structure: **you are only charged per job listing successfully scraped**. All filters (date posted, under 10 applicants, Easy Apply) and deep job detail enrichments are completely free and included at no extra cost.

| Event Name | Pricing | When Charged |
|---|---|---|
| `job` | **$0.002** per job | Charged only for each unique job posting successfully collected and saved to the dataset. All filters and job details are free! |

*Free Account Note*: Free Apify accounts can collect up to 50 items per run. Upgrade to an Apify paid plan for unlimited high-volume scraping.

***

### Example Input Configurations

#### 1. Keyword & Global Location Search

```json
{
  "keywords": ["React Developer", "Node.js Developer"],
  "location": "Worldwide",
  "max_jobs": 100,
  "jobs_date_posted": "past_week",
  "scrape_job_details": true
}
```

#### 2. Company-Specific Job Search with Early Bird (Under 10 Applicants) Filter

```json
{
  "keywords": ["Software Engineer"],
  "location": "United States",
  "companies": ["Apple", "Google", "Microsoft"],
  "max_jobs": 50,
  "jobs_under_10_applicants": true,
  "jobs_easy_apply": true,
  "scrape_job_details": true
}
```

***

### Extracted Dataset Schema & Field Definitions

With **Scrape Full Job Details** enabled by default, the actor visits each posting to extract available specifications and employer attributes.

#### 1. Fields That Most of the Time May Come in the Output

For the vast majority of LinkedIn job postings, these core fields are typically populated and may appear in your output records:

| Field Name | Type | Description |
|---|---|---|
| `title` | String | Official job title of the opening. |
| `company_name` | String | Name of the hiring company. |
| `location` | String | Job workplace location (city, state, region, or country). |
| `description` | String | Full clean plain-text job description with requirements and responsibilities. |
| `description_html` | String | Formatted HTML job description markup. |
| `seniority_level` | String | Career experience level (e.g. `"Mid-Senior level"`, `"Entry level"`, `"Not Applicable"`). |
| `employment_type` | String | Work classification (e.g. `"Full-time"`, `"Contract"`, `"Part-time"`). |
| `posted_date` | String | Publication date timestamp in ISO 8601 format (e.g. `"2026-10-20"`). |
| `posted_time_ago` | String | Relative publication time (e.g. `"2 days ago"`, `"1 week ago"`). |
| `job_id` | String | Unique numeric identifier of the job posting on LinkedIn. |
| `job_urn` | String | Canonical LinkedIn URN (e.g. `"urn:li:jobPosting:4431992044"`). |
| `job_url` | String | Permanent LinkedIn public job viewing URL. |
| `apply_url` | String | Application destination URL or LinkedIn job link. |
| `search_keyword` | String | Search keyword query that discovered this posting. |
| `search_location` | String | Search location filter applied during the run. |
| `scraped_at` | String | UTC timestamp when this job record was collected. |

#### 2. Fields Less Often Available (Present When Provided by the Listing or Employer)

Some fields appear less frequently or only when explicitly provided by the employer or when specific platform badges apply:

| Field Name | Type | Availability & Description |
|---|---|---|
| `industries` | Array of Strings | Industry classification of the employer (present when specified by the company). |
| `job_functions` | Array of Strings | Functional departments or role categories (present when tagged on LinkedIn). |
| `salary_or_benefits` | String | Compensation range or rate (present only when the employer chooses to disclose salary info, e.g. `"$120,000 - $150,000 / yr"`). |
| `company_logo_url` | String | Direct image link to the company's logo (present when the company has uploaded a logo). |
| `company_id` | String | Numeric LinkedIn organization ID (present when resolvable from company profile links). |
| `company_url` | String | Canonical LinkedIn company profile page link (present when the company maintains a public profile). |
| `applicants_count` | String | Total applicant count string (present when displayed on the listing, e.g. `"73 applicants"`, `"Over 200 applicants"`). |
| `workplace_type` | String | Workplace arrangement (`"Remote"`, `"Hybrid"`, or `"On-site"` when explicitly indicated). |
| `is_actively_hiring` | Boolean | True when flagged by the employer with the Actively Hiring badge. |
| `is_easy_apply` | Boolean | True when the posting supports LinkedIn's Easy Apply application feature. |
| `is_under_10_applicants` | Boolean | True when the role has fewer than 10 applicants or is flagged with "Be an early applicant". |
| `is_new_listing` | Boolean | True when flagged on LinkedIn as a newly published opening. |

***

### Example Output Record

A standard full output record with job details enabled:

```json
{
  "title": "Python Developer",
  "company_name": "CACI International Inc",
  "company_id": "3672",
  "company_url": "https://www.linkedin.com/company/caci-international-inc",
  "company_logo_url": "https://media.licdn.com/dms/image/v2/D4E0BAQFob5rET4oo0w/company-logo_100_100/...",
  "location": "Chantilly, VA",
  "workplace_type": "On-site",
  "posted_date": "2026-07-08",
  "posted_time_ago": "3 months ago",
  "salary_or_benefits": "$120,000.00 - $150,000.00",
  "is_actively_hiring": true,
  "is_easy_apply": false,
  "is_under_10_applicants": false,
  "is_new_listing": false,
  "seniority_level": "Not Applicable",
  "employment_type": "Full-time",
  "job_functions": ["Information Technology"],
  "industries": ["Defense and Space Manufacturing"],
  "applicants_count": "73 applicants",
  "description": "Job Title: Python Developer\nJob Category: Information Technology\n...",
  "description_html": "<div class=\"description__text description__text--rich\">...</div>",
  "apply_url": "https://www.linkedin.com/jobs/view/python-developer-at-caci-international-inc-4431992044",
  "job_id": "4431992044",
  "job_urn": "urn:li:jobPosting:4431992044",
  "job_url": "https://www.linkedin.com/jobs/view/4431992044",
  "search_keyword": "Python Developer",
  "search_location": "United States",
  "scraped_at": "2026-10-21T06:01:00.000Z"
}
```

***

### Tips for Best Results

1. **Specific Locations Yield Higher Variety**: Using specific country or metro names (e.g. `"United States"`, `"Germany"`, `"Austin, Texas"`) produces tighter, more relevant job clusters than broad queries.
2. **Platform 1,000 Job Ceiling**: LinkedIn's public guest search caps pagination at 1,000 jobs per individual search query. If you need more than 1,000 jobs in a domain, split your searches by multiple granular keywords or regional sub-locations.
3. **Under 10 Applicants for Fast Sourcing**: Turn on `jobs_under_10_applicants` to find newly opened roles where candidate competition is low.
4. **Detail Enrichment Speed**: When `scrape_job_details` is disabled, the scraper runs at high speed by extracting card metadata directly from search pages. Enable detail scraping when you specifically need full descriptions, seniority levels, and external direct apply links.

***

### Troubleshooting: Getting 0 Results?

If your run finishes with 0 jobs, it is almost always due to strict filter combinations or specific employer hiring practices. Follow this checklist to expand your results:

1. **Turn off "Under 10 Applicants"**:
   Established enterprises and global tech firms (like Apple, Google, Microsoft, Amazon) receive dozens of applications within minutes of posting. If you turn on `jobs_under_10_applicants` while targeting top companies, almost all of their active openings will be filtered out. Turn this off to see all open jobs.

2. **Turn off "Easy Apply"**:
   Major corporations generally do **not** use LinkedIn 1-click Easy Apply. Instead, they require applicants to apply on their official external career portals (e.g. `jobs.apple.com`). If you filter by a specific corporate employer and keep Easy Apply turned on, LinkedIn will return 0 matching jobs. Keep this filter turned off when targeting specific corporate employers.

3. **Try Location: "Worldwide"**:
   A specific company may not currently have openings for your exact keyword in a specific country (e.g. Apple might have 200 Python openings in the US, but 0 in Japan this month). Broadening the location to `"Worldwide"` lets you discover open positions across all countries.

4. **Broaden the "Date Posted" Timeframe**:
   If you have selected `past_24_hours` or `past_week`, try setting `jobs_date_posted` to `"all"` or `"past_month"` to capture listings published earlier.

5. **Direct LinkedIn Verification**:
   If you ever want to verify whether 0 results is expected, open **LinkedIn.com/jobs** in your browser and run the exact same query with the same filters (same keyword, company, location, and filters):
   - **If LinkedIn also returns 0 results**: There are genuinely no public job postings matching that combination on LinkedIn right now (the actor is functioning with 100% accuracy).
   - **If LinkedIn displays active listings**: Please let us know via the **Issues** tab and we will investigate and resolve it immediately!

***

### Support & Feedback

If you encounter an issue, have feature suggestions, or need assistance configuring custom workflows, please open an issue in the **Issues** tab of this actor. We monitor feedback actively and release regular updates.

# Actor input Schema

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

Job titles, skills, or search keywords to find open job postings (e.g., 'Python Developer', 'Data Scientist', 'DevOps'). Each term will be searched independently.

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

Enter a single city, state, country, or region name (e.g., 'United States', 'London', 'Germany', or 'Worldwide'). No need to enter both Location and Geo ID; entering either will work. Only 1 location input is allowed per run (multiple locations are not accepted). If both Location and Geo ID are provided, Geo ID gets priority. You must enter the location name correctly, otherwise it will fallback to Worldwide if incorrect or not found. Pro-Tip: Using the exact numeric Geo ID directly in the Geo ID field provides the highest success rate and best targeting accuracy.

## `geo_id` (type: `string`):

Recommended for Highest Success Rate: Enter a single numeric LinkedIn Geo ID (e.g., '103644278' for United States, '102257491' for London, '106779217' for Bangladesh). Using the exact Geo ID gives the best chance and highest success rate compared to location text. Only 1 Geo ID input is allowed per run (multiple Geo IDs are not accepted). No need to enter both Location and Geo ID; giving either will work. If both are provided, Geo ID gets priority. If the Geo ID is incorrect or returns no results, the scraper automatically searches using your Location name instead. If both are incorrect, it safely falls back to Worldwide.

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

Optional LinkedIn company names, slugs, or profile URLs (e.g., 'Google', 'apple', 'https://www.linkedin.com/company/microsoft'). When provided, only jobs from these companies will be collected.

## `max_jobs` (type: `integer`):

Maximum number of job postings to collect for each keyword (or keyword + company combination). For example, if you provide 2 keywords and set this to 50, the scraper will collect up to 50 jobs for each keyword (up to 100 jobs total). Maximum 1,000 per keyword, as LinkedIn delivers up to 1,000 public listings. Collecting job listings adds a small charge per job scraped, shown on the pricing tab.

## `jobs_date_posted` (type: `string`):

Filter job postings by publication date: All time, Past month, Past week, or Past 24 hours.

## `jobs_under_10_applicants` (type: `boolean`):

When turned on, only returns job listings that currently have fewer than 10 applicants. Important Tip: Well-known companies and tech giants (like Apple, Google, Microsoft) receive dozens of applicants very quickly. If you get 0 results when searching specific top employers, turn this filter off.

## `jobs_easy_apply` (type: `boolean`):

When turned on, only returns job postings that support LinkedIn's 1-click Easy Apply. Important Tip: Many companies (especially major tech firms and large corporations like Apple, Google, Microsoft, Amazon) do NOT use LinkedIn Easy Apply and require applicants to apply directly on their own career websites. If this filter is turned on when searching specific companies, it may return 0 results. It is safest to keep this filter turned off when targeting specific corporate employers.

## `scrape_job_details` (type: `boolean`):

When turned on (enabled by default), visits each individual job link to scrape full descriptions, seniority level, employment type, job functions, industries, applicant count, and direct apply link.

## `proxyCountry` (type: `string`):

Select from the residential proxy country option list. The country your run connects from using residential proxies. Pick the one closest to your target market. If a country is not available right now, the run connects from the United States instead and the log says so.

## Actor input object example

```json
{
  "keywords": [
    "Python Developer"
  ],
  "location": "Worldwide",
  "geo_id": "",
  "companies": [],
  "max_jobs": 50,
  "jobs_date_posted": "all",
  "jobs_under_10_applicants": false,
  "jobs_easy_apply": false,
  "scrape_job_details": true,
  "proxyCountry": "US"
}
```

# Actor output Schema

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

Every job row this run delivered. Use the Export button on the Output tab for CSV, Excel, JSON or XML.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "Python Developer"
    ],
    "location": "Worldwide",
    "geo_id": "",
    "companies": [],
    "max_jobs": 50,
    "jobs_date_posted": "all",
    "jobs_under_10_applicants": false,
    "jobs_easy_apply": false,
    "scrape_job_details": true,
    "proxyCountry": "US"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["Python Developer"],
    "location": "Worldwide",
    "geo_id": "",
    "companies": [],
    "max_jobs": 50,
    "jobs_date_posted": "all",
    "jobs_under_10_applicants": False,
    "jobs_easy_apply": False,
    "scrape_job_details": True,
    "proxyCountry": "US",
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "Python Developer"
  ],
  "location": "Worldwide",
  "geo_id": "",
  "companies": [],
  "max_jobs": 50,
  "jobs_date_posted": "all",
  "jobs_under_10_applicants": false,
  "jobs_easy_apply": false,
  "scrape_job_details": true,
  "proxyCountry": "US"
}' |
apify call crawlix/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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