# LinkedIn Jobs Search (`burbn/linkedin-jobs-search`) Actor

Search LinkedIn jobs with advanced filters including location, employment type, seniority level, salary, remote jobs, and more. Get detailed job descriptions, company info, and applicant counts.

- **URL**: https://apify.com/burbn/linkedin-jobs-search.md
- **Developed by:** [Kevin](https://apify.com/burbn) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Jobs Search Scraper

Extract structured job listings from LinkedIn with keyword search, location targeting, and advanced filters. Collect job titles, descriptions, company information, salary estimates, applicant counts, and direct apply links in JSON, CSV, or Excel format.

#### Why Choose This Scraper?

- No LinkedIn Account Required: Scrapes public job listings safely without logging in or risking account restrictions.
- Fast and Lightweight: API-powered scraping delivers results in seconds without browser overhead.
- Granular Filtering: Filter by date posted, employment type, seniority level, company ID, remote status, and search radius.
- Complete Job Details: Retrieve full descriptions, salary ranges, company websites, and applicant numbers.
- Flexible Export: Export clean, normalized data directly to JSON, CSV, Excel, or consume via Apify API.

### Features

- Keyword and Title Search: Full-text search across job titles, skills, and descriptions.
- Location and Radius Targeting: Search by city, country, or LinkedIn geo ID with kilometer radius support.
- Employment Type Filters: Filter by full-time, part-time, contract, or internship positions.
- Experience and Seniority Levels: Target entry level, associate, mid-senior level, director, or executive roles.
- Remote Work Filter: Quickly isolate remote and work-from-home job opportunities.
- Company-Specific Search: Filter jobs posted by a specific employer using their LinkedIn company ID.
- Freshness and Date Posted: Fetch jobs posted today, in the past 3 days, past week, or past month.
- Sorting Options: Order results by relevance or by date (newest first).
- Direct Apply Links: Access direct application URLs and third-party publisher links.
- Compensation Data: Extract base salary, minimum and maximum ranges, period, and currency when available.
- Applicant Statistics: Track applicant counts to evaluate competition for job openings.

### Quick Start

1. Enter your search query (such as "Software Engineer" or "Marketing Manager").
2. Optionally specify a location (such as "New York, NY" or "United Kingdom") or custom filters.
3. Choose the number of pages to collect (each page returns up to 10 listings).
4. Run the actor and download your dataset in CSV, JSON, or Excel format.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `query` | String | Yes | - | Job search keywords, title, or skills (e.g., "Backend Engineer"). |
| `location` | String | No | - | Geographic location filter (e.g., "London, UK", "San Francisco, CA"). |
| `page` | Integer | No | `1` | Starting page number (range: 1 to 100). |
| `num_pages` | Integer | No | `1` | Number of pages to retrieve (range: 1 to 20, 10 jobs per page). |
| `country` | String | No | `"us"` | Two-letter ISO country code (e.g., "us", "uk", "de", "in") for proxy exit market. |
| `sort_by` | String | No | `"relevance"` | Sort ordering: `relevance` (default) or `date` (newest first). |
| `date_posted` | String | No | `"all"` | Posting timeframe: `all`, `today`, `3days`, `week`, or `month`. |
| `employment_types` | String | No | - | Filter by employment type: `FULLTIME`, `PARTTIME`, `CONTRACTOR`, `INTERN`. |
| `seniority_levels` | String | No | - | Filter by seniority: `Internship`, `Entry level`, `Associate`, `Mid-Senior level`, `Director`, `Executive`, `Not Applicable`. |
| `remote_jobs_only` | Boolean | No | `false` | When enabled, returns only listings explicitly marked as remote. |
| `company_id` | String | No | - | Restrict results to a specific LinkedIn company by its numeric company ID. |
| `geo_id` | String | No | - | LinkedIn numeric geo ID for precise location targeting (e.g., "102571732"). |
| `radius` | Integer | No | - | Search radius in kilometers around the geo\_id location (requires geo\_id). |
| `include_details` | Boolean | No | `true` | Fetch extended job details (descriptions, salary, applicant counts). Set to false for faster runs. |
| `fields` | String | No | - | Comma-separated list of specific fields to return in the output dataset. |

#### Example Input

```json
{
  "query": "Backend Engineer",
  "location": "San Francisco, CA",
  "num_pages": 2,
  "date_posted": "week",
  "employment_types": "FULLTIME",
  "sort_by": "date",
  "remote_jobs_only": false,
  "include_details": true
}
```

### Output Data Structure

Each dataset item represents one job listing. Output fields are organized into logical categories:

#### Job Details

| Field | Type | Description |
|-------|------|-------------|
| `job_id` | String | LinkedIn job ID |
| `job_title` | String | Full title of the job posting |
| `job_description` | String | Full job description text |
| `job_employment_type` | String | Primary employment type (e.g., Full-time) |
| `job_employment_types` | Array | All matching employment types |
| `job_seniority_level` | String | Required experience level |
| `job_function` | String | Functional department |
| `job_industries` | Array | Industry categories associated with the job |
| `job_is_remote` | Boolean | Whether the role is marked as remote |
| `job_highlights` | Object | Key highlights extracted from the listing |

#### Employer Information

| Field | Type | Description |
|-------|------|-------------|
| `employer_name` | String | Company or organization name |
| `employer_logo` | String | URL to the company logo image |
| `employer_website` | String | Official company website URL |
| `employer_linkedin_url` | String | URL to company profile on LinkedIn |
| `job_linkedin_company_id` | String | Numeric LinkedIn company ID |

#### Location Details

| Field | Type | Description |
|-------|------|-------------|
| `job_location` | String | Location string as listed on LinkedIn |
| `job_city` | String | City name |
| `job_state` | String | State or region |
| `job_country` | String | Country code |
| `job_latitude` | Number | Geographic latitude |
| `job_longitude` | Number | Geographic longitude |

#### Compensation and Salary

| Field | Type | Description |
|-------|------|-------------|
| `job_salary_string` | String | Formatted salary range string |
| `job_min_salary` | Number | Minimum compensation figure |
| `job_max_salary` | Number | Maximum compensation figure |
| `job_salary_period` | String | Salary frequency (e.g., year, hour) |
| `job_salary_currency` | String | Currency code (e.g., USD, EUR, GBP) |

#### Application and Metadata

| Field | Type | Description |
|-------|------|-------------|
| `job_apply_link` | String | Direct apply URL |
| `job_apply_is_direct` | Boolean | Whether the application link is direct |
| `apply_options` | Array | Available application methods |
| `job_publisher` | String | Publisher or source platform |
| `job_applicants_count` | Number | Number of registered applicants |
| `job_posted_at` | String | Relative posting time (e.g., "3 days ago") |
| `job_posted_at_date` | String | Formatted date of the posting |
| `scraped_at` | String | Timestamp when the job was collected |

#### Example Output

```json
{
  "source": "linkedin_jobs_search",
  "search_query": "Backend Engineer",
  "position": 1,
  "job_id": "3849102847",
  "job_title": "Senior Backend Engineer",
  "employer_name": "Stripe",
  "employer_logo": "https://media.licdn.com/dms/image/v2/company-logo/stripe.png",
  "employer_website": "https://stripe.com",
  "employer_linkedin_url": "https://www.linkedin.com/company/stripe",
  "job_location": "San Francisco, CA",
  "job_city": "San Francisco",
  "job_state": "California",
  "job_country": "US",
  "job_is_remote": false,
  "job_employment_type": "Full-time",
  "job_seniority_level": "Mid-Senior level",
  "job_salary_string": "$175,000 - $225,000 / year",
  "job_min_salary": 175000,
  "job_max_salary": 225000,
  "job_salary_currency": "USD",
  "job_salary_period": "year",
  "job_applicants_count": 42,
  "job_posted_at": "3 days ago",
  "job_posted_at_date": "2026-09-22",
  "job_apply_link": "https://www.linkedin.com/jobs/view/3849102847",
  "job_description": "We are looking for a Senior Backend Engineer to join our payments infrastructure team...",
  "scraped_at": "2026-09-25T07:30:00.000Z"
}
```

### Use Cases

- Recruitment and Talent Sourcing: Identify active job openings and monitor demand for specific skills across technology, marketing, and finance sectors.
- Job Market Intelligence: Track job posting volume, skill requirements, and hiring velocity across different regions and industries.
- Competitive Analysis: Monitor hiring patterns, department expansions, and open positions at competitor organizations.
- Salary Benchmarking: Collect advertised compensation data across industries and experience levels to determine competitive salary structures.
- Job Boards and Aggregators: Populate specialized job boards, career discovery platforms, and automated candidate alert feeds.
- Career Research: Evaluate open positions based on remote flexibility, required seniority, and location preferences.

### Tips for Best Results

- Optimize Speed: When you only need basic listing data (titles, companies, locations), set `include_details` to `false` for up to 3x faster execution.
- Precise Geography: Combine `geo_id` and `radius` for accurate regional targeting instead of relying solely on general location strings.
- Target Fresh Roles: Set `date_posted` to `today` or `week` and sort by `date` to capture recently posted jobs with lower applicant competition.
- Pagination Control: Use `num_pages` (up to 20 per run) to balance speed and data volume. Each page fetches up to 10 listings.
- Company Intelligence: Use `company_id` to track all open positions posted by a single organization.

### Dataset Views

This actor includes a pre-configured table view in the Apify Console:

- LinkedIn Jobs Overview: Clean, organized table displaying Job Title, Company, Logo, Location, Employment Type, Seniority, Salary, Applicants, Date Posted, and Apply Link.

### Limitations

- Each search page contains up to 10 job listings.
- Up to 20 pages (200 jobs) can be retrieved in a single run. For higher volumes, paginate with the `page` parameter.
- Radius search requires a valid numeric LinkedIn `geo_id`.
- Salary details are only present when disclosed by the employer in the job posting.

### Frequently Asked Questions

#### Do I need a LinkedIn account or login credentials?

No. The scraper accesses public LinkedIn job search results. You do not need to provide LinkedIn cookies, passwords, or personal account details.

#### How many jobs can I collect per run?

You can collect up to 200 jobs per run (20 pages with 10 listings each). For larger datasets, schedule recurring runs or paginate through results using the `page` parameter.

#### How fast does the scraper execute?

Basic listing queries complete in seconds. When `include_details` is set to `true`, the scraper retrieves full job descriptions, salary data, and applicant counts, which adds a short processing time to ensure complete data collection.

#### Can I filter for remote-only positions?

Yes. Set `remote_jobs_only` to `true` to restrict results exclusively to positions marked as remote by the employer.

#### What export formats are supported?

Data can be exported in JSON, CSV, Excel, XML, or HTML table format directly from the Apify platform or programmatically via the Apify API.

### Related Actors

Complement your LinkedIn recruitment and intelligence pipeline with other actors:

- [LinkedIn Profile Scraper](https://apify.com/burbn/linkedin-profile-scraper): Extract complete LinkedIn profile information, including work experience, education, skills, verified professional emails, and company details without logging into an account. Ideal for candidate screening, talent sourcing, and reaching out to hiring managers.

### Tags

`linkedin jobs scraper` `linkedin job search` `scrape linkedin jobs` `linkedin scraper` `linkedin api` `job search api` `extract linkedin jobs` `job scraper` `linkedin employment data` `remote jobs scraper` `salary data scraper` `recruitment intelligence` `talent sourcing tool` `job market data` `linkedin crawler` `apify linkedin jobs`

### Get Started

1. Click try for free on this actor page. [Sign up using this link](https://apify.com?fpr=free-credits)
2. Enter your job keywords in the Query field.
3. Configure optional location, date, or seniority filters.
4. Click Start to run the actor and export your structured job data.

# Actor input Schema

## `query` (type: `string`):

Enter your job search keywords (e.g., 'Software Engineer', 'Data Scientist', 'Product Manager'). This is LinkedIn's keyword search field.

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

Free-text location filter (e.g., 'London, United Kingdom', 'Berlin, Germany', 'New York, US'). Leave empty for worldwide search.

## `page` (type: `integer`):

Starting page number (1-based). Each page returns 10 jobs. Max: 100.

## `num_pages` (type: `integer`):

How many consecutive pages to fetch (each page = 10 jobs). Max: 20 pages = 200 jobs.

## `geo_id` (type: `string`):

LinkedIn numeric geo ID (e.g., '102571732' for New York City). Required if you want radius search to work.

## `radius` (type: `integer`):

Search radius in kilometres around the geo\_id location. Requires geo\_id to be set.

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

2-letter country code (e.g., 'us', 'uk', 'de', 'in'). Selects proxy exit market.

## `sort_by` (type: `string`):

Sort order for job results.

## `date_posted` (type: `string`):

Filter jobs by how recently they were posted.

## `employment_types` (type: `string`):

Filter jobs by employment type.

## `seniority_levels` (type: `string`):

Filter jobs by seniority level.

## `company_id` (type: `string`):

Restrict results to a specific LinkedIn company by its numeric company ID (e.g., '1441' for Google).

## `remote_jobs_only` (type: `boolean`):

If enabled, returns only jobs with an explicit remote marker.

## `include_details` (type: `boolean`):

Fetch each job's detail page (description, salary, seniority, applicants count). Set to false for ~3x faster response but less data.

## `fields` (type: `string`):

Comma-separated list of specific fields to return (e.g., 'job\_title,employer\_name,job\_location'). Leave empty for all fields.

## Actor input object example

```json
{
  "query": "Backend Engineer",
  "page": 1,
  "num_pages": 1,
  "country": "us",
  "sort_by": "relevance",
  "date_posted": "all",
  "employment_types": "",
  "seniority_levels": "",
  "remote_jobs_only": false,
  "include_details": true
}
```

# Actor output Schema

## `jobs_overview` (type: `string`):

Open the dataset view with all found LinkedIn jobs including titles, companies, salaries, and apply links.

# 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 = {
    "query": "Backend Engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("burbn/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 = { "query": "Backend Engineer" }

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

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

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

```

## CLI example

```bash
echo '{
  "query": "Backend Engineer"
}' |
apify call burbn/linkedin-jobs-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,burbn/linkedin-jobs-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0gqf1TojnNqkuPajz/builds/tHkeBPWnrlIrzbqDH/openapi.json