# LinkedIn Jobs by Company (`burbn/linkedin-company-jobs`) Actor

Scrape LinkedIn jobs for specific companies. Search by company name, URL, or numeric ID. Filter by location, employment type, seniority, remote, and more. Get detailed job descriptions, salary info, and applicant counts.

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

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

Extract structured job listings directly from specific target companies on LinkedIn. Scrape by company vanity slug, company profile URL, or numeric company ID with deep keyword, seniority, location, and date posted filters. Collect job titles, full descriptions, employer details, salary figures, applicant counts, and direct apply links in JSON, CSV, or Excel format.

#### Why Choose This Scraper?

- **No LinkedIn Account Required**: Scrapes public LinkedIn job listings safely without logging in, cookies, or risking account bans.
- **Flexible Company Targeting**: Query companies by name, vanity slug (e.g., `google`), full LinkedIn URL, or numeric company ID (`f_C`).
- **Batch Multiple Companies**: Search up to 10 companies simultaneously in a single execution.
- **Fast and Lightweight**: Real-time API-powered scraping delivers results in seconds. Toggle `include_details: false` for up to 3x faster runs.
- **Granular Filtering**: Filter by role keywords, date posted, employment type, seniority level, remote status, and search radius.
- **Complete Job Details**: Retrieve full descriptions, salary ranges, benefits, applicant counts, and direct apply URLs.
- **Flexible Export**: Export clean, normalized data directly to JSON, CSV, Excel, or consume via Apify API and webhooks.

### Features

- **Company-Specific Targeting**: Extract all open positions posted by specific employers using company name, LinkedIn URL, or company ID.
- **Multi-Company Batching**: Provide comma-separated company names or IDs (up to 10) to monitor multiple target organizations in one run.
- **Keyword and Role Filtering**: Narrow down company job openings with optional keywords (e.g., "Software Engineer", "Product Manager").
- **Location and Radius Targeting**: Filter by city, country, or LinkedIn numeric geo ID with kilometer radius support.
- **Employment Type Filters**: Filter by full-time, part-time, contract, or internship positions.
- **Experience and Seniority Levels**: Target entry level, associate, mid-senior level, director, or executive roles.
- **Remote Work Filter**: Quickly isolate remote and work-from-home job opportunities.
- **Freshness and Date Posted**: Fetch jobs posted today, in the past 3 days, past week, or past month.
- **Sorting Options**: Order results by relevance or by date (newest first).
- **Direct Apply Links**: Access direct application URLs and third-party publisher links.
- **Compensation Data**: Extract base salary, minimum and maximum ranges, period, and currency when disclosed by the employer.
- **Applicant Statistics & Badges**: Track applicant counts and LinkedIn badges (e.g., "Actively Hiring") to evaluate competition.

### Quick Start

1. Enter a **Company Name/URL** (such as `google` or `https://www.linkedin.com/company/microsoft`) or a **Company ID** (such as `1441`).
2. (Optional) Add a **Keyword Filter** (such as `"Backend Engineer"`) or specify a **Location**.
3. Choose the number of pages to collect (each page returns up to 10 listings).
4. Run the actor and download your structured dataset in CSV, JSON, or Excel format.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `company` | String | Conditional\* | `"google"` | LinkedIn company vanity slugs or URLs, comma-separated (up to 10). Example: `'google', 'microsoft'`. *Either `company` or `company_id` is required. |
| `company_id` | String | Conditional* | - | LinkedIn numeric company IDs (`f_C`), comma-separated (up to 10). Example: `'1441'`. \*Either `company` or `company_id` is required. |
| `query` | String | No | - | Optional keyword filter applied within company jobs (e.g., `"Software Engineer"`). Leave empty for all company jobs. |
| `location` | String | No | - | Geographic location filter (e.g., `"London, UK"`, `"San Francisco, CA"`). Leave empty for worldwide. |
| `page` | Integer | No | `1` | Starting page number (range: 1 to 100). |
| `num_pages` | Integer | No | `1` | Number of consecutive pages to fetch (range: 1 to 20, 10 jobs per page). |
| `country` | String | No | `"us"` | Two-letter ISO country code (e.g., `"us"`, `"uk"`, `"de"`, `"in"`) for proxy exit market. |
| `sort_by` | String | No | `"relevance"` | Sort ordering: `relevance` (default) or `date` (newest first). |
| `date_posted` | String | No | `"all"` | Posting timeframe: `all`, `today`, `3days`, `week`, or `month`. |
| `employment_types` | String | No | - | Filter by employment type: `FULLTIME`, `PARTTIME`, `CONTRACTOR`, `INTERN`. |
| `seniority_levels` | String | No | - | Filter by seniority: `Internship`, `Entry level`, `Associate`, `Mid-Senior level`, `Director`, `Executive`, `Not Applicable`. |
| `remote_jobs_only` | Boolean | No | `false` | When enabled, returns only listings explicitly marked as remote. |
| `geo_id` | String | No | - | LinkedIn numeric geo ID for precise location targeting (e.g., `"102571732"`). |
| `radius` | Integer | No | - | Search radius in kilometers around the `geo_id` location (requires `geo_id`). |
| `include_details` | Boolean | No | `true` | Fetch extended job details (descriptions, salary, applicant counts). Set to `false` for ~3x faster runs. |
| `fields` | String | No | - | Comma-separated list of specific fields to return in the output dataset. |

#### Example Inputs

##### 1. Basic Company Search

```json
{
  "company": "google",
  "num_pages": 1
}
```

##### 2. Search by Numeric Company ID

```json
{
  "company_id": "1441",
  "query": "Software Engineer",
  "num_pages": 2
}
```

##### 3. Advanced Filtered Search

```json
{
  "company": "microsoft",
  "query": "Cloud Architect",
  "location": "Redmond, WA",
  "date_posted": "week",
  "employment_types": "FULLTIME",
  "seniority_levels": "Mid-Senior level",
  "sort_by": "date",
  "remote_jobs_only": false,
  "include_details": true,
  "num_pages": 3
}
```

##### 4. Batch Multiple Companies

```json
{
  "company": "google,microsoft,apple",
  "query": "Data Scientist",
  "remote_jobs_only": true,
  "date_posted": "month",
  "num_pages": 2
}
```

### Output Data Structure

Each dataset item represents one job listing. Output fields are organized into logical categories:

#### Job Details

| Field | Type | Description |
|-------|------|-------------|
| `job_id` | String | LinkedIn job identifier |
| `job_uid` | String | Clean numeric job ID |
| `job_title` | String | Full title of the job posting |
| `job_description` | String | Full job description text |
| `job_employment_type` | String | Primary employment type (e.g., Full-time) |
| `job_employment_types` | Array | Matching employment type codes (e.g., `["FULLTIME"]`) |
| `job_seniority_level` | String | Required experience level (e.g., Mid-Senior level) |
| `job_function` | String | Functional department |
| `job_industries` | Array | Industry categories associated with the job |
| `job_is_remote` | Boolean | Whether the role is marked as remote |
| `job_highlights` | Object | Key highlights extracted from the listing |
| `job_benefits` | Array | Extracted job benefits and perks |

#### Employer Information

| Field | Type | Description |
|-------|------|-------------|
| `employer_name` | String | Company or organization name |
| `employer_logo` | String | URL to the company logo image |
| `employer_website` | String | Official company website URL |
| `employer_linkedin_url` | String | URL to company profile on LinkedIn |
| `job_linkedin_company_id` | String | Numeric LinkedIn company ID |

#### Location Details

| Field | Type | Description |
|-------|------|-------------|
| `job_location` | String | Location string as listed on LinkedIn |
| `job_city` | String | City name |
| `job_state` | String | State or region |
| `job_country` | String | Country code |
| `job_latitude` | Number | Geographic latitude |
| `job_longitude` | Number | Geographic longitude |

#### Compensation and Salary

| Field | Type | Description |
|-------|------|-------------|
| `job_salary_string` | String | Formatted salary range string (e.g., "$174,000 - $252,000 / year") |
| `job_min_salary` | Number | Minimum compensation figure |
| `job_max_salary` | Number | Maximum compensation figure |
| `job_salary_period` | String | Salary frequency (e.g., year, hour) |
| `job_salary_currency` | String | Currency code (e.g., USD, EUR, GBP) |

#### Application and Metadata

| Field | Type | Description |
|-------|------|-------------|
| `source` | String | Source identifier (`linkedin_company_jobs`) |
| `company_search` | String | Company identifier queried |
| `position` | Number | Item order index |
| `job_apply_link` | String | Direct apply URL |
| `job_apply_is_direct` | Boolean | Whether the application link is direct |
| `apply_options` | Array | Available application methods |
| `job_publisher` | String | Publisher or source platform (e.g., LinkedIn) |
| `job_applicants_count` | Number | Number of registered applicants |
| `job_applicants_label` | String | Formatted applicant count label |
| `job_linkedin_badges` | Array | Badges such as "Actively Hiring" |
| `job_posted_at` | String | Relative posting time (e.g., "2 days ago") |
| `job_posted_at_date` | String | Formatted date of the posting (YYYY-MM-DD) |
| `scraped_at` | String | ISO timestamp when the job was collected |

#### Example Output

```json
{
  "source": "linkedin_company_jobs",
  "company_search": "google",
  "position": 1,
  "job_id": "bGlua2VkaW46NDQ2MDk1MjkwNg",
  "job_uid": "4460952906",
  "job_title": "Senior Software Engineer, Infrastructure, Google Cloud Platforms",
  "job_description": "In most instances, this position requires in-person interviews as part of the hiring process. Google's software engineers develop the next-generation technologies that change how billions of users connect...",
  "job_employment_type": "Full-time",
  "job_employment_types": ["FULLTIME"],
  "job_seniority_level": "Mid-Senior level",
  "job_function": "Information Technology and Engineering",
  "job_industries": ["Information Services and Technology", "Information and Internet"],
  "job_is_remote": false,
  "employer_name": "Google",
  "employer_logo": "https://media.licdn.com/dms/image/v2/D4E0BAQGv3cqOuUMY7g/company-logo_100_100/google_logo.png",
  "employer_website": "https://about.google",
  "employer_linkedin_url": "https://www.linkedin.com/company/google",
  "job_linkedin_company_id": "1441",
  "job_apply_link": "https://www.linkedin.com/jobs/view/4460952906",
  "job_apply_is_direct": false,
  "apply_options": [
    {
      "apply_link": "https://www.linkedin.com/jobs/view/4460952906",
      "is_direct": false,
      "publisher": "LinkedIn"
    }
  ],
  "job_publisher": "LinkedIn",
  "job_location": "Kirkland, WA",
  "job_city": "Kirkland",
  "job_state": "Washington",
  "job_country": "US",
  "job_salary_string": "$174,000 - $252,000 / year",
  "job_min_salary": 174000,
  "job_max_salary": 252000,
  "job_salary_period": "year",
  "job_salary_currency": "USD",
  "job_posted_at": "2 days ago",
  "job_posted_at_date": "2026-09-23",
  "job_applicants_count": 46,
  "job_applicants_label": "46 applicants",
  "job_linkedin_badges": ["Actively Hiring"],
  "scraped_at": "2026-09-25T08:00:00.000Z"
}
```

### Use Cases

- **Competitor Hiring Intelligence**: Monitor open requisitions, expansion departments, and new tech stack adoptions across direct competitors in real time.
- **Account-Based Recruiting (ABR)**: Track target accounts to source top talent, identify departing skills, and reach out to relevant candidates.
- **Sales & Lead Generation**: Track company hiring spikes (e.g., massive hiring in Sales or Engineering) as buying intent signals for B2B solutions.
- **Job Boards and Aggregators**: Automatically curate dedicated career feeds and company microsites with always-fresh job openings.
- **Salary & Compensation Benchmarking**: Collect compensation ranges published by industry leaders to benchmark company salary brackets.
- **Investment & Due Diligence**: Gauge company health, growth velocity, and strategic pivots through active job posting volume and role types.

### Tips for Best Results

- **Find Numeric Company IDs**: If you need the exact `company_id`, use our [LinkedIn Jobs Search](https://apify.com/burbn/linkedin-jobs-search) actor. Each scraped job returns `job_linkedin_company_id` (e.g., `1441` for Google).
- **Optimize Speed**: When you only need basic listing data (titles, locations, URLs), set `include_details` to `false` for up to ~3x faster execution.
- **Batch Multiple Companies**: Save time and compute by passing multiple companies separated by commas (e.g., `google,microsoft,apple`).
- **Target Fresh Roles**: Set `date_posted` to `today` or `week` and sort by `date` to capture recently posted jobs with lower applicant competition.
- **Pagination Control**: Use `num_pages` (up to 20 per run) to balance speed and data volume. Each page fetches up to 10 listings.

### Dataset Views

This actor includes a pre-configured table view in the Apify Console:

- **LinkedIn Company Jobs Overview**: Clean, organized table displaying Job Title, Company, Logo, Location, Employment Type, Seniority, Salary, Applicants, Date Posted, and Apply Link.

### Limitations

- Each search page contains up to 10 job listings.
- Up to 20 pages (200 jobs) can be retrieved per run. For higher volumes, paginate with the `page` parameter.
- You can query up to 10 companies simultaneously per run.
- Salary details are only present when disclosed by the employer in the job posting.
- Radius search requires a valid numeric LinkedIn `geo_id`.

### Frequently Asked Questions

#### Do I need a LinkedIn account or login credentials?

No. The scraper accesses public LinkedIn company job listings. You do not need to provide LinkedIn cookies, passwords, or personal account details.

#### How do I find a company's numeric LinkedIn ID (`company_id`)?

You can find the numeric company ID using the [LinkedIn Jobs Search](https://apify.com/burbn/linkedin-jobs-search) actor. Run a search for any job from the target employer and look for the `job_linkedin_company_id` field in the dataset output (e.g., `1441` for Google, `1035` for Microsoft). Alternatively, you can simply use the company vanity name (e.g., `google`).

#### Can I search multiple companies at once?

Yes. You can provide up to 10 company names or IDs separated by commas in the `company` or `company_id` field (e.g., `google,microsoft,apple`). The scraper will fetch jobs for each company sequentially.

#### Can I filter jobs by role/title inside a specific company?

Yes. Use the `query` parameter (e.g., `"Software Engineer"`, `"Product Designer"`). The scraper will search only within the specified company's open listings.

#### How many jobs can I collect per run?

You can collect up to 200 jobs per run (20 pages × 10 listings). For larger datasets, schedule recurring runs or paginate through results using the `page` parameter.

#### What export formats are supported?

Data can be exported in JSON, CSV, Excel, XML, or HTML table format directly from the Apify platform or programmatically via the Apify API.

### Related Actors

Complement your LinkedIn recruitment and intelligence pipeline with other actors:

- [LinkedIn Jobs Search](https://apify.com/burbn/linkedin-jobs-search): Search LinkedIn jobs globally with keyword and location filters, extract `job_linkedin_company_id`, salary ranges, and applicant statistics.
- [LinkedIn Profile Scraper](https://apify.com/burbn/linkedin-profile-scraper): Extract complete LinkedIn profile information, including work experience, education, skills, verified professional emails, and company details without logging into an account.

### Tags

`linkedin company jobs` `linkedin company jobs scraper` `scrape company jobs` `linkedin jobs scraper` `company jobs api` `linkedin job postings` `extract company jobs` `competitor hiring tracking` `recruitment scraper` `talent sourcing` `job scraper` `linkedin api` `remote jobs scraper` `apify linkedin` `job openings scraper` `company career scraper`

### Get Started

1. Click **Try for free** on this actor page. [Sign up using this link](https://apify.com?fpr=free-credits)
2. Enter your target company name or slug in the **Company Name or URL** field (e.g., `google`).
3. Configure optional keyword, location, date, or seniority filters.
4. Click **Start** to run the actor and export your structured job data.

# Actor input Schema

## `company` (type: `string`):

Enter LinkedIn company vanity slugs or company page URLs, comma-separated (up to 10). Examples: 'microsoft', '/company/google', 'https://www.linkedin.com/company/apple'. Either this or Company ID is required.

## `company_id` (type: `string`):

LinkedIn company numeric IDs (f\_C), comma-separated (up to 10). Example: '1441' for Google. You can find the numeric company ID (job\_linkedin\_company\_id) by using the [LinkedIn Jobs Search](https://apify.com/burbn/linkedin-jobs-search) actor. Either this or Company Name/URL is required.

## `query` (type: `string`):

Optional free-form keyword filter applied within the selected companies. Example: 'Software Engineer', 'Data Scientist'. Leave empty to get the company's entire job list.

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

Free-text location filter (e.g., 'London, United Kingdom', 'Berlin, Germany', 'New York, US'). Leave empty for worldwide search.

## `page` (type: `integer`):

Starting page number (1-based). Each page returns 10 jobs. Max: 100.

## `num_pages` (type: `integer`):

How many consecutive pages to fetch (each page = 10 jobs). Max: 20 pages = 200 jobs.

## `geo_id` (type: `string`):

LinkedIn numeric geo ID (e.g., '102571732' for New York City). Required if you want radius search to work.

## `radius` (type: `integer`):

Search radius in kilometres around the geo\_id location. Requires geo\_id to be set.

## `country` (type: `string`):

2-letter country code (e.g., 'us', 'uk', 'de', 'in'). Selects proxy exit market.

## `sort_by` (type: `string`):

Sort order for job results.

## `date_posted` (type: `string`):

Filter jobs by how recently they were posted.

## `employment_types` (type: `string`):

Filter jobs by employment type.

## `seniority_levels` (type: `string`):

Filter jobs by seniority level.

## `remote_jobs_only` (type: `boolean`):

If enabled, returns only jobs with an explicit remote marker.

## `include_details` (type: `boolean`):

Fetch each job's detail page (description, salary, seniority, applicants count). Set to false for ~3x faster response but less data.

## `fields` (type: `string`):

Comma-separated list of specific fields to return (e.g., 'job\_title,employer\_name,job\_location'). Leave empty for all fields.

## Actor input object example

```json
{
  "company": "google",
  "page": 1,
  "num_pages": 1,
  "country": "us",
  "sort_by": "relevance",
  "date_posted": "all",
  "employment_types": "",
  "seniority_levels": "",
  "remote_jobs_only": false,
  "include_details": true
}
```

# Actor output Schema

## `jobs_overview` (type: `string`):

Open the dataset view with all found LinkedIn company jobs including titles, salaries, and apply links.

# 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 = {
    "company": "google"
};

// Run the Actor and wait for it to finish
const run = await client.actor("burbn/linkedin-company-jobs").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 = { "company": "google" }

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

```

## MCP server setup

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

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/9ao4qtl2k78hgBwKd/builds/1BoILWAv8G5E91bbz/openapi.json