# LinkedIn Jobs Scraper | No Login, No Cookie, Job Descriptions (`starvoid/linkedin-scraper`) Actor

Search LinkedIn job postings and export title, company, location, posting date, link and the full job description as clean JSON. No login and no session cookie, so your own account is never involved. Pay per result.

- **URL**: https://apify.com/starvoid/linkedin-scraper.md
- **Developed by:** [Starvoid](https://apify.com/starvoid) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 jobs

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

## LinkedIn Jobs Scraper

Search LinkedIn job postings and get back clean, structured rows: title, company, location, posting date, link, and the full job description.

**No login. No session cookie. No account of yours is involved.** Other LinkedIn scrapers ask you to paste your own `li_at` cookie, which puts your account at risk of being restricted. This one never asks, because it reads the job pages LinkedIn serves to everyone.

Useful for building a job board, tracking who a competitor is hiring, sourcing roles for candidates, salary and market research, or feeding fresh postings into your own app.

### What you get

```json
{
  "id": "4476983365",
  "url": "https://www.linkedin.com/jobs/view/software-engineer-ii-java-aws-at-jpmorganchase-4476983365",
  "title": "Software Engineer II (Java/AWS)",
  "company": "JPMorganChase",
  "companyUrl": "https://www.linkedin.com/company/jpmorganchase",
  "location": "New York, NY",
  "postedAt": "2026-10-08",
  "postedText": "5 days ago",
  "salary": "$120,000.00/yr - $160,000.00/yr",
  "benefits": "Medical, Vision, Dental",
  "applicants": "Be among the first 25 applicants",
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "industries": "Financial Services",
  "description": "Job Description\n\nYou're ready to gain the skills...",
  "scrapedAt": "2026-10-13T16:52:09.079Z"
}
```

Every field, and when it is filled:

| Field | What it is |
|---|---|
| `id` | LinkedIn's own job id, stable across runs, use it to deduplicate |
| `url` | Direct link to the posting |
| `title` | Job title as posted |
| `company` | Hiring company name |
| `companyUrl` | The company's LinkedIn page, empty for postings without one |
| `location` | As the employer wrote it, from a city to a whole country |
| `postedAt` | Posting date, `YYYY-MM-DD` |
| `postedText` | LinkedIn's wording, for example `5 days ago` |
| `salary` | Only when the employer published a range, which is a minority of postings |
| `benefits` | Only when the employer listed them |
| `applicants` | Applicant count or LinkedIn's "be among the first" note |
| `seniority` | Entry, Associate, Mid-Senior, Director, Executive. Empty when the employer left it blank |
| `employmentType` | Full-time, Part-time, Contract, Temporary, Internship, Volunteer |
| `industries` | Industry of the role |
| `description` | The complete posting text, only when Full job description is on |
| `scrapedAt` | When this row was read, so you can tell fresh rows from stored ones |

Results export as JSON, CSV, Excel or XML, and the same dataset is readable from the Apify API, so you can pull it straight into a database or a sheet.

### How to use it

Fill in the form:

| Field | What it does |
|---|---|
| Keywords | What you would type into LinkedIn's job search, e.g. `python developer` |
| Location | City, region or country, e.g. `Bengaluru, India`. Leave empty for everywhere |
| Number of jobs | How many rows to return. Results arrive in pages of 25 |
| Full job description | On by default. Turn off for a faster, cheaper list |
| Date posted | Any time, past month, past week, past 24 hours |
| Workplace | On-site, remote, hybrid |
| Experience level | Internship through executive |
| Job type | Full-time, part-time, contract, temporary, internship, volunteer |
| Sort by | Most relevant, or most recent |

Or skip the form: build the search in your browser and paste the URL into **Or paste a LinkedIn jobs search URL**. Every filter in that link is used, so what you get matches what you saw.

```json
{
  "keywords": "data engineer",
  "location": "Berlin, Germany",
  "maxResults": 100,
  "includeDetails": true,
  "datePosted": "week",
  "workplace": "remote"
}
```

Run it on a schedule to catch new postings daily, or start it from the Apify API and read the dataset when it finishes. Both work with the same input.

### Pricing

Pay per result. There is no charge for starting a run, and nothing is billed for a search that returns nothing.

| Event | Price | What it is |
|---|---|---|
| Job | $2.00 / 1,000 | One listing row: title, company, location, date, link |
| Job with description | $5.00 / 1,000 | The same row plus the full description, seniority, employment type, industries and applicant count |

So a run of 200 jobs with descriptions costs $1.00, and the same 200 as a plain list costs $0.40. Turning **Full job description** off bills every row at the lower price. If a posting will not load, that row is billed at the lower price too, because that is what you received. Set a maximum cost per run and the run stops at it rather than going past it.

### Notes

- Results come from the job pages LinkedIn publishes publicly, so there is no login step and your own account is never used.
- A few fields are members-only on LinkedIn's side and are therefore never returned: job function, recruiter contact details, and your application status.
- LinkedIn does not answer an unmatched search with nothing, it quietly drops your keywords and returns whatever else it has. Rows that do not match are dropped and never billed, so a typo costs you nothing.
- Runs end successfully even when LinkedIn rate limits us mid-search. You get the rows gathered so far, a note in the log, and you are billed only for what was delivered.
- Residential proxy is on by default, because LinkedIn blocks shared datacenter addresses. You can switch the proxy off to save proxy usage, and if that gets blocked the run switches to residential by itself rather than handing you an empty result.

### Questions

**Do I need a LinkedIn account?** No, and you should not give one to any scraper.

**How fresh is the data?** It is read live at the moment you run it, not from a stored database.

**How many jobs can one search return?** LinkedIn's own search stops producing new results after roughly a thousand per query. For more than that, split the search by location, seniority or date range.

**Can I get the recruiter or company contact details?** Not from this actor. LinkedIn only shows those to signed-in members, and asking you for your cookie is exactly what this actor is built to avoid.

**Why is salary empty on most rows?** Because most employers do not publish one. The field is filled whenever LinkedIn shows a range on the posting.

**Can I run the same search every day and only keep new jobs?** Yes. Schedule it and deduplicate on `id`, which is LinkedIn's own and does not change between runs.

# Actor input Schema

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

What to search for, the same words you would type into LinkedIn's job search, for example "python developer" or "product manager".

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

City, region or country, for example "Bengaluru, India" or "Remote". Leave empty to search everywhere.

## `maxResults` (type: `integer`):

How many jobs to return. Results come in pages of 25.

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

Fetch each posting for the full description, seniority, employment type and industries. Turn it off for a faster, shorter list.

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

Only jobs posted within this period.

## `workplace` (type: `string`):

On-site, remote or hybrid.

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

Only jobs at this seniority, as LinkedIn labels them.

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

Full-time, contract, internship and so on.

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

Order of the results: LinkedIn's own relevance ranking, or newest first.

## `searchUrl` (type: `string`):

Paste a LinkedIn jobs search link and every filter in it is used, ignoring the fields above. Useful when you have already built the search in your browser.

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

Proxy for the requests. Residential is the default because LinkedIn blocks shared datacenter addresses. Turning the proxy off is cheaper and often works, and the run falls back to residential by itself if it gets blocked.

## Actor input object example

```json
{
  "keywords": "python developer",
  "location": "India",
  "maxResults": 10,
  "includeDetails": true,
  "datePosted": "any",
  "workplace": "any",
  "experienceLevel": "any",
  "jobType": "any",
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Every job from this run: title, company, location, posting date, link, and the full description when it was requested.

# 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": "python developer",
    "location": "India",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("starvoid/linkedin-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": "python developer",
    "location": "India",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("starvoid/linkedin-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": "python developer",
  "location": "India",
  "maxResults": 10
}' |
apify call starvoid/linkedin-scraper --silent --output-dataset

```

## MCP server setup

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