# LinkedIn Hiring Leads | $2.99 / 1k | (`glasswing/linkedin-leads`) Actor

Find companies hiring on LinkedIn Jobs and enrich them with websites, generic business emails, phone numbers, job evidence, job age, and hiring-intent scores for B2B lead generation, recruiting, staffing, SaaS sales, outsourcing, and market research.

- **URL**: https://apify.com/glasswing/linkedin-leads.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** Lead generation, Jobs, Agents
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.99 / 1,000 business leads

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 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

## LinkedIn Hiring Leads Finder

Find companies hiring on LinkedIn Jobs and turn public job results into clean company-level leads with websites, generic business emails, phone numbers, job evidence, job age, and hiring-intent scores.

This Apify Actor is built for B2B lead generation, recruiting, staffing, outsourcing, SaaS sales, and market research. Instead of returning noisy job-by-job rows, it groups public LinkedIn job cards by company and enriches each company with public contact data you can export to CSV, Excel, Google Sheets, Make, Zapier, n8n, or your CRM.

### What You Get

- Companies currently hiring for your keywords or LinkedIn Jobs URLs
- Public company websites, domains, contact pages, generic emails, and phone numbers
- LinkedIn job URLs as proof that each company is hiring
- Job titles, locations, latest job date, visible job age, and minimum years of experience when detected
- Hiring-intent score, priority, department, seniority, and lead reason
- One clean Apify Dataset with empty values omitted

### Best For

- Lead generation agencies finding companies with active hiring intent
- Recruiters and staffing agencies targeting companies that may need hiring help
- B2B sales teams prospecting growing companies
- Outsourcing agencies tracking teams expanding engineering, marketing, sales, support, or operations
- SaaS companies selling to teams with current hiring needs
- Market researchers monitoring role demand by city, country, or niche

### Input

Use one field for both keywords and public LinkedIn Jobs URLs:

- `keywords`: job titles, departments, buying-intent phrases, or public LinkedIn Jobs URLs
- `location`: country, city/country, `Remote`, or `Worldwide`
- `maxJobsPerSearch`: optional limit per keyword or URL
- `maxJobs`: total unique company leads to save across the whole run

`maxJobsPerSearch` is applied first for each keyword or URL. `maxJobs` is the global stop limit for the run. For example, 3 keywords with `maxJobsPerSearch` set to `5` can collect up to 15 leads, unless `maxJobs` is `10`, in which case the run stops at 10 total leads.

### Input Examples

Search by keyword and location:

```json
{
  "keywords": [
    "software engineer",
    "sales manager",
    "content creator"
  ],
  "location": "United States",
  "maxJobsPerSearch": 25,
  "maxJobs": 100
}
````

Scan a public LinkedIn Jobs URL:

```json
{
  "keywords": [
    "https://www.linkedin.com/jobs/search/?keywords=content%20creator&location=United%20States"
  ],
  "maxJobs": 100
}
```

The Actor trims input, removes duplicate URLs, accepts `maxJobs`, `maxItems`, or `maxResults`, and keeps `startUrls` for API compatibility. If a location is entered as `Latvia Riga`, it is normalized to `Riga, Latvia` before searching.

### Output Example

```json
{
  "company": "Example Corp",
  "website": "https://example.com/",
  "domain": "example.com",
  "linkedin": "https://www.linkedin.com/company/example-corp",
  "contactPage": "https://example.com/contact",
  "email": "careers@example.com",
  "emails": ["careers@example.com"],
  "phone": "+12025550123",
  "phones": ["+12025550123"],
  "jobs": 3,
  "hiringFor": ["Content Creator", "Content Strategist"],
  "locations": ["New York, United States"],
  "latestJobDate": "2026-04-29",
  "jobAge": "1 day ago",
  "minYearsExperience": 2,
  "department": "Marketing",
  "workMode": "Remote",
  "industry": "Software Development",
  "score": 78,
  "priority": "Hot",
  "intent": "Marketing team expansion",
  "suggestedSellers": "Marketing agency, SEO agency, analytics SaaS",
  "reason": "Example Corp is hiring for Content Creator, Content Strategist. This looks like marketing team expansion.",
  "jobUrls": ["https://www.linkedin.com/jobs/view/123/"]
}
```

Phone numbers are normalized to start with `+`. Empty values are omitted, and the Dataset uses short field names so JSON, CSV, and tables stay easy to scan.

### Output Fields

Key Dataset fields include:

- `company`
- `website`
- `domain`
- `linkedin`
- `contactPage`
- `email`
- `emails`
- `phone`
- `phones`
- `jobs`
- `hiringFor`
- `locations`
- `latestJobDate`
- `jobAge`
- `minYearsExperience`
- `department`
- `seniority`
- `workMode`
- `industry`
- `employees`
- `score`
- `priority`
- `intent`
- `suggestedSellers`
- `reason`
- `jobUrls`

### How It Works

1. Searches public LinkedIn Jobs pages for your keywords, locations, or pasted LinkedIn Jobs URLs.
2. Extracts public job cards and groups them into unique companies.
3. Keeps paging until the total lead limit, per keyword/URL limit, or public result boundary is reached.
4. Checks likely public company websites and contact pages.
5. Keeps generic company emails and public company phone numbers.
6. Saves one clean company lead record per company to the default Dataset.

If LinkedIn has no more public pages for a query, the log says so clearly and continues with the companies already found. Large datasets work best with multiple related keywords, locations, or pasted LinkedIn Jobs URLs.

### Tips For Better Results

- Use buying-intent keywords such as `sales development representative`, `account executive`, `customer success manager`, `software engineer`, `AI engineer`, `content creator`, or `marketing manager`.
- Use `maxJobs` of `40-100` for quick tests.
- Use `maxJobsPerSearch` for an even spread across multiple keywords or URLs.
- Use multiple keywords or locations when one public LinkedIn search does not contain enough available results.
- Run separate searches by country, city, or niche when you want cleaner territory segmentation.

### Responsible Use

- Uses public LinkedIn Jobs pages only
- No LinkedIn login is used or required
- Does not scrape private profiles or gated LinkedIn content
- Does not bypass CAPTCHA, authentication, or private access controls
- Collects company-level public data only
- Skips personal emails and keeps generic company inboxes only

### FAQ

#### Does this require a LinkedIn account?

No. The Actor only requests publicly accessible LinkedIn Jobs pages.

#### Does it collect personal emails?

No. It skips personal emails and keeps generic company emails

#### Why company-level output instead of job-level output?

Most sales and recruiting workflows need companies, websites, and contact channels. Company-level output removes duplicate job rows and makes outreach lists easier to use.

#### Why did a run save fewer leads than my total limit?

A single public LinkedIn search can run out of available public pages before the global limit. Add more related keywords, URLs, or locations to collect more companies.

#### Can I schedule this Actor?

Yes. On Apify you can schedule runs, export the Dataset, or connect it to automation tools and CRMs.

# Actor input Schema

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

Job titles, departments, hiring signals, or public LinkedIn Jobs URLs. Duplicate URLs are ignored.

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

Choose a country or type a city/country. Examples: United States, Berlin, Germany, Riga, Latvia, Remote.

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

Optional unique company lead limit for each keyword or URL. Use 0 for no per-keyword limit.

## `maxJobs` (type: `integer`):

Maximum unique company leads to save across the whole run.

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

Optional API compatibility alias for maxJobs. Leave empty when using the Apify input form.

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

Optional API compatibility alias for maxJobs. Leave empty when using the Apify input form.

## Actor input object example

```json
{
  "keywords": [
    "content creator",
    "sales manager",
    "software engineer"
  ],
  "location": "United States",
  "maxJobsPerSearch": 0,
  "maxJobs": 40
}
```

# 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": [
        "content creator",
        "sales manager",
        "software engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/linkedin-leads").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": [
        "content creator",
        "sales manager",
        "software engineer",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("glasswing/linkedin-leads").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 '{
  "keywords": [
    "content creator",
    "sales manager",
    "software engineer"
  ]
}' |
apify call glasswing/linkedin-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Hiring Leads | $2.99 / 1k |",
        "description": "Find companies hiring on LinkedIn Jobs and enrich them with websites, generic business emails, phone numbers, job evidence, job age, and hiring-intent scores for B2B lead generation, recruiting, staffing, SaaS sales, outsourcing, and market research.",
        "version": "1.0",
        "x-build-id": "BbQICFhATRMyPQkgu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/glasswing~linkedin-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-glasswing-linkedin-leads",
                "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/glasswing~linkedin-leads/runs": {
            "post": {
                "operationId": "runs-sync-glasswing-linkedin-leads",
                "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/glasswing~linkedin-leads/run-sync": {
            "post": {
                "operationId": "run-sync-glasswing-linkedin-leads",
                "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": {
                    "keywords": {
                        "title": "Keywords or LinkedIn Jobs URLs",
                        "type": "array",
                        "description": "Job titles, departments, hiring signals, or public LinkedIn Jobs URLs. Duplicate URLs are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Choose a country or type a city/country. Examples: United States, Berlin, Germany, Riga, Latvia, Remote.",
                        "default": "United States"
                    },
                    "maxJobsPerSearch": {
                        "title": "Per keyword/URL",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Optional unique company lead limit for each keyword or URL. Use 0 for no per-keyword limit.",
                        "default": 0
                    },
                    "maxJobs": {
                        "title": "Total leads",
                        "minimum": 10,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique company leads to save across the whole run.",
                        "default": 40
                    },
                    "maxItems": {
                        "title": "Max items alias",
                        "description": "Optional API compatibility alias for maxJobs. Leave empty when using the Apify input form."
                    },
                    "maxResults": {
                        "title": "Max results alias",
                        "description": "Optional API compatibility alias for maxJobs. Leave empty when using the Apify input form."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```