# LinkedIn Jobs and Indeed Scraper (`agenttoolworks/linkedin-indeed-jobs-scraper`) Actor

LinkedIn Jobs scraper plus Indeed scraper in one run, no account and no cookies: search by keywords, location and country, and get one table with title, company, location, remote or hybrid, posted date, salary, seniority, applicants, full description and apply link.

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

## Pricing

from $0.35 / 1,000 linkedin job with descriptions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What is this LinkedIn Jobs scraper and Indeed scraper?

This Actor is a **LinkedIn Jobs scraper** and an **Indeed scraper** in one run. Type a job title, a skill or a company, a city and a country once, and get the public job listings of **LinkedIn Jobs** and **Indeed** back in **one table, one row format**: title, company, location, posting date, salary (parsed into min, max, currency and period), employment type, seniority, applicant count, remote or hybrid where the board says so, the **full job description**, and links to the job and to apply.

No LinkedIn account, no Indeed account, no cookies: the Actor reads what both boards show any logged-out visitor.

![LinkedIn Jobs scraper and Indeed scraper: one search in, both boards out in one table, from a real run](https://agenttoolworks.com/apify/jobboards-overview.png)

### What data can you extract from LinkedIn Jobs and Indeed?

One row per job, the same fields on both boards. Where a board does not publish a field, it is `null`, never guessed.

| Job data | Pay and conditions | Links and context |
|---|---|---|
| Job ID, title, company, location | Salary as published (`salaryText`) | Job page on the board (`jobUrl`) |
| Full description, as text and HTML | Parsed salary: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Apply link (`applyUrl`) and apply type on LinkedIn (`external` or `easy-apply`) |
| Posting date, the employer's date (`postedAt`) | Employment type (full-time, contract, CDI...) | Company page and company logo |
| Seniority and industries (LinkedIn) | Workplace type: remote, hybrid or on-site, where the board says so | Applicant count (LinkedIn) |
| Board (`provider`: `linkedin` or `indeed`) | Benefits (where listed) | The search that found it, and when it was read |

### What can you use LinkedIn and Indeed job data for?

- **Job market and salary research**: what a role pays in a city, how many employers hire for it, which skills they ask for.
- **Recruiting and sales prospecting**: which companies are hiring for a function right now, with the company page and the applicant count.
- **Job boards and aggregators**: fresh listings from both boards, deduplicated, in one format.
- **Job alerts**: schedule a search and get the new jobs every morning.
- **Data for AI agents and pipelines**: one predictable JSON row whatever the board.

Need the employers' own career pages too (Greenhouse, Lever, Ashby, Workable and more)? Pair it with [JobsRadar](https://apify.com/agenttoolworks/jobsradar-multi-board-job-search): same first columns, so the two outputs stack into one table.

### How to scrape LinkedIn Jobs and Indeed

1. Click **Try for free** (or **Start**) on this page and sign in to Apify.
2. Type the **Keywords** (`data engineer`), the **Location** (`Paris`) and pick the **Country** (`France`).
3. Keep both **Job boards** or pick one.
4. Set **Max jobs per board**. You pay per job returned, so start small to look at the data.
5. Click **Start**. When the run finishes, open the **Output** tab, pick the **Jobs**, **Salaries** or **Descriptions** view, and export as JSON, CSV, Excel or XML, or read it through the API.

![The Actor's input form in Apify Console: keywords, location, country, job boards, max jobs per board and the description switches](https://agenttoolworks.com/apify/jobboards-input-form.jpg)

### Input

| Field | What it does |
|---|---|
| `keywords` | What to search, as you would type it on LinkedIn or Indeed: a job title, a skill or a company. Required. |
| `location` | A city, region or postcode. Empty searches the whole country. |
| `country` | Picks Indeed's country site (fr.indeed.com, uk.indeed.com...) and completes the location for LinkedIn. 30 countries. |
| `boards` | `linkedin`, `indeed`. Both by default. |
| `maxResultsPerBoard` | Stop after this many jobs on each board (default 100, up to 5,000). |
| `includeDescription` | LinkedIn: read each job's own page for the full description, seniority, employment type, industries, applicant count and base pay (default on). Off returns the search card only, at the lower price. |
| `indeedDescriptions` | Indeed: the full description on every row (default on). Off returns the same rows without it, at the lower price. |
| `strictLocation` | Both boards widen a city to its area (a London search returns Teddington). On, only jobs whose location names the searched place are returned and charged. |
| `datePosted` | `any`, `24h`, `3d`, `week`, `2weeks`, `month`. |
| `jobTypes` | Full-time, part-time, contract, temporary, internship, volunteer. |
| `workplaceTypes` | Remote, hybrid, on-site. |
| `experienceLevels` | Internship to executive (LinkedIn seniority; Indeed where its country site offers the filter). |
| `proxy` | `auto` (recommended): LinkedIn through Apify datacenter proxy, Indeed through Apify residential proxy in the searched country, which is what worked in our cloud runs. |

Example: data engineer jobs in Paris on both boards, 20 per board (the run shown on this page).

```json
{
  "keywords": "data engineer",
  "location": "Paris",
  "country": "FR",
  "boards": ["linkedin", "indeed"],
  "maxResultsPerBoard": 20
}
```

Example: remote Python jobs posted in the past week in the United States, LinkedIn only, search cards only (the cheapest LinkedIn rows).

```json
{
  "keywords": "python developer",
  "country": "US",
  "boards": ["linkedin"],
  "datePosted": "week",
  "workplaceTypes": ["remote"],
  "includeDescription": false,
  "maxResultsPerBoard": 500
}
```

Example: nurses in London itself, not the commuter belt, Indeed only, 1,000 jobs.

```json
{
  "keywords": "nurse",
  "location": "London",
  "country": "GB",
  "boards": ["indeed"],
  "strictLocation": true,
  "maxResultsPerBoard": 1000
}
```

### Output

The dataset holds one row per job, with three ready-made views in Apify Console and in the API:

- **Jobs**: board, title, company, location, workplace, type, seniority, posting date, salary, applicants, apply type and links.
- **Salaries**: the salary as published and parsed into min, max, currency and period.
- **Descriptions**: the full description of every job.

**No duplicates**: a job is returned and charged once per run, keyed by board and job ID, across pages and date windows. An employer that posts the same role twice under two IDs gets two rows, as on the board.

![Jobs view of a real run in Apify Console: LinkedIn data engineer jobs in Paris with logo, title, company, location, type, seniority, posting date, applicants and apply type](https://agenttoolworks.com/apify/jobboards-jobs-view.jpg)

![Salaries view of a real run: Indeed nurse jobs in London with the salary as published, parsed min and max, currency and period](https://agenttoolworks.com/apify/jobboards-salaries-view.jpg)

A **LinkedIn** row from a cloud run (`data engineer`, Paris, 2026-10-05; description and logo URL shortened):

```json
{
  "id": "linkedin:4462226292",
  "provider": "linkedin",
  "jobId": "4462226292",
  "title": "Senior Data Engineer",
  "company": "PUR",
  "location": "Paris, Île-de-France, France",
  "postedAt": "2026-09-07",
  "postedText": "3 weeks ago",
  "employmentType": "Full-time",
  "seniority": "Associate",
  "industries": "Environmental Services",
  "salaryText": "€50,000.00/yr - €60,000.00/yr",
  "salaryMin": 50000,
  "salaryMax": 60000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "applicantsCount": 89,
  "applyType": "external",
  "jobUrl": "https://fr.linkedin.com/jobs/view/senior-data-engineer-at-pur-4462226292",
  "applyUrl": "https://fr.linkedin.com/jobs/view/senior-data-engineer-at-pur-4462226292",
  "companyUrl": "https://fr.linkedin.com/company/pur-projet",
  "companyLogo": "https://media.licdn.com/dms/image/v2/D4D0BAQEcPN5Cei30AQ/company-logo_100_100/...",
  "description": "Job title: Senior Data Engineer\nDepartment: Data team\nReports to: Lead Data Engineer\nLocation: Paris, France\nContract: Permanent, local and full-time...",
  "detailStatus": "full",
  "country": "FR",
  "query": "data engineer",
  "scrapedAt": "2026-10-05T01:02:55.121Z"
}
```

An **Indeed** row from a cloud run (`nurse`, London, 2026-10-05), with a one-sided salary kept ("From £37.50 an hour": `salaryMax` stays `null` rather than guessed):

```json
{
  "id": "indeed:7f2a10ab8e5955bf",
  "provider": "indeed",
  "jobId": "7f2a10ab8e5955bf",
  "title": "Nurse Prescriber - PRP, Phlebotomy, ScleroTherapy practitioner",
  "company": "Advanced Aesthetics of London",
  "location": "Claremont KT10 8QS",
  "postedAt": "2026-10-04T16:57:46.648Z",
  "workplaceType": "onsite",
  "salaryText": "From £37.50 an hour",
  "salaryMin": 37.5,
  "salaryMax": null,
  "salaryCurrency": "GBP",
  "salaryPeriod": "hour",
  "jobUrl": "https://uk.indeed.com/viewjob?jk=7f2a10ab8e5955bf",
  "applyUrl": "https://uk.indeed.com/applystart?jk=7f2a10ab8e5955bf",
  "companyUrl": "https://uk.indeed.com/cmp/Advanced-Aesthetics-of-London",
  "description": "Self-Employed: PRP / Phlebotomy / Sclerotherapy Practitioner / Independent Prescriber\nUKPay: From £37.50 per hour...",
  "detailStatus": "full",
  "country": "GB",
  "query": "nurse",
  "scrapedAt": "2026-10-05T01:03:39.716Z"
}
```

#### Run summary

The run's key-value store holds a `SUMMARY` record with one status per board: `ok`, `partial` (fewer jobs than asked while the board shows more, with the reason), or `failed`, plus how many jobs each board returned, how many requests it took and how long. A short result is never silent: a run can succeed on Apify while a board returned nothing, and the summary is where you see it.

### Limits worth knowing before you run it

- **LinkedIn does not show the employer's external apply URL to logged-out visitors**: its Apply button opens a sign-in page. So on LinkedIn rows `applyUrl` is the LinkedIn job page, and `applyType` says whether the job applies on the employer's site (`external`) or through LinkedIn (`easy-apply`). We checked from datacenter and residential addresses in the US and France: 0 of 4,440 cloud rows carried an external URL. The Actor never logs in to get it.
- **LinkedIn workplace type is partial**: LinkedIn publishes no remote or hybrid field to visitors, so the Actor reads it from the title, the location and explicit phrases in the description. Filled on 0 to 13% of LinkedIn rows in our runs. Indeed labels it itself (16 to 30% of rows).
- **LinkedIn salary is filled when the employer publishes it**: 5 to 15% of LinkedIn rows in our runs, the same share as the other LinkedIn scrapers we measured. On Indeed, 22 to 29% in Paris and 86 to 88% in London.
- **Indeed is read through Apify residential proxy** in the searched country: Indeed refused Apify's cloud without proxy and challenged its datacenter proxy in our tests. `proxy: auto` does this for you. It is part of what the Indeed price pays for.
- **Indeed's search is broad**: it matches the keywords anywhere in the job, so a "data engineer" search also returns data scientists and other engineers (7 of the first 20 Indeed titles in Paris named data). That is what Indeed's own site returns. LinkedIn's titles matched on 20 of 20.
- **Past 1,000 results**: LinkedIn shows visitors about 1,000 per search, Indeed's search stops at 1,000. The Actor then reads narrower date windows of the same search and unions them by job ID: 1,812 Indeed jobs for a search Indeed counts at 1,821, and 1,299 LinkedIn cards for a London search. The summary says `partial` when it stops short of what the board shows.

### How it compares with the leaders (measured)

Same queries on every Actor: "data engineer" in Paris and "nurse" in London, 100 jobs each. The leaders' figures are Apify cloud runs of 2026-10-02 (our teardown); ours are Apify cloud runs of 2026-10-05 (builds 0.1.1 and 0.1.2). Prices are the FREE-tier Store prices of 2026-10-02.

| | curious_coder LinkedIn | bebity LinkedIn | valig LinkedIn | valig Indeed | borderline Indeed | misceres Indeed | **This Actor** |
|---|---|---|---|---|---|---|---|
| Price per 1,000 jobs | $2.00 | $1.50 | $0.40 | $0.10 | $5.00 | $6.00 | **LinkedIn $0.35 ($0.15 cards only), Indeed $0.10 ($0.05 without descriptions)** |
| Both boards in one run | no | no | no | no | no | no | **yes** |
| Run time for 100 jobs | 71 to 87 s | 33 to 44 s | 46 to 54 s | 3 to 4 s | 18 to 23 s | 9 to 17 s | **LinkedIn 23 to 36 s, Indeed 10 to 11 s** |
| Salary filled, Paris / London | 6% / 14% | 10% / 12% | 6% / 14% | 20% / 58% | 55% / 80% | 22% / 90% | **LinkedIn 5% / 15%, Indeed 22% / 88%** |
| One-sided salary ("From £X") kept | | | | no | | | **yes** |
| Posting date | employer's | employer's | employer's | Indeed's ingestion date | | none | **employer's, both boards** |
| External apply URL, LinkedIn | 0% | 58 to 93% | 0% | | | | **0%, apply type flagged instead** |
| Applicant count, LinkedIn | | | | | | | **yes** |
| Past 1,000 results | top complaint in its issues | | | "hardcapped at 1000" (its reviews) | | | **yes, by date windows** |
| Duplicate rows | 0 | 0 | 0 | 0 | 0 | 0 | **0** |

The external apply URL is the one LinkedIn field we do not deliver and bebity does; we have not found where it comes from on any logged-out page.

### How much does it cost to scrape LinkedIn Jobs and Indeed?

Pay per event, no subscription, platform usage included. You pay per job returned:

| Event | Price |
|---|---|
| LinkedIn job with its full description and details (the default) | **$0.35 per 1,000 LinkedIn jobs** |
| LinkedIn job, search card only (`includeDescription` off) | **$0.15 per 1,000 LinkedIn jobs** |
| Indeed job with its full description (the default) | **$0.10 per 1,000 Indeed jobs** |
| Indeed job without description (`indeedDescriptions` off) | **$0.05 per 1,000 Indeed jobs** |

Examples:

- **1,000 LinkedIn jobs and 1,000 Indeed jobs**, descriptions included: $0.45.
- **The 40 jobs on this page** (20 per board, with descriptions): under one cent.
- A duplicate, a job past your maximum, or a job left out by a filter (strict city, date, job type) is never charged.
- **Apify's free plan** includes $5 of monthly usage ([apify.com/pricing](https://apify.com/pricing)), enough for about **14,000 LinkedIn jobs** or **50,000 Indeed jobs** with descriptions a month.

Set a maximum cost per run in the run options and the Actor stops cleanly when it is reached.

### Use the Actor through the Apify API

Run it and get the jobs in one HTTP call (replace `YOUR_APIFY_TOKEN`, from **Settings > API & Integrations** in Apify Console):

```bash
curl -X POST "https://api.apify.com/v2/acts/agenttoolworks~linkedin-indeed-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": "data engineer", "location": "Paris", "country": "FR", "maxResultsPerBoard": 50}'
```

Node.js, with the official [`apify-client`](https://docs.apify.com/api/client/js/):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('agenttoolworks/linkedin-indeed-jobs-scraper').call({
    keywords: 'data engineer',
    location: 'Berlin',
    country: 'DE',
    boards: ['linkedin', 'indeed'],
    maxResultsPerBoard: 200,
});
const { items: jobs } = await client.dataset(run.defaultDatasetId).listItems();
console.log(jobs.map((job) => [job.provider, job.title, job.company, job.salaryText, job.postedAt]));
```

Python, with the official [`apify-client`](https://docs.apify.com/api/client/python/):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("agenttoolworks/linkedin-indeed-jobs-scraper").call(
    run_input={"keywords": "nurse", "location": "London", "country": "GB", "boards": ["indeed"], "maxResultsPerBoard": 500}
)
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["company"], job["salaryMin"], job["salaryMax"], job["salaryPeriod"])
```

The **API** tab on this page has ready-made snippets for every language and endpoint.

### FAQ

#### Do I need a LinkedIn or Indeed account?

No. The Actor reads the public job search of both boards the way a logged-out visitor sees it. It never logs in and uses no account or cookies, which also means your own LinkedIn account is never at risk.

#### Does it return the full job description?

Yes, by default, on both boards: as plain text (`description`) and as HTML (`descriptionHtml`). Turn the descriptions off for a cheaper, faster list.

#### Which countries does it cover?

30: the United States, the United Kingdom, Canada, Australia, India, most of Europe, and more (the **Country** list in the input). The country picks Indeed's country site and completes the location on LinkedIn.

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

Up to 5,000 per board per run. Both boards stop at about 1,000 results per search; past that, the Actor reads narrower date windows of the same search. The run summary says when the board shows more than was read.

#### How fast is it?

Measured on Apify, 2026-10-05: 100 LinkedIn jobs with descriptions in 23 to 36 seconds and 1,000 in about 5.5 minutes; 100 Indeed jobs in 10 to 11 seconds and 1,000 in 45 to 63 seconds. The run on this page (20 per board, both boards) took 13 seconds.

#### Can I get only remote jobs, or only jobs from this week?

Yes: `workplaceTypes` (remote, hybrid, on-site), `datePosted` (24 hours to a month), `jobTypes` and `experienceLevels`. Filtered-out jobs are not charged.

#### Can I use it with Make, Zapier, n8n or Google Sheets?

Yes, through Apify's integrations: the dataset works with every Apify integration, and a webhook can fire when a run finishes. Save your input as a task and schedule it for a daily job alert.

#### Can AI agents use it through MCP?

Yes. Apify's hosted MCP server exposes Store Actors to MCP clients such as Claude or Cursor: `https://mcp.apify.com?tools=agenttoolworks/linkedin-indeed-jobs-scraper`.

#### Is it legal to scrape LinkedIn Jobs and Indeed?

The Actor reads only job listings that LinkedIn and Indeed show to any visitor without logging in: jobs and the companies that post them. It never logs in, uses no account and collects no data about job seekers or recruiters' profiles. Both boards' terms restrict automated collection in some form; how you use the data is your responsibility.

#### Something is missing or broken?

Open an issue in the **Issues** tab: we read every one.

### Other Actors by AgentToolWorks

- [Job Scraper for Greenhouse, Lever, Ashby & Workable (JobsRadar)](https://apify.com/agenttoolworks/jobsradar-multi-board-job-search): open roles from seven applicant tracking systems, straight from employers' career pages, deduplicated into one list.
- [Shopify & WooCommerce Scraper and Price Tracker](https://apify.com/agenttoolworks/shopify-woocommerce-scraper): every product of any Shopify or WooCommerce store, with price and stock change tracking.

### Learn more

- [What this LinkedIn Jobs and Indeed scraper returns, board by board](https://agenttoolworks.com/scrapers/linkedin-indeed-jobs-scraper)
- [How to scrape LinkedIn Jobs and Indeed without an account: what each board shows logged out](https://agenttoolworks.com/blog/how-to-scrape-linkedin-jobs-and-indeed)
- [JobsRadar: employers' own job boards for AI agents, as an MCP server](https://agenttoolworks.com/servers/jobsradar)

Built by [AgentToolWorks](https://agenttoolworks.com). Not affiliated with LinkedIn or Indeed.

# Actor input Schema

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

What to search, as you would type it on LinkedIn or Indeed: a job title, a skill or a company (data engineer, nurse, python, Airbus).

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

A city, region or postcode (Paris, London, Berlin, 10001). Empty searches the whole country.

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

Picks Indeed's country site (fr.indeed.com, uk.indeed.com...) and completes the location for LinkedIn.

## `boards` (type: `array`):

Which boards to search. Both by default; each returns up to the maximum below.

## `maxResultsPerBoard` (type: `integer`):

Stop after this many jobs on each board. You are charged per job returned. LinkedIn shows visitors at most 1,000 results per search (with some repeats); when that runs out, the Actor continues with narrower date windows of the same search.

## `includeDescription` (type: `boolean`):

Read each LinkedIn job's own page: full description, seniority, employment type, industries, applicant count and base pay when published. One light request per job; charged as a job with description. Off returns the search card only (title, company, location, date, link).

## `indeedDescriptions` (type: `boolean`):

On (default), every Indeed row carries the job's full description. Off returns the same rows without it (salary, job type, remote or hybrid, posting date, apply link), lighter and charged as a job without description.

## `strictLocation` (type: `boolean`):

Both boards widen a city search to its area (a London search returns Teddington and Morden). On, only jobs whose location names the searched place are returned, and charged. Off by default.

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

Only jobs posted within this window.

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

Keep only these job types. Empty keeps all. On LinkedIn this is read from each job's page, so it turns on job pages.

## `workplaceTypes` (type: `array`):

Keep only these workplace types. Empty keeps all. Indeed filters on its own remote and hybrid labels; LinkedIn shows visitors no workplace field, so a LinkedIn job counts as remote or hybrid when its title or location says so, and as on-site otherwise.

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

Keep only these levels. Empty keeps all. LinkedIn: read from each job's page (seniority). Indeed: applied where its country site offers an experience filter (the US site does).

## `proxy` (type: `string`):

Automatic is what worked best in our tests: LinkedIn through Apify datacenter proxy, Indeed through Apify residential proxy in the searched country (Indeed refuses datacenter and cloud addresses). Override only to test.

## Actor input object example

```json
{
  "keywords": "data engineer",
  "location": "London",
  "country": "FR",
  "boards": [
    "linkedin",
    "indeed"
  ],
  "maxResultsPerBoard": 10,
  "includeDescription": true,
  "indeedDescriptions": true,
  "strictLocation": false,
  "datePosted": "any",
  "proxy": "auto"
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `allFields` (type: `string`):

No description

## `salaries` (type: `string`):

No description

## `descriptions` (type: `string`):

No description

## `summary` (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": "data engineer",
    "location": "Paris",
    "country": "FR",
    "boards": [
        "linkedin",
        "indeed"
    ],
    "maxResultsPerBoard": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("agenttoolworks/linkedin-indeed-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": "data engineer",
    "location": "Paris",
    "country": "FR",
    "boards": [
        "linkedin",
        "indeed",
    ],
    "maxResultsPerBoard": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("agenttoolworks/linkedin-indeed-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": "data engineer",
  "location": "Paris",
  "country": "FR",
  "boards": [
    "linkedin",
    "indeed"
  ],
  "maxResultsPerBoard": 10
}' |
apify call agenttoolworks/linkedin-indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agenttoolworks/linkedin-indeed-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/nAT2OvSVgg9t0bHuw/builds/qvzjfrr2feYjwOCrG/openapi.json