# LinkedIn Job Listing (`truefetch/linkedin-job-listing`) Actor

LinkedIn Job Listing is a LinkedIn job listings API for 98 countries that returns 41 normalized job, salary, company, application, and public contact fields without login.

- **URL**: https://apify.com/truefetch/linkedin-job-listing.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Jobs, Automation, Integrations
- **Stats:** 311 total users, 8 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.81 / 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.
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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Job Listing is a LinkedIn job listings API that searches public LinkedIn jobs across 98 countries and returns 41 normalized role, salary, company, application, and public contact fields without login, built for developers and data teams.**

- **98 selectable countries.**
- **9 public inputs with 3 required.**
- **41 normalized Dataset fields.**
- **No LinkedIn credential input.**

[**Run a one-result test**](https://apify.com/truefetch/linkedin-job-listing) · [**View API**](https://apify.com/truefetch/linkedin-job-listing/api)

Set `max_results` to `1`; the smallest published-result test bills a minimum $0.01000 Actor Start plus one $0.00375 Result, or $0.01375 on FREE.

### What does LinkedIn Job Listing do?

LinkedIn Job Listing is a TrueFetch Actor and LinkedIn jobs API for collecting public vacancies by keyword and country. Optional inputs narrow the request by location, search radius, posting age, remote preference, or employment type. Each accepted job is normalized into the same Dataset fields so repeat runs can feed a stable downstream contract.

LinkedIn's [official filter guide](https://www.linkedin.com/help/linkedin/answer/a507441/filter-and-sort-job-search-results?lang=en) documents location, date, employment-type, and other job-search filters used on the source.

The Actor is designed for teams that need current vacancy signals, source URLs, role attributes, applicant counts when visible, compensation when disclosed, and company context without maintaining a separate data collector. It can support recruiting research, workforce analytics, product features, job alerts, and hiring-intent analysis.

LinkedIn Job Listing is independent of LinkedIn and is not an official LinkedIn API. It does not access private profiles, scrape resumes, identify candidates, send messages, or submit applications. Public page availability, search relevance, applicant counts, salary values, and company details vary by listing and market.

### How do I run LinkedIn Job Listing?

1. Open [LinkedIn Job Listing on Apify](https://apify.com/truefetch/linkedin-job-listing).
2. Supply the required `keyword`, `country`, and `max_results` values.
3. Add only the location and filters that express your intended LinkedIn search.
4. Run one result first, inspect the Dataset, and scale after confirming relevance.

The examples below share one scenario: find one contract Product Designer role in Singapore, posted within the last three days, within a 50-mile search radius, and convert usable salary values to SGD.

```json
{
  "keyword": "Product Designer",
  "country": "Singapore",
  "max_results": 1,
  "location": "Singapore",
  "distance": 50,
  "posted_since": "3 days",
  "job_type": "contract",
  "currency": "SGD"
}
```

`max_results` limits published LinkedIn jobs for the run. It does not guarantee that the public search will expose that many accessible and relevant listings.

### What data does LinkedIn Job Listing return?

The default Dataset defines **41 fields**. Unavailable values remain empty; the Actor does not manufacture salary, applicant, company, or application details.

| Field group | Fields |
| --- | --- |
| Processing | `processor`, `processed_at` |
| Source and application | `platform`, `platform_url`, `official_url`, `easy_apply` |
| Role taxonomy | `title`, `description`, `job_type`, `job_level`, `job_function`, `listing_type`, `skills`, `experience_range` |
| Location and work mode | `location`, `is_remote`, `work_mode` |
| Dates and demand | `posted_date`, `valid_through`, `applicant_count`, `vacancy_count` |
| Compensation | `salary_minimum`, `salary_maximum`, `salary_currency`, `salary_period` |
| Company | `company_name`, `company_type`, `company_founded`, `company_industry`, `company_url`, `company_website`, `company_logo`, `company_addresses`, `company_revenue`, `company_description`, `company_rating`, `employee_count`, `review_count` |
| Public contacts | `emails`, `phones`, `social_links` |

This abbreviated, illustrative item matches the Singapore Product Designer scenario:

```json
{
  "platform": "LinkedIn",
  "platform_url": "https://www.linkedin.com/jobs/view/1234567890",
  "official_url": null,
  "title": "Product Designer",
  "company_name": "Example Product Studio",
  "location": {
    "raw": "Singapore",
    "locality": "Singapore",
    "country": "Singapore",
    "country_code": "SG"
  },
  "posted_date": "2026-07-20",
  "applicant_count": 24,
  "job_type": "Contract",
  "job_level": "Mid-Senior level",
  "job_function": "Design",
  "salary_currency": "SGD",
  "processor": "https://apify.com/truefetch/linkedin-job-listing",
  "processed_at": "2026-07-21T12:00:00.000Z"
}
```

Use the live [Output schema](https://apify.com/truefetch/linkedin-job-listing/output-schema) for field types and representative examples.

### What inputs can I configure?

LinkedIn Job Listing exposes 9 public inputs in schema order, with 3 required and the rest optional.

| Parameter | Type | Required | Description | Example |
| --- | --- | :---: | --- | --- |
| `max_results` | integer | Yes | Maximum number of normalized LinkedIn listings to return. | `6` |
| `keyword` | string | Yes | Job title, skill, or company query for LinkedIn. | `Product Manager` |
| `country` | select | Yes | Country for the LinkedIn regional search. | `Germany` |
| `location` | string | No | City, area, or postal code for LinkedIn. | — |
| `posted_since` | date | No | Earliest posting date where LinkedIn accepts the filter. | — |
| `remote_only` | boolean | No | Return remote roles where LinkedIn accepts the filter. | — |
| `distance` | integer | No | Radius in miles around the location sent to LinkedIn. | — |
| `job_type` | select | No | Employment type filter accepted by LinkedIn. | — |
| `currency` | select | No | Target currency for converting salary amounts returned by LinkedIn. | — |

`country` has 98 accepted values; `job_type` has 5 accepted values; `currency` has 166 accepted values. Optional fields have no request effect when omitted; use the [live Input schema](https://apify.com/truefetch/linkedin-job-listing/input-schema) for types and accepted values.

### What platforms and markets does LinkedIn Job Listing cover?

LinkedIn Job Listing covers 98 country choices with optional location, distance, recency, remote, and employment filters.

The country selector contains 98 values: Algeria, Angola, Argentina, Australia, Austria, Azerbaijan, Bahrain, Bangladesh, Belgium, Bosnia and Herzegovina, Brazil, Bulgaria, Cameroon, Canada, Chile, China, Colombia, Costa Rica, Croatia, Cyprus, Czechia, Denmark, Dominican Republic, Ecuador, Egypt, El Salvador, Estonia, Finland, France, Germany, Ghana, Greece, Guatemala, Hong Kong, Hungary, India, Indonesia, Iraq, Ireland, Israel, Italy, Ivory Coast, Japan, Jordan, Kazakhstan, Kenya, Kuwait, Latvia, Lebanon, Libya, Lithuania, Luxembourg, Malaysia, Malta, Mexico, Morocco, Mozambique, Netherlands, New Zealand, Nigeria, Norway, Oman, Pakistan, Panama, Peru, Philippines, Poland, Portugal, Puerto Rico, Qatar, Romania, Russia, Saudi Arabia, Senegal, Serbia, Singapore, Slovakia, Slovenia, South Africa, South Korea, Spain, Sweden, Switzerland, Taiwan, Thailand, Tunisia, Turkey, Uganda, Ukraine, United Arab Emirates, United Kingdom, United States, Uruguay, Uzbekistan, Venezuela, Vietnam, Yemen, Zambia.

Coverage states where the Actor can form a request; live inventory, relevance, language, and optional field availability still come from the selected public source.

### Why use LinkedIn Job Listing?

| Capability | Practical benefit |
| --- | --- |
| LinkedIn-focused search | Use a narrow source contract when LinkedIn is the required board. |
| Combined public filters | Express role, market, recency, work mode, employment type, and radius in one run. |
| Normalized role taxonomy | Compare populated seniority, function, employment type, and skills fields across repeat searches. |
| Applicant and company context | Capture visible demand and employer signals without treating missing values as facts. |
| Source attribution | Preserve the listing URL and a separate official destination when one is available. |
| Apify delivery | Reuse the same input through the Console, API, schedules, webhooks, or MCP. |

The trade-off is that public LinkedIn data is variable. A stable schema simplifies consumption, but it cannot force every listing to publish salary, applicant, or company information.

### Who is LinkedIn Job Listing for?

| Team | Typical use |
| --- | --- |
| Product developers | Add LinkedIn vacancy search to a job product or internal research tool. |
| Data teams | Build repeatable snapshots of role demand by market, function, or seniority. |
| Recruiting operations | Monitor new openings without mixing several job boards in the same run. |
| Workforce analysts | Study posted roles, employment types, remote signals, and disclosed pay. |
| B2B intelligence teams | Use hiring activity as one source-attributed company signal. |

The Actor is not suitable for private-profile data, candidate contact extraction, recruiter messaging, applications, or guaranteed complete company profiles.

### How can I use LinkedIn Job Listing through the API or MCP?

The public Actor ID is **`E4AxzjmyF6mhrmww2`**; the name form **`truefetch/linkedin-job-listing`** is also accepted. This synchronous HTTP request runs the shared Singapore scenario:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/E4AxzjmyF6mhrmww2/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "Product Designer",
    "country": "Singapore",
    "max_results": 1,
    "location": "Singapore",
    "distance": 50,
    "posted_since": "3 days",
    "job_type": "contract",
    "currency": "SGD"
  }'
```

This configuration follows the current [Apify MCP documentation](https://docs.apify.com/integrations/mcp) and limits the available tool to this Actor:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=truefetch/linkedin-job-listing",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Ask the connected client for the same one-result Product Designer scenario. The [API page](https://apify.com/truefetch/linkedin-job-listing/api) provides asynchronous, SDK, and OpenAPI options.

### How much does LinkedIn Job Listing cost?

LinkedIn Job Listing costs $0.00375 per Result on FREE plus $0.01000 per minimum Actor Start event, so the smallest one-result test totals $0.01375.

| Apify tier | Actor Start | Per Result |
| --- | ---: | ---: |
| FREE | $0.01000 | $0.00375 |
| BRONZE | $0.01000 | $0.00338 |
| SILVER | $0.01000 | $0.00300 |
| GOLD | $0.01000 | $0.00281 |
| PLATINUM | $0.01000 | $0.00281 |
| DIAMOND | $0.01000 | $0.00281 |

Result is billed once for each item written to the default Dataset. Actor Start event count depends on selected memory, with a minimum of one event.

Smallest useful test: $0.01000 + 1 × $0.00375 = **$0.01375** on FREE when one item is published. A zero-result run can still incur Actor Start. [Prices can change; check live pricing](https://apify.com/truefetch/linkedin-job-listing/pricing) before scheduling volume.

### How does LinkedIn Job Listing compare with alternatives?

| Decision factor | LinkedIn Job Listing | Multi-board Job Search | Manual LinkedIn browsing |
| --- | --- | --- | --- |
| Source | LinkedIn only | Several compatible boards | LinkedIn only |
| Output | Structured 41-field Dataset | Shared multi-source schema | Human-readable pages |
| Repeatability | Saved input, API, MCP, schedules | Same, with broader source scope | Manual steps and copying |
| Best fit | LinkedIn-specific hiring signals | Cross-board coverage | Occasional one-off review |
| Main trade-off | Public fields can be sparse | Source depth is normalized | No reliable structured pipeline |

Choose LinkedIn Job Listing when LinkedIn is a required source and repeatable structured output matters. Choose [Job Search](https://apify.com/truefetch/job-search) when board diversity is more important than source-specific focus.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation | Next step |
| --- | --- | --- |
| Results are fewer than `max_results` | The value is a cap; public availability and relevance determine actual volume. | Broaden the keyword, location, or posting window. |
| A country-wide query feels broad | Without `location`, LinkedIn searches the selected country. | Add a city or region and an appropriate distance. |
| Some role attributes are empty | Seniority, function, skills, and employment type are not visible on every listing. | Keep these fields nullable downstream. |
| Applicant count is empty | LinkedIn does not always display an applicant count publicly. | Do not interpret null as zero applicants. |
| Salary is missing or unchanged | Conversion needs disclosed numeric pay, a source currency, and available exchange rates. | Compare only populated salary records. |
| `official_url` is empty | A separate employer destination is not always exposed. | Use `platform_url` to retain source attribution. |
| A listing disappears between runs | Public vacancies can close, change, or become unavailable. | Store collection timestamps and treat each run as a snapshot. |

For support, reproduce the problem with one keyword, one country, and `max_results: 1`, then share the run URL through [Apify Issues](https://apify.com/truefetch/linkedin-job-listing/issues). Do not share API tokens.

### Frequently asked questions

#### Can I use linkedin job listings api without linkedin login?

Yes. LinkedIn Job Listing runs on Apify without asking for a source-site publisher credential; an Apify account and token are still required for authenticated API or MCP calls.

#### How do I get linkedin job postings by keyword?

Set `keyword`, `country`, and `max_results`, then add only the optional fields present in this Actor's input table. Results are capped by source availability and relevance.

#### Does LinkedIn Job Listing require a source-site login?

No source-site username, password, cookie, or API key appears in the public input. The Actor collects accessible public listings independently of the source.

#### Why are salary, company, applicant, or contact values empty?

Those values are nullable because public listings do not expose the same detail. Empty means unavailable from the collected source, not zero or false.

#### Is there a free jobs API?

Apify accounts include platform usage under the current Apify plan, while this Actor bills Actor Start and Result events. Use the one-result calculation in Pricing to evaluate the smallest test.

#### Can I schedule runs to monitor LinkedIn job postings over time?

Yes. Test a small input first, then use Apify schedules and webhooks. Preserve `processed_at` and source URLs because listings can change, close, or reappear.

#### How is billing counted for LinkedIn Job Listing?

Billing uses Actor Start events and one Result event per default Dataset item. A requested result limit is a cap, not a prepaid bundle or a guarantee of source inventory.

### Related TrueFetch Actors

LinkedIn Job Listing has three nearby TrueFetch alternatives, each for a different source decision.

- [Job Search](https://apify.com/truefetch/job-search) — Use it when multiple boards matter more than source focus.
- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing) — Use it for an Indeed-only search contract.
- [Glassdoor Job Listing](https://apify.com/truefetch/glassdoor-job-listing) — Use it for employer-rating and disclosed-salary context.

### Support

Use the [Store page](https://apify.com/truefetch/linkedin-job-listing) for the run interface, the [API page](https://apify.com/truefetch/linkedin-job-listing/api) for generated clients, [Issues](https://apify.com/truefetch/linkedin-job-listing/issues) for reproducible bugs, and the [TrueFetch community](https://t.me/TrueFetch) for usage questions.

[**Run a one-result test**](https://apify.com/truefetch/linkedin-job-listing) · [**View API**](https://apify.com/truefetch/linkedin-job-listing/api)

**Last Updated:** August 10, 2026

# Actor input Schema

## `max_results` (type: `integer`):

Maximum LinkedIn job rows to return

## `keyword` (type: `string`):

Job title, skill, or company query to search on LinkedIn

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

Country-specific LinkedIn market used for the search

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

Optional city, area, or postal code for the LinkedIn search

## `posted_since` (type: `string`):

Optional earliest posting date for the LinkedIn search

## `remote_only` (type: `boolean`):

Optional remote-only filter for the LinkedIn search

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

Optional search radius in miles around the LinkedIn location

## `job_type` (type: `string`):

Optional employment type for the LinkedIn search; `all` disables this filter

## `currency` (type: `string`):

Optional target currency for normalized LinkedIn salary amounts

## Actor input object example

```json
{
  "max_results": 6,
  "keyword": "Product Manager",
  "country": "Germany"
}
```

# Actor output Schema

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

Default dataset overview of normalized job listings and company fields collected by All Jobs Scraper.

# 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 = {
    "max_results": 6,
    "keyword": "Product Manager",
    "country": "Germany"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/linkedin-job-listing").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 = {
    "max_results": 6,
    "keyword": "Product Manager",
    "country": "Germany",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/linkedin-job-listing").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 '{
  "max_results": 6,
  "keyword": "Product Manager",
  "country": "Germany"
}' |
apify call truefetch/linkedin-job-listing --silent --output-dataset

```

## MCP server setup

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

```

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/E4AxzjmyF6mhrmww2/builds/lTLZLbVkgg5WYtmSl/openapi.json