# Linkedin Jobs Search (`benjarapi/linkedin-jobs-search`) Actor

Scrape LinkedIn job search result (including company details)

- **URL**: https://apify.com/benjarapi/linkedin-jobs-search.md
- **Developed by:** [Benjar Scraping API](https://apify.com/benjarapi) (community)
- **Categories:** Jobs, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 – Extract Job Postings, Salaries & Recruiters

**Scrape LinkedIn jobs at scale — no login or account required.** This LinkedIn Jobs Scraper returns structured job postings enriched with full job descriptions, salary ranges, applicant counts, hiring recruiter details, and company data. Search by **keywords + filters** or simply **paste a LinkedIn jobs search URL**, and export clean JSON, CSV, or Excel.

Perfect for **recruiters, sourcers, job boards, ATS integrations, market and salary research, lead generation, and labor-market analytics**.

> 🔓 **No LinkedIn login required** — there's no account risk and no cookies to manage.

---

### ✨ Why use this LinkedIn job scraper?

- **⚡ Fast** — listing and enrichment are **pipelined** in parallel over rotating proxy IPs, and company pages use an **early-abort stream** that downloads only the ~5% holding the data (typically a few seconds per ~10 jobs).
- **🔑 No login / no cookies** — zero account risk.
- **🔗 Paste-a-URL or build-a-search** — drop in any `linkedin.com/jobs/search/?...` URL, or use keyword + filter inputs.
- **💰 Salary extraction** — parses salary into `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod`.
- **📄 Full job descriptions** — both `descriptionText` and `descriptionHtml`.
- **🧑‍💼 Recruiter / job poster** — name, title, photo, and profile URL of the person who posted the job.
- **🏢 Company enrichment** — website, description, employee count, and address.
- **🎯 Rich filters** — date posted, job type, experience level, remote/hybrid/on-site, company, distance, and sort order.
- **🧹 Auto-deduplication** — duplicate jobs are removed automatically.
- **📦 Export anywhere** — JSON, CSV, Excel, or push to your own API/webhook.

---

### 🚀 Quick start

1. Enter **Search keywords** (e.g. `Software Engineer`) and a **Location** (e.g. `United States`) — *or* paste a full **LinkedIn jobs search URL**.
2. Set **Maximum jobs to collect** (e.g. `50`).
3. Click **Start** and download your results as JSON, CSV, or Excel.

That's it — no LinkedIn credentials needed.

---

### 📥 Input

Provide **either** `keywords` **or** a `searchUrl`. Everything else is optional.

| Field | Type | Description |
| --- | --- | --- |
| `keywords` | String | Search terms, e.g. `Software Engineer`, `Product Manager`. Ignored when `searchUrl` is set. |
| `searchUrl` | String | A full `https://www.linkedin.com/jobs/search/?...` URL. When provided, keywords, location, and all filters are taken from it, overriding the manual inputs. |
| `location` | String | Location name, e.g. `United States`, `Berlin, Germany`. Use this **or** `geoId`. |
| `geoId` | String | Numeric LinkedIn geo id (e.g. `103644278` = United States). Takes precedence over `location`. Found in the `geoId` parameter of a LinkedIn jobs search URL. |
| `maxJobs` | Integer | Maximum jobs to collect (default `50`). See [Limitations](#️-limitations) for the per-search cap. |
| `scrapeDetails` | Boolean | Default `true`. Enriches each job with full description, criteria (seniority, employment type, function, industries), applicant count, apply type, company URL, and recruiter. |
| `scrapeCompany` | Boolean | Default `true`. Adds each company's website, description, slogan, employee count, and address. Requires `scrapeDetails`. |
| `maxConcurrency` | Integer | Parallel requests, `1`–`20` (default `10`). Higher is faster. |
| `maxTimeoutMs` | Integer | Per-request timeout in ms (default `12000`, min `3000`). A hung request aborts and retries on a fresh proxy IP; lower it to fail bad IPs faster, raise it for slow proxies. |
| `datePosted` | Enum (String) | Restrict by recency. One of `""` (any time), `r86400` (past 24h), `r604800` (past week), `r2592000` (past month). |
| `jobType` | Array of Enums | One or more of `F` (Full-time), `P` (Part-time), `C` (Contract), `T` (Temporary), `I` (Internship), `V` (Volunteer), `O` (Other). |
| `experienceLevel` | Array of Enums | One or more of `1` (Internship), `2` (Entry level), `3` (Associate), `4` (Mid-Senior level), `5` (Director), `6` (Executive). |
| `workplaceType` | Array of Enums | One or more of `1` (On-site), `2` (Remote), `3` (Hybrid). |
| `companyId` | Array of Strings | Restrict to specific numeric LinkedIn company id(s). |
| `sortBy` | Enum (String) | `""` / `R` (Relevance) or `DD` (Most recent). |
| `distance` | Integer | Search radius in miles around the location. |
| `proxyConfiguration` | Proxy | **Residential proxies strongly recommended.** Defaults to Apify residential proxies. |

#### Example input — keyword search

```json
{
  "keywords": "Software Engineer",
  "location": "United States",
  "maxJobs": 50,
  "datePosted": "r604800",
  "jobType": ["F"],
  "experienceLevel": ["3", "4"],
  "workplaceType": ["2"],
  "scrapeDetails": true,
  "scrapeCompany": true,
  "maxConcurrency": 10,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

#### Example input — paste a LinkedIn jobs search URL

```json
{
  "searchUrl": "https://www.linkedin.com/jobs/search/?keywords=Product%20Manager&location=Berlin%2C%20Germany&f_WT=2&f_TPR=r86400",
  "maxJobs": 100,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

***

### 📤 Output

Each result is one job posting. Results stream to the dataset and export as **JSON, CSV, Excel, HTML, or XML**, or to a webhook/API.

#### Fields

| Field | Type | When | Description |
| --- | --- | --- | --- |
| `id` | String | Always | LinkedIn job id. |
| `title` | String | Always | Job title. |
| `companyName` | String | Always | Hiring company name. |
| `companyUrl` | String | Always | LinkedIn company page URL. |
| `companyLogo` | String | Always | Company logo image URL. |
| `location` | String | Always | Job location. |
| `jobUrl` | String | Always | LinkedIn job posting URL. |
| `postedAt` | String (ISO) | Always | Posting date/time, ISO 8601. |
| `postedDate` | String | Always | Posting date, `YYYY-MM-DD`. |
| `postedTimestamp` | Number | Always | Posting time, epoch milliseconds. |
| `salary` | String | Always | Raw salary text (when shown). |
| `salaryMin` / `salaryMax` | Number | Always | Parsed salary bounds (when shown). |
| `salaryCurrency` | String | Always | Salary currency, e.g. `USD`. |
| `salaryPeriod` | String | Always | Salary period, e.g. `yr`, `hr`. |
| `benefits` | Array | Always | Listed benefits (when shown). |
| `seniority` | String | `scrapeDetails` | Seniority level. |
| `employmentType` | String | `scrapeDetails` | e.g. Full-time, Contract. |
| `jobFunction` | String | `scrapeDetails` | Job function. |
| `industries` | String | `scrapeDetails` | Industry. |
| `applicantsCount` | Number | `scrapeDetails` | Number of applicants. |
| `applicantsText` | String | `scrapeDetails` | Raw applicants text. |
| `applyType` | String | `scrapeDetails` | `offsite` or `easy_apply`. |
| `descriptionText` | String | `scrapeDetails` | Full description, plain text. |
| `descriptionHtml` | String | `scrapeDetails` | Full description, HTML. |
| `jobPosterName` | String | `scrapeDetails` | Recruiter / job poster name. |
| `jobPosterTitle` | String | `scrapeDetails` | Recruiter title. |
| `jobPosterPhoto` | String | `scrapeDetails` | Recruiter photo URL. |
| `jobPosterProfileUrl` | String | `scrapeDetails` | Recruiter LinkedIn profile URL. |
| `companyWebsite` | String | `scrapeCompany` | Company website. |
| `companyDescription` | String | `scrapeCompany` | Company description. |
| `companySlogan` | String | `scrapeCompany` | Company slogan/tagline. |
| `companyEmployeesCount` | Number | `scrapeCompany` | Approximate employee count. |
| `companyAddress` | Object | `scrapeCompany` | `{ locality, region, country }`. |
| `applyUrl` | null | Always | External apply link (see [Limitations](#️-limitations)). |
| `scrapedAt` | String (ISO) | Always | When the job was scraped. |

#### Example output

```json
{
  "id": "3801234567",
  "title": "Senior Software Engineer",
  "companyName": "Acme Corp",
  "companyUrl": "https://www.linkedin.com/company/acme-corp",
  "companyLogo": "https://media.licdn.com/dms/image/...",
  "location": "San Francisco, CA",
  "jobUrl": "https://www.linkedin.com/jobs/view/3801234567",
  "postedAt": "2026-06-18T12:00:00.000Z",
  "postedDate": "2026-06-18",
  "postedTimestamp": 1750248000000,
  "salary": "$160,000 - $210,000/yr",
  "salaryMin": 160000,
  "salaryMax": 210000,
  "salaryCurrency": "USD",
  "salaryPeriod": "yr",
  "benefits": ["401(k)", "Medical insurance"],
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering and Information Technology",
  "industries": "Software Development",
  "applicantsCount": 87,
  "applicantsText": "Over 80 applicants",
  "applyType": "offsite",
  "descriptionText": "We are looking for a Senior Software Engineer...",
  "descriptionHtml": "<p>We are looking for a Senior Software Engineer...</p>",
  "jobPosterName": "Jane Recruiter",
  "jobPosterTitle": "Technical Recruiter at Acme Corp",
  "jobPosterPhoto": "https://media.licdn.com/dms/image/...",
  "jobPosterProfileUrl": "https://www.linkedin.com/in/jane-recruiter",
  "companyWebsite": "https://acme.com",
  "companyDescription": "Acme Corp builds...",
  "companySlogan": "Build the future",
  "companyEmployeesCount": 5200,
  "companyAddress": { "locality": "San Francisco", "region": "CA", "country": "US" },
  "applyUrl": null,
  "scrapedAt": "2026-06-19T09:30:00.000Z"
}
```

***

### 💡 Common use cases

- **Recruiting & sourcing** — build talent pipelines and reach hiring managers via the job-poster fields.
- **Job boards & aggregators** — keep a fresh, deduplicated feed of postings.
- **Salary & compensation research** — analyze `salaryMin`/`salaryMax` across roles, regions, and seniority.
- **Lead generation** — find companies that are hiring, plus their websites and recruiters.
- **Labor-market & hiring-trend analytics** — track demand by skill, location, remote vs on-site, and experience level.
- **ATS / CRM enrichment** — feed structured job + company data into your own systems.

***

### ⚠️ Limitations

- **~1000 results per search.** A single search query returns at most ~1000 jobs. To collect more, **slice the query** (by date, location, job type, etc.) and combine the runs.
- **No apply URL.** The external apply link isn't available, so `applyUrl` is always `null`. The apply *type* (`offsite` vs `easy_apply`) is still reported. Use `jobUrl` to open the posting.
- **Public data only.** Fields reflect what LinkedIn publicly exposes; not every posting includes salary, applicants, or a job poster.
- **Use residential proxies** and keep `maxConcurrency` reasonable (≤10) for the most reliable runs. If you see many timeouts on otherwise healthy runs, lower `maxTimeoutMs`; raise it only if your proxy is slow but reliable.

***

### ❓ FAQ

**Do I need a LinkedIn account or login?**
No. There are no credentials, cookies, or account risk involved.

**How many jobs can I scrape per run?**
Up to ~1000 per individual search query. Split broad searches into narrower ones (by date window, location, or filters) and combine the results to collect more.

**Can I scrape remote-only jobs?**
Yes — set `workplaceType` to `2` (Remote), or add `f_WT=2` to your search URL.

**Does it return salaries?**
When LinkedIn shows a salary, it's returned as raw text plus parsed `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod`. Not every posting includes salary data.

**Can I get the recruiter / job poster?**
Yes — with `scrapeDetails` enabled you get the poster's name, title, photo, and LinkedIn profile URL when available.

**Why is `applyUrl` null?**
The external apply link requires a logged-in session, which this actor avoids. Use `jobUrl` to open the posting on LinkedIn.

**Which proxies should I use?**
Residential proxies are strongly recommended. The default configuration already requests Apify residential proxies.

**What output formats are supported?**
JSON, CSV, Excel, HTML, and XML, plus webhook/API integrations.

***

### ⚖️ Legal & ethical use

This actor collects **publicly available** job data only. You are responsible for using it in compliance with LinkedIn's terms, applicable laws (including GDPR/CCPA where relevant), and a valid legal basis for any personal data you process. Do not use scraped data for spam or any unlawful purpose.

# Actor input Schema

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

Keywords to search LinkedIn jobs (e.g. "Software Engineer", "Product Manager"). Ignored when a Search URL is provided.

## `searchUrl` (type: `string`):

Full LinkedIn jobs search URL (https://www.linkedin.com/jobs/search/?...). If provided, keywords, location, geoId and all filters are extracted from it, overriding the manual inputs below.

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

Location name, e.g. "United States", "Berlin, Germany". Use either this or Geo ID.

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

Numeric LinkedIn geo id (e.g. 103644278 for the United States). Takes precedence over the text location. Find it in a LinkedIn jobs search URL's geoId parameter.

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

Maximum number of jobs to collect. The LinkedIn guest API exposes at most ~1000 results per query, so values above 1000 are capped.

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

Fetch each job's detail page to enrich it with full description, job criteria (seniority, employment type, function, industries), applicant count, apply type, company URL, and the job poster (recruiter). Adds one request per job.

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

Enrich each job with its company's website, description, slogan, employee count, and address (from the company's public page). Companies are fetched once and reused across jobs. Requires 'Scrape job details'.

## `maxConcurrency` (type: `integer`):

Number of requests to run in parallel (1-20). Higher is faster; each request uses a rotating proxy IP to avoid rate limits.

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

Restrict to jobs posted within this window.

## `jobType` (type: `array`):

Employment type(s) to include.

## `experienceLevel` (type: `array`):

Experience level(s) to include.

## `workplaceType` (type: `array`):

On-site, remote, or hybrid.

## `companyId` (type: `array`):

Restrict to specific LinkedIn company id(s) (the numeric f\_C facet value).

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

Result ordering.

## `distance` (type: `integer`):

Search radius in miles around the location.

## `maxTimeoutMs` (type: `integer`):

How long to wait for a single guest request before aborting and retrying on a fresh proxy IP. Lower values fail bad IPs faster (the guest endpoints normally answer in under 2s); raise it only if your proxy has high latency.

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

Proxy used for the guest requests. Residential proxies are strongly recommended — the guest API is IP rate-limited.

## Actor input object example

```json
{
  "keywords": "Software Engineer",
  "location": "United States",
  "maxJobs": 50,
  "scrapeDetails": true,
  "scrapeCompany": true,
  "maxConcurrency": 10,
  "datePosted": "",
  "jobType": [],
  "experienceLevel": [],
  "workplaceType": [],
  "companyId": [],
  "sortBy": "",
  "maxTimeoutMs": 12000,
  "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 = {
    "keywords": "Software Engineer",
    "searchUrl": "",
    "location": "United States",
    "geoId": "",
    "maxJobs": 50,
    "jobType": [],
    "experienceLevel": [],
    "workplaceType": [],
    "companyId": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("benjarapi/linkedin-jobs-search").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",
    "searchUrl": "",
    "location": "United States",
    "geoId": "",
    "maxJobs": 50,
    "jobType": [],
    "experienceLevel": [],
    "workplaceType": [],
    "companyId": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("benjarapi/linkedin-jobs-search").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",
  "searchUrl": "",
  "location": "United States",
  "geoId": "",
  "maxJobs": 50,
  "jobType": [],
  "experienceLevel": [],
  "workplaceType": [],
  "companyId": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call benjarapi/linkedin-jobs-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Jobs Search",
        "description": "Scrape LinkedIn job search result (including company details)",
        "version": "0.0",
        "x-build-id": "nzwPOYL9jJcbAhMvP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benjarapi~linkedin-jobs-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benjarapi-linkedin-jobs-search",
                "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/benjarapi~linkedin-jobs-search/runs": {
            "post": {
                "operationId": "runs-sync-benjarapi-linkedin-jobs-search",
                "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/benjarapi~linkedin-jobs-search/run-sync": {
            "post": {
                "operationId": "run-sync-benjarapi-linkedin-jobs-search",
                "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": "Search keywords",
                        "type": "string",
                        "description": "Keywords to search LinkedIn jobs (e.g. \"Software Engineer\", \"Product Manager\"). Ignored when a Search URL is provided."
                    },
                    "searchUrl": {
                        "title": "LinkedIn jobs search URL",
                        "type": "string",
                        "description": "Full LinkedIn jobs search URL (https://www.linkedin.com/jobs/search/?...). If provided, keywords, location, geoId and all filters are extracted from it, overriding the manual inputs below."
                    },
                    "location": {
                        "title": "Location (text)",
                        "type": "string",
                        "description": "Location name, e.g. \"United States\", \"Berlin, Germany\". Use either this or Geo ID."
                    },
                    "geoId": {
                        "title": "Geo ID",
                        "type": "string",
                        "description": "Numeric LinkedIn geo id (e.g. 103644278 for the United States). Takes precedence over the text location. Find it in a LinkedIn jobs search URL's geoId parameter."
                    },
                    "maxJobs": {
                        "title": "Maximum jobs to collect",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect. The LinkedIn guest API exposes at most ~1000 results per query, so values above 1000 are capped."
                    },
                    "scrapeDetails": {
                        "title": "Scrape job details",
                        "type": "boolean",
                        "description": "Fetch each job's detail page to enrich it with full description, job criteria (seniority, employment type, function, industries), applicant count, apply type, company URL, and the job poster (recruiter). Adds one request per job.",
                        "default": true
                    },
                    "scrapeCompany": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Enrich each job with its company's website, description, slogan, employee count, and address (from the company's public page). Companies are fetched once and reused across jobs. Requires 'Scrape job details'.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of requests to run in parallel (1-20). Higher is faster; each request uses a rotating proxy IP to avoid rate limits.",
                        "default": 10
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "",
                            "r86400",
                            "r604800",
                            "r2592000"
                        ],
                        "type": "string",
                        "description": "Restrict to jobs posted within this window.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "type": "array",
                        "description": "Employment type(s) to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "F",
                                "P",
                                "C",
                                "T",
                                "I",
                                "V",
                                "O"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Volunteer",
                                "Other"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "type": "array",
                        "description": "Experience level(s) to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-Senior level",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "On-site, remote, or hybrid.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        }
                    },
                    "companyId": {
                        "title": "Company IDs",
                        "type": "array",
                        "description": "Restrict to specific LinkedIn company id(s) (the numeric f_C facet value).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "R",
                            "DD"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": ""
                    },
                    "distance": {
                        "title": "Distance (miles)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Search radius in miles around the location."
                    },
                    "maxTimeoutMs": {
                        "title": "Per-request timeout (ms)",
                        "minimum": 3000,
                        "type": "integer",
                        "description": "How long to wait for a single guest request before aborting and retrying on a fresh proxy IP. Lower values fail bad IPs faster (the guest endpoints normally answer in under 2s); raise it only if your proxy has high latency.",
                        "default": 12000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for the guest requests. Residential proxies are strongly recommended — the guest API is IP rate-limited."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
