# Albinor LinkedIn Jobs Scraper with Hiring Manager suggestion (`believable_fork/albinor-linkedin-jobs-hm-store`) Actor

Cookie-free LinkedIn jobs scraper for public listings with hiring-manager suggestions, duplicate removal, and optional company enrichment.

- **URL**: https://apify.com/believable\_fork/albinor-linkedin-jobs-hm-store.md
- **Developed by:** [Chris](https://apify.com/believable_fork) (community)
- **Categories:** Jobs, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Albinor LinkedIn Jobs Scraper with Hiring Manager suggestion

Run job searches and save results.

This actor is not affiliated with, endorsed by, or sponsored by LinkedIn.

### Usage

Use either:

- `startUrls`: paste one or more LinkedIn jobs search URLs
- `keyword` with `locations` and/or `countries`: search by job title across one or more places

Optional:

- `maxItems`: limit the number of saved results
- `saveOnlyUniqueItems`: remove duplicate jobs
- `findHiringManagers`: include hiring-manager suggestions
- `hiringManagerTitles`: enter target titles

### Output

Run results are saved to the default dataset.

`COMPANY_HIRING_REPORT` is also saved in the default key-value store.

# Actor input Schema

## `startUrls` (type: `array`):

Optional LinkedIn job-search URLs. Use these when you want exact control over a search you already built in LinkedIn.
## `keyword` (type: `array`):

Optional keyword searches. Combine with one or more countries or locations for keyword-based scraping.
## `location` (type: `string`):

Legacy single-location field. You can still use it, but `locations` is better when you want multiple specific places.
## `locations` (type: `array`):

Optional free-text list of specific locations for keyword searches. Users can type any city, region, or place name, for example 'London', 'Toronto, Ontario', or 'Berlin'.
## `country` (type: `string`):

Legacy single-country field. You can still use it, but `countries` is better when you want multiple countries.
## `countries` (type: `array`):

Optional free-text list of countries for country-wide searches. Users can type any country name, for example 'United Kingdom', 'Canada', or 'United States'.
## `distance` (type: `string`):

Optional LinkedIn distance filter for keyword searches.
## `publishedAt` (type: `string`):

Optional recency filter for keyword searches.
## `jobType` (type: `array`):

Optional employment type filters for keyword searches.
## `experienceLevel` (type: `array`):

Optional seniority filters for keyword searches.
## `workType` (type: `array`):

Optional workplace filters for keyword searches.
## `salaryBase` (type: `string`):

Optional minimum salary filter applied after scrape when salary data is present on the listing.
## `maxItems` (type: `integer`):

Maximum number of dataset items to save. Leave empty to use the default.
## `saveOnlyUniqueItems` (type: `boolean`):

When enabled, jobs are deduplicated across searches before saving.
## `enrichCompanyData` (type: `boolean`):

When enabled, the actor also fetches public LinkedIn company pages for richer company metadata.
## `findHiringManagers` (type: `boolean`):

When enabled, the actor will search the public web for likely LinkedIn profiles of hiring-manager titles inside the companies posting these jobs.
## `hiringManagerTitles` (type: `array`):

Free-text list of target titles to look for in the hiring companies. Users can type any titles they want, such as CISO, Head of Security, Head of Cyber, Cyber Director, VP Security, or Security Manager.
## `maxHiringManagersPerCompany` (type: `integer`):

Maximum number of likely hiring-manager contacts to attach for each company.
## `maxCompaniesForHiringManagers` (type: `integer`):

Limit how many hiring companies get a public hiring-manager lookup. Useful to control cost and runtime.
## `includeRecruiterCompanies` (type: `boolean`):

When disabled, the actor skips recruiter, staffing, and job-board style companies during hiring-manager discovery.
## `maxConcurrency` (type: `integer`):

How many job details to fetch at the same time.
## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings. Recommended for larger commercial runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=London"
    }
  ],
  "keyword": [
    "Software Engineer",
    "Data Scientist"
  ],
  "publishedAt": "any",
  "maxItems": 500,
  "saveOnlyUniqueItems": true,
  "enrichCompanyData": true,
  "findHiringManagers": false,
  "maxHiringManagersPerCompany": 3,
  "maxCompaniesForHiringManagers": 25,
  "includeRecruiterCompanies": false,
  "maxConcurrency": 5
}
````

# 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 = {
    "startUrls": [
        {
            "url": "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=London"
        }
    ],
    "keyword": [
        "Software Engineer",
        "Data Scientist"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("believable_fork/albinor-linkedin-jobs-hm-store").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 = {
    "startUrls": [{ "url": "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=London" }],
    "keyword": [
        "Software Engineer",
        "Data Scientist",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("believable_fork/albinor-linkedin-jobs-hm-store").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 '{
  "startUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search/?keywords=software%20engineer&location=London"
    }
  ],
  "keyword": [
    "Software Engineer",
    "Data Scientist"
  ]
}' |
apify call believable_fork/albinor-linkedin-jobs-hm-store --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Albinor LinkedIn Jobs Scraper with Hiring Manager suggestion",
        "description": "Cookie-free LinkedIn jobs scraper for public listings with hiring-manager suggestions, duplicate removal, and optional company enrichment.",
        "version": "0.4",
        "x-build-id": "fqumYGEbZgq9Z7a90"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/believable_fork~albinor-linkedin-jobs-hm-store/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-believable_fork-albinor-linkedin-jobs-hm-store",
                "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/believable_fork~albinor-linkedin-jobs-hm-store/runs": {
            "post": {
                "operationId": "runs-sync-believable_fork-albinor-linkedin-jobs-hm-store",
                "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/believable_fork~albinor-linkedin-jobs-hm-store/run-sync": {
            "post": {
                "operationId": "run-sync-believable_fork-albinor-linkedin-jobs-hm-store",
                "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",
                "properties": {
                    "startUrls": {
                        "title": "LinkedIn search URLs",
                        "type": "array",
                        "description": "Optional LinkedIn job-search URLs. Use these when you want exact control over a search you already built in LinkedIn.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional keyword searches. Combine with one or more countries or locations for keyword-based scraping.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Legacy single-location field. You can still use it, but `locations` is better when you want multiple specific places."
                    },
                    "locations": {
                        "title": "Specific locations",
                        "type": "array",
                        "description": "Optional free-text list of specific locations for keyword searches. Users can type any city, region, or place name, for example 'London', 'Toronto, Ontario', or 'Berlin'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Legacy single-country field. You can still use it, but `countries` is better when you want multiple countries."
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional free-text list of countries for country-wide searches. Users can type any country name, for example 'United Kingdom', 'Canada', or 'United States'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "distance": {
                        "title": "Distance (miles)",
                        "enum": [
                            "5",
                            "10",
                            "25",
                            "50",
                            "100"
                        ],
                        "type": "string",
                        "description": "Optional LinkedIn distance filter for keyword searches."
                    },
                    "publishedAt": {
                        "title": "Published within",
                        "enum": [
                            "any",
                            "r86400",
                            "r604800",
                            "r2592000"
                        ],
                        "type": "string",
                        "description": "Optional recency filter for keyword searches.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional employment type filters for keyword searches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "contract",
                                "temporary",
                                "internship",
                                "volunteer",
                                "other"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Volunteer",
                                "Other"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional seniority filters for keyword searches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry-level",
                                "associate",
                                "mid-senior",
                                "director",
                                "executive"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry-level",
                                "Associate",
                                "Mid-Senior",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "workType": {
                        "title": "Work type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional workplace filters for keyword searches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "on-site",
                                "remote",
                                "hybrid"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        }
                    },
                    "salaryBase": {
                        "title": "Minimum salary",
                        "enum": [
                            "40000",
                            "60000",
                            "80000",
                            "100000",
                            "120000"
                        ],
                        "type": "string",
                        "description": "Optional minimum salary filter applied after scrape when salary data is present on the listing."
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of dataset items to save. Leave empty to use the default.",
                        "default": 500
                    },
                    "saveOnlyUniqueItems": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "When enabled, jobs are deduplicated across searches before saving.",
                        "default": true
                    },
                    "enrichCompanyData": {
                        "title": "Enrich company data",
                        "type": "boolean",
                        "description": "When enabled, the actor also fetches public LinkedIn company pages for richer company metadata.",
                        "default": true
                    },
                    "findHiringManagers": {
                        "title": "Find hiring managers",
                        "type": "boolean",
                        "description": "When enabled, the actor will search the public web for likely LinkedIn profiles of hiring-manager titles inside the companies posting these jobs.",
                        "default": false
                    },
                    "hiringManagerTitles": {
                        "title": "Hiring manager titles",
                        "type": "array",
                        "description": "Free-text list of target titles to look for in the hiring companies. Users can type any titles they want, such as CISO, Head of Security, Head of Cyber, Cyber Director, VP Security, or Security Manager.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxHiringManagersPerCompany": {
                        "title": "Max hiring managers per company",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of likely hiring-manager contacts to attach for each company.",
                        "default": 3
                    },
                    "maxCompaniesForHiringManagers": {
                        "title": "Max companies for hiring-manager search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Limit how many hiring companies get a public hiring-manager lookup. Useful to control cost and runtime.",
                        "default": 25
                    },
                    "includeRecruiterCompanies": {
                        "title": "Include recruiter or staffing companies",
                        "type": "boolean",
                        "description": "When disabled, the actor skips recruiter, staffing, and job-board style companies during hiring-manager discovery.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many job details to fetch at the same time.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Recommended for larger commercial runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
