# LinkedIn Company Profile & Public Job Market Scraper (`hoang_minh_quan/linkedin-company-jobs-scraper`) Actor

Scrape public LinkedIn company pages (size, industry, HQ) and open job listings. Business/market data only — does not scrape personal profiles or sensitive individual PII.

- **URL**: https://apify.com/hoang\_minh\_quan/linkedin-company-jobs-scraper.md
- **Developed by:** [Hoang Minh Quan](https://apify.com/hoang_minh_quan) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Company & Jobs Intelligence API — Firmographics + Open Roles in One Structured Feed

**Stop copy-pasting company pages and job boards. Get HQ, size, industry, and open roles as API-ready JSON — without scraping personal profiles.**

***

### The problem

B2B teams need LinkedIn data every day — but the platform fights automation and personal-profile scraping is a compliance minefield.

- SDRs manually open company pages to guess **size, industry, and HQ** before outreach.
- Recruiters refresh `/jobs/` tabs and keyword searches — **hours lost** on roles that were posted yesterday.
- Generic scrapers return messy HTML or **reject `/in/` URLs** without giving you clean company + job rows.
- Competitive intelligence teams track hiring spikes too late — after the press release, not when the reqs go live.

If your GTM stack still depends on “someone checked LinkedIn this morning,” your pipeline is always behind the market.

***

### The solution

This Actor turns **public LinkedIn company pages and job listings** into a **B2B intelligence API**:

1. **Company profiles** — Industry, size, HQ, founded year, specialties, website, follower count, and description.
2. **Company jobs** — Open roles from each company’s `/jobs/` page with location, seniority, and employment type.
3. **Keyword job search** — Cross-company discovery by role keywords and optional location filter.
4. **Deliver** — Typed `recordType` rows (`company` | `job`) + `OUTPUT` summary for CRM, ATS, or warehouse sync.

You don’t buy “LinkedIn scraping.” You buy **account and hiring intelligence** your rev ops team can actually ingest.

> Public company and job posting data only. **No personal `/in/` profile scraping. No individual PII.**

***

### Key features

- **Company watchlists** — `companyUrls[]` (URL or slug, e.g. `google`)
- **Dual extraction modes** — Toggle `scrapeCompanyProfile` and `scrapeCompanyJobs` independently
- **Keyword job discovery** — `jobKeywords[]` + optional `jobLocation` filter
- **Rich job fields** — Title, location type (Remote/Hybrid), seniority, employment type, public applicant text
- **Firmographic depth** — Staff count, industry, headquarters, specialties, website, followers
- **Error transparency** — `includeErrors` pushes stubs when auth walls block a page
- **Residential proxy + retries** — built for LinkedIn’s auth walls on datacenter IPs
- **Developer-ready JSON** — consistent schema + `OUTPUT` run summary

***

### Quick start (Try for free)

1. Open the Actor in [Apify Console](https://console.apify.com/actors/QJY3Wcch7UgwBYyCm).
2. Prefill company URL is ready — click **Start** with residential proxy on.
3. Filter dataset by `recordType` for companies vs jobs; export or sync via Apify API.

```json
{
  "companyUrls": ["https://www.linkedin.com/company/google/"],
  "scrapeCompanyProfile": true,
  "scrapeCompanyJobs": true,
  "maxJobsPerCompany": 20,
  "useApifyProxy": true,
  "proxyCountry": "US"
}
```

**Pro tip:** Combine `companyUrls[]` for target accounts with `jobKeywords[]` like `machine learning engineer` to catch both firmographics and market-wide hiring signals in one scheduled run.

***

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `companyUrls` | `string[]` | `[]` | Public company pages only (URL or slug). `/in/` profiles rejected |
| `jobKeywords` | `string[]` | `[]` | Optional job search terms (e.g. `software engineer`) |
| `jobLocation` | `string` | — | Optional location filter (e.g. `United States`, `Ho Chi Minh City`) |
| `scrapeCompanyProfile` | `boolean` | `true` | Extract industry, size, HQ, website, etc. |
| `scrapeCompanyJobs` | `boolean` | `true` | Extract open roles from each company `/jobs/` page |
| `maxJobsPerCompany` | `integer` | `20` | Cap jobs per company (1–100) |
| `maxJobsFromSearch` | `integer` | `50` | Cap jobs per keyword search (1–200) |
| `maxAttempts` | `integer` | `3` | Retries with fresh residential session (1–6) |
| `useApifyProxy` | `boolean` | `true` | **Strongly recommended** — LinkedIn shows auth walls on datacenter IPs |
| `proxyCountry` | `string` | `"US"` | Residential exit country (ISO 2-letter) |
| `includeErrors` | `boolean` | `true` | Push error stubs when a company page cannot be read |

***

### Output

#### Dataset row (company)

```json
{
  "recordType": "company",
  "companySlug": "google",
  "companyName": "Google",
  "tagline": "Organize the world's information",
  "description": "A problem isn't truly solved until we've solved it for everyone...",
  "industry": "Software Development",
  "companySize": "10,001+ employees",
  "staffCount": 180000,
  "headquarters": "Mountain View, CA",
  "foundedYear": 1998,
  "specialties": ["search", "ads", "cloud", "android"],
  "website": "https://about.google/",
  "followerCount": 32000000,
  "companyUrl": "https://www.linkedin.com/company/google/",
  "logoUrl": "https://media.licdn.com/...",
  "scrapedAt": "2026-08-07T10:00:00.000Z"
}
```

#### Dataset row (job)

```json
{
  "recordType": "job",
  "jobId": "4123456789",
  "title": "Software Engineer, Cloud",
  "companyName": "Google",
  "companySlug": "google",
  "companyUrl": "https://www.linkedin.com/company/google/",
  "location": "Mountain View, CA",
  "locationType": "Hybrid",
  "employmentType": "Full-time",
  "seniorityLevel": "Mid-Senior level",
  "postedAt": "2 days ago",
  "applicantsText": "Over 100 applicants",
  "description": "Minimum qualifications: Bachelor's degree...",
  "jobUrl": "https://www.linkedin.com/jobs/view/4123456789",
  "searchKeywords": null,
  "scrapedAt": "2026-08-07T10:00:00.000Z"
}
```

#### `OUTPUT` key-value summary

```json
{
  "totalRecords": 25,
  "companies": 1,
  "jobs": 24,
  "scrapedAt": "2026-08-07T10:00:00.000Z"
}
```

***

### Use cases

#### 1. Sales & ABM teams

Enrich target account lists with live firmographics — industry, employee count, HQ, website — before SDRs open Salesforce. Trigger plays when `staffCount` or hiring velocity shifts.

#### 2. Recruiting & talent intelligence

Monitor competitor `companyUrls` and keyword searches (`product manager`, `data engineer`) daily. Pipe new `job` rows into your ATS or Slack channel the morning reqs go live.

#### 3. Market research & investment signals

Track hiring spikes across sectors and geographies. Aggregate `job` records by `seniorityLevel` and `locationType` to spot expansion, remote-first pivots, or cost-cutting before earnings calls.

***

### Compliance & ethics

- Scrapes **public** LinkedIn company pages and job postings only.
- **Rejects** personal `/in/` profile URLs — no individual employee PII.
- Does not collect emails, phone numbers, or private applicant data.
- You are responsible for lawful use under your jurisdiction and LinkedIn’s terms.

***

### Call to action

**Try it free on Apify** → run the prefill Google company URL, then add your target account list.

Want always-on hiring radar? Schedule weekly runs on `jobKeywords[]` and sync `recordType: job` rows into your CRM or data warehouse.

**Actor:** [LinkedIn Company Profile & Public Job Market Scraper](https://console.apify.com/actors/QJY3Wcch7UgwBYyCm)\
**ID:** `QJY3Wcch7UgwBYyCm`

# Actor input Schema

## `companyUrls` (type: `array`):

Public LinkedIn company pages only (e.g. https://www.linkedin.com/company/google/ or slug "google"). Personal /in/ profiles are rejected.

## `jobKeywords` (type: `array`):

Optional public jobs search terms (e.g. "software engineer", "marketing manager").

## `jobLocation` (type: `string`):

Optional location filter for job search (e.g. "United States", "Ho Chi Minh City").

## `scrapeCompanyProfile` (type: `boolean`):

Extract public company fields: industry, size, HQ, website, etc.

## `scrapeCompanyJobs` (type: `boolean`):

Extract open roles listed on each company /jobs/ page.

## `maxJobsPerCompany` (type: `integer`):

Cap jobs scraped from each company jobs page.

## `maxJobsFromSearch` (type: `integer`):

Cap jobs from each jobKeywords search.

## `maxAttempts` (type: `integer`):

Retries with a fresh residential proxy session.

## `useApifyProxy` (type: `boolean`):

Strongly recommended. LinkedIn frequently shows auth walls on datacenter IPs.

## `proxyCountry` (type: `string`):

Residential proxy exit country (ISO 2-letter).

## `includeErrors` (type: `boolean`):

Push error stubs when a company page cannot be read (auth wall, etc.).

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/google/"
  ],
  "jobKeywords": [],
  "scrapeCompanyProfile": true,
  "scrapeCompanyJobs": true,
  "maxJobsPerCompany": 20,
  "maxJobsFromSearch": 50,
  "maxAttempts": 3,
  "useApifyProxy": true,
  "proxyCountry": "US",
  "includeErrors": true
}
```

# 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 = {
    "companyUrls": [
        "https://www.linkedin.com/company/google/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hoang_minh_quan/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 = { "companyUrls": ["https://www.linkedin.com/company/google/"] }

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

```

## MCP server setup

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