# LinkedIn Jobs Scraper (No Login) + Direct Apply Links (`hydrocore/linkedin-jobs-scraper-no-login`) Actor

Scrape public LinkedIn job listings without login or cookies: title, company, location, salary min/max, remote/hybrid, applicants, seniority, full description and the employer's direct apply link (Greenhouse, Lever, Ashby, Workable, Workday). Only-new-jobs mode for daily alerts.

- **URL**: https://apify.com/hydrocore/linkedin-jobs-scraper-no-login.md
- **Developed by:** [Hydrocore Data](https://apify.com/hydrocore) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.22 / 1,000 job with full details

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 Scraper (No Login) + Direct Apply Links

Turn any LinkedIn job search into a clean spreadsheet. Type a job title and a place, for example `data analyst` in `United States`. You get every matching job with the company, location, salary, remote/hybrid/on-site, number of applicants, the full description and, where we can find it, **the direct link to apply on the employer's own website** instead of LinkedIn.

You don't need a LinkedIn account, cookies or a login. The scraper only reads the public job pages that LinkedIn shows to anyone who isn't logged in.

**Sample result** (real row from a test run for remote `software engineer` jobs in the US, trimmed):

```json
{ "title": "Software Engineer Full Stack / Backend I (Full Time) - United States", "company": "Cisco",
  "location": "Boise, ID", "workplaceType": "remote", "postedDate": "2026-11-05", "applicantsCount": 26,
  "employmentType": "Full-time", "jobUrl": "https://www.linkedin.com/jobs/view/4487715416" }
```

### What is this, in plain words?

A "scraper" is a small robot that visits web pages for you and copies the useful parts into a table. This one does the same job search you would do on linkedin.com/jobs and opens every job for you. It then gives you the results as Excel, CSV, JSON or Google Sheets (through Apify integrations). You can run it once, or schedule it daily as your own job alert.

### What data do I get?

For every job:

- **Job**: LinkedIn job ID, title, link, posted date ("2026-11-03") and "23 hours ago" text
- **Company**: name, LinkedIn company page and logo
- **Location** and **workplace type**: `remote`, `hybrid` or `on-site` (plus a simple `isRemote` true/false)
- **Salary**: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` (year/hour/month) and the original text. We take it from LinkedIn's pay box or, when LinkedIn has none, from the description (`salarySource` tells you which).
- **Applicants**: for example `55` ("55 applicants")
- **Seniority, employment type, job function and industries**
- **Full description** as plain text, HTML or both
- **Direct apply link** (`applyUrl`): the job's page on the employer's own careers site, when the company uses a public job board we can check (Greenhouse, Lever, Ashby, Workable, Workday or Personio), or an apply link written in the description. `applyUrlMatch` says how sure we are (`exact-title`, `similar-title` or `in-description`).

Switch **Full job details** off for a much cheaper "card" version: title, company, location, date and salary if shown in the list are filled, the detail columns are `null` and `detailsScraped` is `false`. It's useful when you only need volume.

### What can I use it for?

- **Job hunting**: a daily list of new jobs that match you, with the link to apply directly with the employer (often faster, and you skip LinkedIn's "Easy Apply" crowd).
- **Recruiting and staffing agencies**: find which companies are hiring for the roles you fill, right now. Lead lists with the company, role and location.
- **Sales prospecting**: a company that hires 10 "data engineers" probably needs data tools. Hiring is one of the strongest buying signals.
- **Salary research**: collect pay ranges for one role across cities or countries.
- **Labour-market and academic research**: track how many remote jobs, which skills and which industries over time.
- **Job boards and newsletters**: feed a niche job board (for example "remote Python jobs in Europe") with fresh postings and direct apply links.

### How do I use it?

1. Click **Try for free** (or **Start**).
2. In **Search keywords**, type one or more job titles or skills, one per line, for example `marketing manager`.
3. In **Locations**, type a city, state or country, for example `Austin, Texas` or `Germany`. Leave it empty for worldwide.
4. Optional filters: **Posted within** (past 24 hours, week...), **Workplace type** (remote, hybrid, on-site), **Job type**, **Experience level**.
5. Set **Max jobs per search** low for your first run, for example 20.
6. Click **Start**. 15 jobs with full details take about 25 seconds. Then click **Export** to download the table.

**Tip:** you can also run any search on linkedin.com/jobs with all the filters you like, copy the address from your browser, and paste it into **LinkedIn job search URLs**.

#### Daily job alert in 3 steps

1. Choose **Posted within: Past 24 hours**, **Sort by: Most recent**, and switch on **Only new jobs since the last run**.
2. Save the task and click **Schedule** to run it once a day.
3. Optional: add an Apify integration (email, Slack, Google Sheets) to get the new jobs sent to you.

Each run then saves, and charges for, only jobs you haven't received before.

### Input

| Field | What it does | Example |
|---|---|---|
| Search keywords | Job titles or skills, one per line | `python developer` |
| Locations | Cities, states, countries or `Remote`. Empty = worldwide. | `London` |
| LinkedIn job search URLs | Optional. Paste a search link from linkedin.com/jobs. | `https://www.linkedin.com/jobs/search/?keywords=nurse&location=Texas` |
| Posted within | Any time, past hour, 24 hours, week or month | `week` |
| Workplace type | On-site, remote, hybrid (each one searched separately, so every job gets an exact type) | `["remote"]` |
| Job type / Experience level | LinkedIn's own filters | `["full-time"]` |
| Sort by | Most recent (best for alerts) or most relevant | `recent` |
| Distance (miles) | Radius around the location | `25` |
| Title must contain / Exclude words / Exclude companies | Your own filters. Skipped jobs are free. | `["senior"]` |
| Only jobs with a salary | Keep only jobs where a pay range was found | `true` |
| Max jobs per search / in total | Stop after this many jobs (default 100 per search) | `50` |
| Full job details | On (default) = full record. Off = cheap card only. | `true` |
| Find the direct employer apply link | On by default, costs nothing extra | `true` |
| Description format | Plain text, HTML, both or none | `text` |
| Only new jobs since the last run | Monitoring mode, see the FAQ | `true` |
| Monitoring list name | Optional name to keep one memory for several searches or tasks | `nurses-texas` |
| Max spend for this run (USD) | The run stops before it costs more | `2` |
| Proxy | Optional. Not needed for normal runs. | off |

Example input:

```json
{
  "keywords": ["software engineer"],
  "locations": ["San Francisco, CA"],
  "postedWithin": "week",
  "maxJobsPerSearch": 15
}
```

### Output example

Every row has the same columns in the same order (`null` when LinkedIn doesn't show a value; dates are ISO, salaries and counts are numbers). A real row from a test run on 2026-11-05 (default input; the description and logo link are shortened):

```json
{
  "recordType": "job",
  "jobId": "4478595713",
  "title": "Sr. Data Analyst",
  "company": "Accenture Federal Services",
  "location": "Washington, DC",
  "workplaceType": null,
  "isRemote": false,
  "postedDate": "2026-10-20",
  "postedAgo": "2 weeks ago",
  "salaryMin": 103200,
  "salaryMax": 196400,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "applicantsCount": 200,
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "applyType": "offsite",
  "applyUrl": "https://boards.greenhouse.io/accenturefederalservices/jobs/4721318006?gh_jid=4721318006",
  "jobUrl": "https://www.linkedin.com/jobs/view/4478595713",
  "companyLinkedinUrl": "https://www.linkedin.com/company/accenturefederalservices",
  "companyLogoUrl": "https://media.licdn.com/dms/image/v2/D560BAQFeC7XvJhgEZg/company-logo_100_100/company-logo_100_100/0/1689352061532?e=2147483647&v=beta&t=...",
  "salaryText": "$103,200—$196,400 USD",
  "salarySource": "description",
  "applicantsText": "Over 200 applicants",
  "jobFunction": null,
  "industries": "IT Services and IT Consulting",
  "benefits": "Actively Hiring",
  "workplaceTypeSource": null,
  "applyUrlSource": "greenhouse",
  "applyUrlMatch": "exact-title",
  "atsBoard": "greenhouse:accenturefederalservices",
  "detailsScraped": true,
  "descriptionText": "At Accenture Federal Services, nothing matters more than helping the US federal government make the nation stronger and safer and life be...",
  "descriptionHtml": null,
  "isNew": null,
  "searchKeywords": "data analyst",
  "searchLocation": "United States",
  "searchUrl": null,
  "scrapedAt": "2026-11-05T04:34:44.719Z"
}
```

**Views.** The Output tab opens in **Overview** (logo, title, company, location, workplace, date, salary, applicants, seniority, links). There are also **Salary**, **Apply links**, **Descriptions** and **Detailed** (all fields) views.

> Changed in v1.1: `recordType` is now always `job` (it was `details` or `card`); the new `detailsScraped` column says whether the job page was opened. `companyLogo` → `companyLogoUrl`. Every row has a fixed column order with `null` for missing values (card-only rows now have the detail columns as `null` instead of leaving them out).

In an earlier run (software engineer, San Francisco), 8 of 15 jobs came back with a direct employer apply link. The run also saves a `RUN_SUMMARY` record in the key-value store, with each search, how many jobs were found and saved, and any warnings in plain English.

### How much does it cost?

You pay per job saved (pay-per-event). Apify platform usage is included, so there are no extra compute costs. Paid Apify plans get a lower price automatically.

| Event | Apify Free plan | Paid plans (Starter and up) |
|---|---|---|
| Actor start (once per run) | $0.0005 | $0.0005 |
| Job with full details | $0.00034 ($0.34 per 1,000) | $0.00022 ($0.22 per 1,000) |
| Job card only (details off) | $0.00016 | $0.00010 (Starter), $0.00008–0.00009 (higher plans) |

The direct apply link, salary parsing and filters cost nothing extra. Jobs you skip with filters, duplicates and jobs you already got in "only new" mode are **free**.

Worked examples (Free plan):

| Run | Calculation | Total |
|---|---|---|
| 15 jobs with details | $0.0005 + 15 × $0.00034 | **$0.0056** |
| 100 jobs with details | $0.0005 + 100 × $0.00034 | **$0.0345** |
| 500 jobs with details | $0.0005 + 500 × $0.00034 | **$0.1705** |
| 1,000 job cards | $0.0005 + 1,000 × $0.00016 | **$0.1605** |
| Daily alert, 0 new jobs today | start fee only | **$0.0005** |

Set **Max spend for this run** (or Apify's "Maximum cost per run") and the scraper stops cleanly before it goes over. Set a Max spend limit and the run stops cleanly before going over.

### Why this Actor?

Prices below are from the public Apify Store listings, **as of Nov 2026** (checked on 4 November 2026). Prices change, so check the listings for current figures.

| Actor | Per job, Free plan | Per job, paid plans | Start fee |
|---|---|---|---|
| **This Actor** (full details) | **$0.00034** | **$0.00022** | $0.0005 |
| curious_coder/linkedin-jobs-scraper | $0.002 | $0.001 | $0.00005 |
| bebity/linkedin-jobs-scraper | $0.0015 | $0.00125–0.001 | — |
| cheap_scraper/linkedin-job-scraper | $0.0007 | $0.0006–0.00035 | $0.005 |
| valig/linkedin-jobs-scraper | $0.0004 | $0.00036–0.00028 | $0.001 |

What you get here for the price:

- **Competitive pricing** with pay-only-for-useful-results — filtered-out, duplicate and already-seen jobs in "only new" mode are free.
- **Direct employer apply links**: we check the company's public job board (Greenhouse, Lever, Ashby, Workable, Workday, Personio) and match the job, at no extra cost. We didn't find this feature in the listings above.
- **Clean salary fields**: min, max, currency and period as separate columns, also when the pay is only written in the description.
- **Exact remote/hybrid/on-site** for every job, using LinkedIn's own filter.
- **"Only new jobs" mode** that never charges twice for the same job, which makes daily alerts cost cents.
- **Fails softly and honestly**: a search that LinkedIn answers with unrelated "suggested" jobs is skipped (not charged), and every problem is explained in the log and the `RUN_SUMMARY`.
- **Hard spending limit** respected to the cent.

### FAQ

**How do I scrape LinkedIn jobs without logging in?**
Type a job title in **Keywords** and a place in **Locations**, then click Start. The scraper reads LinkedIn's public job pages, so you never share a password or cookies.

**How do I export LinkedIn job search results to Excel or Google Sheets?**
After the run, open the **Output** tab and download Excel or CSV, or connect Google Sheets under Integrations. Schedule the run daily with **Only new jobs** on to get a fresh list every morning.

**Do I need a LinkedIn account?**
No. The scraper never logs in. It reads only the public job pages anyone can see without an account. Never give a scraper your LinkedIn password.

**Is it legal?**
The scraper reads only public job postings, without logging in, solving captchas or getting around any access control. Job postings are business information. It doesn't collect profiles of people. You are still responsible for how you use the data. Respect LinkedIn's terms, copyright in job descriptions and privacy laws such as the GDPR. If you are unsure, ask a lawyer.

**Why don't all jobs have a direct apply link?**
LinkedIn hides the employer's apply link from logged-out visitors. We find it when the company uses a public job board we can check, or writes the link in the description. Tech companies and start-ups often use these boards (30–60% of jobs in our tests). Large corporations and staffing agencies often use their own systems, so for broad searches the share can be much lower (about 4% in one 500-job test). When there is no link, `applyUrl` is empty and you can still apply through `jobUrl`.

**How does "Only new jobs" work?**
The scraper remembers the job IDs it delivered for the same search (in a named storage in your Apify account called `linkedin-jobs-monitor`). Next time it saves only jobs you haven't had yet, and you pay only for those. If several tasks should share one memory, or you change the filters but want to keep the memory, give them the same **Monitoring list name**. To start fresh, use a new name.

**Do I need a proxy?**
No, not for normal runs. LinkedIn sometimes slows down very large runs ("too many requests"). The scraper waits and slows down automatically. If you run very large searches often and they get slow:

1. Open the **Proxy** field in the input.
2. Choose **Apify Proxy** (datacenter is enough).
3. Start the run. Proxy usage is billed by Apify separately on your account.

**How many jobs can I get?**
LinkedIn shows logged-out visitors at most about 1,000 jobs per search. To get more, split the search, for example by city, by "Posted within" or by experience level, and put several keywords or locations into one run.

**How fast is it?**
In our tests: 15 jobs with details in about 25 seconds, 60 job cards in under 5 seconds, 500 jobs with details in about 10–12 minutes. The scraper paces itself to stay polite to LinkedIn.

**My search returned 0 jobs. Why?**
Either no job matches (check the spelling, or try a wider location or date range), or LinkedIn answered with unrelated "suggested" jobs. In that case the scraper skips them on purpose so you don't pay for junk. The log and `RUN_SUMMARY` say which one it was. You only pay the $0.0005 start fee.

**How do I limit my spending?**
Set **Max spend for this run (USD)**. The scraper stops before going over it and tells you in the log.

### Limits

- At most about 1,000 jobs per search (LinkedIn's limit for logged-out visitors).
- Very large runs can be slowed by LinkedIn's rate limits. The scraper backs off rather than retrying forever, and never tries to solve captchas.
- Direct apply links are only found for companies on public job boards (see the FAQ). The scraper never applies for you.
- Salary appears only when the employer publishes it. Some descriptions give it in unusual formats we can't read, and then the salary fields are empty.
- `applicantsCount` is LinkedIn's rounded public number (for example "over 200 applicants" gives 200).
- LinkedIn can change its public pages at any time. If something breaks, open an issue and we'll fix it quickly.

### Ready-made examples

Open one, click **Try for free** and change the inputs to your own:

- [Remote software engineer jobs in the US](https://apify.com/hydrocore/linkedin-jobs-scraper-no-login/examples/remote-software-engineer-jobs-us)
- [Data analyst jobs with salary shown](https://apify.com/hydrocore/linkedin-jobs-scraper-no-login/examples/data-analyst-jobs-with-salary)
- [Daily LinkedIn job alert for product manager roles](https://apify.com/hydrocore/linkedin-jobs-scraper-no-login/examples/product-manager-daily-job-alert)

### Related scrapers by hydrocore

- [ATS Job Board Scraper](https://apify.com/hydrocore/ats-job-board-scraper): jobs straight from Greenhouse, Lever, Ashby, Workable
- [ATS Job Scraper Pro](https://apify.com/hydrocore/ats-job-board-scraper-pro): adds Workday and Personio
- [Website Contact & Social Finder](https://apify.com/hydrocore/website-contact-social-finder): emails and socials of hiring companies

### Support

Found a bug or missing a field? Open an issue on the **Issues** tab, and please include the run link.

# Actor input Schema

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

Job titles or skills, one per line, exactly as you would type them into LinkedIn's job search, for example "registered nurse" or "python developer". Every keyword is searched in every location below.

## `locations` (type: `array`):

Cities, states, countries or "Remote", one per line, for example "Austin, Texas", "Germany" or "London". Leave empty to search worldwide.

## `searchUrls` (type: `array`):

Instead of (or as well as) keywords: open linkedin.com/jobs, run a search with the filters you want, and paste the address from your browser here (it looks like https://www.linkedin.com/jobs/search/?keywords=...\&location=...). Its keywords, location and filters are used. You do not need to be logged in.

## `postedWithin` (type: `string`):

Only jobs posted in this period. For a daily job alert, choose "Past 24 hours" and schedule the Actor once a day (also see "Only new jobs").

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

Only these workplace types. When you pick one or more, each is searched separately, so every job gets an exact workplaceType from LinkedIn's own filter. Leave empty for all; the type is then read from the title, location and description where it is stated.

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

Only these job types. Leave empty for all.

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

Only these experience levels. Leave empty for all.

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

"Most recent" is best for alerts and for "Only new jobs" (the run can stop as soon as it reaches jobs you already have).

## `distanceMiles` (type: `integer`):

Optional radius around the location, for example 25. Empty or 0 = LinkedIn's default.

## `titleMustInclude` (type: `array`):

Keep only jobs whose title contains at least one of these words, for example "senior" or "manager". Not case sensitive. Skipped jobs are not charged.

## `excludeWords` (type: `array`):

Skip jobs whose title or company contains any of these words, for example "intern" or "recruiting agency". Skipped jobs are not charged.

## `excludeCompanies` (type: `array`):

Skip jobs from these companies (name or part of it), for example staffing agencies you do not want. Skipped jobs are not charged.

## `salaryOnly` (type: `boolean`):

Keep only jobs where a pay range was found (on LinkedIn or in the description). Needs "Full job details". Jobs without a salary are skipped for free (their page is still read, so the run takes a bit longer).

## `maxJobsPerSearch` (type: `integer`):

Stop each search (each keyword + location combination) after this many saved jobs. LinkedIn shows at most about 1,000 jobs of one search to logged-out visitors; split big searches by location to get more.

## `maxJobsTotal` (type: `integer`):

Optional overall limit for the whole run. Empty or 0 = no overall limit.

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

On: open each job and save the full record (description, applicants, seniority, job type, function, industries, salary, apply type and direct apply link), charged as "Job with details". Off: save only the search card (title, company, location, posted date, link, salary when the card shows it), charged at the cheaper "Basic job card" price and much faster.

## `resolveApplyLinks` (type: `boolean`):

LinkedIn hides the employer's own apply link from logged-out visitors. With this on, the Actor checks whether the company posts the same job on a public job board (Greenhouse, Lever, Ashby, Workable, Workday or Personio) and adds that job's apply link to applyUrl. Included in the "Job with details" price. Found for companies that use these systems; empty for the others.

## `checkCompanyWebsite` (type: `boolean`):

When the company's job board cannot be guessed from its name, read the company website (from its public LinkedIn page) and its careers page to find it. Finds more apply links (for example Workday boards) but adds a few seconds per new company. Results are remembered for 7 days in your key-value store linkedin-jobs-ats-cache, so later runs are faster.

## `descriptionFormat` (type: `string`):

How to save the job description (with full details on).

## `onlyNewJobs` (type: `boolean`):

Remember the jobs already delivered for this search and save only jobs you have not received before, so scheduled runs never charge you twice for the same job. The first run saves everything it finds. Memory is kept in your key-value store linkedin-jobs-monitor.

## `monitorKey` (type: `string`):

Optional. By default the memory is tied to the exact keywords, locations and filters. Give it a name (for example nurses-texas) to keep the same memory when you edit the search.

## `maxSpendUsd` (type: `string`):

Optional, for example 2.00. The run stops before going over it. Apify's own "Maximum cost per run" option is respected too; the lower of the two applies.

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

Not needed for normal use. If LinkedIn starts answering "too many requests" on very large runs, enable Apify Proxy (datacenter is enough) and the Actor switches IP instead of waiting. Proxy traffic is billed by Apify to your account. Used only for LinkedIn pages.

## Actor input object example

```json
{
  "keywords": [
    "data analyst"
  ],
  "locations": [
    "United States"
  ],
  "postedWithin": "any",
  "sortBy": "recent",
  "salaryOnly": false,
  "maxJobsPerSearch": 100,
  "includeDetails": true,
  "resolveApplyLinks": true,
  "checkCompanyWebsite": true,
  "descriptionFormat": "text",
  "onlyNewJobs": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Title, company, location, salary, apply link.

## `salary` (type: `string`):

Pay ranges.

## `apply` (type: `string`):

Direct employer apply links.

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

Full job descriptions.

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

Every job saved, all fields.

## `summary` (type: `string`):

Per search: pages read, jobs saved, skipped, apply links found, charged and why it stopped.

# 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 analyst"
    ],
    "locations": [
        "United States"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("hydrocore/linkedin-jobs-scraper-no-login").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 analyst"],
    "locations": ["United States"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("hydrocore/linkedin-jobs-scraper-no-login").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 analyst"
  ],
  "locations": [
    "United States"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call hydrocore/linkedin-jobs-scraper-no-login --silent --output-dataset

```

## MCP server setup

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

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/X16zEENAmfuLseQXz/builds/wfcNfR9x5RSD1281a/openapi.json