# LinkedIn Jobs API | Search Job Listings & Salaries (`johnvc/linkedin-jobs-api`) Actor

Search public LinkedIn job listings as clean, structured JSON. Find jobs by keyword, location, seniority, and job type, or fetch specific job URLs. Get title, company, location, salary, description, and apply links. Pay per job, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/linkedin-jobs-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 92 total users, 54 monthly users, 100.0% runs succeeded, 10 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.88 / 1,000 job scrapeds

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?

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 API | Search Job Listings & Salaries

The **LinkedIn Jobs API** turns public [LinkedIn](https://www.linkedin.com) job listings into clean, structured JSON. Use this actor with Claude, Cursor, or any MCP-compatible AI agent to find jobs by keyword, location, seniority, and job type, and get title, company, salary, description, and apply links, on reliable infrastructure and billed per job.

Run a keyword-and-location search, or fetch specific job posting URLs directly. Data comes from LinkedIn's public job pages, the same pages a signed-out visitor sees. It works as a straightforward **LinkedIn jobs scraper** for recruiting, market and salary research, and lead generation, and it is built API-first and MCP-ready so AI agents can call it as a tool.

***

### 🧩 Part of the Alpha OSINT LinkedIn suite: no login, no cookies

Eight Actors that read only what LinkedIn shows to a signed-out visitor. None of them asks for your account, your password or an `li_at` session cookie, so none of them can get your LinkedIn account restricted. Each one takes what the previous one returns, so you can chain them into a full people-and-company workflow:

| Step | You want to | Use |
|---|---|---|
| 1 | Find people by name, job title, company, school or location, no profile URL needed | [LinkedIn People Search API](https://apify.com/johnvc/linkedin-people-search-api?fpr=9n7kx3) |
| 2 | Turn profile URLs into full structured profiles: experience, education, followers | [LinkedIn Profile API](https://apify.com/johnvc/linkedin-profile-api?fpr=9n7kx3) |
| 3 | Enrich the employer: industry, size, headquarters, specialties, follower count | [LinkedIn Company API](https://apify.com/johnvc/linkedin-company-api?fpr=9n7kx3) |
| 4 | List the people who work at a company, each checked against their public profile | [LinkedIn Company Employees API](https://apify.com/johnvc/linkedin-company-employees-api?fpr=9n7kx3) |
| 5 | See what a company is hiring for, with salary data where LinkedIn publishes it | **LinkedIn Jobs API** (this Actor) |
| 6 | Search jobs as a guest with filters, total result counts and autocomplete ids | [LinkedIn Job Scraper](https://apify.com/johnvc/linkedin-job-search-scraper?fpr=9n7kx3) |
| 7 | Read what a person or company posts, with reactions, comments and shares | [LinkedIn Posts API](https://apify.com/johnvc/linkedin-posts-api?fpr=9n7kx3) |
| 8 | Map the skills people list to courses, learner reviews and full syllabi | [LinkedIn Learning API](https://apify.com/johnvc/linkedin-learning-api?fpr=9n7kx3) |

A worked map of these chains, with live adoption and success-rate stats for every Actor, is at [alphaosint.com/linkedin](https://alphaosint.com/linkedin/).

### 📋 What this API returns

| Field | Description |
|---|---|
| `jobUrl`, `jobId` | The job posting's public URL and identifier. |
| `title` | The job title. |
| `companyName`, `companyUrl`, `companyLogo` | The hiring company. |
| `location`, `countryCode` | Where the job is based. |
| `description` | The full job description text. |
| `seniorityLevel`, `employmentType`, `jobFunction` | Role level, type, and function. |
| `industries` | Industries associated with the role. |
| `salary` | The listed pay range or base salary, when present. |
| `postedDate`, `postedAgo`, `numApplicants` | When it was posted (date, and LinkedIn's "3 days ago" text) and how many have applied. |
| `salaryMin`, `salaryMax`, `salaryCurrency` | The pay range parsed into numbers, when a salary is listed. |
| `applyType` | Whether applying happens on the employer's site (`external`) or on LinkedIn (`linkedin`), when shown. |
| `applyUrl` | The employer's application link, when LinkedIn shows it to signed-out visitors (usually it does not). |
| `summary` | A plain-language one-line interpretation of the job. |
| `fromCache` | `true` when the row was served from the shared cache (see "Fresh data and the cache" below). |

**Not available:** `jobPoster` (the recruiter who posted the job). LinkedIn does not show the job poster to signed-out visitors, so this field is no longer returned. `countryCode` comes from the `country` input, or from the job location when it names a US state or a country; it is absent otherwise.

***

### 🎯 Use cases

- **Recruiting & sourcing.** Track open roles at target companies by keyword and location.
- **Market & salary research.** Analyze demand, seniority mix, and pay ranges across a role or region.
- **Lead generation.** Companies that are hiring are buying, find them by search and reach out.
- **Job aggregators.** Feed fresh, structured LinkedIn listings into a job board or newsletter.
- **Competitive hiring intelligence.** Watch which teams a competitor is building out.
- **AI agent workflows.** Drive this API over MCP from Claude to search and summarize jobs in-conversation.

***

### 🔁 Use it as a LinkedIn jobs scraper at scale

Point this LinkedIn jobs scraper at a role and a location and it returns one clean row per listing, with the same flat, predictable fields every time, which is what makes the output easy to load into a sheet, a database, or an ATS. Cap each search with `maxJobs` so a broad query never overshoots your budget, and narrow it with the seniority, job type, remote, and date filters to get exactly the roles you want.

The output doubles as **recruitment data** and **hiring signals**: which companies are staffing up, which teams they are building, and what they pay. If a search returns nothing, you get a clear error row for that search instead of a failed run, so one empty query never sinks the batch. Whether you run LinkedIn jobs scraping once or across thousands of listings, the shape of the data stays the same.

***

### ⚙️ Input examples

#### Search by keyword and location

```json
{
  "keyword": "python developer",
  "location": "New York",
  "maxJobs": 25
}
```

#### Search with filters

```json
{
  "keyword": "product manager",
  "location": "London",
  "experienceLevel": "mid-senior",
  "jobType": "full-time",
  "remote": true,
  "timeRange": "past-week",
  "maxJobs": 50
}
```

#### Fetch specific jobs by URL

```json
{
  "jobUrls": [
    "https://www.linkedin.com/jobs/view/4286961888"
  ]
}
```

`maxJobs` caps how many jobs are returned per search, so you control cost. The API returns one row per job.

#### How the filters work

- `keyword`, `location` (or `country` when location is empty), `company`, and `timeRange` are sent to LinkedIn's search. `company` is matched to LinkedIn's company list; if no close match is found, the company name is added to the keyword search instead.
- `jobType`, `experienceLevel`, and `remote` are applied **after fetching**, because LinkedIn's public search no longer applies them itself. Each job's listed employment type and seniority level must match the filter.
- `remote` is a **text match**: a job counts as remote when the word "remote" appears in its title, its location, or the first 2,000 characters of its description, and is not negated ("not remote", "no remote"). Treat it as a strong hint, not a guarantee.
- With any of these three filters on, the API checks at most 3 times `maxJobs` jobs, so a very narrow filter can return fewer than `maxJobs`. Jobs that do not match are skipped and never charged.
- Filters apply to searches only; every URL in `jobUrls` returns its job.

#### Fresh data and the cache

Results are shared through a cache, so a job someone fetched recently can come back instantly. Set `maxAgeDays` to control it:

- empty (default): job details up to 7 days old, search result pages up to about 6 hours old, company lookups up to 30 days old;
- a number: never serve anything older than that many days (it cannot raise the defaults above);
- `0`: always fetch fresh.

A row served from the cache has `fromCache: true`, and its `fetched_at` is the time it was originally fetched.

***

### 📤 Example output

Each job is returned as one JSON row:

```json
{
  "result_type": "job",
  "jobId": "4286961888",
  "jobUrl": "https://www.linkedin.com/jobs/view/4286961888",
  "title": "Senior Python Developer",
  "companyName": "GlossGenius",
  "companyUrl": "https://www.linkedin.com/company/glossgenius",
  "location": "New York, NY",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering and Information Technology",
  "industries": ["Software Development"],
  "salary": "$150,000.00/yr - $190,000.00/yr",
  "salaryMin": 150000,
  "salaryMax": 190000,
  "salaryCurrency": "USD",
  "postedDate": "2026-06-20T00:00:00.000Z",
  "postedAgo": "2 weeks ago",
  "numApplicants": 47,
  "applyType": "external",
  "countryCode": "US",
  "summary": "Senior Python Developer, at GlossGenius, New York, NY, Full-time, $150,000.00/yr - $190,000.00/yr",
  "fromCache": false
}
```

***

### 💰 Pricing (pay-per-event)

You pay per job returned. There is no per-run setup fee. The current per-event price is shown on the Store card and in the Actor's Monetization details. Because billing is per job, you only pay for the jobs actually delivered, and `maxJobs` lets you cap the volume of each search. Jobs skipped by the job type, experience level, or remote filters are not charged. A job served from the cache is billed the same as a freshly fetched one.

***

### 🔌 Use the LinkedIn Jobs API from Claude (MCP)

This Actor is MCP-server-compatible, so [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), Claude (desktop and web), Cursor, and other MCP clients can call it as a tool through Apify's hosted MCP server.

Add it with this Actor-specific URL:

`https://mcp.apify.com/?tools=actors,docs,johnvc/linkedin-jobs-api`

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

**New to Claude Code or Claude Cowork?** Start a [free trial](https://claude.ai/referral/uIlpa7nPLg).

Then ask Claude:

> *"Use the LinkedIn Jobs API to find remote senior product manager roles in the US posted this week and summarize the salary ranges."*

***

### 💸 Pay per run with crypto (x402)

The LinkedIn Jobs API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/linkedin-jobs-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: run job monitoring on a schedule

This API earns its keep as a recurring step in a pipeline, not a one-off run:

- **Tasks and Schedules.** Save a keyword-and-location search as a Task, then attach a Schedule to refresh that job feed daily, weekly, or monthly with no code, so new roles land automatically.
- **n8n, Make, and Zapier.** Trigger a run on a schedule or an event, then route fresh listings into your ATS, CRM, or a Slack channel. Apify has native connectors for each.
- **Supabase, Google Sheets, and databases.** Send the dataset straight to storage with a webhook or the Apify API so the rows land where your team already works.
- **MCP.** Call the API as a tool from Claude and other AI agents (see the section above) to search and summarize jobs inside an agent workflow.
- **Webhooks.** Fire a webhook on run completion to kick off the next step in your own system, such as scoring or de-duping new roles.

***

### 🔗 Related Tools

Build a full picture of who is hiring, the companies behind the roles, and the people posting them by pairing this with the rest of the LinkedIn suite:

- [LinkedIn Company API](https://apify.com/johnvc/linkedin-company-api?fpr=9n7kx3) - firmographics and sales intelligence for the companies that are hiring.
- [LinkedIn Company Employees API](https://apify.com/johnvc/linkedin-company-employees-api?fpr=9n7kx3) - the people who already work at a hiring company, such as the team a new role joins.
- [LinkedIn Profile API](https://apify.com/johnvc/linkedin-profile-api?fpr=9n7kx3) - structured data on the recruiters and people behind a posting.
- [LinkedIn Posts API](https://apify.com/johnvc/linkedin-posts-api?fpr=9n7kx3) - a company's or person's public posts and engagement, for hiring signals and outreach.
- [LinkedIn Learning API](https://apify.com/johnvc/linkedin-learning-api?fpr=9n7kx3) - course and skills data, to map the skills a role needs to courses that teach them.

Comparison point: some LinkedIn job scrapers on the Store are unmaintained or low-rated (for example [worldunboxer/rapid-linkedin-scraper](https://apify.com/worldunboxer/rapid-linkedin-scraper?fpr=9n7kx3), rated under 4 stars). This API is built for reliability, pay-per-job billing, and MCP access from AI agents.

***

### 📎 Applications

Ready-made task pages for common jobs. Open one, run it, or duplicate it as a starting point:

#### [Scrape LinkedIn Jobs to Structured JSON](https://apify.com/johnvc/linkedin-jobs-api/examples/scrape-linkedin-jobs-to-structured-json?fpr=9n7kx3)

Turn a keyword and location into clean JSON: title, company, location, salary, seniority, and apply link.

#### [Search LinkedIn Jobs by Keyword and Location](https://apify.com/johnvc/linkedin-jobs-api/examples/search-linkedin-jobs-by-keyword-and-location?fpr=9n7kx3)

Run a keyword-and-location search and get one structured row per job.

#### [LinkedIn Jobs Data API for Python](https://apify.com/johnvc/linkedin-jobs-api/examples/linkedin-jobs-data-api-for-python?fpr=9n7kx3)

Call the API from Python: a keyword and location in, structured job rows out.

#### [Scrape LinkedIn Jobs in an n8n Workflow](https://apify.com/johnvc/linkedin-jobs-api/examples/scrape-linkedin-jobs-in-an-n8n-workflow?fpr=9n7kx3)

Add job listings to an n8n workflow: pass a keyword and location, get structured rows back.

#### [Monitor Company Hiring on LinkedIn](https://apify.com/johnvc/linkedin-jobs-api/examples/monitor-company-hiring-on-linkedin?fpr=9n7kx3)

Track which roles a target company is opening by filtering on company and date.

#### [Track Remote LinkedIn Jobs by Keyword](https://apify.com/johnvc/linkedin-jobs-api/examples/track-remote-linkedin-jobs-by-keyword?fpr=9n7kx3)

Pull only remote roles posted recently, filtered by keyword, remote, and date window.

#### [Get LinkedIn Jobs in Claude via MCP](https://apify.com/johnvc/linkedin-jobs-api/examples/get-linkedin-jobs-in-claude-via-mcp?fpr=9n7kx3)

Use job search as a tool in Claude and other AI agents over MCP.

#### [Collect LinkedIn Jobs from a URL List](https://apify.com/johnvc/linkedin-jobs-api/examples/collect-linkedin-jobs-from-a-url-list?fpr=9n7kx3)

Paste up to 1000 LinkedIn job URLs and get one clean row each.

***

### 🚀 How to get started

1. Open the Actor and enter a `keyword` and `location` (or paste job URLs into `jobUrls`).
2. Set `maxJobs` to bound the volume, then run it and read the results from the dataset (JSON, CSV, Excel, or API).

[View on Apify Store](https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3)

**Example code:** [Python quick-start + MCP setup on GitHub](https://github.com/johnisanerd/Apify-LinkedIn-Jobs-API) - call the API from Python, or install it as a tool in Claude, Cursor, and ChatGPT.

***

### 🤖 Ask an AI assistant about this API

Open a ready-to-send prompt about the LinkedIn Jobs API in the AI of your choice:

- 💬 [ChatGPT](https://chatgpt.com/?q=Using%20the%20LinkedIn%20Jobs%20API%20on%20Apify%20%28https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3%29%2C%20walk%20me%20through%20this%20use%20case:%20%22Search%20LinkedIn%20Jobs%20by%20Keyword%20and%20Location%22.%20Show%20me%20the%20input%20JSON%2C%20the%20output%20fields%2C%20and%20how%20to%20automate%20it%20with%20the%20API%20or%20MCP.)
- 🧠 [Claude](https://claude.ai/new?q=Using%20the%20LinkedIn%20Jobs%20API%20on%20Apify%20%28https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3%29%2C%20walk%20me%20through%20this%20use%20case:%20%22Search%20LinkedIn%20Jobs%20by%20Keyword%20and%20Location%22.%20Show%20me%20the%20input%20JSON%2C%20the%20output%20fields%2C%20and%20how%20to%20automate%20it%20with%20the%20API%20or%20MCP.)
- 🔍 [Perplexity](https://www.perplexity.ai/search?q=Using%20the%20LinkedIn%20Jobs%20API%20on%20Apify%20%28https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3%29%2C%20walk%20me%20through%20this%20use%20case:%20%22Search%20LinkedIn%20Jobs%20by%20Keyword%20and%20Location%22.%20Show%20me%20the%20input%20JSON%2C%20the%20output%20fields%2C%20and%20how%20to%20automate%20it%20with%20the%20API%20or%20MCP.)
- 🅒 [Copilot](https://copilot.microsoft.com/?q=Using%20the%20LinkedIn%20Jobs%20API%20on%20Apify%20%28https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3%29%2C%20walk%20me%20through%20this%20use%20case:%20%22Search%20LinkedIn%20Jobs%20by%20Keyword%20and%20Location%22.%20Show%20me%20the%20input%20JSON%2C%20the%20output%20fields%2C%20and%20how%20to%20automate%20it%20with%20the%20API%20or%20MCP.)

### ❓ FAQ

#### Do I need to give you my LinkedIn cookies or login?

No, never. This Actor does not ask for, accept or store your LinkedIn cookies, your session cookie (`li_at`), your password or your account. There is no input field for any of them. It reads LinkedIn's public pages the way a signed-out visitor sees them. Any cookie involved is one LinkedIn's site hands to that anonymous visit, and it is used only inside that single run.

#### Is this a LinkedIn Jobs API or a LinkedIn jobs scraper?

Both descriptions fit. You call it like an API (a keyword and location in, structured JSON out), and under the hood it is a LinkedIn jobs scraper that reads public job listings. You never touch scraping infrastructure; you get clean, one-row-per-job data back.

#### What input should I provide?

A `keyword` and/or `location` (plus optional filters like `experienceLevel`, `jobType`, `remote`, and `timeRange`) to search, or specific LinkedIn job URLs in `jobUrls` (e.g. `https://www.linkedin.com/jobs/view/4286961888`). Supply a keyword, a location, a company, or at least one URL.

#### How do I search for remote jobs?

Set `remote` to true and add a `keyword` and `location`. Combine it with `timeRange` (past 24 hours, past week, past month) to pull only recently posted remote roles. The remote filter is a text match on each job's title, location, and the start of its description, so it can miss a remote job that never says "remote", or include one that mentions it in passing.

#### Do you return salaries?

Yes, when LinkedIn lists a pay range or base salary for the role, it is returned in the `salary` field. This makes the output a useful source of pay-range and recruitment data across a role or region.

#### Is it legal to scrape public LinkedIn job listings?

This actor collects only public job posting data. Public-data scraping has been addressed in court cases such as [hiQ Labs v. LinkedIn](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn), but you are responsible for your own use, including [GDPR](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation) and platform terms. Consult your own counsel for your use case.

#### Can I run it from Claude or another AI agent over MCP?

Yes. The Actor is MCP-server-compatible, so [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) and other MCP clients call it as a tool. See the MCP section above for the setup URL.

#### Can I schedule it or connect it to my other apps?

Yes. Save your search as a Task and attach a Schedule for recurring runs, and connect the output to n8n, Make, Zapier, Supabase, or your own system by webhook. See the Integrations section above.

#### How many jobs do I get per search?

As many as `maxJobs` (default 25, up to 500 per search). Raise it for broader searches; each returned job is billed, so `maxJobs` is also your cost cap.

#### What if a search returns no jobs?

The API returns a clear error row for that search explaining why, so an empty search does not fail the whole run.

***

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
See the [LinkedIn Jobs API source page](https://www.alphaosint.com/sources/linkedin-jobs-api/) for related tools and use cases.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/linkedin-jobs-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.10.04

# Actor input Schema

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

Job title or keyword to search for, e.g. 'python developer'. Combine with Location and filters.

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

Location to search within, e.g. 'New York' or 'United Kingdom'.

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

Two-letter country code to scope the search, e.g. 'US', 'GB', 'DE'.

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

Employment type filter. LinkedIn's public search no longer applies this filter itself, so it is applied after fetching: each job's listed employment type must match. Jobs that do not match are skipped and not charged.

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

Seniority filter. LinkedIn's public search no longer applies this filter itself, so it is applied after fetching: each job's listed seniority level must match. Jobs that do not match are skipped and not charged.

## `remote` (type: `boolean`):

Return only remote jobs. Applied after fetching as a text match: a job qualifies when the word 'remote' appears in its title, location, or the first 2,000 characters of its description, and is not negated ('not remote', 'no remote'). Jobs that do not match are skipped and not charged.

## `company` (type: `string`):

Filter to a specific company name. The name is matched to LinkedIn's company list; if no close match is found, the name is added to the keyword search instead.

## `timeRange` (type: `string`):

Only jobs posted within this window.

## `jobUrls` (type: `array`):

One or more specific LinkedIn job posting URLs, e.g. https://www.linkedin.com/jobs/view/4286961888. Each returns one row. Use instead of, or in addition to, the keyword search above. Up to 1000 per run. Need larger batches? Contact us and we can raise this limit for your account.

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

Maximum number of jobs to return for each keyword search or search URL. Caps upstream cost. Ignored for specific job URLs.

## `maxAgeDays` (type: `integer`):

Serve results fetched within this many days from the shared cache. 0 = always fetch fresh. Empty = the default for each record type.

## Actor input object example

```json
{
  "keyword": "python developer",
  "location": "New York",
  "remote": false,
  "maxJobs": 25
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: collected jobs and any error rows.

## `overview` (type: `string`):

Tabular overview of every dataset item using the dataset schema's default view. Columns: logo, title, company, location, type, salary, URL, summary.

## `compensation` (type: `string`):

Salary, seniority, applicant count, and direct apply link per job.

# 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 = {
    "keyword": "python developer",
    "location": "New York"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/linkedin-jobs-api").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 = {
    "keyword": "python developer",
    "location": "New York",
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/linkedin-jobs-api").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 '{
  "keyword": "python developer",
  "location": "New York"
}' |
apify call johnvc/linkedin-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/8gL3E4qLSkxxDyeDl/builds/NLFVdzpkV2vpOYoiY/openapi.json