# LinkedIn Jobs Scraper: No Login, Company & Funding Data (`santamaria-automations/linkedin-scraper`) Actor

Scrape public LinkedIn job listings without login: title, company, location, posted date, seniority, job type, applicants, description and apply link. Filter by location, remote, experience and date. Optional company profiles with funding.

- **URL**: https://apify.com/santamaria-automations/linkedin-scraper.md
- **Developed by:** [NanoScrape](https://apify.com/santamaria-automations) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 465 total users, 19 monthly users, 72.7% runs succeeded, 5 bookmarks
- **User rating**: 4.31 out of 5 stars

## Pricing

from $1.00 / 1,000 job-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 Scraper

Scrape public job postings from [LinkedIn](https://www.linkedin.com/jobs/) without a login: keyword searches, pasted search URLs, company job pages, or a list of job URLs. Every listing comes back as structured JSON with title, company, location, normalized salary and posted date.

- **Full details by default**: description, seniority, industry, applicant count and hiring manager on every job. Set `includeJobDetails: false` for fast SERP-only mode, measured at 1.1 to 1.6 jobs per second at 128 MB (table further down).
- **Company URL scraping**: paste a `linkedin.com/company/.../jobs` URL in `startUrls` to pull one employer's open roles.
- **Per-day age filter**: `postedWithinDays` accepts any number of days, not just 1, 7 or 30.
- **Company data**: funding rounds, last round, Crunchbase URL, featured employees and latest company updates (with `includeCompanyDetails`).

**Quick start.** Pass this input (an empty `{}` input also works and runs this same search with 15 results and full details):

```json
{ "searchQueries": ["Software Engineer"], "location": "Berlin", "maxResults": 10 }
```

```json
{
  "id": "4371481846",
  "title": "Senior Software Engineer, Checkout",
  "company": "GetYourGuide",
  "location": "Zurich, Zurich, Switzerland",
  "country": "CH",
  "employment_type": "full-time",
  "easy_apply": false,
  "apply_url": "https://www.linkedin.com/jobs/view/4371481846",
  "posted_at": "2026-03-09"
}
```

**Price:** $0.001 per result, so Apify's $5 free monthly credit covers 5,000 job listings.

Pairs naturally with our **Indeed**, **Jobrapido**, **StepStone**, **Jobs.ch**, **Karriere.at**, and **Pracuj.pl** scrapers for full multi-source coverage.

### What you get

- **Global coverage** across every LinkedIn region, with auto-detected ISO country codes for 40+ countries.
- **Four modes**: keyword search, SERP-only bulk mode, paste a LinkedIn search URL, or re-check a list of specific job URLs.
- **City-level expansion** when a whole country is specified, so you can bypass LinkedIn's ~990-result-per-query ceiling and pull thousands of results in one run.
- **Structured salary**: `salary_min`, `salary_max`, `salary_currency`, `salary_period` parsed from raw text.
- **Multi-query search** with automatic cross-query deduplication and per-query limits.
- **Rich job data**: title, company, location, description, seniority, industry, job function, applicant count, company logo.
- **Hiring manager**: poster name, title, and LinkedIn profile URL from detail pages.
- **Company enrichment**: type, founded year, headquarters, follower count, specialties, employee count, website, description, funding data, featured employees, and latest updates. Fetched once per unique company and applied to every job from that employer.
- **Funding intelligence**: total rounds, last round type, date, amount, and Crunchbase URL, straight from the company profile.
- **Featured employees**: name and LinkedIn URL of the visible (non-blurred) employee cards on the company page. Useful for finding key contacts per company.
- **Company updates**: up to 5 recent posts from the company's LinkedIn feed.
- **Status detection**: `online`, `expired`, or `offline` in direct-URL mode.
- **Swiss canton detection**: automatic ZH / BE / GE mapping for CH jobs.
- **Posted date normalized to ISO-8601.**
- **Advanced filters**: date posted (per-day precision via postedWithinDays), job type, experience level, remote/hybrid/on-site, Easy Apply, Early Applicant (fewer than 10 applications).

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client, including Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, and custom agents.

**Apify MCP server URL:**

```
https://mcp.apify.com?tools=santamaria-automations/linkedin-scraper
```

**Example prompt once connected:**

> "Use `linkedin-scraper` to scrape job listings from LinkedIn. Return results as a table."

Clients that support dynamic tool discovery (Claude.ai, VS Code) will receive the full input schema automatically via `add-actor`.

### Use cases

- **Recruitment and sourcing.** Monitor open roles by keyword and geography, and build candidate pipelines from employer hiring signals.
- **Job aggregators and vertical search.** Ingest normalized LinkedIn listings into your own job board, ATS, or talent marketplace.
- **Competitor hiring intelligence.** Track which companies are hiring for which roles, at which seniority levels, in which locations, week over week.
- **Labour-market research.** Quantify hiring velocity by industry, role, and region. Build reports on remote-work adoption or senior-level demand.
- **Salary benchmarking.** Capture salary text when publicly displayed and benchmark by role, seniority, and location.
- **Still-alive monitoring.** Re-check previously scraped jobs in direct-URL mode to flag expired postings in your own database.

### Example output

```json
{
  "id": "4371481846",
  "title": "Senior Software Engineer, Checkout",
  "company": "GetYourGuide",
  "location": "Zurich, Zurich, Switzerland",
  "canton": "ZH",
  "country": "CH",
  "job_status": "online",
  "top_listing": false,
  "actively_hiring": true,
  "easy_apply": false,
  "employment_type": "full-time",
  "seniority_level": "Mid-Senior level",
  "remote_option": "hybrid",
  "salary_text": "$120,000 - $160,000/yr",
  "salary_min": 120000,
  "salary_max": 160000,
  "salary_currency": "USD",
  "salary_period": "year",
  "company_industry": "Technology, Information and Internet",
  "company_employee_count": "501-1000 employees",
  "company_website": "https://www.getyourguide.com",
  "company_type": "Privately Held",
  "company_founded": "2009",
  "company_headquarters": "Berlin, Germany",
  "company_follower_count": "48321",
  "company_specialties": ["Travel", "Tours", "Activities", "Experiences"],
  "company_jobs_url": "https://www.linkedin.com/company/getyourguide-ag/jobs",
  "company_funding_rounds": "8",
  "company_last_funding_type": "Series E",
  "company_last_funding_date": "2019-07-19",
  "company_last_funding_amount": "484,000,000 $",
  "company_crunchbase_url": "https://www.crunchbase.com/organization/getyourguide",
  "company_featured_employees": [
    { "name": "Tao Tao", "url": "https://www.linkedin.com/in/taotao" },
    { "name": "Johannes Reck", "url": "https://www.linkedin.com/in/johannesreck" }
  ],
  "company_latest_updates": [
    { "url": "https://www.linkedin.com/posts/getyourguide_...", "text": "Exciting news from our team..." }
  ],
  "job_function": "Engineering and Information Technology",
  "applicants": "<25",
  "description_snippet": "Get ready for an exciting career with GetYourGuide...",
  "description_full": "Full job description with all details...",
  "posted_at": "2026-03-05T00:00:00.000Z",
  "source_url": "https://www.linkedin.com/jobs/view/4371481846",
  "source_platform": "linkedin",
  "search_query": "Software Engineer",
  "company_url": "https://de.linkedin.com/company/getyourguide-ag",
  "company_logo_url": "https://media.licdn.com/dms/image/company-logo/...",
  "apply_url": "https://www.linkedin.com/jobs/view/4371481846",
  "scraped_at": "2026-03-09T08:30:00.000Z"
}
```

### Speed and cost by mode

Numbers below come from real runs on 2026-07-28 at the default 128 MB memory. Your mileage will vary a bit with network conditions and LinkedIn's rate limits, but the ratios between modes are stable.

| Mode | Config | Items | Runtime | Throughput | Cost (at $0.001/result) |
|------|--------|-------|---------|------------|-------------------------|
| SERP only (fast bulk) | `includeJobDetails: false` | 10 | 9 s | ~1.1 jobs/s | $0.011 |
| SERP only (fast bulk) | `includeJobDetails: false` | 50 | ~30 s | ~1.6 jobs/s | $0.051 |
| Full detail search | default | 25 | 43 s | ~0.58 jobs/s | $0.026 |
| Start-URL (search) | default | 25 | 46 s | ~0.54 jobs/s | $0.026 |
| Start-URL (company jobs page) | `includeCompanyDetails: true` | 15 | 43 s | ~0.35 jobs/s | $0.016 |
| Direct-URL check | 3 URLs, enrichment on | 3 | 7 s | ~0.43 jobs/s | $0.004 |
| Large search + full enrichment | 100 results, everything on | 100 | 7 min | ~0.24 jobs/s | $0.101 |

**Reading the table:**

- **SERP-only mode** is roughly 3-5x faster than the default because it skips the per-job detail fetch. Use it for market scans where title + company + location + logo is enough.
- **Full-detail mode** adds one HTTP request per job to pull the full description, employment type, applicant count, and hiring-manager fields.
- **Company enrichment** adds one HTTP request per *unique* company with a 1 s courtesy delay. A 100-job run from 80 distinct employers adds roughly 80 s of runtime.
- **Direct-URL mode** is the cheapest way to re-check existing job IDs, because it skips search entirely.

### How to use

Pick one of four modes, configure filters, run.

#### Mode 1: Fast keyword search (`includeJobDetails: false`)

Returns title, company, location, logo, posted date, and normalized salary for every listing at roughly 1-2 jobs per second. Set `includeJobDetails: false` (and leave `includeCompanyDetails` off) to run in this mode.

```json
{
  "searchQueries": ["Software Engineer", "Data Scientist"],
  "location": "Switzerland",
  "postedWithinDays": 7,
  "maxResultsPerQuery": 100
}
```

Specifying a whole country (`"location": "Germany"` or `"country": "DE"`) automatically expands to major cities like Berlin, Munich, Hamburg, Frankfurt, and more. This bypasses LinkedIn's ~990-result-per-query ceiling and pulls thousands of results in one run.

#### Mode 2: Full-detail search (opt in for richer data)

This is the default (`includeJobDetails: true`): every job's detail page is fetched too. Adds the full description, employment type, seniority, industry, job function, applicant count, company info, and hiring manager. Roughly 2-4x slower than Mode 1.

```json
{
  "searchQueries": ["Data Scientist"],
  "location": "Germany",
  "includeJobDetails": true,
  "maxResultsPerQuery": 100
}
```

Add `"includeCompanyDetails": true` alongside `includeJobDetails` to also fetch each employer's company page: founded year, headquarters, follower count, specialties, funding rounds, featured employees, and latest company updates. One extra HTTP request per unique company.

#### Mode 3: Start URLs (paste your own search URL)

Paste any LinkedIn job search URL directly from your browser. The actor paginates from it and extracts all matching jobs.

```json
{
  "startUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=DevOps+Engineer&location=Netherlands&f_WT=2"
  ],
  "maxResultsPerQuery": 200
}
```

You can also paste a company jobs page:

```json
{
  "startUrls": [
    "https://www.linkedin.com/company/getyourguide-ag/jobs/"
  ],
  "maxResultsPerQuery": 100
}
```

#### Mode 4: Direct URLs (still-alive monitoring)

Pass a list of LinkedIn job URLs. The actor fetches each one and returns the full job data plus a `job_status` of `online`, `offline`, `expired`, or `unknown`. Perfect for verifying that jobs in your own database are still live.

```json
{
  "directUrls": [
    "https://www.linkedin.com/jobs/view/3812345678",
    "https://www.linkedin.com/jobs/view/3823456789"
  ]
}
```

#### Input parameters

| Parameter | Description | Example |
|-----------|-------------|---------|
| `startUrls` | LinkedIn search URLs pasted from your browser (actor paginates each) | `["https://www.linkedin.com/jobs/search/?keywords=..."]` |
| `searchQueries` | Keywords to search (deduplicated across queries) | `["Software Engineer", "Data Engineer"]` |
| `searchQuery` | Single keyword (legacy, backward compatible) | `"Data Scientist"` |
| `location` | City, region, or country | `"Zurich"`, `"Switzerland"`, `"San Francisco Bay Area"` |
| `country` | Alternative to `location`, country name or code | `"DE"`, `"Germany"` |
| `postedWithinDays` | Only return jobs posted within the last N days. Uses f_TPR with per-day precision (any integer). Set 0 for no filter. | `1`, `7`, `30` |
| `datePosted` | Legacy date filter: `any`, `past-24h`, `past-week`, `past-month`. Prefer `postedWithinDays` for programmatic use. | `"past-week"` |
| `sortBy` | `newest` or `relevance`. NOTE: LinkedIn currently has no sort URL param (removed in 2026 redesign). This input is accepted for fleet-standard compatibility but has no effect on results order. Will be wired when LinkedIn restores the filter. | `"newest"` |
| `jobType` | `full-time`, `part-time`, `contract`, `temporary`, `internship` | `"full-time"` |
| `experienceLevel` | `entry`, `associate`, `mid-senior`, `director`, `executive` | `"mid-senior"` |
| `remoteFilter` | `remote`, `on-site`, `hybrid` | `"remote"` |
| `easyApplyOnly` | Only return jobs with LinkedIn Easy Apply (f_AL=true). One-click apply without leaving LinkedIn. | `true` |
| `earlyApplicantOnly` | Only return jobs with fewer than 10 applications (LinkedIn's Early Applicant filter, f_EA=true). Useful for standing out by applying early. | `true` |
| `maxResultsPerQuery` | Max results per keyword | `100` |
| `maxResults` | Global cap (0 = unlimited) | `500` |
| `titleFilter` | Comma-separated title terms (case-insensitive substring OR-match). Applied after SERP, before detail fetch. Non-matching jobs are skipped entirely (no billing). Empty disables the filter. | `"senior, staff, principal"` |
| `includeJobDetails` | Fetch full descriptions and structured data from job detail pages | `true` |
| `includeCompanyDetails` | Fetch company profile once per unique employer for type, founded year, headquarters, followers, specialties, funding, featured employees, and latest updates. Requires `includeJobDetails`. | `true` |
| `directUrls` | List of LinkedIn job URLs (skips search) | `["https://..."]` |
| `easyApply` | Legacy field name for Easy Apply filter. Use `easyApplyOnly` for new integrations. | `true` |

If none of `searchQueries`, `startUrls` or `directUrls` is set, the actor runs a default search ("Software Engineer" in Berlin, 15 results, full details).

### Output fields

**Always present**: `id`, `title`, `company`, `location`, `country`, `canton` (CH only), `job_status`, `detail_status` (`ok` / `failed` / null), `top_listing`, `actively_hiring`, `easy_apply`, `posted_at`, `source_url`, `source_platform`, `search_query`, `apply_url`, `company_url`, `company_logo_url`, `scraped_at`.

**Salary** (when publicly shown by the employer): `salary_text` (raw), `salary_min`, `salary_max`, `salary_currency` (ISO 4217), `salary_period` (`year` / `month` / `hour`).

**With `includeJobDetails: true` or direct URLs**: `description_snippet`, `description_full`, `description_html` (raw HTML), `employment_type`, `seniority_level`, `company_industry`, `job_function`, `applicants`, `remote_option`, `company_employee_count`, `company_website`, `company_description`, `job_poster_name`, `job_poster_title`, `job_poster_profile_url`, `job_poster_photo_url`.

**With `includeCompanyDetails: true`** (requires `includeJobDetails`): `company_type`, `company_founded`, `company_headquarters`, `company_follower_count`, `company_specialties`, `company_jobs_url`. Also improves fill rates for `company_industry`, `company_employee_count`, `company_website`, and `company_description`.

**Funding** (when publicly displayed by the company): `company_funding_rounds`, `company_last_funding_type`, `company_last_funding_date` (ISO-8601), `company_last_funding_amount`, `company_crunchbase_url`.

**People and activity**: `company_featured_employees` (array of `{name, url}` for the visible non-blurred employee cards on the company page), `company_latest_updates` (array of `{url, text}` for up to 5 recent company posts).

The `applicants` field is normalized:

| LinkedIn shows | Output |
|----------------|--------|
| "Be among the first 25 applicants" | `<25` |
| "95 applicants" | `95` |
| "Over 200 applicants" | `200+` |

### Pricing

Pay only for what you receive. No monthly fees, no minimum spend. New accounts get $5 free per month, which covers 5,000 results.

| Event | Price |
|-------|-------|
| Actor start | $0.001 |
| Per job result | $0.001 |

**Realistic examples**

- 1,000 search results: about $1.00
- 1,000 jobs with full descriptions: about $1.00
- Still-alive check of 500 URLs: about $0.50

Compare to commercial job-data feeds at EUR 1,000 to 5,000 per month.

### Usage

#### Apify Console

1. Go to the [actor page](https://apify.com/santamaria-automations/linkedin-scraper).
2. Fill in `searchQueries` and `location`.
3. Click **Start**. Download the dataset as JSON, CSV, or Excel.

#### API

```bash
curl -X POST "https://api.apify.com/v2/acts/santamaria-automations~linkedin-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["Software Engineer", "Data Scientist"],
    "location": "Switzerland",
    "maxResultsPerQuery": 100
  }'
```

#### Node.js SDK

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

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

const run = await client.actor('santamaria-automations/linkedin-scraper').call({
  searchQueries: ['Data Scientist', 'ML Engineer'],
  location: 'Zurich',
  postedWithinDays: 7,
  includeJobDetails: true,
  maxResultsPerQuery: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} jobs`);
```

#### Still-alive monitoring

```javascript
const run = await client.actor('santamaria-automations/linkedin-scraper').call({
  directUrls: [
    'https://www.linkedin.com/jobs/view/3812345678',
    'https://www.linkedin.com/jobs/view/3823456789',
  ],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(job => console.log(`${job.id}: ${job.job_status}`));
```

#### Precision title filter

Returns only senior-track listings whose title contains "senior", "staff", or "principal" (case-insensitive substring match). Non-matching SERP rows are dropped before the detail-fetch step, so you don't pay for job-detail events on jobs you don't want.

```json
{
  "searchQueries": ["software engineer"],
  "titleFilter": "senior, staff, principal",
  "location": "United States",
  "postedWithinDays": 7,
  "maxResults": 50
}
```

Example matched titles: "Senior Software Engineer, Backend", "Staff Engineer (Platform)", "Principal Software Engineer".

#### Scheduled daily use case

Run on a daily schedule to pull only the jobs posted in the last 24 hours. Combine with Easy Apply or Early Applicant filters to surface the highest-signal listings for outreach or alerts.

```json
{
  "searchQueries": ["Software Engineer"],
  "location": "Germany",
  "postedWithinDays": 1,
  "easyApplyOnly": false,
  "earlyApplicantOnly": true,
  "maxResultsPerQuery": 200
}
```

Set `postedWithinDays: 7` if you run weekly instead. The filter uses LinkedIn's `f_TPR=r<seconds>` URL parameter with per-day precision, so `postedWithinDays: 3` gives you exactly the past 3 days, not rounded to a week bucket.

### FAQ

**Do I need to log in or provide a LinkedIn account?**
No. The actor only uses LinkedIn's public job search, the same pages LinkedIn shows visitors without an account. Nothing behind the login wall.

**Which countries are supported?**
Every country LinkedIn serves. Country codes are auto-detected for 30+ locales including DACH (AT, CH, DE), EU (FR, IT, ES, NL, BE, PL, PT, SE, NO, DK, IE, FI, and more), UK, US, Canada, Australia, India, Singapore, Japan, Brazil, and Mexico.

**How large can a single search go?**
LinkedIn caps search at roughly 1,000 results per query. When you specify a country (`"location": "Germany"` or `"country": "DE"`), the actor automatically expands to all major cities, giving you thousands of results per keyword in a single run.

**Are salary fields always populated?**
Salary is only available when LinkedIn publicly displays it on the listing, which varies by employer and country. It is much more common in US listings than in EU ones.

**How much does company enrichment slow things down?**
One extra HTTP request per unique company, with a 1-second delay between requests. A search returning 100 jobs from 80 distinct companies adds roughly 80 seconds to the run.

**What happens if I start the actor with no input?**
It runs a small default search ("Software Engineer" in Berlin, up to 15 results, full details) so you see real output right away. Provide `searchQueries`, `startUrls` or `directUrls` to run your own search.

### Limitations

- If LinkedIn rate-limits or blocks a search (HTTP 429 or 999 on every retry, or a sign-in wall), that search ends and the log says `Query 'X': rate-limited or blocked by LinkedIn after N jobs`. Jobs already saved stay in the dataset. If every search is rate-limited or blocked after all proxy fallbacks and no job was saved, the run still ends as succeeded with a clear status message ("0 jobs saved: LinkedIn blocked every search after all proxy fallbacks") and only the start fee is charged. If some jobs were saved, the run succeeds and the status message says how many searches were rate-limited or blocked and that results may be incomplete. Rows are charged only for jobs saved. Try again later or with fewer queries.
- LinkedIn caps search at ~1,000 results per keyword per location. Country-level inputs trigger automatic city expansion to work around this ceiling.
- Some fields (salary, company website, employee count) depend on what the employer chose to publish and may be null.
- Job-poster fields are not exposed on every listing. Availability depends on LinkedIn's public pages.
- Only publicly accessible listings are scraped. Nothing behind LinkedIn authentication.

### Changelog

- 3.3.x: fewer failed runs: shared proxy fallback chain, blocked searches end with a clear message instead of an error, stop before the run timeout.

### Legal notice

This actor scrapes only publicly available job postings from LinkedIn's public job search (no login required, no data behind the authentication wall). Users are responsible for ensuring their use complies with LinkedIn's Terms of Service and applicable laws in their jurisdiction.

### Issues and feedback

Facing an issue or need an extra field? [Open an issue on the Issues tab](https://console.apify.com/actors/HxVzxLvPwxYkc6ndm/issues). We respond within 24 hours and welcome feature requests.

### Related Actors

Complete your global job-board coverage with our full suite:

- [Indeed Scraper](https://apify.com/santamaria-automations/indeed-scraper), a global job aggregator.
- [Jobrapido Scraper](https://apify.com/santamaria-automations/jobrapido-scraper), multi-country aggregator (DACH + 50 countries).
- [StepStone.de Scraper](https://apify.com/santamaria-automations/stepstone-de-scraper), a German job board.
- [Jobs.ch Scraper](https://apify.com/santamaria-automations/jobs-ch-scraper), a Swiss job site.
- [Karriere.at Scraper](https://apify.com/santamaria-automations/karriere-at-scraper), an Austrian job board.
- [Arbeitsagentur.de Scraper](https://apify.com/santamaria-automations/arbeitsagentur-de-scraper), German Federal Employment Agency.
- [Stellenanzeigen.de Scraper](https://apify.com/santamaria-automations/stellenanzeigen-de-scraper), German national job board.
- [Pracuj.pl Scraper](https://apify.com/santamaria-automations/pracuj-pl-scraper), a Polish job site.
- [Naukri Scraper](https://apify.com/santamaria-automations/naukri-scraper), an Indian and Gulf job board.
- [Computrabajo Scraper](https://apify.com/santamaria-automations/computrabajo-scraper), a Latin American job board (19 countries).
- [Seek Scraper](https://apify.com/santamaria-automations/seek-scraper), Asia-Pacific job board (Australia, New Zealand, and 6 more countries).

**Enrich your job data:**

- [Website Job Extractor](https://apify.com/santamaria-automations/website-job-extractor), pull jobs straight from company career pages.
- [Website Contact Extractor](https://apify.com/santamaria-automations/website-contact-extractor), emails and phones from company websites.

Or browse all [santamaria-automations actors](https://apify.com/santamaria-automations) for the full scraping suite.

# Changelog

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

# Actor input Schema

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

Paste LinkedIn job search URLs directly from your browser. The actor paginates from each URL and extracts all matching jobs. Example: https://www.linkedin.com/jobs/search/?keywords=Engineer\&location=Germany

## `directUrls` (type: `array`):

List of LinkedIn job URLs to check directly (skips search). Use this for 'still alive' checks or re-scraping specific jobs. Example: https://www.linkedin.com/jobs/view/1234567890

## `searchQueries` (type: `array`):

One or more search keywords. Each keyword runs as a separate search. Results are deduplicated across queries.

## `searchQuery` (type: `string`):

Single search keyword (backward compatible). Use 'searchQueries' for multiple keywords.

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

City, region, or country to search in (e.g., 'Zurich', 'Switzerland', 'San Francisco Bay Area')

## `country` (type: `string`):

Alternative to location - specify just the country (e.g., 'Switzerland', 'Germany', 'United States')

## `postedWithinDays` (type: `integer`):

Only return jobs posted within the last N days. Uses LinkedIn's f_TPR URL filter with the formula r\<days\*86400> seconds, giving per-day precision. LinkedIn's UI shows discrete options (1, 7, 30 days) but the URL parameter accepts any integer. Set 0 (default) for no date filter. Preferred over datePosted for scheduled/programmatic use.

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

Optional legacy: prefer postedWithinDays. Filter by when the job was posted.

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

NOTE: LinkedIn currently has no sort URL parameter on the public job search page. They removed the sort filter surface in a 2026 redesign (their UI shows 'we're working on bringing back the filters'). This input is kept for fleet-standard compatibility. The actor accepts and logs the value but does not send it to LinkedIn. Set to 'newest' as a forward-compatible default; sorting will be wired automatically when LinkedIn restores the filter.

## `jobType` (type: `string`):

Filter by employment type

## `experienceLevel` (type: `string`):

Filter by required experience level

## `remoteFilter` (type: `string`):

Filter by workplace type

## `easyApplyOnly` (type: `boolean`):

Only return jobs with LinkedIn's Easy Apply feature, which lets candidates apply without leaving LinkedIn. Maps to the f_AL=true URL filter. Useful for high-volume outreach or when you want to track one-click application availability.

## `earlyApplicantOnly` (type: `boolean`):

Only return jobs with fewer than 10 applications so far (LinkedIn's 'Be among the first applicants' filter). Maps to the f_EA=true URL filter. Useful for candidates who want to stand out by applying early. Combine with postedWithinDays=1 for the freshest low-competition listings.

## `maxResultsPerQuery` (type: `integer`):

Per-keyword cap. Total possible results = maxResultsPerQuery x number of searchQueries (deduplicated). Example: 100 x 8 queries = up to 800 results.

## `maxResults` (type: `integer`):

Total cap across all queries. Set to 0 for unlimited (each query limited by maxResultsPerQuery).

## `titleFilter` (type: `string`):

Comma-separated title terms (case-insensitive substring OR-match). Filters SERP results by job title before detail fetch. Empty disables the filter. Example: 'Software Engineer, Data Scientist, ML Engineer'. Skipping non-matching titles saves detail requests and rows.

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

Deprecated: use easyApplyOnly instead. Kept for backward compatibility with existing integrations.

## `includeJobDetails` (type: `boolean`):

ON by default. Fetches each job's detail page and adds the full description, employment type, seniority level, industry, company website, employee count, hiring manager name/title/profile, and more. Adds roughly 1 HTTP request per job (~2-4x slower). Set to false for a fast SERP-only scan (title, company, location, logo, posted date, salary).

## `includeCompanyDetails` (type: `boolean`):

ON by default. Enriches each job with the employer's company profile: type, founded year, headquarters, follower count, specialties, funding rounds, featured employees, and latest company updates. One HTTP request per unique company (deduplicated across the run). Requires Include Job Details to also be ON.

## Actor input object example

```json
{
  "startUrls": [],
  "directUrls": [],
  "searchQueries": [
    "Software Engineer"
  ],
  "searchQuery": "Software Engineer",
  "location": "Berlin",
  "country": "",
  "postedWithinDays": 0,
  "datePosted": "any",
  "sortBy": "newest",
  "jobType": "",
  "experienceLevel": "",
  "remoteFilter": "",
  "easyApplyOnly": false,
  "earlyApplicantOnly": false,
  "maxResultsPerQuery": 20,
  "maxResults": 0,
  "titleFilter": "",
  "easyApply": false,
  "includeJobDetails": true,
  "includeCompanyDetails": true
}
```

# Actor output Schema

## `jobListings` (type: `string`):

Dataset containing scraped job listings

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [],
    "directUrls": [],
    "searchQueries": [
        "Software Engineer"
    ],
    "location": "Berlin",
    "maxResultsPerQuery": 20
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [],
    "directUrls": [],
    "searchQueries": ["Software Engineer"],
    "location": "Berlin",
    "maxResultsPerQuery": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "directUrls": [],
  "searchQueries": [
    "Software Engineer"
  ],
  "location": "Berlin",
  "maxResultsPerQuery": 20
}' |
apify call santamaria-automations/linkedin-scraper --silent --output-dataset

```

## MCP server setup

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