# LinkedIn Jobs Scraper — Public Listings, No Login (`fabrikit/linkedin-jobs-scraper`) Actor

Scrape public LinkedIn job listings without an account: search by keywords, location or geoId, date posted, job type, experience level and remote/hybrid. Title, company, location, posted date, URL and optional full description, seniority and applicants. From US$0.35 per 1,000 jobs.

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

## Pricing

from $0.35 / 1,000 job scrapeds

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 Scraper — Public Listings, No Login

LinkedIn Jobs Scraper extracts public job listings from linkedin.com **without a LinkedIn account, cookies or API key**. Search by keywords and location (or a LinkedIn `geoId`), filter by date posted, job type, experience level and remote / hybrid / on-site, and download clean JSON, CSV or Excel with the job title, company, location, listing date and URL. Turn on `includeDetails` to add the full description, seniority level, employment type, job function, industries and applicant count.

**Pricing: from US$0.35 per 1,000 jobs.** Job details are an optional add-on at US$0.50 per 1,000.

### What you get

**Every job (search data, event `job-result`):** `jobId`, public `url`, `title`, `company` with `companyUrl` and `companyLogo`, `location`, `listedAt` (ISO date) and `listedAgo`, `isNew`, card badges such as "Actively Hiring" (`benefits`), the salary text when the card shows one (`salary`, rare on public cards), the search that found the job (`searchKeywords`, `searchLocation`) and `scrapedAt`.

**With `includeDetails` (event `job-details`):** `description` as plain text, `seniorityLevel`, `employmentType`, `jobFunction`, `industries`, `applicantsCount` and `applicantsText` ("165 applicants" or "Be among the first 25 applicants"), `postedAgo` and `easyApply` (false when the application happens on the employer's site).

No personal data: the Actor never collects recruiter or poster names, and e-mail addresses, phone numbers, personal profile links and named contacts are removed from descriptions.

### How it works

The Actor reads the same lightweight HTML fragments that the public LinkedIn job search page loads for visitors who are not logged in (10 jobs per request), so it is fast and does not need a browser. LinkedIn serves at most about 1,000 results per keyword + location; for bigger crawls add more keywords, locations or a tighter `datePosted`, and the Actor de-duplicates by `jobId` across all searches.

Requests are paced about one per 1.5 seconds and rotate browser fingerprints, cookies and proxy IPs every few calls, which keeps LinkedIn's rate limits away: expect roughly 400 jobs per minute for search data and about 40 jobs per minute with `includeDetails`. When LinkedIn rate-limits an IP anyway (HTTP 429 or 999) the Actor backs off, retries with a new session and automatically switches to Apify **RESIDENTIAL** proxies for the rest of the run.

`applicantsCount` is 200 when LinkedIn shows "Over 200 applicants". LinkedIn's own filters are not strict: a `jobTypes: ["full-time"]` search can still include the odd volunteer or contract role, exactly as on the website.

### Input examples

Remote entry-level data jobs in the United States posted this week, with full descriptions:

```json
{
  "keywords": ["data analyst"],
  "locations": ["United States"],
  "datePosted": "pastWeek",
  "jobTypes": ["full-time"],
  "experienceLevels": ["entry-level", "associate"],
  "workplaceTypes": ["remote"],
  "includeDetails": true,
  "maxItems": 200
}
```

Several titles in several cities (each keyword is combined with each location), newest first, search data only:

```json
{
  "keywords": ["product manager", "product owner"],
  "locations": ["London", "Berlin", "Amsterdam"],
  "sortBy": "date",
  "maxItems": 1000
}
```

Using a LinkedIn `geoId` instead of a location name (103644278 = United States):

```json
{ "keywords": ["registered nurse"], "geoId": "103644278", "datePosted": "past24h", "maxItems": 100 }
```

### Input fields

| Field | Description |
|---|---|
| `keywords` | Job titles or skills, one search each |
| `locations` | Cities, regions or countries as typed on LinkedIn, one search each |
| `geoId` | Numeric LinkedIn geo ID from a LinkedIn jobs URL; applied to every search |
| `datePosted` | `any`, `past24h`, `pastWeek`, `pastMonth` |
| `jobTypes` | `full-time`, `part-time`, `contract`, `temporary`, `internship`, `volunteer`, `other` |
| `experienceLevels` | `internship`, `entry-level`, `associate`, `mid-senior`, `director`, `executive` |
| `workplaceTypes` | `on-site`, `remote`, `hybrid` |
| `sortBy` | `relevance` (default) or `date` |
| `includeDetails` | Add the description and detail fields (add-on price, one extra request per job) |
| `maxItems` | Exact number of unique jobs to return (default 50) |
| `proxyConfiguration` | Apify Proxy; the Actor moves to RESIDENTIAL automatically when LinkedIn blocks datacenter IPs |

### Output example

```json
{
  "jobId": "4457552683",
  "url": "https://www.linkedin.com/jobs/view/java-software-engineer-iii-payments-fx-services-at-jpmorganchase-4457552683",
  "title": "Java Software Engineer III - Payments FX Services",
  "company": "JPMorganChase",
  "companyUrl": "https://www.linkedin.com/company/jpmorganchase",
  "companyLogo": "https://media.licdn.com/dms/image/v2/D4E0BAQGxpntCyRgsuA/company-logo_100_100/...",
  "location": "Greater London, England, United Kingdom",
  "listedAt": "2026-10-03",
  "listedAgo": "2 weeks ago",
  "isNew": false,
  "salary": null,
  "benefits": ["Actively Hiring"],
  "searchKeywords": "software engineer",
  "searchLocation": "London",
  "scrapedAt": "2026-10-20T11:10:29.000Z",
  "description": "Job Description\n\nAre you ready to elevate your impact and shape the future of financial technology? ...",
  "seniorityLevel": "Not Applicable",
  "employmentType": "Full-time",
  "jobFunction": null,
  "industries": "Financial Services",
  "applicantsCount": 165,
  "applicantsText": "165 applicants",
  "postedAgo": "2 weeks ago",
  "easyApply": false
}
```

Without `includeDetails` the record stops at `scrapedAt`.

### Pricing

| Event | Price | Example |
|---|---|---|
| Job scraped (`job-result`) | US$0.35 per 1,000 | 1,000 jobs = US$0.35; 10,000 jobs = US$3.50 |
| Job details (`job-details`, only with `includeDetails`) | US$0.50 per 1,000 | 1,000 jobs with descriptions = US$0.85 in total |

Platform compute and proxy usage are included in these prices. `maxItems` is exact and duplicates are never charged.

### How it compares

Most LinkedIn job scrapers on the Store charge US$1.50-2.00 per 1,000 jobs and bundle the description into every record. This Actor splits the two so you only pay for the detail page when you need it, and it is roughly 60-80 % cheaper for list-level monitoring. It only covers what LinkedIn shows to visitors without an account: no "people" data, no recruiter profiles, no salary insights that require login, and at most ~1,000 results per search (split your searches to go beyond).

### Integrations

Run it on a schedule and send new jobs to Google Sheets, Airtable, Slack, a webhook or your database with Apify integrations, or call it from n8n, Make and Zapier. Every run is available through the Apify API (`/v2/acts/.../runs` and the dataset endpoints) and through the Apify MCP server, so AI agents can search LinkedIn jobs as a tool.

### FAQ

**Is this legal?** The Actor collects job advertisements that LinkedIn shows publicly to anyone without an account, and stores no personal data. You are responsible for using the data in line with LinkedIn's terms and the laws that apply to you (GDPR and similar). It is not affiliated with or endorsed by LinkedIn.

**Do I need a proxy?** On the Apify platform, yes: LinkedIn rate-limits datacenter IPs. Leave `proxyConfiguration` on Apify Proxy; the Actor starts there and switches to RESIDENTIAL automatically when blocked. The run summary (`SUMMARY` in the key-value store) tells you which rung was used.

**Why do I get fewer jobs than LinkedIn shows?** LinkedIn's public search stops after about 1,000 results per query and some cards repeat between pages. Split the search by location, date or job type.

**Why is `salary` empty?** LinkedIn rarely shows pay on public cards. The field is filled whenever the card has one.

**Why are some descriptions missing?** A job can be removed between the search and the detail request (404), or LinkedIn can rate-limit detail requests; the Actor logs each case in `SUMMARY.errors` and keeps the search data.

**Does it return recruiter names, e-mails or phone numbers?** No. Company data only; contact details of people found in descriptions are redacted.

### Use cases

Job-market research and salary/demand dashboards, lead generation (companies actively hiring for a skill or in a region), tracking competitors' hiring, feeding job boards and newsletters, alerting candidates to new remote roles, and training data for job-classification models.

### Related Actors

Built on the same job-scraping engine as our [Reed Jobs Scraper](https://apify.com/fabrikit/reed-jobs-scraper) (UK) and [Seek Jobs Scraper](https://apify.com/fabrikit/seek-jobs-scraper) (Australia and New Zealand): same flat output style, exact `maxItems`, de-duplication and personal-data redaction.

### Changelog

- **0.1** (October 2026) — First release: keyword + location / geoId search, date, job type, experience and workplace filters, exact `maxItems`, de-duplication, optional job details, header and proxy ladder with automatic RESIDENTIAL fallback, personal-data redaction.

***

### En español

Scraper de **ofertas de empleo públicas de LinkedIn** sin cuenta ni login: busca por palabra clave y ubicación (o `geoId`), filtra por fecha, tipo de empleo, nivel de experiencia y remoto/híbrido, y entrega título, empresa, ubicación, fecha y enlace; con `includeDetails` agrega la descripción completa, seniority, tipo de contrato, funciones, industrias y cantidad de postulantes. Desde **US$0,35 por 1.000** ofertas. No entrega nombres, correos ni teléfonos de reclutadores.

# Actor input Schema

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

Job titles or skills, one search per entry (for example: data analyst, product manager, 'react developer'). Each keyword is combined with each location.

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

Cities, regions or countries as you would type them on LinkedIn, one search per entry (for example: London, United States, Berlin, Germany). Leave empty when you use geoId.

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

Numeric LinkedIn geo ID taken from a LinkedIn jobs URL (geoId=...), for example 103644278 = United States, 101165590 = United Kingdom, 101282230 = Germany. More precise than a location name; applied to every search.

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

Only jobs posted in this period (LinkedIn filter f_TPR).

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

Only these job types (LinkedIn filter f_JT). Leave empty for all.

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

Only these experience levels (LinkedIn filter f_E). Leave empty for all.

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

On-site, remote and/or hybrid (LinkedIn filter f_WT). Leave empty for all.

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

Order of the results: LinkedIn relevance (default) or most recent first.

## `includeDetails` (type: `boolean`):

Fetch each job's detail page to add the full description (plain text), seniority level, employment type, job function, industries, applicant count and the Easy Apply flag. One extra request per job, charged as the 'job-details' event. Turn off for the fastest, cheapest run.

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

Stop after this many unique jobs across all searches. LinkedIn serves at most about 1,000 results per keyword + location; add more keywords or locations for bigger crawls.

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

Apify Proxy settings. LinkedIn rate-limits datacenter IPs (HTTP 429/999); the Actor retries with new sessions and switches to Apify RESIDENTIAL proxies automatically when needed. Selecting the RESIDENTIAL group here starts there directly.

## Actor input object example

```json
{
  "keywords": [
    "data analyst"
  ],
  "locations": [
    "United States"
  ],
  "datePosted": "any",
  "sortBy": "relevance",
  "includeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs collected during the run (one record per job, details merged in when includeDetails is on)

# 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": [
        "data analyst"
    ],
    "locations": [
        "United States"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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": ["data analyst"],
    "locations": ["United States"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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": [
    "data analyst"
  ],
  "locations": [
    "United States"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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