# LinkedIn Jobs Search API (`apixyz/linkedin-jobs-scraper`) Actor

Run up to 20 LinkedIn guest job searches, apply supported filters, deduplicate job IDs, and optionally add available public details to a bounded set. No login or cookies.

- **URL**: https://apify.com/apixyz/linkedin-jobs-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/apixyz) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Run up to 20 LinkedIn guest job searches in one call, apply supported filters, and export job cards deduplicated by job ID. Optional detail enrichment adds available public descriptions and criteria to as many as 250 returned jobs. No LinkedIn account, cookies, or proxy setup is required.

The current Store configuration charges $0.005 at run start and $0.002 per accepted job row. Apify platform usage is billed separately to the user.

### Built for repeatable job research

Use one search for a focused sourcing export or submit a bulk query list for several keyword and location combinations. Recruiting operations teams can feed the results into an internal workflow. Labor-market researchers can repeat the same search definition across named markets without merging duplicate job IDs afterward.

Supported filters cover posting age, workplace type, employment type, experience level, Easy Apply, and sort order. Each run records query-level stop reasons plus overall completeness in `OUTPUT_SUMMARY`.

### Sample output

```json
{
  "jobId": "4440655897",
  "title": "Medical AI Evaluator (Remote, Hourly Contractor)",
  "company": "CNTXT AI",
  "companyUrl": "https://www.linkedin.com/company/cntxt-ai",
  "location": "Miami, FL",
  "salary": null,
  "postedAt": "2026-07-15",
  "postedText": "6 days ago",
  "url": "https://www.linkedin.com/jobs/view/4440655897/",
  "descriptionText": "We are looking for licensed clinicians to evaluate model output...",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Contract",
  "jobFunction": "Health Care Provider",
  "industries": "Technology, Information and Internet",
  "applicantsText": "Over 200 applicants",
  "searchKeywords": "AI evaluator",
  "searchLocation": "United States",
  "scrapedAt": "2026-07-21T19:21:50.000Z"
}
````

Salary stays null when the search card does not show one. Detail fields stay null when enrichment is off, the detail cap has been reached, or the public detail fragment is unavailable.

### Input

Set `keywords`, `location`, or both for a single search. The `queries` field accepts up to 20 bulk entries with `keywords`, `location`, and optional `geoId` or `companyId`. Shared filters apply to each bulk entry. `maxItems` caps the combined output at 10,000 jobs, and the run has a fixed 400-page request budget.

```json
{
  "queries": [
    { "keywords": "clinical AI", "location": "United States" },
    { "keywords": "LLM evaluation", "location": "France" }
  ],
  "postedLimit": "week",
  "workplaceType": ["remote"],
  "includeJobDetails": true,
  "maxDetailItems": 100,
  "maxItems": 500
}
```

Turn on `includeJobDetails` to request description text, description HTML, seniority, employment type, job function, industries, and applicant text. Detail requests run sequentially and are capped at 250 rows. On a 500-row export with a 100-row detail cap, the remaining 400 rows keep their card data and null detail fields.

### Output and export

The default dataset view shows the compact job-card fields. A second view exposes the available detail columns. Download results as JSON, CSV, Excel, or XML from Apify, or read the dataset through its API.

`OUTPUT_SUMMARY` reports query outcomes, total card and page counts, detail outcomes, stop reasons, and run completeness. Read it before treating a capped or interrupted export as complete.

### Pricing

The current public configuration uses a $0.005 Actor-start event and a $0.002 `job-collected` event. A run that returns 340 accepted rows creates $0.685 in Actor event charges. Apify platform usage, including compute and data transfer where applicable, is charged separately under the user's Apify plan.

Blocked and empty runs have no per-job events. The start event and any platform usage can still apply.

### Source and run limits

This Actor reads LinkedIn's public guest job-search surface and available public job-detail fragments. Guest access can stop at a login wall or return markup that the current parser cannot identify. Those conditions are recorded as incomplete outcomes.

Search work is bounded to 20 queries, 400 result-page requests, and 10,000 returned rows. Detail work is bounded to 250 sequential requests with a short interval between attempts. Pagination advances by the number of cards actually returned, which covers the 10-card and 25-card pages seen in structural test fixtures.

### Common questions

**Does it use my LinkedIn account?** No. The input has no credential field; requests use guest job endpoints.

**Why did the run return fewer jobs than `maxItems`?** The public search may have ended, a configured limit may have been reached, or the guest surface may have blocked further pages. The query entry in `OUTPUT_SUMMARY` gives the recorded reason.

**Can I fetch full descriptions for all 10,000 rows?** The detail limit is 250 jobs per run. Larger outputs remain useful as card-level exports.

**Does it scrape profiles?** The scope covers job-search cards and public job-detail fragments.

### Support

For a reproducible issue report, include the Apify run ID, the relevant input fields, and `OUTPUT_SUMMARY`. Remove private labels and downstream customer data before sharing a report.

# Actor input Schema

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

Job title, skill, or free-text search, for example "software engineer".

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

City, region, or country, for example "Berlin, Germany" or "United States". Full place names produce clearer searches than abbreviations.

## `queries` (type: `array`):

Run several searches in one go. Each entry takes keywords, location, and optionally geoId or companyId. Shared filters below apply to every query. When set, this overrides the single Keywords/Location fields.

## `postedLimit` (type: `string`):

Only jobs posted inside this window.

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

Select one or more workplace types.

## `employmentType` (type: `array`):

Select one or more employment types.

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

Seniority bands as LinkedIn defines them.

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

Only jobs with LinkedIn's Easy Apply.

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

Date surfaces the freshest postings first.

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

Adds the full description (text + HTML), seniority level, employment type, job function, industries, and applicant count to the first maxDetailItems returned rows. Later rows remain card-only. One extra request per enriched job, so runs take longer.

## `maxDetailItems` (type: `integer`):

Applies only when Fetch full job details is on. Details are fetched sequentially with polite spacing; the default is 100 and the hard maximum is 250. Remaining returned rows keep null detail fields.

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

Stop once this many jobs have been returned across all queries. The run also stops after 400 result-page requests.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "location": "United States",
  "sortBy": "relevance",
  "includeJobDetails": false,
  "maxDetailItems": 100,
  "maxItems": 100
}
```

# 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"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apixyz/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",
}

# Run the Actor and wait for it to finish
run = client.actor("apixyz/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"
}' |
apify call apixyz/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Search API",
        "description": "Run up to 20 LinkedIn guest job searches, apply supported filters, deduplicate job IDs, and optionally add available public details to a bounded set. No login or cookies.",
        "version": "0.2",
        "x-build-id": "Lct5cQDvPkq9h3lg8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apixyz~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apixyz-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/apixyz~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apixyz-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/apixyz~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apixyz-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": "Keywords",
                        "type": "string",
                        "description": "Job title, skill, or free-text search, for example \"software engineer\"."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or country, for example \"Berlin, Germany\" or \"United States\". Full place names produce clearer searches than abbreviations."
                    },
                    "queries": {
                        "title": "Bulk queries (optional)",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Run several searches in one go. Each entry takes keywords, location, and optionally geoId or companyId. Shared filters below apply to every query. When set, this overrides the single Keywords/Location fields.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "keywords": {
                                    "title": "Keywords",
                                    "type": "string",
                                    "description": "Search keywords for this query."
                                },
                                "location": {
                                    "title": "Location",
                                    "type": "string",
                                    "description": "City, region, or country for this query."
                                },
                                "geoId": {
                                    "title": "Geo ID",
                                    "type": "string",
                                    "description": "Optional LinkedIn geo ID; overrides location when set."
                                },
                                "companyId": {
                                    "title": "Company ID",
                                    "type": "string",
                                    "description": "Optional LinkedIn company ID to restrict this query to one company."
                                }
                            }
                        }
                    },
                    "postedLimit": {
                        "title": "Posted within",
                        "enum": [
                            "1h",
                            "24h",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Only jobs posted inside this window."
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "Select one or more workplace types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "remote",
                                "hybrid",
                                "onsite"
                            ],
                            "enumTitles": [
                                "Remote",
                                "Hybrid",
                                "On-site"
                            ]
                        }
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Select one or more employment types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "contract",
                                "temporary",
                                "internship",
                                "volunteer"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Volunteer"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "type": "array",
                        "description": "Seniority bands as LinkedIn defines them.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry",
                                "associate",
                                "mid-senior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-senior",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "easyApply": {
                        "title": "Easy Apply only",
                        "type": "boolean",
                        "description": "Only jobs with LinkedIn's Easy Apply."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Date surfaces the freshest postings first.",
                        "default": "relevance"
                    },
                    "includeJobDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Adds the full description (text + HTML), seniority level, employment type, job function, industries, and applicant count to the first maxDetailItems returned rows. Later rows remain card-only. One extra request per enriched job, so runs take longer.",
                        "default": false
                    },
                    "maxDetailItems": {
                        "title": "Max jobs to enrich with details",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Applies only when Fetch full job details is on. Details are fetched sequentially with polite spacing; the default is 100 and the hard maximum is 250. Remaining returned rows keep null detail fields.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop once this many jobs have been returned across all queries. The run also stops after 400 result-page requests.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```