# LinkedIn Jobs Scraper Pro & Recruiter Contacts (`scrapemint/linkedin-jobs-scraper-pro`) Actor

Scrape LinkedIn jobs from search URLs, keywords, or company pages. Each row ships parsed salary, skill array, seniority tier, Easy Apply flag, and recruiter contact. Optional company enrichment with size, industry, and founded year. City splitting for high volume runs. Cookie free. Pay per row.

- **URL**: https://apify.com/scrapemint/linkedin-jobs-scraper-pro.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** Automation, Jobs, Social media
- **Stats:** 10 total users, 7 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Pro — Company Enrichment & Recruiter Contacts

Scrape LinkedIn jobs from search URLs, keywords, or company pages without a cookie or login. Each row ships parsed salary, skill array, seniority tier, Easy Apply flag, recruiter contact, and direct apply URL. Optional company enrichment pulls industry, size, headcount range, founded year, and headquarters. City splitting breaks past LinkedIn's 1000 result cap. Pay per row.

**Built for** technical recruiters, sales teams selling to tech buyers, M&A scouts watching hiring velocity, comp researchers benchmarking pay bands, and founders vetting competitor hiring pipelines.

**Keywords this actor ranks for:** linkedin jobs scraper, linkedin jobs api, scrape linkedin jobs no login, linkedin jobs search url scraper, linkedin company jobs scraper, linkedin recruiter contact scraper, linkedin job skills scraper, linkedin jobs to JSON, linkedin jobs to CSV, linkedin salary scraper, linkedin hiring tracker, linkedin jobs by company, linkedin recruiter intel, easy apply detection, linkedin jobs API alternative.

---

### Why this actor

| Other LinkedIn jobs scrapers | **This actor** |
|---|---|
| Single input mode (keywords or URL only) | Three modes: search URLs, keywords, OR company URLs |
| Raw description, no parsing | Parsed salary, 250+ skill array, seniority tier, Easy Apply flag |
| 1000 result cap leaves you stuck | City splitting breaks past the cap automatically |
| No company context | Optional enrichment with industry, size, headcount, founded, HQ, hiring velocity |
| No recruiter info | Optional recruiter name, title, and profile URL pulled from the job page |
| No direct apply URL | Direct apply URL extracted when the company uses an external ATS |

---

### How it works

```mermaid
flowchart LR
    A[Search URL<br/>OR keywords<br/>OR company URL] --> B[Parse filters<br/>+ optional city split]
    B --> C[LinkedIn guest listing<br/>seeMoreJobPostings]
    C --> D[Extract job IDs]
    D --> E[Job detail page<br/>jobPosting/id]
    E --> F[Parse + enrich<br/>salary skills seniority<br/>Easy Apply recruiter]
    F --> G[One row per job]
    F --> H[Optional company<br/>about page]
    H --> I[One row per company]
    G --> J[(JSON CSV API)]
    I --> J
````

No cookie at any stage. Works against the same public guest endpoints Google uses when indexing jobs. Filters from your search URL flow straight through.

***

### What you get per row

```mermaid
flowchart LR
    R[Job row] --> R1[Identity<br/>id title url]
    R --> R2[Company<br/>name slug companyUrl]
    R --> R3[Apply<br/>easyApply directApplyUrl]
    R --> R4[Compensation<br/>salaryMin salaryMax currency period]
    R --> R5[Signals<br/>seniorityTier remote applicants]
    R --> R6[Skills<br/>250+ term match]
    R --> R7[Recruiter<br/>name title profileUrl]
```

Each unique company can also push as its own row with `kind: "company"`, carrying industry, headcount range, founded year, headquarters, specialties, and follower count.

***

### Quick start

**Paste a search URL from your browser**

```json
{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800"
  ],
  "maxJobs": 100,
  "scrapeCompanyDetails": true
}
```

**Watch every job at three target companies**

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/openai/",
    "https://www.linkedin.com/company/anthropic/",
    "https://www.linkedin.com/company/databricks/"
  ],
  "scrapeCompanyDetails": true,
  "scrapeRecruiterContact": true
}
```

**High volume run with city splitting (breaks past the 1000 cap)**

```json
{
  "keywords": ["staff software engineer"],
  "splitByCity": true,
  "country": "United States",
  "maxJobs": 5000,
  "scrapeCompanyDetails": false
}
```

**Recruiter sourcing run with recruiter contact extraction**

```json
{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=product%20manager&location=California"
  ],
  "scrapeRecruiterContact": true,
  "maxJobs": 200
}
```

***

### Sample output

**Job row**

```json
{
  "kind": "job",
  "id": "4406118990",
  "url": "https://www.linkedin.com/jobs/view/4406118990/",
  "title": "Software Engineer, New Grad",
  "company": "Notion",
  "companySlug": "notionhq",
  "companyUrl": "https://www.linkedin.com/company/notionhq",
  "location": "San Francisco, CA",
  "remote": "onsite",
  "postedAt": "2026-04-24T21:22:48.000Z",
  "applicants": 200,
  "easyApply": false,
  "directApplyUrl": null,
  "applyUrl": "https://www.notion.com/careers/...",
  "seniorityLevel": "Entry level",
  "seniorityTier": "entry",
  "employmentType": "Full-time",
  "salaryMin": 126000,
  "salaryMax": 146000,
  "salaryCurrency": "USD",
  "salaryPeriod": "annual",
  "skills": ["claude", "css", "elasticsearch", "figma", "javascript", "mongodb", "mysql", "node.js", "openai", "postgresql", "python", "react", "typescript"],
  "experienceYearsMin": null,
  "scrapedAt": "2026-04-26T08:00:00.000Z"
}
```

**Company row** (when `scrapeCompanyDetails` is on)

```json
{
  "kind": "company",
  "slug": "notionhq",
  "url": "https://www.linkedin.com/company/notionhq/",
  "name": "Notion",
  "tagline": "One workspace. Every team.",
  "industry": "Software Development",
  "size": "1,001-5,000 employees",
  "headcountMin": 1001,
  "headcountMax": 5000,
  "founded": 2013,
  "headquarters": "San Francisco, California",
  "specialties": ["productivity", "collaboration", "knowledge management"],
  "followers": 245000,
  "scrapedAt": "2026-04-26T08:00:00.000Z"
}
```

**Recruiter contact** (when `scrapeRecruiterContact` is on, attached to job row)

```json
{
  "recruiter": {
    "name": "Jane Doe",
    "title": "Senior Technical Recruiter",
    "profileUrl": "https://www.linkedin.com/in/janedoe/"
  }
}
```

***

### Who uses this

| Role | Use case |
|---|---|
| Technical recruiter | Watch open reqs at target companies. Pull the recruiter contact directly from the job page. |
| Sales team | Spot companies hiring roles that imply need for your product (Snowflake hiring = data warehouse migration). |
| Comp researcher | Benchmark pay bands by title, seniority, geography, and skill stack across thousands of jobs. |
| M\&A scout | Track hiring velocity at private companies. Combine job count with company size for a growth signal. |
| Founder | Watch a competitor's open reqs as a real time pipeline of strategy and team shape. |
| BI analyst | Pipe parsed salary, skills, and seniority into a dashboard or warehouse. |

***

### Input reference

| Field | Type | What it does |
|---|---|---|
| `searchUrls` | string\[] | LinkedIn jobs search URLs from your browser. |
| `keywords` | string\[] | Alternative to URLs. Each keyword runs as its own search. |
| `locations` | string\[] | Locations combined with keywords. |
| `companyUrls` | string\[] | LinkedIn company URLs to find every open job at the firm. |
| `maxJobs` | integer | Hard cap on jobs returned. 0 means everything LinkedIn exposes. |
| `experienceLevel` | enum | internship, entry, associate, mid-senior, director, executive. |
| `jobType` | enum | full-time, part-time, contract, temporary, volunteer, internship. |
| `remoteFilter` | enum | onsite, remote, hybrid. |
| `postedSince` | enum | 1d, 1w, 1m. |
| `splitByCity` | boolean | Split each search across the top cities of the country to break past the 1000 cap. |
| `country` | enum | Country whose top cities are used when splitByCity is on. |
| `scrapeCompanyDetails` | boolean | Pull each unique company's about page. |
| `scrapeRecruiterContact` | boolean | Extract recruiter name, title, and profile URL. |
| `extractSkills` | boolean | Scan description for 250+ skills across tech, business, and soft. |
| `parseSalary` | boolean | Parsed salary range, currency, and period. |
| `classifySeniority` | boolean | Map title to one of ten seniority buckets. |
| `detectEasyApply` | boolean | Flag Easy Apply vs external ATS jobs. |
| `dedupe` | boolean | Skip job IDs from previous runs. |
| `concurrency` | integer | Pages processed in parallel. |
| `proxyConfiguration` | object | Apify proxy. Residential is required at scale. |

***

### API call

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USER~linkedin-jobs-scraper-pro/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchUrls": ["https://www.linkedin.com/jobs/search/?keywords=staff%20engineer&location=California"],
    "maxJobs": 200,
    "scrapeCompanyDetails": true
  }'
```

***

### Pricing

The first few rows per run are free so you can validate output. After that, each job row is charged. Company rows and recruiter rows are billed separately and only when those toggles are on, so the base cost stays low when you only need job data.

***

### FAQ

#### Do I need a LinkedIn account or cookie?

No. The actor only touches LinkedIn's public guest endpoints, the same ones Google uses to index public job listings.

#### What is the difference between this and a basic LinkedIn jobs scraper?

This one accepts three input modes (search URLs, keywords, company URLs), splits searches by city to break past the 1000 result cap, enriches with company about page data, extracts recruiter contact info, parses salary and skills on every row, and detects Easy Apply vs external ATS jobs.

#### How does the search URL input work?

Open LinkedIn jobs in incognito, set your filters (location, experience, posted in last week, remote), and copy the URL. The actor parses query parameters and runs the same filters against the public guest API.

#### Why does LinkedIn cap results at about 1000 per search?

That is a LinkedIn product limit on the guest search API. Turn on `splitByCity` and the actor splits each keyword across the top cities of your chosen country. Twenty cities means up to 20,000 results before the cap kicks in per city.

#### How accurate is the salary parser?

Strong on jobs that publish a range in the description (mandatory under California, New York, Washington, and Colorado pay transparency laws). Currency support: USD, EUR, GBP, CAD, AUD, INR, CHF. Plausibility checks reject outliers like gift card amounts. Jobs without a published range return `salaryMin: null`.

#### What does Easy Apply detection actually catch?

Jobs that route through LinkedIn's one click apply flow, which typically receive 3 to 5 times more applicants than jobs that link to an external ATS. Recruiters use this signal to spot lower competition reqs. Sales teams use it to spot companies still using LinkedIn's funnel vs a custom ATS like Greenhouse or Lever.

#### Where does the recruiter contact come from?

The "Meet the hiring team" block on the job detail page. Some jobs show the in house recruiter, some show the hiring manager, and some show neither. Turn on `scrapeRecruiterContact` and rows with this block populate the `recruiter` field.

#### Can I track every open role at a target company?

Yes. Paste the company URL into `companyUrls`. The actor walks every active job posting at that company and returns each as a job row. Combined with `scrapeCompanyDetails`, you also get one company row with size, industry, founded, and HQ.

#### Can I run this on a schedule?

Yes. Use the Apify scheduler for hourly, daily, or weekly runs. Combined with `dedupe: true`, only new job IDs are pushed. Great for competitor hiring watch and recruiter alerting.

#### Is scraping LinkedIn allowed?

This actor reads HTML any anonymous web visitor can see. Respect LinkedIn's terms and rate limit sensibly. Do not redistribute job descriptions or recruiter contact info you have no lawful basis to publish.

***

### Related actors

- **LinkedIn Hiring Tracker & Salary Intelligence** — keyword driven version with deeper salary parsing and tech stack focus
- **LinkedIn Profile & Company Post Tracker** — public LinkedIn posts without a cookie, with reactions and comments
- **TripAdvisor Property Rank Tracker** — daily rank, rating drift, and competitor signals for hotels and restaurants
- **Website Content Crawler** — websites to clean Markdown with token counts and RAG ready chunks
- **Reddit Brand Monitor & Lead Finder** — subreddit mentions and high intent leads

# Actor input Schema

## `searchUrls` (type: `array`):

LinkedIn jobs search URLs from your browser. Open LinkedIn jobs in incognito, set your filters, copy the URL. Each URL runs as its own search. Example: 'https://www.linkedin.com/jobs/search/?keywords=software%20engineer\&location=United%20States\&f\_TPR=r604800'.

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

Job search terms. Each keyword runs as a separate search. Combined with locations below.

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

Locations to combine with keywords. Use the spelling LinkedIn accepts. Leave empty for worldwide.

## `companyUrls` (type: `array`):

LinkedIn company URLs. The actor pulls every active job posting at each company. Example: 'https://www.linkedin.com/company/openai/'.

## `maxJobs` (type: `integer`):

Hard cap on jobs returned across all queries. Set to 0 for everything LinkedIn exposes (about 1000 per search).

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

Filter by seniority. Applied when keywords mode is used. Search URLs already carry their own filters.

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

Employment type filter. Applied when keywords mode is used.

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

Restrict to onsite, remote, or hybrid roles.

## `postedSince` (type: `string`):

Only include jobs posted within this window.

## `splitByCity` (type: `boolean`):

When enabled, the actor splits each keyword search across the top cities of the chosen country. Use this to break past LinkedIn's roughly 1000 results per search cap.

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

Country whose top cities are used when splitByCity is on.

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

Fetch each unique company's About page to enrich rows with industry, company size, headcount, founded year, headquarters, specialties, and active job count. Pushed as a separate dataset row per company.

## `scrapeRecruiterContact` (type: `boolean`):

Parse the 'Meet the hiring team' block on each job detail to extract recruiter name, title, and LinkedIn profile URL. Pushed inline on the job row.

## `extractSkills` (type: `boolean`):

Scan the description for 250+ skills across tech, business, and soft skill categories. Returns a deduped sorted array on every job row.

## `parseSalary` (type: `boolean`):

Extract salary range, currency, and period from the description. Plausibility checks reject outliers like gift card amounts.

## `classifySeniority` (type: `boolean`):

Map the title to intern, entry, mid, senior, staff, lead, manager, director, vp, or c-suite.

## `detectEasyApply` (type: `boolean`):

Flag jobs that use LinkedIn Easy Apply vs an external apply URL. Easy Apply jobs typically receive 3 to 5 times more applicants.

## `dedupe` (type: `boolean`):

Skip job IDs already pushed in previous runs. Turn off to refresh stale rows.

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

Number of pages processed in parallel. Four is the safe default.

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

Apify proxy. Datacenter works for low volume. Residential is required above a few hundred jobs or for company enrichment.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800"
  ],
  "keywords": [],
  "locations": [],
  "companyUrls": [],
  "maxJobs": 25,
  "experienceLevel": "",
  "jobType": "",
  "remoteFilter": "",
  "postedSince": "",
  "splitByCity": false,
  "country": "United States",
  "scrapeCompanyDetails": false,
  "scrapeRecruiterContact": false,
  "extractSkills": true,
  "parseSalary": true,
  "classifySeniority": true,
  "detectEasyApply": true,
  "dedupe": true,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchUrls": [
        "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/linkedin-jobs-scraper-pro").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 = {
    "searchUrls": ["https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/linkedin-jobs-scraper-pro").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 '{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/linkedin-jobs-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper Pro & Recruiter Contacts",
        "description": "Scrape LinkedIn jobs from search URLs, keywords, or company pages. Each row ships parsed salary, skill array, seniority tier, Easy Apply flag, and recruiter contact. Optional company enrichment with size, industry, and founded year. City splitting for high volume runs. Cookie free. Pay per row.",
        "version": "0.1",
        "x-build-id": "E7SfNY2Lamexfw8es"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~linkedin-jobs-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-linkedin-jobs-scraper-pro",
                "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/scrapemint~linkedin-jobs-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-linkedin-jobs-scraper-pro",
                "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/scrapemint~linkedin-jobs-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-linkedin-jobs-scraper-pro",
                "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": {
                    "searchUrls": {
                        "title": "LinkedIn jobs search URLs",
                        "type": "array",
                        "description": "LinkedIn jobs search URLs from your browser. Open LinkedIn jobs in incognito, set your filters, copy the URL. Each URL runs as its own search. Example: 'https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=United%20States&f_TPR=r604800'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords (alternative to URL input)",
                        "type": "array",
                        "description": "Job search terms. Each keyword runs as a separate search. Combined with locations below.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations (used with keywords)",
                        "type": "array",
                        "description": "Locations to combine with keywords. Use the spelling LinkedIn accepts. Leave empty for worldwide.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyUrls": {
                        "title": "Company URLs (find every open job at a firm)",
                        "type": "array",
                        "description": "LinkedIn company URLs. The actor pulls every active job posting at each company. Example: 'https://www.linkedin.com/company/openai/'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on jobs returned across all queries. Set to 0 for everything LinkedIn exposes (about 1000 per search).",
                        "default": 25
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "",
                            "internship",
                            "entry",
                            "associate",
                            "mid-senior",
                            "director",
                            "executive"
                        ],
                        "type": "string",
                        "description": "Filter by seniority. Applied when keywords mode is used. Search URLs already carry their own filters.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "contract",
                            "temporary",
                            "volunteer",
                            "internship",
                            "other"
                        ],
                        "type": "string",
                        "description": "Employment type filter. Applied when keywords mode is used.",
                        "default": ""
                    },
                    "remoteFilter": {
                        "title": "Remote filter",
                        "enum": [
                            "",
                            "onsite",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Restrict to onsite, remote, or hybrid roles.",
                        "default": ""
                    },
                    "postedSince": {
                        "title": "Posted since",
                        "enum": [
                            "",
                            "1d",
                            "1w",
                            "1m"
                        ],
                        "type": "string",
                        "description": "Only include jobs posted within this window.",
                        "default": ""
                    },
                    "splitByCity": {
                        "title": "Split search by city for high volume",
                        "type": "boolean",
                        "description": "When enabled, the actor splits each keyword search across the top cities of the chosen country. Use this to break past LinkedIn's roughly 1000 results per search cap.",
                        "default": false
                    },
                    "country": {
                        "title": "Country to split by",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "India",
                            "France",
                            "Spain",
                            "Netherlands",
                            "Brazil"
                        ],
                        "type": "string",
                        "description": "Country whose top cities are used when splitByCity is on.",
                        "default": "United States"
                    },
                    "scrapeCompanyDetails": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Fetch each unique company's About page to enrich rows with industry, company size, headcount, founded year, headquarters, specialties, and active job count. Pushed as a separate dataset row per company.",
                        "default": false
                    },
                    "scrapeRecruiterContact": {
                        "title": "Scrape recruiter contact",
                        "type": "boolean",
                        "description": "Parse the 'Meet the hiring team' block on each job detail to extract recruiter name, title, and LinkedIn profile URL. Pushed inline on the job row.",
                        "default": false
                    },
                    "extractSkills": {
                        "title": "Extract skills",
                        "type": "boolean",
                        "description": "Scan the description for 250+ skills across tech, business, and soft skill categories. Returns a deduped sorted array on every job row.",
                        "default": true
                    },
                    "parseSalary": {
                        "title": "Parse salary",
                        "type": "boolean",
                        "description": "Extract salary range, currency, and period from the description. Plausibility checks reject outliers like gift card amounts.",
                        "default": true
                    },
                    "classifySeniority": {
                        "title": "Classify seniority tier",
                        "type": "boolean",
                        "description": "Map the title to intern, entry, mid, senior, staff, lead, manager, director, vp, or c-suite.",
                        "default": true
                    },
                    "detectEasyApply": {
                        "title": "Detect Easy Apply jobs",
                        "type": "boolean",
                        "description": "Flag jobs that use LinkedIn Easy Apply vs an external apply URL. Easy Apply jobs typically receive 3 to 5 times more applicants.",
                        "default": true
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip job IDs already pushed in previous runs. Turn off to refresh stale rows.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of pages processed in parallel. Four is the safe default.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Datacenter works for low volume. Residential is required above a few hundred jobs or for company enrichment.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
