# LinkedIn Hiring Posts Scraper - No Login, Intent Score (`codetr/linkedin-hiring-posts-scraper`) Actor

Find who is hiring on LinkedIn. Search public hiring posts by role, location and language. Get exact post dates, a hiring-intent score, roles, salary, emails and apply links. No login or cookies.

- **URL**: https://apify.com/codetr/linkedin-hiring-posts-scraper.md
- **Developed by:** [Yusuf Barış](https://apify.com/codetr) (community)
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 Hiring Posts Scraper: find who is hiring, no login needed

**LinkedIn Hiring Posts Scraper** finds public LinkedIn posts where companies, recruiters and hiring managers announce open roles, such as *"We're hiring a Senior Backend Engineer in Berlin"*. Tell it which roles, locations and languages you care about, and get back clean, structured rows: the post link, the exact publishing time, who posted it, the roles, location, work mode, salary when stated, any contact details shown in the post, and a hiring-intent score.

No LinkedIn account, no cookies and no login. Nothing is ever posted, sent or changed on LinkedIn.

### What does LinkedIn Hiring Posts Scraper do?

Job-board scrapers return formal job listings. But many roles are announced first as a post in the feed, written by the person who will actually do the hiring. This Actor collects those posts and turns each one into a data row you can sort, filter and export.

- **Find hiring posts by role and place.** Enter job titles such as `software engineer` or `sales manager`, add locations, a work mode (remote, hybrid, on-site) and a time window.
- **See exactly when a post was published.** Every row has the precise publishing time, so "last 24 hours" and "last 7 days" are accurate.
- **Skip the noise.** Each post gets a hiring-intent score from 0 to 100. Posts by people looking for work (`#OpenToWork`) and "I just started a new job" announcements are removed by default.
- **Get structured details.** Roles, location, work mode, employment type, salary, hashtags, company, emails and apply links, whenever the post mentions them.
- **Receive each post only once.** Turn on **Only new posts** and put the Actor on a schedule to get just the posts that earlier runs did not deliver.
- **Search in six languages.** English, Turkish, German, Spanish, French and Portuguese hiring phrases are built in.

### Who is it for?

| You are a... | Use it to... |
|---|---|
| **Recruiter or staffing agency** | Find companies that are hiring right now, and the people posting about it, before the role reaches a job board. |
| **Sales or lead-gen professional** | Treat "company hiring for X" as a buying signal and reach out while the budget is fresh. |
| **Job seeker** | Discover roles posted in the feed, with the poster one message away. |
| **Market researcher or analyst** | Track hiring demand for a role, region or technology over time. |
| **Automation builder** | Send every new hiring post to Slack, Google Sheets, Airtable, Make or n8n. |

### How to use LinkedIn Hiring Posts Scraper

1. Click **Try for free** and open the **Input** tab.
2. Add one or more **Roles**, for example `software engineer`. Optionally add **Locations**, a **Work mode** and how recent the posts must be.
3. Set **Maximum results** and click **Start**.
4. When the run finishes, open the **Output** tab. The **Overview** table shows the posts at a glance. Download the data as JSON, CSV, Excel, XML or HTML, or read it through the API.

Want a daily feed? Enable **Only new posts since the last run**, then click **Schedule** and choose how often to run it.

### Input

You need at least one **role** or **keyword**. Everything else is optional.

| Field | Type | Default | Description |
|---|---|---|---|
| `roles` | array | | Job titles to look for. Each role is searched separately and the results are combined. |
| `locations` | array | | Cities, regions or countries. A post matches if it mentions any of them. |
| `keywords` | array | | Extra words the post must contain, such as a technology, an industry or a company. Can be used on its own. |
| `languages` | array | `["en"]` | Hiring phrases to look for: `en`, `tr`, `de`, `es`, `fr`, `pt`. |
| `workMode` | string | `any` | `remote`, `hybrid` or `onsite`. Posts that do not state a work mode are kept. |
| `postedWithin` | string | `30d` | `24h`, `7d`, `30d` or `any`. |
| `onlyWithContact` | boolean | `false` | Keep only posts that show an email address or an apply link. |
| `excludeJobSeekers` | boolean | `true` | Drop posts from people looking for work and new-job announcements. |
| `minIntentScore` | integer | `40` | Minimum hiring-intent score (0-100). Lower it to see more, borderline posts. |
| `onlyNew` | boolean | `false` | Skip posts that an earlier run with the same search already delivered. |
| `maxItems` | integer | `25` | Number of unique posts to return, 1-200. |

#### Example input

```json
{
  "roles": ["software engineer"],
  "locations": ["Remote"],
  "workMode": "remote",
  "postedWithin": "7d",
  "maxItems": 25
}
```

### Output

Each row in the dataset is one hiring post. Open the **Overview** and **Details** tables on the Output tab, or download the dataset in the format you need.

#### Example output

```json
{
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7512161093054689280/",
  "postId": "7512161093054689280",
  "postedAt": "2026-10-03T09:21:14.000Z",
  "postedAgo": "8 days ago",
  "authorName": "Jane Doe",
  "authorProfileUrl": "https://www.linkedin.com/in/jane-doe-1a2b3c4/",
  "companyHint": "Acme Labs",
  "postTextPreview": "We're hiring a Principal Software Engineer (remote, US-only). $200k - $250k with a 10-12% bonus...",
  "roles": ["software engineer", "Principal Software Engineer"],
  "location": null,
  "workMode": "remote",
  "employmentType": "full-time",
  "salary": "$200k - $250k",
  "emails": [],
  "applyLinks": ["https://lnkd.in/abc123"],
  "hashtags": ["#hiring"],
  "intentScore": 85,
  "intentSignals": ["hiring-phrase", "role", "job-details", "salary", "fresh"],
  "language": "en",
  "checkedAt": "2026-10-11T12:00:00.000Z"
}
```

#### Output fields

| Field | Description |
|---|---|
| `postUrl`, `postId` | Link to the post and a stable id that is safe to use for deduplication. |
| `postedAt`, `postedAgo` | Exact publishing time (ISO 8601) and a relative date such as "3 days ago". |
| `authorName`, `authorProfileUrl` | Who wrote the post. The profile link is filled when the author's personal profile can be identified, otherwise it is `null`. |
| `companyHint` | Company named in the text, for example "Acme Labs is hiring...". |
| `postTextPreview` | The beginning of the post text (up to 500 characters). |
| `roles`, `location`, `workMode`, `employmentType`, `salary` | Details taken from the post. `null` or empty when the post does not say. |
| `emails`, `applyLinks`, `hashtags` | Contact details, application links and hashtags found in the post. |
| `intentScore`, `intentSignals` | 0-100 estimate that the post is a real hiring post, and the signals behind it. |
| `language` | Detected language of the post. |
| `checkedAt` | When the row was created (ISO 8601). |

### How much will it cost to scrape LinkedIn hiring posts?

The Actor uses **pay-per-event** pricing: a small fee for each run plus a fee for each hiring post saved to the dataset. You only pay for posts that pass your filters. A search that finds nothing saves nothing, so no results are charged.

See the **Pricing** tab for the current rates. Apify's free plan includes monthly credits, and free-plan users can export up to 5 results per day with this Actor.

**Tips to keep costs low:**

- Use a narrow `postedWithin` window and schedule frequent runs with `onlyNew` instead of running large one-off searches.
- Set `maxItems` to what you will actually use.
- Raise `minIntentScore` to avoid paying for borderline posts.

### Tips for better results

- **Be specific.** `React developer` finds more relevant posts than `developer`. Add a location to focus the results.
- **Use several roles in one run.** The results are combined and duplicates are removed.
- **Add a language.** For example `["tr", "en"]` looks for Turkish and English hiring posts together. Enter roles and locations in the language of the posts you want.
- **Lower `minIntentScore`** (for example to 25) if you want to review borderline posts yourself.
- **Use `onlyWithContact` for outreach lists.** It keeps only posts where an email or apply link is visible. Expect fewer results, because most posts do not include one.

### Integrations

Connect the Actor to the tools you already use through Apify integrations: Slack, Google Sheets, Airtable, Make, Zapier, n8n, webhooks and more. Combine a schedule with **Only new posts** to send each new hiring post to a channel or a spreadsheet exactly once. You can also run the Actor from your own code through the Apify API and the official client libraries for JavaScript and Python.

### FAQ

#### Do I need a LinkedIn account?

No. The Actor does not log in to LinkedIn and does not need your cookies or credentials, so there is no account that could be restricted.

#### Which posts does it find?

Public LinkedIn posts that announce open roles and match your roles, locations and filters. It does not see private posts or anything that requires a login to view.

#### Is this a complete feed of all hiring posts on LinkedIn?

No. It finds posts that are publicly visible, which is a part of all posts. It is a discovery tool, not a complete feed. Specific roles and locations work better than very broad ones, and running it on a schedule builds up coverage over time.

#### How accurate is the posting date?

Every row has the exact time the post was published, so time filters such as "last 7 days" are precise.

#### Why are emails and apply links often empty?

Only the beginning of each post is publicly visible, so contact details appear when they are in that part, which is common for short posts and less common for long ones. Use `onlyWithContact` if you only want posts that show a contact.

#### What does the intent score mean?

It is an estimate that the post comes from an employer or recruiter looking for candidates. It is based on hiring phrases, job-description wording, the details found in the post and how recent it is. Posts by job seekers score close to zero. Review borderline scores before acting on them.

#### Can I search in other languages?

Yes. Set `languages` to any of `en`, `tr`, `de`, `es`, `fr`, `pt`. Hiring phrases for each language are included. Roles and locations are used exactly as you type them, so enter them in the language of the posts you want.

#### Can I run it on a schedule and get only new posts?

Yes. Enable `onlyNew` and create a schedule. Each run returns only posts that no earlier run with the same roles, locations, keywords, languages and work mode has delivered.

#### What happens if nothing is found?

The run still finishes successfully with an empty dataset and a clear message, and no results are charged. Try a broader role, a longer `postedWithin` window or a lower `minIntentScore`.

#### Is it legal to scrape LinkedIn hiring posts?

The Actor works with publicly available posts only and does not log in or access private data. Public posts and contact details can still contain personal data, such as names and email addresses. Use the output for lawful purposes and follow GDPR and similar regulations when you contact people. You are responsible for how you use the data. If you are unsure, consult a legal professional.

### Need help or a custom solution?

If a result looks wrong, you need another language or filter, or you want a custom version of this Actor, open an issue in the **Issues** tab of the Actor page and describe the search you ran. Real examples are the fastest way to get a fix.

# Actor input Schema

## `roles` (type: `array`):

Job titles you want hiring posts for, for example `software engineer` or `sales development representative`. Each role is searched separately and the results are combined.

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

Cities, regions or countries, for example `Berlin` or `United Kingdom`. A post matches if it mentions any of them. Leave empty to search everywhere.

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

Additional words the post should contain, such as a technology (`Python`), an industry (`fintech`) or a company name. Can also be used alone when you have no specific role.

## `languages` (type: `array`):

Languages of the hiring phrases to look for. Supported codes: `en` (English), `tr` (Turkish), `de` (German), `es` (Spanish), `fr` (French), `pt` (Portuguese). Enter roles and locations in the language of the posts you want.

## `workMode` (type: `string`):

Only keep posts for this work mode. Posts that do not state a work mode are kept.

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

How recent the post must be, based on the date the post was published.

## `excludeJobSeekers` (type: `boolean`):

Drop posts from people looking for work (for example #OpenToWork) and 'I started a new job' announcements.

## `onlyWithContact` (type: `boolean`):

Keep only posts that show an email address or an application link. Useful for outreach lists, but it returns fewer posts.

## `minIntentScore` (type: `integer`):

Only keep posts with a hiring-intent score of at least this value (0-100). Lower it to see more borderline posts; raise it for only clear hiring announcements.

## `onlyNew` (type: `boolean`):

Skip posts that an earlier run with the same roles, locations, keywords, languages and work mode already delivered. Combine with a schedule to receive each post exactly once.

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

How many unique hiring posts to return, up to 200. Free Apify plan users are limited to 5 results per day. This was set by the Actor developer, not Apify. Paying plans can take the full amount.

## Actor input object example

```json
{
  "roles": [
    "software engineer"
  ],
  "languages": [
    "en"
  ],
  "workMode": "any",
  "postedWithin": "30d",
  "excludeJobSeekers": true,
  "onlyWithContact": false,
  "minIntentScore": 40,
  "onlyNew": false,
  "maxItems": 10
}
```

# Actor output Schema

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

Table of hiring posts with author, company, roles, location, work mode, salary, contacts and intent score.

## `details` (type: `string`):

Post text preview, hashtags, language and the signals behind each hiring-intent score.

## `posts` (type: `string`):

Every field of every hiring post in the default dataset.

# 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 = {
    "roles": [
        "software engineer"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("codetr/linkedin-hiring-posts-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 = {
    "roles": ["software engineer"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("codetr/linkedin-hiring-posts-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 '{
  "roles": [
    "software engineer"
  ],
  "maxItems": 10
}' |
apify call codetr/linkedin-hiring-posts-scraper --silent --output-dataset

```

## MCP server setup

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