# LinkedIn Company Jobs Scraper: Hiring & New Openings (`deepmine/linkedin-company-jobs-scraper`) Actor

LinkedIn company jobs scraper: every open job of the companies you name (page URL, ID or name), worldwide, with its full job page and the company's LinkedIn profile at one price. Only-new-jobs monitor for hiring signals; similar jobs, applicants and pay when shown. No login.

- **URL**: https://apify.com/deepmine/linkedin-company-jobs-scraper.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.59 / 1,000 jobs

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 Company Jobs Scraper: Hiring & New Openings

This **LinkedIn company jobs scraper** gets the open jobs of the companies you name (a LinkedIn company page URL, the company's LinkedIn ID or just its name), worldwide by default, and puts the **job details** (full description, seniority, job type, applicants line, apply type, similar jobs, and the pay range when LinkedIn shows it) and the **company's LinkedIn profile** (website, domain, industry, size, headcount, followers, headquarters and address) on every row, at one price. Give the run a monitor name and each scheduled run returns only the **new openings**.

| 💼 Title | 🏢 Company | 📍 Location | 💰 Pay | 👥 Applicants | 🏭 Company size | 📅 Posted |
|---|---|---|---|---|---|---|
| Principal Software Engineer, Infrastructure Security | OpenAI | New York, NY | $401,000 - $510,000 per year | 155 applicants | 1,001-5,000 employees | 2026-10-18T14:35:00Z |
| Manager I, Engineering - Coordination Systems Storage | Datadog | New York, NY | $192,000 - $240,000 per year | Be among the first 25 applicants | 1,001-5,000 employees | 2026-10-18T11:35:00Z |
| Applied Scientist - CoreAI Voice Agent | Microsoft | Vancouver, British Columbia, Canada | $85,800 - $169,300 per year | 136 applicants | 10,001+ employees | 2026-10-18T17:02:00Z |

<sub>Collected 2026-10-18 at 17:35 UTC from the prefilled run (OpenAI by its page URL, Datadog by name, Microsoft by its ID 1035, 34 jobs each; Apify run 6uifq8aRQ5Xq8G4vv, build 0.1.1): 102 jobs, every one with its job details and company data, in 14 seconds. One row from each company.</sub>

**$1.99 per 1,000 jobs** on the Starter plan ($2.29 Free, $1.79 Scale, $1.59 Business), job details and company data included, no start fee. The prefilled run (102 jobs) costs about $0.20.

No LinkedIn account, login or cookies.

### What it's for

- **Hiring signals for sales.** What your target accounts hire for tells you what they're building and buying: a new data team, a first security hire, an office in a new country. Each row carries the company's website and domain, ready for your CRM.
- **Competitor tracking.** Every role a competitor opens, where, at what level and at what pay (LinkedIn's pay box, or the range written in the description, in the currency the posting states). When the description says its range is for another country, `salaryAppliesTo` says which: Stripe's Toronto jobs quote "the annual US base salary range", so they come out in USD for the United States.
- **Recruiting and job hunting.** Follow the employers you care about and get each new opening the day it's listed, with its applicant count.
- **Job boards and feeds.** An employer's whole job list with full descriptions, refreshed on a schedule.

### Only new jobs: monitors

Type a **monitor name** (for example `weekly-fintech`) and schedule the run. The first run delivers the jobs it finds and remembers them; every later run with the same name returns only jobs no earlier run delivered. Jobs it already knows are skipped before their pages are read, so they're **never charged twice**.

- **A monitor's first run** = `deliver` (default: you get today's jobs) or `baseline` (it only remembers the jobs listed now, up to 5,000 per search, with no rows and no charge, so the next run brings only jobs posted after it).
- The monitor lives in your own Apify account as a named key-value store, `linkedin-company-jobs-<monitor name>`. **Start the monitor over** forgets it.
- A job that drops out of LinkedIn's list and comes back isn't delivered again. A run that the platform restarts keeps its first-run choice and doesn't repeat or recharge rows.

On 2026-10-18 a monitor's first run delivered 46 jobs and the same monitor 14 seconds later delivered 0 (46 skipped, run succeeded); a baseline on Datadog remembered 615 jobs at no charge, and the run after it delivered 0.

### How to set it up

1. **Companies**: one per line. A page URL (`https://www.linkedin.com/company/stripe`), the company's LinkedIn ID (`1035` is Microsoft; it's the `f_C` number in a LinkedIn jobs URL), or a name (looked up on LinkedIn: `OUTPUT.companies` says which company each name matched). The same company given twice (an ID and a name) is searched once (`OUTPUT.companyAliases`). A name LinkedIn doesn't know is listed in the status message and costs nothing. Up to 50 companies per run.
2. **Job titles or keywords** and **Locations**: optional. Each company is searched for each keyword in each location; empty means all its jobs, worldwide. A job found by several companies or searches is delivered and charged once, and every search that found it is in the run's `PROVENANCE` record.
3. **Posted within**: any time by default. LinkedIn serves at most 1,000 jobs per search, so for a bigger employer the run goes on by posting date over the last year: on 2026-10-18 Microsoft (LinkedIn showed 2,000+) gave 1,628 jobs in 162 seconds, every job of the newest 5.7 days included.
4. **Max jobs per company** (100 when the input doesn't say; the prefill uses 34) and, in Advanced, **Max jobs in total** for the whole run. You pay only for the jobs you get.
5. **Monitor name** and an Apify **Schedule** (daily or weekly) for only new jobs.

```json
{
  "companies": ["https://www.linkedin.com/company/stripe", "HubSpot", "1035"],
  "keywords": ["engineer"],
  "locations": ["United States"],
  "maxResults": 200,
  "monitorName": "weekly-check"
}
```

**Filters** (optional): remote / hybrid / on-site, job type, experience level, title must / must not include, industry, Easy Apply only, fewer than 10 applicants, only jobs that show pay, distance from a location, and job ids to skip. Jobs a filter leaves out aren't charged. Inputs written for other company-jobs scrapers (`companyUrls`, `startUrls`, `keyword`, `location`, `maxItems`, `datePosted`, ...) work as they are.

### Output

One row per job, the company first. Fields, in row order: `companyLogo`, `title`, `company`, `location`, `salary`, `salaryMin`, `salaryMax`, `salaryPeriod`, `salaryCurrency`, `salarySource`, `salaryAppliesTo`, `employmentType`, `seniority`, `workplaceType`, `applicants`, `applicantsText`, `isEasyApply`, `applyType`, `applyUrl`, `postedAt`, `postedTimeAgo`, `isReposted`, `jobState`, `detailsStatus`, `jobUrl`, `companyUrl`, `companySlug`, `companyInput`, `companyWebsite`, `companyDomain`, `companyIndustry`, `companySize`, `companySizeMin`, `companySizeMax`, `companyEmployeesOnLinkedIn`, `companyFollowers`, `companyHeadquarters`, `companyType`, `companyFounded`, `companySlogan`, `companySpecialties`, `companyDescription`, `companyStreetAddress`, `companyCity`, `companyRegion`, `companyPostalCode`, `companyCountry`, `companyOfficeLocations`, `companyAffiliatedPages`, `companyRecentPosts`, `jobPosterName`, `jobPosterTitle`, `jobPosterUrl`, `jobPosterPhoto`, `industries`, `benefits`, `jobInsights`, `yearsOfExperience`, `contactEmail`, `emails`, `phones`, `descriptionSnippet`, `description`, `descriptionHtml`, `similarJobs`, `peopleAlsoViewed`, `locationCity`, `locationState`, `locationCountry`, `jobId`, `companyId`, `searchKeywords`, `searchLocation`, `searchUrl`, `scrapedAt`.

How full they were on 2026-10-18 (the prefilled run's 102 jobs, and 1,628 Microsoft jobs):

| Field | Prefill (OpenAI, Datadog, Microsoft) | Microsoft, any time |
|---|---|---|
| Title, company, location, posting time, job link, description, job type, seniority, industry, applicants line, apply type | 100% | 100% |
| Company website, domain, industry, size, headcount, followers, headquarters, city, country | 100% | 100% |
| Similar jobs and "people also viewed" (up to 10 each) | 100% | 100% |
| Pay range (`salary`, with numbers and currency) | 76% | 65% |
| Applicant count as a number | 84% | 76% |
| Workplace (remote / hybrid / on-site) | 80% | 48% |
| Company founded, slogan | 33% (Datadog) | 0% (Microsoft's page has none) |
| Emails in the description | 0% | 0.5% |
| Job poster | 0% | 0% |

- `companyInput` is the company as you typed it, so you can join rows back to your list; `searchUrl` is the LinkedIn search the job came from.
- `applyType` is `easyApply` or `external`. `applyUrl` is the LinkedIn page of an Easy Apply job; LinkedIn doesn't show an employer's own application link to logged-out visitors, so it's empty for external ones (no link is made up).
- `detailsStatus` says whether the job page was read (`ok`); a job whose page didn't load still comes with its search card.
- Big employers' jobs rarely name a job poster; LinkedIn shows one only when the poster chose to. `emails` and `phones` are the ones written in the description.
- `descriptionHtml` comes only with **Description as HTML too**, and `matchedKeywords`, `unmatchedKeywords` and `keywordMatchScore` (which of your skills each description names) only with **Skills to look for**. Empty values are `null`.

The run summary (`OUTPUT`) has each company's result (`companies`: matched ID, jobs, LinkedIn's count, why it stopped), the aliases, the monitor's counts and the run's stop reason. A run that gets no jobs because LinkedIn refused it fails with a clear message instead of passing as a success.

### Pricing

Pay per job, no start fee and no minimum: the prefilled run (102 jobs) costs about $0.20 on Starter.

| Your Apify plan | Per 1,000 jobs, details and company data included |
|---|---|
| Free | $2.29 |
| Starter | $1.99 |
| Scale | $1.79 |
| Business | $1.59 |

Platinum and Diamond plans pay the Business price. You're billed only for rows in your dataset: jobs a filter leaves out, jobs a monitor delivered before and a monitor's baseline are free, and the run stops at your spending limit.

### FAQ

**How is this different from LinkedIn Jobs Search?** Same engine. [LinkedIn Jobs Search](https://apify.com/deepmine/linkedin-jobs-search) starts from keywords and places; this one starts from employers, remembers what it sent you, and includes job and company details in one price.

**A name matched the wrong company.** Use the company's page URL or ID instead; `OUTPUT.companies` shows the ID each name matched.

**Do I need a LinkedIn account?** No. It reads only what LinkedIn shows logged-out visitors.

### Feedback

Missing a field, or a company that doesn't come back the way you expect? Open an issue on the **Issues** tab and we'll look into it. If the data helps you, a short review on this page helps other people find it.

# Actor input Schema

## `companies` (type: `array`):

Every open job of these companies, worldwide. A LinkedIn company page (https://www.linkedin.com/company/stripe), its numeric company ID (1035) or its name (Datadog). Names are looked up on LinkedIn; the log says which company matched.

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

Only each company's jobs matching these words, e.g. engineer, sales. Each keyword is its own search inside each company. Empty = all of the company's jobs.

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

Only each company's jobs in these places, e.g. United States, London. Each location is its own search inside each company. Empty = worldwide.

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

Only jobs LinkedIn lists as posted in this period. Any time = every open job.

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

Stop each company (each keyword × location inside it) after this many jobs. Companies with more than 1,000 open jobs are read in posting-date windows past LinkedIn's 1,000 per search.

## `monitorName` (type: `string`):

Give the search a name (e.g. competitors-weekly): every run with this name skips the jobs earlier runs delivered (not read, not charged). Schedule it for a hiring feed. Empty = a normal run.

## `monitorFirstRun` (type: `string`):

Deliver: the first run returns today's jobs and remembers them. Baseline: it only remembers every job listed now (no rows, no charge), so later runs bring only new openings.

## `workplaceTypes` (type: `array`):

Only these workplace types, from LinkedIn's own Remote flag and the job page. Empty = all.

## `employmentTypes` (type: `array`):

Only these job types, as the job page shows them. Empty = all.

## `experienceLevels` (type: `array`):

Only these seniority levels, as the job page shows them. Empty = all.

## `titleIncludes` (type: `array`):

Keep only jobs whose title names one of these words or phrases, e.g. engineer. Empty = any title.

## `titleExcludes` (type: `array`):

Leave out jobs whose title names any of these, e.g. intern, contract. Empty = none left out.

## `industries` (type: `array`):

Only jobs whose page lists an industry containing one of these, e.g. Software Development. Empty = any industry.

## `easyApply` (type: `boolean`):

Only jobs you apply to on LinkedIn itself.

## `under10Applicants` (type: `boolean`):

LinkedIn's Under 10 applicants filter: fresh jobs few people applied to.

## `requireSalary` (type: `boolean`):

Keep only jobs whose page, description or title states pay.

## `distance` (type: `integer`):

With Locations: LinkedIn's distance filter around each one, e.g. 25. Empty = LinkedIn's default.

## `sortBy` (type: `string`):

With keywords: LinkedIn's best matches first, or the newest first. Without keywords jobs come newest first.

## `includeRelatedJobs` (type: `boolean`):

Adds similarJobs and peopleAlsoViewed: the other jobs LinkedIn shows on each job's page (up to 10 each). Same price.

## `includeHtml` (type: `boolean`):

Adds descriptionHtml with LinkedIn's formatting (lists, bold).

## `matchKeywords` (type: `array`):

Adds which of these each job names in its title or description, with a match score, e.g. Python, React | ReactJS. Empty = no match columns.

## `maxTotalResults` (type: `integer`):

Stop the whole run after this many jobs, across all companies: a ceiling on the cost. Empty = no cap besides Max jobs per company and your spending limit.

## `resetMonitor` (type: `boolean`):

Forget what this monitor delivered before; this run is its first run again. Turn it off after one run.

## `skipJobIds` (type: `array`):

LinkedIn job IDs or job URLs you already have: not read, not delivered, not charged.

## `proxyConfiguration` (type: `object`):

Leave as is: Apify datacenter proxies first, residential only for retries LinkedIn refused.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/openai",
    "Datadog",
    "1035"
  ],
  "postedWithin": "anyTime",
  "maxResults": 34,
  "monitorFirstRun": "deliver",
  "easyApply": false,
  "under10Applicants": false,
  "requireSalary": false,
  "sortBy": "relevance",
  "includeRelatedJobs": true,
  "includeHtml": false,
  "resetMonitor": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `jobPostersUrl` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "companies": [
        "https://www.linkedin.com/company/openai",
        "Datadog",
        "1035"
    ],
    "maxResults": 34,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/linkedin-company-jobs-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 = {
    "companies": [
        "https://www.linkedin.com/company/openai",
        "Datadog",
        "1035",
    ],
    "maxResults": 34,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/linkedin-company-jobs-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 '{
  "companies": [
    "https://www.linkedin.com/company/openai",
    "Datadog",
    "1035"
  ],
  "maxResults": 34,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/linkedin-company-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/linkedin-company-jobs-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/EzsViACv5j7xdAKDv/builds/R0WtD2oTAQcOCWyFV/openapi.json