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

LinkedIn Jobs scraper for B2B lead generation. Find companies hiring on LinkedIn and export company websites, business emails, phone numbers, salaries, industries, applicant counts, and hiring-intent scores.

- **URL**: https://apify.com/glasswing/linkedin-leads.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 51 total users, 3 monthly users, 100.0% runs succeeded, 1 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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Scrape Companies Hiring on LinkedIn (Emails, Phones & Buying Signals)

Turn public **LinkedIn Jobs** into a clean, deduplicated list of **B2B sales and recruiting leads**. This LinkedIn scraper finds every company that is actively hiring for your keywords and enriches each one with its **website, generic business email, phone number, industry, employee-facing salary, applicant count, and a hiring-intent score** — then exports straight to **CSV, Excel, Google Sheets, JSON, Make, Zapier, n8n, or your CRM**.

No LinkedIn login, no cookies, no personal profiles — **public company-level data only**. Built for lead generation, recruiting, staffing, outsourcing, SaaS sales, and market research.

> Companies that are hiring are companies that are spending. This Actor surfaces that buying intent and hands you the contact channels to act on it.

### Why use this LinkedIn lead scraper

- **Company-level leads, not noisy job rows.** It groups public LinkedIn job postings by company, so you get one clean prospect per company instead of duplicate listings.
- **Real contact data, verified.** Generic business emails (validated against the IANA TLD list and matched to the company domain) and phone numbers (validated to E.164) — junk and vendor data are dropped, not exported.
- **Hiring intent built in.** A 0–100 hiring-intent score, priority (Hot / Warm / Research needed), intent category, and suggested buyer types help you prioritize outreach.
- **Every value makes sense or it is omitted.** Salaries are read from LinkedIn's structured pay block (correct amount, period, and currency), industries are split into canonical members, and nothing nonsensical is ever written.
- **Fast and reliable.** Runs behind a proxy automatically to avoid rate limits, returns the full requested volume, and finishes a 50-lead run in ~25 seconds.
- **No login required.** It only requests publicly accessible LinkedIn Jobs pages — safe, simple, and schedulable.

### Who it's for

- **Lead generation agencies** building targeted B2B prospect lists of companies with active hiring intent
- **Recruiters and staffing agencies** finding companies that are expanding and may need hiring help
- **B2B sales and SDR teams** prospecting growing companies and timing outreach to buying signals
- **Outsourcing and dev-shop agencies** tracking teams scaling engineering, marketing, sales, support, or operations
- **SaaS companies** selling tools to teams that are clearly hiring (and budgeting) right now
- **Market researchers** monitoring role demand and hiring trends by city, country, industry, or niche

### What you get

Each row is one company that is hiring, enriched with:

- **Company identity** — `company`, `website`, `domain`, `linkedin`, `logo`, `industry`, `industries`
- **Contact channels** — `email`, `emails`, `phone`, `phones`, `contactPage`
- **Hiring evidence** — `jobs` (matching), `applicants`, `hiringFor` (job titles), `jobFunction`, `department`, `seniority`, `employmentType`, `workMode`, `easyApply`, `locations`, `latestJobDate`, `jobAge`, `minYearsExperience`, `jobUrls`
- **Compensation** — `salary`, `salaryMin`, `salaryMax`, `salaryPeriod`, `salaryCurrency`
- **Prioritization** — `score`, `priority`, `intent`, `suggestedSellers`, `reason`, `summary`

### Input

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

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

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

There is nothing to configure for speed or proxy — both are tuned automatically.

#### 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. A location entered as `Latvia Riga` is normalized to `Riga, Latvia` before searching.

### Output example

Example record with the company and contact details masked. Every field is either correct or omitted — the Actor drops a value rather than emit something that does not make sense.

```json
{
  "company": "Example Brand Co",
  "website": "https://examplebrand.com/",
  "domain": "examplebrand.com",
  "linkedin": "https://www.linkedin.com/company/example-brand",
  "contactPage": "https://examplebrand.com/contact",
  "email": "careers@examplebrand.com",
  "emails": ["careers@examplebrand.com"],
  "phone": "+1XXXXXXXXXX",
  "phones": ["+1XXXXXXXXXX"],
  "jobs": 1,
  "applicants": 69,
  "hiringFor": ["Social Content Lead"],
  "jobFunction": "Marketing, Public Relations, and Writing/Editing",
  "department": "Marketing",
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "workMode": "On-site",
  "locations": ["Los Angeles, CA"],
  "latestJobDate": "2026-06-03",
  "jobAge": "1 week ago",
  "minYearsExperience": 6,
  "salary": "USD 95,000-110,000/yearly",
  "salaryMin": 95000,
  "salaryMax": 110000,
  "salaryPeriod": "yearly",
  "salaryCurrency": "USD",
  "industry": "Business Consulting and Services",
  "industries": [
    "Business Consulting and Services",
    "IT Services and IT Consulting",
    "Professional Training and Coaching"
  ],
  "score": 55,
  "priority": "Warm",
  "intent": "Marketing team expansion",
  "suggestedSellers": "Marketing agency, SEO agency, analytics SaaS",
  "reason": "Example Brand Co is hiring for Social Content Lead. This looks like marketing team expansion.",
  "summary": "We are hiring a Social Content Lead to grow our brand across social channels...",
  "jobUrls": ["https://www.linkedin.com/jobs/view/1234567890/"]
}
```

### Data quality — every value makes sense or it is dropped

This is the difference between a usable lead list and a noisy export:

- **Salary** is read only from LinkedIn's structured compensation block (e.g. `$95,000.00/yr`), never guessed from page text, so the amount, period, and currency are correct. Sign-on bonuses and equity are ignored. When no pay range is published, salary is omitted instead of invented.
- **Emails** are kept only when the domain belongs to the company; personal and third-party vendor emails embedded on a site are dropped. TLDs are validated against the official IANA list.
- **Phones** are validated to E.164 (correct country calling code and national-number length). Concatenated junk and impossible numbers are rejected.
- **Industries** are split into canonical LinkedIn industries, so a company is never reported with several industries glued into one string.
- **Websites** come from the job's apply link or a domain that corroborates with the LinkedIn company slug, so generic single-word brand names never map to the wrong company.

### Speed and reliability

Measured on Apify (4 GB), repeated runs, "content creator" / United States:

| Leads | Time | Rate blocks |
| --- | --- | --- |
| 30 | ~14s | none |
| 50 | ~25s | none |

There is nothing to tune. The Actor runs behind **Apify proxy automatically** with fixed, optimized crawl concurrency and request pacing, which avoids LinkedIn's per-IP rate limit and returns the full requested volume at maximum safe speed.

Reliability safeguards:

- On a rate limit, the Actor never crashes — it logs the boundary and keeps the leads already found, so no data is lost.
- Each company website lookup is time-capped and returns partial results, so a slow or dead site can never stall a run or discard a website that was already found.

### 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. Opens each job to read structured details (salary, seniority, employment type, job function, industries, applicants).
4. Checks likely public company websites and contact pages for generic emails and phone numbers.
5. Scores hiring intent and writes one clean company lead per company to the dataset.

If LinkedIn has no more public pages for a query, the log says so clearly and the run continues with the companies already found. For large lists, use multiple related keywords, locations, or pasted LinkedIn Jobs URLs.

### How to use (step by step)

1. Enter one or more `keywords` (job titles or buying-intent phrases) and a `location`.
2. Set `maxJobs` to how many company leads you want (try `40`–`100` for a quick run).
3. Click **Start**, or schedule the Actor to run daily/weekly.
4. Open the **Dataset** and export to CSV, Excel, Google Sheets, or JSON — or pull it from the Apify API.

### Export and integrations

- Export the Dataset to **CSV, Excel, JSON, XML, or RSS** in one click.
- Send leads to **Google Sheets, Make (Integromat), Zapier, n8n**, or any webhook.
- Pull results programmatically from the **Apify API** and push them into your **CRM** (HubSpot, Salesforce, etc.).
- **Schedule** recurring runs to keep a fresh hiring-leads feed.

### 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, higher for full territory sweeps.
- Use `maxJobsPerSearch` for an even spread across multiple keywords or URLs.
- Run separate searches by country, city, or niche for cleaner territory segmentation.

### FAQ

#### Does this LinkedIn scraper require a LinkedIn account or login?

No. The Actor only requests publicly accessible LinkedIn Jobs pages. No login, cookies, or session is used.

#### What contact data does it return?

Public company website, domain, contact page, generic business emails (e.g. info@, sales@, careers@) on the company's own domain, and validated public phone numbers. Personal emails and unrelated vendor emails are skipped.

#### Why company-level output instead of individual people?

Most sales and recruiting workflows need the company, its website, and a contact channel. Company-level output removes duplicate job rows and produces a cleaner outreach list. It does not scrape personal LinkedIn profiles.

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

A single public LinkedIn search has a finite number of public result pages. The Actor collects everything available and stops cleanly. Add more related keywords, URLs, or locations to collect more companies.

#### Can I export to Google Sheets, Excel, or my CRM?

Yes. Export the Dataset to CSV/Excel/JSON, or connect Apify to Google Sheets, Make, Zapier, n8n, or your CRM via the API and integrations.

#### Can I schedule it?

Yes. Schedule runs on Apify, then export or push the dataset to your tools automatically.

#### Is scraping public LinkedIn Jobs data allowed?

This Actor collects only public, company-level job data and does not bypass authentication or access controls. Review LinkedIn's terms and your local regulations, and use the data responsibly for legitimate B2B outreach.

### Responsible and compliant 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 access controls
- Collects company-level public data only
- Skips personal emails and keeps generic company inboxes only

# 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": [
    "marketing manager",
    "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": [
        "marketing manager",
        "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": [
        "marketing manager",
        "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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing manager",
    "sales manager",
    "software engineer"
  ]
}' |
apify call glasswing/linkedin-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/linkedin-leads"
        }
    }
}

```

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/00Grbp5rC5pMN2iiv/builds/7qWfA428yA3xIuCZA/openapi.json