# LinkedIn Jobs Scraper - Salary, Recruiter & Company ($0.5/1k) (`harshmaur/linkedin-jobs-scraper`) Actor

Scrape LinkedIn jobs by keyword, location & filters, or any LinkedIn search URL - no login or cookies. Get salary, seniority, applicant count, recruiter contact, and full descriptions in text, Markdown & HTML. Optional company details; beat the ~1,000 cap. Pay per result. MCP & AI-agent ready.

- **URL**: https://apify.com/harshmaur/linkedin-jobs-scraper.md
- **Developed by:** [Harsh Maur](https://apify.com/harshmaur) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 60.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Jobs Scraper — Scrape LinkedIn Jobs, Salaries, Recruiters & Company Data (No Login)

Extract job listings from **LinkedIn** at scale — by job title and location, with filters, or straight from a LinkedIn jobs search URL. Get the title, company, location, posting date, full description, seniority, salary, applicant count, the **job poster (recruiter) contact**, and optional **company details** — exported to JSON, CSV, or Excel, or pulled via the Apify API. **No LinkedIn account, login, or cookies required.**

### What does LinkedIn Jobs Scraper do? {#what-does-it-do}

It turns any LinkedIn job search into a clean, structured dataset — one row per job, ready for spreadsheets, BI tools, a database, or an AI pipeline.

#### ✅ No login or cookies
Reads LinkedIn's public, logged-out job pages. You never share credentials or risk an account.

#### 🔎 Search by keyword or paste a URL
Drive it with a job title + location + filters, or paste a search URL you built on LinkedIn — use either or both.

#### 🧾 Full job details
Description (text + HTML), seniority level, employment type, job function, industries, applicant count, and salary (parsed into min/max/currency/period).

#### 🧑‍💼 Recruiter contact
When a posting lists a job poster, you get their name, title, and LinkedIn profile URL — great for sourcing and outreach.

#### 🏢 Optional company enrichment
Turn on `scrapeCompany` to add each employer's description, website, employee count, and headquarters.

#### 🌎 Beat the 1,000-result cap
`splitByLocation` fans a search across a country's metros so a single run can gather far more than LinkedIn's per-search ceiling.

#### 🔄 Export anywhere
JSON, CSV, Excel, HTML table, RSS, or JSONL — plus the Apify API and integrations.

### How to scrape LinkedIn jobs without logging in {#how-to-scrape}

LinkedIn serves its public jobs feed to logged-out visitors. This Actor reads that same feed, ten listings at a time, following a search until it hits your **Max jobs** limit or LinkedIn's ~1,000-results-per-search ceiling. With **Scrape full job details** on, it then opens each posting for the description, criteria, salary, applicant count, and recruiter.

Two ways to drive it, separately or together:

- **By keyword** — a job title (e.g. `product manager`), a location (`Berlin`, `United States`, `Remote`), and optional filters: date posted, workplace type, job type, experience level, sort order.
- **By URL** — build a filtered search on linkedin.com/jobs and paste the page URL; the Actor reproduces that exact search and paginates it.

### What data can you extract from LinkedIn jobs? {#what-data}

Every job is one dataset item with a consistent shape (missing values come back as `null`, never omitted):

| Field | Description |
| --- | --- |
| `title` | Job title |
| `company`, `companyUrl`, `companyLogo` | Employer name, LinkedIn company page, logo |
| `location` | Job location as shown on the listing |
| `postedAt`, `postedTimeAgo` | ISO posting date + human "3 days ago" |
| `employmentType` | Full-time, Part-time, Contract, … |
| `seniorityLevel` | Entry, Associate, Mid-Senior, Director, … |
| `jobFunction`, `industries` | LinkedIn job function + industries |
| `applicants` | Applicant count (LinkedIn caps display at ~200) |
| `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Raw + parsed compensation (when listed) |
| `benefits` | Listing badges (e.g. "Actively Hiring") |
| `jobPosterName`, `jobPosterTitle`, `jobPosterProfileUrl`, `jobPosterPhoto` | Recruiter / hiring contact (when present) |
| `descriptionText`, `descriptionMarkdown`, `descriptionHtml` | Full job description as clean text, **Markdown**, and HTML |
| `companyDescription`, `companyWebsite`, `companyEmployeesCount`, `companyHeadquarters` | Company-page fields (with `scrapeCompany`) |
| `url`, `jobId` | Canonical job URL + LinkedIn job id |
| `searchTerm`, `searchPosition`, `scrapedAt` | Which search found it, its rank, when scraped |

### LinkedIn job scraping use cases {#use-cases}

- **Recruiting & sourcing** — build candidate-market maps and reach the recruiter behind each role via the job-poster fields.
- **Salary & labor-market research** — aggregate parsed salary ranges by title, seniority, and region.
- **Lead generation** — companies posting jobs are companies that are hiring (and buying); enrich with company size + website.
- **Job boards & aggregators** — keep a niche board stocked with fresh, structured listings.
- **Competitive intelligence** — track a competitor's open roles, locations, and growth signals over time.
- **AI & RAG pipelines** — feed clean descriptions into matching, summarization, or classification.

### How to scrape LinkedIn jobs by keyword and location {#scrape-by-keyword}

#### Search by title + location

```json
{ "keywords": "software engineer", "location": "United States", "maxItems": 200 }
````

#### Filter by workplace type (remote / hybrid / on-site)

```json
{ "keywords": "data scientist", "location": "United States", "workplaceType": "remote", "maxItems": 200 }
```

#### Filter by experience level and recency

```json
{ "keywords": "marketing manager", "location": "New York, NY", "experienceLevel": "mid-senior", "datePosted": "7" }
```

#### Get the newest postings first

```json
{ "keywords": "product manager", "location": "London", "datePosted": "1", "sortBy": "recent" }
```

### How to scrape LinkedIn jobs from a search URL {#scrape-by-url}

Built a finely-filtered search on LinkedIn? Paste its URL and it's scraped as-is (the URL's own filters are honored):

```json
{ "startUrls": [{ "url": "https://www.linkedin.com/jobs/search/?keywords=devops&location=Germany&f_E=4&f_WT=2" }], "maxItems": 300 }
```

### How to scrape more than 1,000 LinkedIn jobs {#beat-the-cap}

LinkedIn returns at most ~1,000 results for any single search. Enable **Split by location** to automatically fan the search across the chosen country's major metro areas — each metro is its own search with its own ceiling — and results are de-duplicated by job id across cities:

```json
{ "keywords": "software engineer", "splitByLocation": true, "splitCountry": "us", "maxItems": 5000 }
```

### How to scrape LinkedIn company details {#scrape-company}

Turn on **Scrape company details** to add each employer's description, website, employee count, and HQ. Company pages are fetched once per unique employer (cached), so it stays efficient even across thousands of jobs:

```json
{ "keywords": "account executive", "location": "United States", "scrapeDetails": true, "scrapeCompany": true, "maxItems": 100 }
```

### Fast, lightweight runs {#fast-mode}

Only need the search-card fields (title, company, location, posted date, logo, URL)? Turn **Scrape full job details** off to skip the per-job page fetch for a faster, cheaper run:

```json
{ "keywords": "sales", "location": "Remote", "scrapeDetails": false, "maxItems": 1000 }
```

### Limiting results {#limits}

- **Max jobs** (`maxItems`) caps the total across every search and URL. Set `0` for no cap (stops when LinkedIn runs out of results).
- A single search is bounded by LinkedIn's ~1,000-result ceiling; use **Split by location** to go beyond it.

### Output example {#output-example}

```json
{
  "title": "Senior Data Scientist",
  "company": "Acme Analytics",
  "companyUrl": "https://www.linkedin.com/company/acme-analytics",
  "companyLogo": "https://media.licdn.com/dms/image/.../company-logo_100_100",
  "location": "San Francisco, CA",
  "postedAt": "2026-06-12",
  "postedTimeAgo": "3 days ago",
  "benefits": ["Actively Hiring"],
  "employmentType": "Full-time",
  "seniorityLevel": "Mid-Senior level",
  "jobFunction": "Engineering and Information Technology",
  "industries": "Software Development",
  "applicants": 87,
  "salary": "$170,000.00/yr - $210,000.00/yr",
  "salaryMin": 170000,
  "salaryMax": 210000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "jobPosterName": "Jane Recruiter",
  "jobPosterTitle": "Talent Partner at Acme Analytics",
  "jobPosterProfileUrl": "https://www.linkedin.com/in/jane-recruiter",
  "companyDescription": "Acme Analytics builds decision-intelligence tools…",
  "companyWebsite": "https://acme.example",
  "companyEmployeesCount": 6420,
  "companyHeadquarters": "San Francisco, California, US",
  "applyUrl": null,
  "url": "https://www.linkedin.com/jobs/view/4416601085",
  "descriptionText": "About the role…",
  "descriptionMarkdown": "## About the role\n\n- Build…",
  "jobId": "4416601085",
  "searchTerm": "data scientist",
  "searchPosition": 4,
  "scrapedAt": "2026-06-18T12:00:00.000Z"
}
```

The recruiter, salary, and `applyUrl` fields populate only when LinkedIn exposes them on a given posting; the `company*` fields appear when `scrapeCompany` is enabled.

### How much does it cost to scrape LinkedIn jobs? {#pricing}

Pay only per result — **no login, no start fee, no subscription**. From **$0.50 per 1,000 jobs** — about half the price of the most popular LinkedIn jobs scraper, and you get more per job: parsed salary, the recruiter (job-poster) contact, Markdown descriptions, and optional company details. Turn **Scrape full job details** off for a faster, cheaper run with the core search-card fields only.

### Use LinkedIn Jobs Scraper with AI agents and MCP {#ai-mcp}

Every Apify Actor is callable by AI agents through the **Apify MCP server**, so assistants like Claude can run this scraper and read its results as a tool. It also pairs naturally with LLM workflows — pull clean `descriptionText` into matching, summarization, or candidate-screening prompts.

### Integrate with n8n, Zapier, and Make {#integrations}

Trigger runs and collect results from your stack via the Apify API or native integrations.

**Run and get results synchronously (good for small scrapes):**

```
POST https://api.apify.com/v2/acts/harshmaur~linkedin-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN
Content-Type: application/json

{ "keywords": "product manager", "location": "United States", "maxItems": 100 }
```

**Run asynchronously (for large scrapes), then fetch the dataset when done:**

```
POST https://api.apify.com/v2/acts/harshmaur~linkedin-jobs-scraper/runs?token=YOUR_TOKEN
```

Schedule recurring runs from the Apify console to keep a live LinkedIn jobs feed.

### Support {#support}

Found a bug or need a field added? Open an issue on the Actor's **Issues** tab — questions and feature requests are welcome, and fixes ship quickly.

### FAQ {#faq}

#### Do I need a LinkedIn account, login, or cookies?

No. The scraper only reads LinkedIn's public, logged-out job pages — no credentials of any kind.

#### How many jobs can I scrape from LinkedIn?

Up to ~1,000 per search (LinkedIn's own ceiling). Enable **Split by location** to fan out across a country's metros and gather many thousands in one run.

#### Can I scrape only remote jobs?

Yes — set **Workplace type** to `Remote` (or `Hybrid`/`On-site`), or paste a remote-filtered LinkedIn search URL.

#### Can I get the recruiter or hiring manager's contact?

When a posting lists a job poster, you get their name, title, and profile URL. Not every job names one.

#### Does it include salary data?

When LinkedIn shows compensation on a listing, you get the raw string plus parsed `salaryMin`/`salaryMax`/`salaryCurrency`/`salaryPeriod`. Many listings don't publish salary.

#### Can I scrape a specific filtered search I built on LinkedIn?

Yes — paste its URL into **Search URLs** and its filters are honored as-is.

#### Can I get job descriptions as Markdown?

Yes — every scraped description is returned as clean **Markdown** (`descriptionMarkdown`) in addition to plain text and raw HTML. Markdown keeps the headings and bullet lists intact, which is ideal for feeding LLMs and RAG pipelines.

#### Which export formats are supported?

JSON, CSV, Excel, HTML table, RSS, and JSONL from the dataset, plus the Apify API.

#### How fresh is the data?

Every run fetches live results from LinkedIn; use **Date posted** to restrict to the last 24 hours, week, or month.

#### Can AI agents use this scraper?

Yes — it's available as a tool via the Apify MCP server.

### Other Actors {#other-actors}

Part of a family of no-login, pay-per-result scrapers:

| Actor | Description |
| --- | --- |
| [Indeed Jobs Scraper](https://apify.com/harshmaur/indeed-scraper) | Indeed listings with salary, company details, and full descriptions |
| [Reddit Scraper](https://apify.com/harshmaur/reddit-scraper) | Posts, comments, communities, and user profiles |
| [Reddit Comments Scraper](https://apify.com/harshmaur/reddit-comments-scraper) | Every comment and nested reply from any post |
| [Reddit Search Scraper](https://apify.com/harshmaur/reddit-search-scraper) | Keyword search across posts, comments, and communities |
| [Reddit Subreddit Scraper](https://apify.com/harshmaur/reddit-subreddit-scraper) | Entire subreddits, past the listing cap |

Pair the **LinkedIn** and **Indeed** scrapers to build a cross-source hiring or market-research dataset.

### Resources {#resources}

- 📖 [Apify Platform Documentation](https://docs.apify.com/)
- 📝 [Web Scraping Best Practices](https://blog.apify.com/web-scraping-best-practices/)
- ⚖️ [Is Web Scraping Legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

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

What to search for, e.g. "software engineer", "product manager", "registered nurse". Leave empty if you are only using Search URLs below.

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

City, state, country, or region — e.g. "New York, NY", "United States", "London", "Remote". Leave empty to search worldwide.

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

Only return jobs posted within this window.

## `workplaceType` (type: `string`):

On-site, remote, or hybrid roles.

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

Employment type.

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

Seniority of the role.

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

Order results by relevance (LinkedIn default) or most recent.

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

Paste one or more LinkedIn job search URLs to scrape directly (e.g. a filtered search you built on linkedin.com/jobs). The fields above do NOT apply to these — they are scraped as-is, then paginated.

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

Maximum number of job listings to scrape across all searches and URLs. LinkedIn caps a single search at ~1000 results. Set 0 for no limit (stops when LinkedIn runs out of results).

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

Open each job's page to fetch the full description, seniority, employment type, job function, industries, applicant count, salary, and the job poster (recruiter) contact. Disable for a faster, cheaper run that returns just the search-card fields (title, company, location, posted date, logo, URL).

## `scrapeCompany` (type: `boolean`):

Also fetch each company's LinkedIn page for its description, website, employee count, and headquarters. Adds one request per unique company (results are cached, so shared employers are fetched once). Off by default.

## `splitByLocation` (type: `boolean`):

LinkedIn caps any single search at ~1,000 results. Enable this to fan the keyword search out across the chosen country's major metro areas (this replaces the Location field above), collecting far more than 1,000 jobs. Results are de-duplicated across cities.

## `splitCountry` (type: `string`):

When 'Split by location' is on, the country whose major metro areas the search is fanned out across.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "location": "United States",
  "datePosted": "",
  "workplaceType": "",
  "jobType": "",
  "experienceLevel": "",
  "sortBy": "",
  "startUrls": [],
  "maxItems": 50,
  "scrapeDetails": true,
  "scrapeCompany": false,
  "splitByLocation": false,
  "splitCountry": "us"
}
```

# Actor output Schema

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

All scraped LinkedIn 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 = {
    "keywords": "software engineer",
    "location": "United States",
    "datePosted": "",
    "workplaceType": "",
    "jobType": "",
    "experienceLevel": "",
    "sortBy": "",
    "maxItems": 50,
    "splitCountry": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("harshmaur/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": "software engineer",
    "location": "United States",
    "datePosted": "",
    "workplaceType": "",
    "jobType": "",
    "experienceLevel": "",
    "sortBy": "",
    "maxItems": 50,
    "splitCountry": "us",
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "software engineer",
  "location": "United States",
  "datePosted": "",
  "workplaceType": "",
  "jobType": "",
  "experienceLevel": "",
  "sortBy": "",
  "maxItems": 50,
  "splitCountry": "us"
}' |
apify call harshmaur/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=harshmaur/linkedin-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper - Salary, Recruiter & Company ($0.5/1k)",
        "description": "Scrape LinkedIn jobs by keyword, location & filters, or any LinkedIn search URL - no login or cookies. Get salary, seniority, applicant count, recruiter contact, and full descriptions in text, Markdown & HTML. Optional company details; beat the ~1,000 cap. Pay per result. MCP & AI-agent ready.",
        "version": "0.0",
        "x-build-id": "3tcT9UEdPl2KXv2yd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/harshmaur~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-harshmaur-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/harshmaur~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-harshmaur-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/harshmaur~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-harshmaur-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Job title / keywords",
                        "type": "string",
                        "description": "What to search for, e.g. \"software engineer\", \"product manager\", \"registered nurse\". Leave empty if you are only using Search URLs below."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, country, or region — e.g. \"New York, NY\", \"United States\", \"London\", \"Remote\". Leave empty to search worldwide."
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "",
                            "1",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only return jobs posted within this window.",
                        "default": ""
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "enum": [
                            "",
                            "on-site",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "On-site, remote, or hybrid roles.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Employment type.",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "",
                            "internship",
                            "entry",
                            "associate",
                            "mid-senior",
                            "director",
                            "executive"
                        ],
                        "type": "string",
                        "description": "Seniority of the role.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Order results by relevance (LinkedIn default) or most recent.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste one or more LinkedIn job search URLs to scrape directly (e.g. a filtered search you built on linkedin.com/jobs). The fields above do NOT apply to these — they are scraped as-is, then paginated.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape across all searches and URLs. LinkedIn caps a single search at ~1000 results. Set 0 for no limit (stops when LinkedIn runs out of results).",
                        "default": 50
                    },
                    "scrapeDetails": {
                        "title": "Scrape full job details",
                        "type": "boolean",
                        "description": "Open each job's page to fetch the full description, seniority, employment type, job function, industries, applicant count, salary, and the job poster (recruiter) contact. Disable for a faster, cheaper run that returns just the search-card fields (title, company, location, posted date, logo, URL).",
                        "default": true
                    },
                    "scrapeCompany": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Also fetch each company's LinkedIn page for its description, website, employee count, and headquarters. Adds one request per unique company (results are cached, so shared employers are fetched once). Off by default.",
                        "default": false
                    },
                    "splitByLocation": {
                        "title": "Split by location (get more than ~1,000)",
                        "type": "boolean",
                        "description": "LinkedIn caps any single search at ~1,000 results. Enable this to fan the keyword search out across the chosen country's major metro areas (this replaces the Location field above), collecting far more than 1,000 jobs. Results are de-duplicated across cities.",
                        "default": false
                    },
                    "splitCountry": {
                        "title": "Split country",
                        "enum": [
                            "us",
                            "uk",
                            "ca",
                            "au",
                            "in",
                            "de",
                            "fr",
                            "nl",
                            "es",
                            "ie",
                            "ae",
                            "sg",
                            "br"
                        ],
                        "type": "string",
                        "description": "When 'Split by location' is on, the country whose major metro areas the search is fanned out across.",
                        "default": "us"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
