# LinkedIn Jobs Scraper - Search & Export (`fetch_cat/linkedin-jobs-scraper`) Actor

Export public LinkedIn jobs by keyword, location, filters, or URL. Collect company details, descriptions, salary and applicant signals when available; download CSV, Excel, or JSON.

- **URL**: https://apify.com/fetch\_cat/linkedin-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 65 total users, 28 monthly users, 99.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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 Jobs Scraper - Search & Export

Search and export public LinkedIn jobs by keyword, location, experience level, job type, Easy Apply, or public search and individual job URLs.

Use this Actor to turn LinkedIn Jobs searches into clean recruiting, labor-market, sales, and job-board datasets. Results can be downloaded as CSV, JSON, Excel, XML, RSS, or used through the Apify Dataset API.

> **Automate job-match scoring in n8n:** Use the ready-made [Score LinkedIn job matches with OpenAI, Google Sheets, Slack, and Apify](https://n8n.io/workflows/17019-score-linkedin-job-matches-with-openai-google-sheets-slack-and-apify/) workflow to run this Actor, rank job postings with AI, and send matches to your team.

### Ready-to-run examples

Open a saved example to inspect its inputs, then adjust the limits and filters for your own run. Examples are starting points; source availability can change.

- [Job Alert Dataset Export](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-job-alert-dataset-export)
- [Part Time Developer Jobs](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-part-time-developer-jobs)
- [Remote AI Product Jobs](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-remote-ai-product-jobs)
- [Industry Hiring Snapshot](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-industry-hiring-snapshot)
- [Competitor Hiring Monitor](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-competitor-hiring-monitor)
- [Location Salary Keyword Research](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples/linkedin-location-salary-keyword-research)

[View all ready-to-run examples](https://apify.com/fetch_cat/linkedin-jobs-scraper/examples)

### Quick start

Use a focused search and a low cap. This example adds the documented experience-level and employment-type filters.

```json
{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "maxItems": 10,
  "includeDetails": true,
  "datePosted": "pastWeek",
  "workplaceType": "remote",
  "experienceLevels": [
    "entry",
    "associate"
  ],
  "jobTypes": [
    "fullTime"
  ],
  "sortBy": "recent"
}
```

### Example output

Shortened illustrative record, not a current job listing. Optional fields may be null.

```json
{
  "jobId": "4374834620",
  "title": "Software Engineer (New Grads)",
  "companyName": "Giga",
  "companyUrl": "https://www.linkedin.com/company/gigaml",
  "location": "New York, NY",
  "postedAtText": "5 days ago",
  "jobUrl": "https://www.linkedin.com/jobs/view/software-engineer-new-grads-at-giga-4374834620",
  "description": "About Giga...",
  "employmentType": "Volunteer",
  "seniorityLevel": "Not Applicable",
  "industries": "Software Development",
  "applicantsText": "Over 200 applicants",
  "sourceSearchUrl": "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search?...",
  "scrapedAt": "2026-06-17T11:13:45.322Z"
}
```

### Input settings

| Setting | JSON key | Type / default | What it does |
| --- | --- | --- | --- |
| Keywords | `keywords` | array / not set | Job titles, skills, company names, or search phrases. When neither keywords nor start URLs are supplied, the Actor searches for software engineer jobs for backward compatibility. |
| Location | `location` | string / not set | LinkedIn location text for keyword searches, such as United States, London, Berlin, or Remote. |
| LinkedIn jobs search or job URLs | `startUrls` | array / not set | Public LinkedIn Jobs search URLs or direct /jobs/view/ URLs. They are processed in addition to keyword searches; submit an empty keywords list to use only these URLs. |
| Maximum jobs | `maxItems` | integer / `20` | Maximum unique job rows saved across all searches and direct URLs. Use a small value while testing to cap spend. Minimum 1; maximum 10000. |
| Fetch job details | `includeDetails` | boolean / `true` | Fetch each public job page for description text and HTML, criteria, applicant and salary text, application link, workplace type, and other fields. Search-card rows are preserved if individual detail pages fail. |
| Date posted | `datePosted` | string / `"any"` | Filter keyword searches using LinkedIn's public date-posted options. Values: `any`, `past24h`, `pastWeek`, `pastMonth`. |
| Workplace type | `workplaceType` | string / `"any"` | Filter keyword searches by on-site, remote, or hybrid roles. Values: `any`, `onsite`, `remote`, `hybrid`. |
| Experience levels | `experienceLevels` | array / `[]` | Optional LinkedIn experience-level filters. Select any combination. Values: `internship`, `entry`, `associate`, `midSenior`, `director`, `executive`. |
| Job types | `jobTypes` | array / `[]` | Optional LinkedIn employment-type filters. Select any combination. Values: `fullTime`, `partTime`, `contract`, `temporary`, `volunteer`, `internship`, `other`. |
| Easy Apply only | `easyApplyOnly` | boolean / `false` | Ask LinkedIn's public search endpoint to return only jobs marked for Easy Apply. |
| Sort by | `sortBy` | string / `"relevance"` | Choose LinkedIn relevance ranking or newest jobs first. Values: `relevance`, `recent`. |
| Retries per request | `retryCount` | integer / `3` | Retries temporary blocks, rate limits, timeouts, TLS failures, and server errors with a fresh proxy route. Minimum 0; maximum 8. |
| Initial retry delay (milliseconds) | `initialRetryDelayMillis` | integer / `1000` | Initial backoff before retrying a temporary request failure. Later retries wait longer and Retry-After is honored. Minimum 250; maximum 30000. |
| Request pacing (milliseconds) | `requestPacingMillis` | integer / `250` | Delay between successful request batches. Increase it if a broad run is rate-limited. Minimum 0; maximum 10000. |
| Detail request concurrency | `detailConcurrency` | integer / `4` | Maximum public job detail pages fetched at once. Lower values reduce request pressure; higher values finish enrichment faster. Minimum 1; maximum 12. |
| Safe run-time limit (seconds) | `runTimeSecs` | integer / `240` | Stop requesting new pages early enough to preserve saved rows and write RUN\_SUMMARY before the platform timeout. Minimum 30; maximum 270. |
| Proxy configuration | `proxyConfiguration` | object / `{"useApifyProxy":true}` | Apify Proxy is recommended for LinkedIn public pages. Temporary failures rotate to a fresh proxy URL automatically. |

### Filter and URL behavior

`datePosted`, `workplaceType`, `experienceLevels`, `jobTypes`, `easyApplyOnly`, and `sortBy` configure keyword-generated searches. When supplying a prebuilt search URL, keep the desired filters in that URL. For URL-only collection, send `keywords: []`. Direct job URLs do not become a fresh filtered search.

`includeDetails: false` keeps collection to search-card fields. When a detail request fails, a previously collected search-card row can still be saved with `detailFetched: false`. Check `RUN_SUMMARY` for failures and partial coverage. Retry and pacing controls can reduce request pressure but do not guarantee access.

LinkedIn controls how public searches interpret filters, and search behavior can change. Treat requested filters as search constraints, not a guarantee that every returned job matches. Verify returned fields before using the dataset for exact eligibility rules.

### Output fields

| JSON key | Type | Meaning |
| --- | --- | --- |
| `jobId` | string | LinkedIn job posting identifier. |
| `title` | string / null | Public job title. |
| `companyName` | string / null | Public employer name. |
| `companyUrl` | string / null | Public LinkedIn company page when available. |
| `companyId` | string / null | Numeric LinkedIn company identifier when present in the public URL. |
| `companyLogoUrl` | string / null | Public company logo image URL when visible. |
| `location` | string / null | Location shown on the posting. |
| `postedAtText` | string / null | Relative posting-age text shown by LinkedIn. |
| `postedAt` | string / null | Normalized public posting timestamp when available. |
| `jobUrl` | string | Direct public LinkedIn job URL. |
| `description` | string / null | Clean public job description text when detail fetching succeeds. |
| `descriptionHtml` | string / null | Public job description markup when detail fetching succeeds. |
| `employmentType` | string / null | Employment type shown in job criteria. |
| `seniorityLevel` | string / null | Seniority level shown in job criteria. |
| `industries` | string / null | Industry text shown in job criteria. |
| `jobFunction` | string / null | Job function shown in job criteria. |
| `workplaceType` | string / null | On-site, remote, or hybrid label when visible on the detail page. |
| `salaryText` | string / null | Public compensation text when disclosed. |
| `applicantsText` | string / null | Public applicant-count text when visible. |
| `applicantsCount` | integer / null | Numeric portion of the public applicant-count text. |
| `applyUrl` | string / null | Public application destination when exposed by the page. |
| `easyApply` | boolean / null | Whether the public application control is labeled Easy Apply. |
| `criteria` | object | All public label/value job criteria found on the detail page. |
| `sourceSearchUrl` | string / null | Search or direct-job source that produced the row. |
| `sourceKind` | string | Whether the row came from a search page or direct job URL. |
| `detailFetched` | boolean | True when public detail enrichment succeeded. |
| `scrapedAt` | string | ISO timestamp when the row was parsed. |

`applicantsCount` is a numeric extraction from public applicant text, not necessarily an exact total: for example, “Over 200 applicants” may produce `200`. Keep `applicantsText` for context.

### Pricing

The `start` event is charged once after input validation. The `result` event applies to each unique saved job row. A saved search-card row remains a billable result if optional detail enrichment fails; source errors and duplicate jobs are not additional job results. A valid empty run can still incur its start charge.

See the [live Pricing tab](https://apify.com/fetch_cat/linkedin-jobs-scraper/pricing) for current rates and discounts. Check the cost shown for your account before scaling a run; any applicable platform usage is shown by Apify separately.

### At a glance

- **Public job search**: Search LinkedIn Jobs by role, skill, company keyword, location, date posted, workplace type, and sort order.
- **Search URL reuse**: Paste a public LinkedIn Jobs search URL when you already built the right search in the browser.
- **Detail enrichment**: Optionally fetch job descriptions, seniority, employment type, industries, and applicant text from public job pages.
- **Hiring intelligence**: Monitor hiring demand by company, role, region, seniority, skill, and remote or hybrid status.
- **API export**: Send job rows to spreadsheets, CRMs, BI tools, job boards, matching pipelines, or AI agents.

### What can it do?

LinkedIn Jobs Scraper collects public job posting data from LinkedIn Jobs and saves one dataset row per job posting.

- **Find matching roles**: Enter one or more keywords such as `software engineer`, `data analyst`, `nurse`, or `sales development representative`.
- **Filter by market**: Add a location, date-posted option, workplace type, and sort order.
- **Collect public details**: Enable detail fetching when you need descriptions, criteria, industries, seniority, and applicant text.
- **Deduplicate results**: The Actor deduplicates by LinkedIn job ID across searches and start URLs.
- **Export clean rows**: Use the Apify UI, Dataset API, integrations, schedules, and webhooks.

### Weekly competitor hiring intelligence with AI

Turn public job listings into a repeatable competitor brief:

1. Save one focused search per competitor, role family, or region and run it weekly with an Apify schedule.
2. Keep `includeDetails: true` when an AI model needs descriptions, seniority, employment type, or industry context—not only job counts.
3. Send the finished dataset through an Apify webhook or API to n8n, a warehouse, or your AI workflow.
4. Compare the current run with the previous snapshot, then ask the model to group roles by function, summarize new locations and skills, and cite each finding with `jobUrl`.
5. Route the brief to a dashboard or an approved internal channel. Keep the raw rows for verification instead of relying on an uncited summary.

**Choose the right source:** Start here for broad public LinkedIn search by keyword and location. Add [ATS Jobs Scraper](https://apify.com/fetch_cat/ats-jobs-scraper) for normalized employer-hosted boards across six ATS platforms, or [Workday Jobs Scraper](https://apify.com/fetch_cat/workday-jobs-scraper) for named companies whose career sites run on Workday. These Actors produce separate datasets; join them downstream using company, title, location, and job URL rather than assuming identical schemas.

### Turn hiring into account research

Monitoring jobs for sales signals? Pair this Actor with [LinkedIn Public Company Profiles Scraper](https://apify.com/fetch_cat/linkedin-company-profiles-scraper) for firmographics, then [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder) for public business contact evidence. Join separate datasets by reviewed company URL or website domain; keep each job URL as the source for the hiring signal.

### Common workflows

- **Recruiting research**: Build lists of roles, companies, locations, and job URLs for sourcing and market mapping.
- **Lead generation**: Find companies hiring for roles that indicate buying intent, growth, or an active initiative.
- **Labor-market analysis**: Compare demand across locations, job titles, workplace types, or posting freshness.
- **Job-board ingestion**: Export public LinkedIn job rows for review before adding them to downstream workflows.
- **Competitive tracking**: Monitor target companies or role families on a daily or weekly schedule.
- **Student or job-seeker research**: Export matching roles into a table for comparison and follow-up.

### How to run it

1. Open the Actor on Apify.
2. Enter one or more keywords, a location, or public LinkedIn Jobs search URLs.
3. Set `maxItems` to the number of jobs you want to save.
4. Choose date, workplace, sort, and detail options.
5. Start the run.
6. Download the dataset or connect it to your workflow.

### Search tips

- **Start specific**: Use role names like `backend engineer`, `account executive`, or `data analyst` instead of one broad word.
- **Use one region per run**: Separate locations make comparison and deduplication easier.
- **Monitor freshness**: Use `sortBy: "recent"` and `datePosted: "past24h"` or `pastWeek` for alerts.
- **Control cost**: Keep `maxItems` low while testing and increase it after the search returns relevant roles.
- **Fetch details only when needed**: Disable `includeDetails` when company, title, location, and URL are enough.

### Limits and caveats

- The Actor extracts publicly visible LinkedIn Jobs data.
- It does not access private recruiter data, logged-in-only data, messages, applicants, or private profiles.
- LinkedIn may change page structures or rate-limit requests, so very large or broad runs should be split into focused searches.
- Some optional fields are empty when LinkedIn does not show them publicly for a job.

### Integrations

You can connect the dataset to downstream tools:

- Export CSV or Excel to spreadsheets for recruiting reports.
- Send company lists to a CRM for lead prioritization.
- Use Apify schedules for daily or weekly hiring monitoring.
- Trigger webhooks when a run finishes.
- Pull results into a database, warehouse, BI dashboard, matching model, or AI agent.

### FAQ

#### Can I scrape LinkedIn jobs without a LinkedIn account?

Yes. This Actor targets public LinkedIn Jobs pages and public job data.

#### Can I export LinkedIn jobs to CSV or Excel?

Yes. Apify datasets can be downloaded as CSV, JSON, Excel, XML, RSS, HTML, or accessed through the API.

#### Why are some detail fields empty?

LinkedIn does not show every field on every public job. Detail fields also require `includeDetails` to be enabled.

#### Can I run it every day?

Yes. Use Apify schedules and set a focused query, date filter, and moderate `maxItems` value.

### Related scrapers

- [Greenhouse Job Board Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/fetch_cat/workday-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/fetch_cat/lever-jobs-scraper)
- [SmartRecruiters Jobs Scraper](https://apify.com/fetch_cat/smartrecruiters-jobs-scraper)
- [RemoteOK Jobs Scraper](https://apify.com/fetch_cat/remoteok-jobs-scraper)

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses job-search inputs and public job-posting results to produce the output dataset and sends requests to public Linkedin Jobs pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

### API usage

Use your Apify API token through the `APIFY_TOKEN` environment variable. Node.js and Python examples wait for the run and read its first dataset page; paginate the dataset for larger exports.

**Node.js**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/linkedin-jobs-scraper').call({
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "maxItems": 10,
  "includeDetails": true,
  "datePosted": "pastWeek",
  "workplaceType": "remote",
  "experienceLevels": [
    "entry",
    "associate"
  ],
  "jobTypes": [
    "fullTime"
  ],
  "sortBy": "recent"
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
import json
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = json.loads('''{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "maxItems": 10,
  "includeDetails": true,
  "datePosted": "pastWeek",
  "workplaceType": "remote",
  "experienceLevels": [
    "entry",
    "associate"
  ],
  "jobTypes": [
    "fullTime"
  ],
  "sortBy": "recent"
}''')
run = client.actor("fetch_cat/linkedin-jobs-scraper").call(run_input=run_input)
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

**cURL**

Save the quickstart JSON as `input.json`. This request starts a run asynchronously; use its returned run ID to check completion and its `defaultDatasetId` to retrieve results.

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~linkedin-jobs-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  --data-binary @input.json
```

### MCP and AI agents

Use the official [Apify MCP server](https://docs.apify.com/integrations/mcp), not a separate custom server. The focused URL below selects this Actor. Authenticate with Apify when your client prompts you; configuration syntax and OAuth support depend on the client.

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=fetch_cat/linkedin-jobs-scraper"
```

**HTTP-capable MCP client configuration**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/linkedin-jobs-scraper"
    }
  }
}
```

**Example prompt:** "Export up to 10 entry-level remote software engineering jobs in the United States from the past week. Include source URLs and distinguish missing details from zero values."

Use the same input keys as the input table. Review the returned source URLs and any error or availability fields before using results in an automated summary.

### Support

If a run fails or output looks wrong, open an issue from the Actor page. Include the Apify run ID or run URL, non-sensitive input JSON, expected output, actual output, and one reproducible public URL (or the exact search input). Do not share tokens, cookies, passwords, or private data.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills, company names, or search phrases. When neither keywords nor start URLs are supplied, the Actor searches for software engineer jobs for backward compatibility.

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

LinkedIn location text for keyword searches, such as United States, London, Berlin, or Remote.

## `startUrls` (type: `array`):

Public LinkedIn Jobs search URLs or direct /jobs/view/ URLs. They are processed in addition to keyword searches; submit an empty keywords list to use only these URLs.

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

Maximum unique job rows saved across all searches and direct URLs. Use a small value while testing to cap spend.

## `includeDetails` (type: `boolean`):

Fetch each public job page for description text and HTML, criteria, applicant and salary text, application link, workplace type, and other fields. Search-card rows are preserved if individual detail pages fail.

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

Filter keyword searches using LinkedIn's public date-posted options.

## `workplaceType` (type: `string`):

Filter keyword searches by on-site, remote, or hybrid roles.

## `experienceLevels` (type: `array`):

Optional LinkedIn experience-level filters. Select any combination.

## `jobTypes` (type: `array`):

Optional LinkedIn employment-type filters. Select any combination.

## `easyApplyOnly` (type: `boolean`):

Ask LinkedIn's public search endpoint to return only jobs marked for Easy Apply.

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

Choose LinkedIn relevance ranking or newest jobs first.

## `retryCount` (type: `integer`):

Retries temporary blocks, rate limits, timeouts, TLS failures, and server errors with a fresh proxy route.

## `initialRetryDelayMillis` (type: `integer`):

Initial backoff before retrying a temporary request failure. Later retries wait longer and Retry-After is honored.

## `requestPacingMillis` (type: `integer`):

Delay between successful request batches. Increase it if a broad run is rate-limited.

## `detailConcurrency` (type: `integer`):

Maximum public job detail pages fetched at once. Lower values reduce request pressure; higher values finish enrichment faster.

## `runTimeSecs` (type: `integer`):

Stop requesting new pages early enough to preserve saved rows and write RUN\_SUMMARY before the platform timeout.

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

Apify Proxy is recommended for LinkedIn public pages. Temporary failures rotate to a fresh proxy URL automatically.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "datePosted": "any",
  "workplaceType": "any",
  "experienceLevels": [],
  "jobTypes": [],
  "easyApplyOnly": false,
  "sortBy": "relevance",
  "retryCount": 3,
  "initialRetryDelayMillis": 1000,
  "requestPacingMillis": 250,
  "detailConcurrency": 4,
  "runTimeSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

# 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",
    "startUrls": []
};

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

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/linkedin-jobs-scraper").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 '{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "startUrls": []
}' |
apify call fetch_cat/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/0XhGPLTjZjicBXYV5/builds/PDb9USYDWoAz0YVwk/openapi.json