# LinkedIn Jobs Scraper: No Login Required (`apexweb/linkedin-jobs-guest-scraper`) Actor

Scrape public LinkedIn job listings without an account, cookies, or login. Search by keyword and location, filter by recency and remote only, and get clean JSON with title, company, location, posting date, and job URL.

- **URL**: https://apify.com/apexweb/linkedin-jobs-guest-scraper.md
- **Developed by:** [Adam Tokar](https://apify.com/apexweb) (community)
- **Categories:** Jobs, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 job listings

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 (No Login Required)

Scrape public LinkedIn job listings without an account, without cookies, and without logging in. Search by keyword and location, filter by how recently a job was posted, and get clean structured JSON you can feed straight into a job board, a tracker, a spreadsheet, or an AI matching pipeline.

Built for recruiters, job boards, market researchers, and anyone building automated job search tooling.

### What it does

- Searches LinkedIn's public jobs listing for one or many keywords at once.
- Filters by location, by recency (only jobs posted in the last N hours), and by remote only.
- Optionally fetches the full job detail page for each result.
- Routes traffic through Apify residential proxies for reliable, geo accurate results.
- Outputs one clean record per job, ready to export as JSON, CSV, or Google Sheets.

No LinkedIn account, session cookie, or password is ever required or requested.

### Input

| Field | Type | Description |
|---|---|---|
| `keywords` | array | **Required.** One or more search terms, for example `["python developer", "data engineer"]`. Each is searched separately. |
| `location` | string | Location filter, for example `United States`, `London`, `Berlin`. |
| `hours_old` | integer | Only return jobs posted within this many hours. Useful for daily runs. |
| `pages_per_keyword` | integer | How many result pages to walk per keyword. 25 jobs per page. |
| `remote_only` | boolean | Only return remote positions. |
| `fetch_details` | boolean | Also open each job page for the fuller record. Slower, richer. |
| `use_residential_proxy` | boolean | Route through residential proxies. Recommended for reliability. |

#### Example input

```json
{
    "keywords": ["python developer", "backend engineer"],
    "location": "United States",
    "hours_old": 24,
    "pages_per_keyword": 2,
    "remote_only": true,
    "fetch_details": false
}
````

### Output

Each dataset item is one job:

```json
{
    "job_id": "4012345678",
    "title": "Senior Python Developer",
    "company": "Example Corp",
    "location": "Remote, United States",
    "url": "https://www.linkedin.com/jobs/view/4012345678",
    "posted_at": "2026-07-24",
    "keywords": "python developer",
    "source": "linkedin",
    "scraped_at": "2026-07-25T09:14:00.000Z"
}
```

Export to JSON, CSV, Excel, or Google Sheets from the Apify console, or pull it via the API.

### Typical uses

- Feed a daily job digest or job alert product.
- Build a niche job board for one role, city, or industry.
- Track hiring activity at a set of companies over time.
- Supply job listings to an AI matcher or resume tailoring pipeline.

Pairs naturally with the **LinkedIn Job Matcher** Actor, which scores each of these listings against a candidate CV and drafts a tailored cover note.

### Honest limitations

- It reads LinkedIn's public listing surface only. Jobs visible solely to logged in users are out of scope.
- LinkedIn changes its public markup from time to time. If a field stops populating, open an issue and it gets fixed.
- Very large runs should be split across scheduled runs rather than one giant run, both for reliability and to stay polite to the source.

### Notes on responsible use

This Actor only reads publicly accessible job postings, the same pages any visitor can open without signing in. It does not log in, does not touch private data, does not collect personal profiles, and does not submit applications. Requests are throttled. Please respect LinkedIn's terms and your local laws when using the output.

# Actor input Schema

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

Job-title keywords to search. One LinkedIn query per entry.

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

Free-text location passed to LinkedIn (e.g. 'United States', 'Boston, MA').

## `hours_old` (type: `integer`):

Only return jobs posted within this many hours. 168 = last 7 days.

## `pages_per_keyword` (type: `integer`):

How many pages to paginate per keyword. Each page = up to 25 jobs.

## `remote_only` (type: `boolean`):

Apply LinkedIn's remote-only filter (f\_WT=2). Off by default — let the scoring pipeline handle it.

## `use_residential_proxy` (type: `boolean`):

Strongly recommended — datacenter IPs get rate-limited by LinkedIn within ~10 requests.

## `fetch_details` (type: `boolean`):

When true, also fetch each job's detail page to extract description, work\_type (remote/hybrid/onsite), seniority level, employment type, and salary when listed. Adds ~3-5s per job. Default false.

## Actor input object example

```json
{
  "keywords": [
    "Director of Marketing",
    "VP Marketing",
    "Head of Demand Generation",
    "Director of Growth Marketing",
    "Director of Product Marketing"
  ],
  "location": "United States",
  "hours_old": 168,
  "pages_per_keyword": 3,
  "remote_only": false,
  "use_residential_proxy": true,
  "fetch_details": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("apexweb/linkedin-jobs-guest-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("apexweb/linkedin-jobs-guest-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call apexweb/linkedin-jobs-guest-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apexweb/linkedin-jobs-guest-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper: No Login Required",
        "description": "Scrape public LinkedIn job listings without an account, cookies, or login. Search by keyword and location, filter by recency and remote only, and get clean JSON with title, company, location, posting date, and job URL.",
        "version": "0.1",
        "x-build-id": "3YW87feDSvQ8kMdVu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apexweb~linkedin-jobs-guest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apexweb-linkedin-jobs-guest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/apexweb~linkedin-jobs-guest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apexweb-linkedin-jobs-guest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/apexweb~linkedin-jobs-guest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apexweb-linkedin-jobs-guest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job-title keywords to search. One LinkedIn query per entry.",
                        "default": [
                            "Director of Marketing",
                            "VP Marketing",
                            "Head of Demand Generation",
                            "Director of Growth Marketing",
                            "Director of Product Marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Free-text location passed to LinkedIn (e.g. 'United States', 'Boston, MA').",
                        "default": "United States"
                    },
                    "hours_old": {
                        "title": "Hours since posted (max)",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "Only return jobs posted within this many hours. 168 = last 7 days.",
                        "default": 168
                    },
                    "pages_per_keyword": {
                        "title": "Pages per keyword",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many pages to paginate per keyword. Each page = up to 25 jobs.",
                        "default": 3
                    },
                    "remote_only": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Apply LinkedIn's remote-only filter (f_WT=2). Off by default — let the scoring pipeline handle it.",
                        "default": false
                    },
                    "use_residential_proxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Strongly recommended — datacenter IPs get rate-limited by LinkedIn within ~10 requests.",
                        "default": true
                    },
                    "fetch_details": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "When true, also fetch each job's detail page to extract description, work_type (remote/hybrid/onsite), seniority level, employment type, and salary when listed. Adds ~3-5s per job. Default false.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
