# LinkedIn Company Jobs Scraper – Vacancies Export (`scrapingmonkey/linkedin-company-jobs-scraper`) Actor

Collect public LinkedIn jobs by company slug, URL, or ID. Export titles, employers, locations, posting dates, and listing labels with filters and pagination.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

Collect public vacancies from a list of LinkedIn companies, with the employer context preserved on every job. **LinkedIn Company Jobs Scraper** accepts company slugs, URLs, or numeric IDs and returns job titles, locations, posting dates, company details, and visible listing labels.

Use it to follow hiring at target employers, compare role demand, or build a vacancy database. Set a page budget for each company and narrow the results with keywords or location before exporting them.

| At a glance | Details |
|---|---|
| 📥 Input | LinkedIn company slugs, company URLs, or numeric company IDs |
| 📤 Output | One row per collected job, including its source company |
| 🔎 Filters | Keywords, location, posting time, workplace, seniority, job type, and more |
| 📄 Pagination | Configurable pages per company; normally 10 job cards per page |
| 🔐 Login required | No LinkedIn credentials or cookies |

### What the LinkedIn company jobs scraper collects 💼

The Actor collects the job cards visible in LinkedIn's public company-filtered search. Each card can include:

- Job ID, job URL, and title
- Employer name, ID, page URL, and logo when exposed on the card
- Job location, posting date, and relative posting-time text
- Benefits and labels shown on the listing
- Actively hiring and promoted indicators
- The source company's ID, slug, name, and URL

Company slugs and URLs are resolved before searching. A numeric ID can be used directly; in that case, source-company name, slug, and URL remain empty. Employer information from each job card is still returned when available.

### How to scrape LinkedIn company jobs 🚀

1. Add company slugs such as `microsoft`, company URLs, or numeric IDs.
2. Choose `pagesPerCompany` and add any filters.
3. Start the Actor and review the job rows and any failed results.
4. Export the dataset or pass selected job URLs to a details workflow.

```json
{
  "inputList": [
    "microsoft"
  ],
  "pagesPerCompany": 2,
  "keywords": "software engineer",
  "location": "United States"
}
```

The same filters apply to every company in the run. Duplicate job IDs are removed across pages for each company; jobs returned under different company searches can appear more than once.

### Company job data fields and output 📦

| Field group | Included data |
|---|---|
| Result | Original company input and success or failed status |
| Source company | Resolved company ID, slug, name, and URL |
| Job | ID, URL, title, location, posting date, and relative time |
| Listed employer | Company ID, name, URL, and logo from the job card |
| Listing labels | Benefits, actively hiring indicator, and promoted indicator |

Complete illustrative output item with all 19 fields. The employer, vacancy, dates, and values below are fictional examples, not a live result:

```json
{
  "input": "example-analytics",
  "status": "success",
  "source_company_id": "12345678",
  "source_company_slug": "example-analytics",
  "source_company_name": "Example Analytics",
  "source_company_url": "https://www.linkedin.com/company/example-analytics/",
  "id": "9876543210",
  "url": "https://www.linkedin.com/jobs/view/9876543210/",
  "title": "Software Engineer",
  "company.id": "12345678",
  "company.name": "Example Analytics",
  "company.url": "https://www.linkedin.com/company/example-analytics/",
  "company.logo": "https://example.com/company-logo.png",
  "location": "Singapore",
  "posted_at": "2026-09-06",
  "posted_time": "2 days ago",
  "benefits": [
    "Actively Hiring",
    "Medical insurance"
  ],
  "actively_hiring": true,
  "is_promoted": false
}
```

Each job occupies one row in one table. JSON uses the same literal field names, including `company.name`; company details are separate columns. `benefits` is an ordered list within that row.

Successful cards may contain empty strings or empty lists when LinkedIn omits data. The hiring and promoted flags reflect labels found on the card; `false` does not prove that an employer is inactive. A failed result retains `input`, sets `status` to `failed`, and uses `null` for the other fields.

### Input requirements and company coverage ⚙️

| Parameter | Type | Default | Rules and meaning |
|---|---|---|---|
| `inputList` | array of strings | Required | At least one company slug, company URL, or numeric company ID |
| `pagesPerCompany` | integer | `1` | Minimum 1; no fixed upper limit |
| `keywords` | string | `""` | Job keywords applied within each company's results |
| `location` | string | `""` | LinkedIn location text |
| `geoId` | string | `""` | LinkedIn geographic ID |
| `timePosted` | string | `""` | Posting-time value from LinkedIn's `f_TPR` URL parameter |
| `workplaceType` | string | `""` | Workplace value from LinkedIn's `f_WT` URL parameter |
| `experienceLevel` | string | `""` | Experience-level value from LinkedIn's `f_E` URL parameter |
| `jobType` | string | `""` | Job-type value from LinkedIn's `f_JT` URL parameter |
| `sortBy` | string | `""` | Sort value from LinkedIn's `sortBy` URL parameter |
| `distance` | integer | `0` | Minimum 0; zero leaves the distance filter unset |
| `easyApply` | boolean | `false` | Request LinkedIn's Easy Apply filter |
| `earlyApplicant` | boolean | `false` | Request LinkedIn's early-applicant filter |

Accepted forms include `microsoft`, `https://www.linkedin.com/company/microsoft/`, and `1035`. Enter company targets rather than job URLs. Filter strings are passed through to LinkedIn; use its filter values, not display labels, for the coded filters. To reuse filters from a LinkedIn job-search URL, copy its parameter values into the corresponding input fields.

Pages normally contain 10 job cards. Pagination stops at the requested limit, when a page contains fewer than 10 parsed jobs, or when no new job IDs appear. A company with no jobs on its first page produces a failed row. An empty later page simply ends that company's pagination.

The Actor collects listing summaries. Use LinkedIn Job Details Scraper for descriptions, application links, and available salary or qualification fields.

### LinkedIn company hiring use cases 🎯

#### Target-account hiring research

Follow vacancies at a defined employer list and retain the company that led to each result for account-level reporting.

#### Role and location comparisons

Compare the titles and locations employers advertise, using the same filters and page budget across a run.

#### Vacancy alerts

Schedule repeat runs and compare job IDs in your own database to identify newly observed listings.

#### Job enrichment pipelines

Collect job URLs by company, select relevant openings, and retrieve their full public descriptions with Job Details Scraper.

### Pricing and billable job rows 💰

Check the Actor's **Pricing** tab for the current charging model and rate.

Under dataset-item pricing, each saved job is a result. Saved failed rows can also count, including a company with no jobs on the first page or a page that remains unavailable after retries. Automatic retries do not independently create extra rows.

`pagesPerCompany` limits pages requested, not an exact row count. Begin with one page per company to estimate the volume for your chosen filters.

### LinkedIn company jobs API and integrations 🔌

Use the Actor ID from the API tab for `$ACTOR_ID` and your Apify token for `$APIFY_TOKEN`:

```bash
curl -X POST "https://api.apify.com/v2/acts/$ACTOR_ID/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputList":["microsoft"],"pagesPerCompany":2,"keywords":"software engineer","location":"United States"}'
```

Run the same search from Apify schedules, REST, or client libraries. Send its default dataset to a spreadsheet, vacancy database, Make, Zapier, or your own reporting workflow. Job IDs provide a useful key for comparing repeated runs.

### Reliability and collection limits ⚠️

The Actor processes up to five requests concurrently and retries temporary request failures. An invalid company entry or an unavailable public page is saved as a failed result without stopping other companies.

A later-page failure can leave successful jobs and a failed row for the same company in the dataset. Already saved rows remain available. Duplicate suppression applies within each company's pagination, so combine results by job ID if your downstream workflow needs uniqueness across companies or runs.

Public search can change, return fewer results than requested, or omit optional card details. The dataset is a snapshot of the collected pages, not a guaranteed inventory of every vacancy at the employer.

### Frequently asked questions ❓

#### Can I use a company ID instead of a URL?

Yes. A numeric company ID searches jobs directly. Source-company name, slug, and URL stay empty because the company profile is not resolved for that input form.

#### Will two pages always return 20 jobs?

No. Each page normally contains 10 cards, but short pages, duplicates, unavailable results, or an early end to the search can reduce the total.

#### Does it return full descriptions?

It returns public job-card fields. Use Job Details Scraper with the collected IDs or URLs to retrieve available descriptions and other detail fields.

#### Why did a company with no vacancies produce a failed row?

An empty first page is recorded as a failed result so the submitted company remains visible. Empty pages after collected jobs end pagination without adding a failure.

#### Do I need a LinkedIn account?

No LinkedIn account, password, or session cookies are required.

### Support, responsible use, and related actors 🛟

For a reproducible issue, share the run ID, a public company input, the filters used, and the expected result through the Actor's support channel.

Use public job data in accordance with applicable privacy, copyright, contractual, and platform requirements.

# Actor input Schema

## `inputList` (type: `array`):

Add one company slug, company URL or numeric company ID per item.

## `pagesPerCompany` (type: `integer`):

Number of job pages to request. Each page normally contains 10 jobs.

## `keywords` (type: `string`):

Optional job keywords.

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

Optional LinkedIn location text.

## `geoId` (type: `string`):

Optional LinkedIn geographic ID.

## `timePosted` (type: `string`):

Optional LinkedIn f\_TPR filter value.

## `workplaceType` (type: `string`):

Optional workplace type filter value.

## `experienceLevel` (type: `string`):

Optional experience level filter value.

## `jobType` (type: `string`):

Optional job type filter value.

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

Optional LinkedIn sort value.

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

Optional distance filter.

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

Return Easy Apply jobs only.

## `earlyApplicant` (type: `boolean`):

Apply LinkedIn's early applicant filter.

## Actor input object example

```json
{
  "inputList": [
    "microsoft"
  ],
  "pagesPerCompany": 1,
  "keywords": "",
  "location": "",
  "geoId": "",
  "timePosted": "",
  "workplaceType": "",
  "experienceLevel": "",
  "jobType": "",
  "sortBy": "",
  "distance": 0,
  "easyApply": false,
  "earlyApplicant": false
}
```

# Actor output Schema

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

Actor dataset rows. Use the status column to distinguish successful extraction from failed processing.

# 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 = {
    "inputList": [
        "microsoft"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapingmonkey/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 = { "inputList": ["microsoft"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapingmonkey/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 '{
  "inputList": [
    "microsoft"
  ]
}' |
apify call scrapingmonkey/linkedin-company-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapingmonkey/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/xHymUkcP73JLt5mdO/builds/UYKOoTgAn8SI3qSqY/openapi.json