# LinkedIn Jobs Search Scraper (`knowten/linkedin-jobs-search-scraper`) Actor

Search LinkedIn jobs and extract the full posting: description, criteria, applicants, hiring contact, salary and company firmographics. No browser, no login.

- **URL**: https://apify.com/knowten/linkedin-jobs-search-scraper.md
- **Developed by:** [Knowten](https://apify.com/knowten) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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

## LinkedIn Jobs Search Scraper

**The fastest, most cost-effective way to extract rich job listings, recruiter contact details, salary ranges, and company firmographics from LinkedIn.**

No LinkedIn account required. No login credentials. No cookie management. Just enter your search keywords and location, and get clean, structured data delivered in seconds.

***

### Why Choose This LinkedIn Jobs Scraper?

| Feature | What It Means for You |
|---|---|
| ⚡ **Blazing Fast Throughput** | Pipelined search and data enrichment running in parallel for instant data delivery. |
| 💰 **Slashes Cloud Compute Costs** | Runs effortlessly on just **128 MB – 256 MB** of memory, saving you up to **80% on Apify compute units** compared to heavy, bloated scrapers. |
| 🔒 **100% Ban-Proof & Safe** | Never requires logging in with your personal or corporate LinkedIn account. Zero risk of account restriction or session expiration. |
| 🎯 **Deep Enrichment (43+ Fields)** | Go beyond basic titles: extract full descriptions (HTML & Markdown), recruiter contacts, salary breakdowns, and complete company firmographics. |
| 🧠 **Smart Location Mapping** | Type any city, region, or country in plain text—the Actor automatically resolves it to LinkedIn's official geographic identifier (`geoId`). |
| 🔄 **Multi-Pass Discovery** | Overcomes LinkedIn's public result rotation with smart deduplication, unlocking significantly more unique postings per query than basic scrapers. |

***

### High-Impact Use Cases

- 🎯 **B2B Lead Generation & Sales Prospecting**: Identify fast-growing companies that are actively hiring, along with the names, headlines, and profile links of the hiring recruiters.
- 👥 **Recruitment & Talent Acquisition**: Monitor real-time talent demand, competitor hiring surges, and open job roles across industries and regions.
- 💼 **Job Boards & Career Portals**: Automatically populate and synchronize your niche job board with clean descriptions, direct application URLs, and employer logos.
- 📊 **Labor Market & Compensation Research**: Analyze real-time salary distributions, emerging job titles, and remote vs. on-site employment dynamics.
- 🤖 **AI Agents & Workforce Intelligence**: Feed continuous, structured labor market data into AI models, RAG systems, and market research agents.

***

### Extracted Data Fields (43+ Attributes)

Every record is strictly structured and validated, ready for instant export to CSV, Excel, JSON, or downstream databases:

#### 1. Core Job Information

- `jobId`: Unique LinkedIn job identifier.
- `title`: Standardized job title.
- `jobUrl`: Direct, permanent URL to the job listing.
- `location`: Geographic location displayed on the posting.
- `postedAt`: ISO formatted posting date (`YYYY-MM-DD`).
- `postedText`: Human-readable posting timeframe (e.g., `"2 days ago"`).
- `benefits`: Key highlighted perks or hiring status (e.g., `"Actively Hiring"`).

#### 2. Job Details & Classification

- `seniorityLevel`: Seniority required (`Entry level`, `Mid-Senior level`, `Director`, `Executive`, etc.).
- `employmentType`: Contract type (`Full-time`, `Part-time`, `Contract`, `Internship`, etc.).
- `jobFunction`: Primary department or role function.
- `industries`: Associated industry verticals.
- `applicantsCount`: Current number of applicants.
- `applicantsText`: Text representation of applicant interest (e.g., `"Over 200 applicants"`).
- `descriptionText`: Clean, human-readable plain text job description.
- `descriptionHtml`: Full raw HTML description preserving formatting and bullet points.
- `descriptionLength`: Character count of the description.

#### 3. Salary & Compensation Insights

*Parsed automatically from job descriptions:*

- `salaryMin`: Minimum base compensation (numeric).
- `salaryMax`: Maximum base compensation (numeric).
- `salaryCurrency`: Standard currency symbol or code (e.g., `USD`, `EUR`, `GBP`).
- `salaryPeriod`: Pay interval (`year`, `month`, `hour`).
- `salaryRaw`: Verbatim compensation text as written in the listing.

#### 4. Hiring Contact / Recruiter Details

*Captured when the hiring manager chooses to display their profile on the listing:*

- `recruiterName`: Full name of the recruiter or hiring manager.
- `recruiterHeadline`: Current professional headline/role of the recruiter.
- `recruiterProfileUrl`: Direct LinkedIn profile URL for seamless outreach.

#### 5. Company Profile & Firmographics (Optional Enrichment)

- `companyName`: Official employer name.
- `companyUrl`: Link to the company's LinkedIn profile.
- `companySlug`: LinkedIn company identifier handle.
- `companyLogo`: High-resolution company logo URL.
- `companyIndustry`: Primary operating sector.
- `companySize`: Staff bracket (e.g., `"51-200 employees"`).
- `companyEmployeeCount`: Estimated total workforce.
- `companyEmployeesOnLinkedIn`: Number of employees registered on LinkedIn.
- `companyHeadquarters`: City/Country of company headquarters.
- `companyWebsite`: Official corporate website.
- `companyFounded`: Year established.
- `companySpecialties`: Comma-separated list of corporate specialties.
- `companyFollowers`: Total follower count on LinkedIn.

***

### Sample Output

```json
{
  "jobId": "4462078258",
  "title": "Senior Cloud Solutions Architect",
  "jobUrl": "https://www.linkedin.com/jobs/view/senior-cloud-solutions-architect-4462078258",
  "companyName": "Acme Cloud Technologies",
  "companyUrl": "https://www.linkedin.com/company/acme-cloud",
  "companySlug": "acme-cloud",
  "companyLogo": "https://media.licdn.com/dms/image/company-logo.png",
  "location": "San Francisco, CA",
  "postedAt": "2026-09-12",
  "postedText": "4 days ago",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering, Information Technology",
  "industries": "Software Development, Cloud Computing",
  "applicantsCount": 47,
  "applicantsText": "47 applicants",
  "benefits": "Actively Hiring",
  "descriptionText": "We are seeking an experienced Cloud Solutions Architect to design scalable cloud infrastructure...",
  "descriptionLength": 2840,
  "salaryMin": 165000.0,
  "salaryMax": 195000.0,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryRaw": "$165,000/yr - $195,000/yr",
  "recruiterName": "Sarah Jenkins",
  "recruiterHeadline": "Senior Technical Recruiter at Acme Cloud",
  "recruiterProfileUrl": "https://www.linkedin.com/in/sarah-jenkins-tech",
  "companyIndustry": "Software Development",
  "companySize": "501-1,000 employees",
  "companyEmployeeCount": 780,
  "companyEmployeesOnLinkedIn": 620,
  "companyHeadquarters": "San Francisco, California",
  "companyWebsite": "https://www.acmecloudtech.example.com",
  "companyFounded": 2018,
  "companyFollowers": 45200,
  "searchKeywords": "Cloud Architect",
  "searchLocation": "San Francisco, CA",
  "scrapedAt": "2026-09-16T12:30:00.000Z"
}
```

***

### Quick Start Guide

You can launch a targeted scrape in three simple steps:

1. **Enter Keywords**: Type what you're looking for (e.g., `"Python Developer"`, `"Account Executive"`, `"Growth Marketing"`).
2. **Specify Location**: Enter any city, country, or region (e.g., `"Austin, TX"`, `"United Kingdom"`, or `"Germany"`).
3. **Run & Export**: Hit **Save & Start**. Your data will be ready to download in CSV, Excel, or JSON format, or accessible via the Apify API.

***

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| **`keywords`** | `string` | `"python developer"` | Job title, skills, or search terms as typed on LinkedIn. |
| **`location`** | `string` | `"Spain"` | City, region, or country. Automatically mapped to LinkedIn's internal geographic ID. |
| **`maxItems`** | `integer` | `100` | Target number of jobs to retrieve. Set as high as needed. |
| **`datePosted`** | `string` | `"any"` | Timeframe filter: `any`, `past24h` (last 24 hours), `pastWeek` (last 7 days), or `pastMonth` (last 30 days). |
| **`jobTypes`** | `array` | `[]` | Contract type filter: `fullTime`, `partTime`, `contract`, `temporary`, `internship`, `volunteer`. |
| **`experienceLevels`** | `array` | `[]` | Seniority filter: `internship`, `entryLevel`, `associate`, `midSenior`, `director`, `executive`. |
| **`sortBy`** | `string` | `"relevance"` | Order results by `"relevance"` or `"date"`. |
| **`scrapeJobDetails`** | `boolean` | `true` | When enabled, retrieves full descriptions, recruiter info, salary estimates, and applicant counts. |
| **`scrapeCompanyDetails`** | `boolean` | `false` | When enabled, enriches each employer with full company firmographics (HQ, size, website, followers). |
| **`concurrency`** | `integer` | `6` | Number of parallel scraping workers. Can be increased to 15–25 when using Apify Proxy for faster runs. |
| **`proxyConfiguration`** | `object` | `{ "useApifyProxy": true }` | Apify Proxy configuration. Standard datacenter proxies work smoothly out-of-the-box. |

***

### Pro Tips for Maximum Performance

#### 1. Daily Automated Job Alerts

Set `datePosted` to `"past24h"` and use Apify's built-in **Schedules** tab to run the Actor automatically every morning at 8:00 AM. Connect a webhook or integration to deliver new jobs directly to your Slack, CRM, or email inbox.

#### 2. Maximizing Market Coverage

LinkedIn's public search dynamically caps search results per single query. To build large-scale datasets (thousands of jobs), run targeted queries across specific cities or seniority levels rather than one generic nationwide search.

#### 3. Boosting Extraction Speed

If you are running large batches with Apify Proxy enabled, you can safely increase `concurrency` to **15–20** and reduce `requestDelayMs` to **100–150 ms**. The Actor's streaming architecture will deliver results significantly faster.

***

### Integrations & API Usage

Export your data directly into your workflows using Apify's pre-built integrations:

- **No-Code / Low-Code**: Connect instantly with **Make**, **Zapier**, **Google Sheets**, **Airtable**, or custom **Webhooks**.
- **Data Warehousing**: Export directly to **Snowflake**, **BigQuery**, or **AWS S3**.
- **Developer API**: Access datasets programmatically in Python, Node.js, or via cURL.

#### Python Example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "keywords": "Data Scientist",
    "location": "New York, NY",
    "maxItems": 100,
    "datePosted": "pastWeek",
    "scrapeJobDetails": True,
    "scrapeCompanyDetails": True
}

run = client.actor("YOUR_USERNAME/linkedin-jobs-search-scraper").call(run_input=run_input)

## Stream extracted jobs from dataset
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} at {item['companyName']} - Recruiter: {item.get('recruiterName')}")
```

#### Node.js / JavaScript Example

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

const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

const input = {
    keywords: "Full Stack Engineer",
    location: "London, United Kingdom",
    maxItems: 50,
    datePosted: "past24h",
    scrapeJobDetails: true
};

const run = await client.actor("YOUR_USERNAME/linkedin-jobs-search-scraper").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Successfully scraped ${items.length} jobs!`);
console.table(items, ['title', 'companyName', 'location', 'salaryRaw']);
```

***

### Frequently Asked Questions

##### Do I need to provide LinkedIn cookies or account credentials?

**No.** This Actor operates entirely on publicly accessible job postings. You never need to supply login credentials, session cookies, or personal accounts, eliminating any risk of account suspension.

##### Does it capture recruiter / hiring manager contact info?

**Yes.** When employers choose to display their hiring team on the job post, the Actor captures the recruiter's full name, headline, and direct LinkedIn profile URL.

##### How does salary extraction work?

LinkedIn does not provide structured salary fields on public job cards. This Actor incorporates an intelligent text parser that extracts minimum salary, maximum salary, currency, and pay period directly from the job description text.

##### What proxy configuration should I use?

The Actor is pre-configured to use **Apify Proxy** with datacenter proxies, which provides seamless reliability and performance. Residential proxies are supported but rarely necessary.

***

### Support & Custom Requirements

Need custom fields, integration assistance, or high-volume enterprise scraping? Feel free to reach out via the **Issues** tab on the Apify Actor page.

# Actor input Schema

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

What to search for, exactly as you would type it in LinkedIn's job search box.

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

City, region or country. Resolved to LinkedIn's internal geoId automatically.

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

How many job postings to return. Set as high as you like - the Actor stops on its own once a query is exhausted. In practice a single keywords+location combination yields roughly 100-350 unique jobs from LinkedIn's public search, regardless of this value; run several narrower queries (different cities, seniority levels, or weeks) to accumulate more.

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

Only return jobs posted within this window.

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

Contract type. Leave empty for all. LinkedIn ignores this filter server-side for anonymous requests, so it is enforced by the Actor itself after reading each job's detail page - this automatically turns "Scrape full job details" on if you had it off, and the search keeps going past "Max jobs" worth of raw postings until it actually finds that many matches, up to a cap of 20x "Max jobs" postings scanned - so a narrow type like Volunteer costs more requests than the job count implies, and may return fewer than "Max jobs" if that type is rare for your search.

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

Seniority filter. Leave empty for all.

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

Order search results by relevance or by posting date.

## `scrapeJobDetails` (type: `boolean`):

Fetch each posting's page for the full description, seniority, employment type, industries, applicant count, hiring contact and salary. Costs one extra request per job.

## `scrapeCompanyDetails` (type: `boolean`):

Also fetch each company's public page for industry, size, headquarters, website, type, specialties and follower count. One request per unique company (cached), so the cost is low.

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

Parallel HTTP requests. Measured safe defaults: 6-8 without proxy rotation, 15-25 with Apify Proxy enabled (a rotating proxy spreads LinkedIn's own per-IP rate limit across many exit IPs, so higher concurrency stays safe). The Actor barely uses CPU/RAM even at high values - raise this first if a run feels slow. Lower it only if you start getting blocked.

## `requestDelayMs` (type: `integer`):

Base delay applied before every request; random jitter is added on top. This is a direct throughput lever - it gates every single request, so it matters more than it looks. With Apify Proxy rotating IPs, try lowering it to 100-150ms for large runs.

## `impersonate` (type: `string`):

TLS/HTTP2 fingerprint presented to LinkedIn.

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

LinkedIn's public job endpoints tolerate datacenter IPs well. Switch to residential only if you see blocks.

## Actor input object example

```json
{
  "keywords": "data engineer",
  "location": "Madrid, Spain",
  "maxItems": 100,
  "datePosted": "any",
  "jobTypes": [],
  "experienceLevels": [],
  "sortBy": "relevance",
  "scrapeJobDetails": true,
  "scrapeCompanyDetails": false,
  "concurrency": 6,
  "requestDelayMs": 250,
  "impersonate": "chrome",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Extracted LinkedIn job postings including descriptions, applicants, salary, recruiter info, and company details.

# 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": "Spain"
};

// Run the Actor and wait for it to finish
const run = await client.actor("knowten/linkedin-jobs-search-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": "Spain",
}

# Run the Actor and wait for it to finish
run = client.actor("knowten/linkedin-jobs-search-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": "Spain"
}' |
apify call knowten/linkedin-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,knowten/linkedin-jobs-search-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/uy6jW9eXo8dPDaCxj/builds/u2ft7cA68NNMi819x/openapi.json