# LinkedIn Profiles, Companies, and Comments (`kaix/linkedin-profile-company-scraper`) Actor

🔥 ~$0.08/1K profiles 🔥 Search profiles, companies, services, and posts. Read profile and company details, employees, comments, and reactions. No LinkedIn login or cookies required.

- **URL**: https://apify.com/kaix/linkedin-profile-company-scraper.md
- **Developed by:** [Kai](https://apify.com/kaix) (community)
- **Stats:** 4 total users, 3 monthly users, 18.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 1,000 profiles

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 Profile and Company Scraper

Find LinkedIn profiles and companies. Collect work history, education, skills, company details, employee candidates, and activity. Add available contact information to your results.

No LinkedIn login or cookies required.

**$0.10 per 1,000 returned profiles, companies, employee profiles, or posts.** Comments have a separate price. Reactions are free.

Go to [comparison and prices](#why-this-scraper), [quick start](#quick-start), [operations](#choose-an-operation), [input](#input), [output](#read-the-output), or [limits](#search-and-field-limits).

### Use cases

- Recruitment research: find profiles and review their work history, education, and skills.
- Company research: collect industry, size, locations, website, and company updates.
- Prospect lists: find employee candidates by company, job title, and location.
- Contact research: collect available email addresses and website links.
- Activity research: read posts, comments, and reactions for selected profiles or companies.

### Why this scraper?

| | This scraper | HarvestAPI Actors |
| --- | --- | --- |
| Price per 1,000 profiles | **$0.10** | [$4 for profile details](https://apify.com/harvestapi/linkedin-profile-scraper/pricing) |
| Price per 1,000 companies | **$0.10** | [$3–4, depending on plan](https://apify.com/harvestapi/linkedin-company/pricing) |
| Price per 1,000 employee profiles | **$0.10** | [$1.50–3 basic; $4–8 full, depending on plan](https://apify.com/harvestapi/linkedin-company-employees/pricing) |
| Profile input | Full profile URLs | URLs, public identifiers, or profile IDs ([Profile Scraper](https://apify.com/harvestapi/linkedin-profile-scraper)) |
| Company input | Company URLs for details; keywords for company suggestions or LinkedIn search results | Company URLs or company names in the [Company Scraper](https://apify.com/harvestapi/linkedin-company). |
| LinkedIn login or cookies | Not required | Not required for [profiles](https://apify.com/harvestapi/linkedin-profile-scraper), [companies](https://apify.com/harvestapi/linkedin-company), or [employees](https://apify.com/harvestapi/linkedin-company-employees) |
| Profile sections | Available work history, education, skills, and other sections | Full experience, education, and skills ([Profile Scraper](https://apify.com/harvestapi/linkedin-profile-scraper)) |
| Employee search | Find candidates by company, job title, and location. Up to 1,000 results per run. | Filtered employee search. Up to 2,500 results per query ([Employees Scraper](https://apify.com/harvestapi/linkedin-company-employees)). |
| Employee filters | Search text, geography, industry, language, and first name | Location, title, industry, and years at company ([Employees Scraper](https://apify.com/harvestapi/linkedin-company-employees)) |
| Email search | Available addresses from profiles and linked websites. Delivery is not verified. | Optional email search with delivery checks ([Profile Scraper](https://apify.com/harvestapi/linkedin-profile-scraper)) |
| Company funding | Funding information when available | Funding fields in [Company Scraper](https://apify.com/harvestapi/linkedin-company) results |

For the listed result charges, our $0.10 rate is:

- **97.5% lower** than the [$4 profile-details rate](https://apify.com/harvestapi/linkedin-profile-scraper/pricing).
- **96.7–97.5% lower** than the [$3–4 company rate](https://apify.com/harvestapi/linkedin-company/pricing).
- **93.3–96.7% lower** than the [$1.50–3 basic employee rate](https://apify.com/harvestapi/linkedin-company-employees/pricing).
- **97.5–98.75% lower** than the [$4–8 full employee rate](https://apify.com/harvestapi/linkedin-company-employees/pricing).

For example, 10,000 returned profiles, companies, employee profiles, or posts cost **$1.00**. Employee pricing counts each returned employee profile.

### Quick start

1. Select an operation from the table below.
2. Enter your LinkedIn URLs or search terms. You can also copy and edit a JSON example below.
3. Start the run. Open its Dataset to view the results or export them as JSON, CSV, or Excel.

### Choose an operation

Set `mode` to choose an operation.

| Mode | Required input | Result |
| --- | --- | --- |
| `profileDetails` | `profileUrls` | Available profile details |
| `companyDetails` | `companyUrls` | Available company details |
| `profileSearch` | A name, `keywords`, or supported filters | Matching profiles |
| `companySearch` | `keywords`, or supported filters | Matching companies |
| `companyEmployees` | `companyUrls`, or `companyNames` with `publicWeb` | Employee candidates |
| `profileServicesSearch` | `keywords` | Service provider results |
| `profilePosts` | `profileUrls` | Posts from selected profiles |
| `companyPosts` | `companyUrls` | Posts from selected companies |
| `postSearch` | `keywords` | Matching posts |
| `profileComments` | `profileUrls` | Comment activity from selected profiles |
| `profileReactions` | `profileUrls` | Reaction activity from selected profiles |
| `postComments` | `postUrls` | Comments on selected posts |
| `postReactions` | `postUrls` | Reactions to selected posts |

### Choose how much detail to collect

| Need | Setting | Result |
| --- | --- | --- |
| Find profiles or companies | `profileSearch` or `companySearch` with `fetchDetails: false` | Names, links, and available search information. |
| Add profile or company details | `fetchDetails: true` (default) | Available details for each search result. |
| Read known profiles or companies | `profileDetails` or `companyDetails` | Details for the URLs you supply. |
| Add website contacts or company facts | Select `enrichment` options | Available information from the selected websites or registries. |

Employee discovery also reads available profile details. More detail can increase run time.

### Read known profiles or companies

Use full HTTPS LinkedIn URLs. Replace the example URLs with your targets.

```json
{
  "mode": "profileDetails",
  "profileUrls": ["https://www.linkedin.com/in/satyanadella"]
}
```

```json
{
  "mode": "companyDetails",
  "companyUrls": ["https://www.linkedin.com/company/microsoft"]
}
```

Direct detail modes read the unique URLs you supply. Search limits do not apply to these modes.

### Search profiles or companies

Profile search uses LinkedIn search by default. Set `fetchDetails` to `false` to save only search results.

```json
{
  "mode": "profileSearch",
  "profileSearchSource": "member",
  "firstName": "Satya",
  "lastName": "Nadella",
  "maxResults": 5,
  "maxPages": 1,
  "fetchDetails": true
}
```

Company suggestions return name matches. This source has no pagination.

```json
{
  "mode": "companySearch",
  "keywords": "Microsoft",
  "maxResults": 5,
  "fetchDetails": false
}
```

#### Choose a search source

| Source | Use it to | Required input |
| --- | --- | --- |
| `publicWeb` | Find profiles or employees listed in public web search | A name or keywords for profiles; company names or URLs for employees |
| `directory` | Find profiles in LinkedIn's name directory | Both `firstName` and `lastName`. Keywords, job titles, and locations are not accepted. |
| `member` | Search LinkedIn with optional exact filters | Profiles: a name, keywords, or filters. Companies: keywords or filters. Employees: company URLs. |
| `suggestions` | Find companies by name | `keywords`. Returns name matches without additional pages. |
| `featured` | Read the small employee sample on a company page | Company URLs. Search terms are not accepted. |

Use `profileSearchSource` for profiles, `companySearchSource` for companies, and `employeeSource` for employees. The input table below lists the defaults.

#### Use exact search filters

These filters use the `member` source. Supply LinkedIn filter IDs, such as company or location IDs, instead of names.

<details>
<summary>Advanced filter examples</summary>

Use these examples if you already have the LinkedIn filter IDs. For search terms such as job titles or city names, use `jobTitles` and `locations` in profile or employee search.

This people search uses a current-company ID, geography ID, industry ID, profile language, and first name:

```json
{
  "mode": "profileSearch",
  "profileSearchSource": "member",
  "keywords": "Consulting",
  "searchOptions": {
    "startPage": 1,
    "filters": {
      "currentCompanyIds": [
        "1035"
      ],
      "peopleGeoIds": [
        "103644278"
      ],
      "peopleIndustryIds": [
        "4"
      ],
      "profileLanguages": [
        "en"
      ],
      "firstName": "John"
    }
  },
  "maxResults": 10,
  "maxPages": 1,
  "fetchDetails": true
}
```

This company search uses industry and company-size filters:

```json
{
  "mode": "companySearch",
  "companySearchSource": "member",
  "keywords": "Microsoft",
  "searchOptions": {
    "startPage": 1,
    "filters": {
      "companyIndustryIds": [
        "4"
      ],
      "companySizeCodes": [
        "I"
      ]
    }
  },
  "maxResults": 10,
  "maxPages": 1,
  "fetchDetails": true
}
```

Set `searchOptions.startPage` to begin on a later page. Results can change between runs. `profileLanguages` selects profile languages; it does not translate results.

For employee search, the company URL selects the company. Do not add `currentCompanyIds` to employee filters.

</details>

#### Find service providers

Use keywords to find service providers. Some service results contain a description without a profile name or link.

```json
{
  "mode": "profileServicesSearch",
  "keywords": "Consulting",
  "maxResults": 10,
  "maxPages": 1,
  "fetchDetails": true
}
```

### Find employee candidates

Use company URLs to search LinkedIn for employees. Job titles and locations become search text:

```json
{
  "mode": "companyEmployees",
  "employeeSource": "member",
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft"
  ],
  "jobTitles": [
    "Software Engineer"
  ],
  "locations": [
    "London"
  ],
  "maxResults": 5,
  "maxPages": 1
}
```

For the small public company-page sample, use `employeeSource: "featured"` with company URLs and no search terms. It is not a complete employee list.

For public web candidates, select `publicWeb` and use company names or URLs:

```json
{
  "mode": "companyEmployees",
  "employeeSource": "publicWeb",
  "companyNames": ["Microsoft"],
  "maxResults": 10,
  "maxPages": 1
}
```

Each candidate has a company relationship: `current`, `past`, or `unverified`. This is based on listed positions, which can include board or advisory roles. Past and unverified candidates remain in the results.

### Read posts, comments, and reactions

Set `maxResults` to limit the total number of records. For activity, `maxPages` cannot exceed 20.

Use `profilePosts` with profile URLs or `companyPosts` with company URLs:

```json
{
  "mode": "companyPosts",
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft"
  ],
  "maxResults": 10,
  "maxPages": 2
}
```

Use a LinkedIn post URL to read comments. Change the mode to `postReactions` to read the available reaction list:

```json
{
  "mode": "postComments",
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7506722035688079361/"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

Posts can show more comments or reactions than the run can collect.

<details>
<summary>More activity inputs</summary>

#### Profile posts

```json
{
  "mode": "profilePosts",
  "profileUrls": [
    "https://www.linkedin.com/in/tomkerkhove"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

#### Search posts

```json
{
  "mode": "postSearch",
  "keywords": "Microsoft",
  "maxResults": 10,
  "maxPages": 1
}
```

#### Profile comment activity

```json
{
  "mode": "profileComments",
  "profileUrls": [
    "https://www.linkedin.com/in/tomkerkhove"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

#### Profile reaction activity

```json
{
  "mode": "profileReactions",
  "profileUrls": [
    "https://www.linkedin.com/in/tomkerkhove"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

#### Post reaction list

```json
{
  "mode": "postReactions",
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7506722035688079361/"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

</details>

### Add email addresses or company data

Set `enrichment.emailDiscovery` to `true` to collect available email addresses from the profile's contact information and matching linked websites.

```json
{
  "mode": "profileDetails",
  "profileUrls": [
    "https://www.linkedin.com/in/tomkerkhove"
  ],
  "enrichment": {
    "emailDiscovery": true
  }
}
```

Results appear in `data.emailDiscovery`. An email address is not guaranteed for each person. Mailbox delivery is not verified. A company's general contact address is not assigned to an employee.

For search results, keep `fetchDetails: true` to collect email addresses or other additional data.

#### Add company website and registry data

This example adds the company's website information and a selected SEC company record:

```json
{
  "mode": "companyDetails",
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft"
  ],
  "enrichment": {
    "officialWebsite": true,
    "registries": [
      {
        "subjectUrl": "https://www.linkedin.com/company/microsoft",
        "kind": "sec",
        "id": "789019"
      }
    ],
    "maxSources": 2
  }
}
```

Website and registry results appear in `data.externalEnrichment`.

### Input

Supply one JSON object with an operation and its required fields. The examples above are ready to edit with your names and URLs.

#### Main input options

| Field | Default | Use |
| --- | --- | --- |
| `mode` | Required | Choose an operation from the mode table. |
| `profileUrls` | Empty list | Up to 1,000 profile URLs for details or activity. |
| `companyUrls` | Empty list | Up to 1,000 company URLs for details, employees, or posts. |
| `postUrls` | Empty list | Up to 1,000 LinkedIn post URLs for comments or reactions. |
| `firstName`, `lastName` | Not set | Profile search names. |
| `keywords` | Not set | Search words for profiles, companies, services, posts, or employees. |
| `companyNames` | Empty list | Company names for public employee search. |
| `jobTitles`, `locations` | Empty lists | Add job titles or locations to profile and employee search text. |
| `profileSearchSource` | `member` | Select LinkedIn profile search, public web search, or the name directory. |
| `companySearchSource` | `suggestions` | Select company suggestions or LinkedIn company search. |
| `employeeSource` | `member` | Search LinkedIn with company URLs. If no URLs or source are given, company names use `publicWeb`. |
| `maxResults` | `25` | Up to 1,000 results across a search or activity run. |
| `maxPages` | `10` | From 1 to 100 search pages. Activity accepts a maximum of 20. |
| `fetchDetails` | `true` | Add details to search results. |
| `searchOptions` | No filters | Select an initial page and supported exact filters. |
| `enrichment` | Off | Add available email addresses, website contacts, or company facts. |

### Read the output

Each Dataset item is one profile, company, post, comment, or reaction result. The collected fields are inside `data`. Search and employee results can also show how the profile was found.

Open **Profiles, companies, and activity** and **Additional records** in the run output to view all saved records.

#### Field groups

These fields appear in `data` when available. Additional profile and company details can appear in `data.sourceViews`.

##### Profile fields

| Group | Fields |
| --- | --- |
| Identity | `id`, optional `numericId`, `publicIdentifier`, `linkedinUrl`, `name`, `firstName`, `lastName`, `headline`, `about` |
| Location and images | `location`, `locationDetails`, `imageUrl`, `photo`, `backgroundPhoto` |
| Counts and flags | `followers`, `connections`, `followerCount`, `connectionsCount`, `openToWork`, `hiring`, `premium`, `influencer`, `verified`, `badges`, `registeredAt` |
| Work and education | `currentPosition`, `experience`, `education`, `jobTitles`, `organizationAssociations` |
| Skills and credentials | `topSkills`, `skills`, `certifications`, `languages`, `courses`, `instructorCourses` |
| Other sections | `projects`, `volunteering`, `receivedRecommendations`, `honors`, `honorsAndAwards`, `publications`, `patents`, `featured` |
| Links and content | `websites`, `moreProfiles`, `articles`, `posts`, `activities`, `interests` |

##### Company fields

| Group | Fields |
| --- | --- |
| Identity and description | `id`, `publicIdentifier`, `universalName`, `linkedinUrl`, `name`, `tagline`, `description` |
| Contact and classification | `website`, `phone`, `industry`, `industries`, `companyType`, `specialties`, `specialtiesList`, `specialities` |
| Size and dates | `companySize`, `employeeCount`, `employeeSizeRange`, `employeeCountRange`, `followers`, `followerCount`, `founded`, `foundedOn` |
| Locations | `headquarters`, `locations`, `structuredLocations` |
| Images and links | `imageUrl`, `logo`, `logos`, `backgroundPhoto`, `backgroundCover`, `backgroundCovers`, `callToActionUrl`, `jobsUrl` |
| Related records | `affiliatedPages`, `similarPages`, `jobSearchSuggestions`, `featuredEmployees`, `featuredEmployeesComplete` |
| Content | `updates`, `companyPosts`, `pastEvents`, `recentJobOpenings` |
| Funding | `fundingData`, when available |

##### Activity fields

| Record | Main fields |
| --- | --- |
| Post | `id`, `linkedinUrl`, `content`, `author`, `postedAt`, `action`, `actionActor`, `postImages`, `videos`, `documents`, `links`, `engagement`, `quotedPosts` |
| Comment | `id`, `linkedinUrl`, `postId`, `postUrl`, `parentCommentId`, `commentary`, `actor`, date fields, `engagement`, `post` |
| Reaction | `id`, `reactionType`, `action`, `linkedinUrl`, `postId`, `postUrl`, `actor`, `post` |

#### Result fields

| Field | Type | Meaning |
| --- | --- | --- |
| `type` | string | `profile`, `company`, `post`, `comment`, or `reaction`. |
| `url` | string or null | Profile, company, or activity URL, when available. |
| `name` | string or null | Name, when available. Hidden names remain null. |
| `status` | string | `success`, `partial`, or `error`. |
| `data` | object or null | Search, detail, or activity fields. |
| `error` | object or null | Error `code` and `message`. Partial rows can keep data and an error. |
| `source` | string | Where the result came from. |
| `scrapedAt` | string | Date and time when the result was collected. |
| `searchResult` | optional object | The search result used to find this profile or company. |
| `discovery` | optional object | Search terms, company, and whether the person lists a current or past role. |
| `collection` | optional object | Activity source URL, completeness, stop reason, and displayed total. |
| `actorOutput` | optional object | Additional output format that shows which fields are available. Included for rows with data when enabled. |

#### Result status

| `status` | Meaning |
| --- | --- |
| `success` | The requested sources were read. Fields can still be absent. |
| `partial` | Useful data was saved, but a source failed or an identity was hidden. |
| `error` | No usable detail data was saved. `data` is `null`. |

#### Selected output examples

These examples use sample values and show selected fields. The company example shows how `data` fits inside a result.

<details>
<summary>Profile, company, activity, and email examples</summary>

##### Profile data

```json
{
  "type": "profile",
  "name": "Example Person",
  "headline": "Software engineer",
  "experience": [
    {
      "position": "Software engineer",
      "companyName": "Example Company",
      "startDate": { "year": 2024, "month": "Jan", "day": null, "text": "Jan 2024" },
      "skills": ["TypeScript"]
    }
  ],
  "registeredAt": null
}
```

##### Company result

```json
{
  "type": "company",
  "url": "https://www.linkedin.com/company/example",
  "name": "Example Company",
  "status": "success",
  "data": {
    "type": "company",
    "url": "https://www.linkedin.com/company/example",
    "name": "Example Company",
    "website": "https://example.com",
    "industry": "Software Development",
    "employeeCount": 120,
    "structuredLocations": [
      {
        "displayAddress": "Stockholm, Sweden",
        "locality": "Stockholm",
        "country": "Sweden",
        "streetAddress": null,
        "postalCode": null,
        "primary": true
      }
    ],
    "fundingData": null
  },
  "error": null,
  "source": "public_page",
  "scrapedAt": "2026-09-29T10:00:00.000Z"
}
```

##### Post data

```json
{
  "type": "post",
  "id": "1234567890123456789",
  "linkedinUrl": "https://www.linkedin.com/feed/update/urn:li:activity:1234567890123456789/",
  "content": "An example company update.",
  "author": {
    "type": "company",
    "name": "Example Company",
    "linkedinUrl": "https://www.linkedin.com/company/example"
  },
  "postedAt": { "date": null, "timestamp": null, "postedAgoText": "2d" },
  "engagement": { "likes": null, "reactionsCount": 12, "comments": 3 },
  "quotedPosts": []
}
```

##### Email data

```json
{
  "emailDiscovery": {
    "emails": [
      {
        "address": "contact@example.com",
        "sources": [{ "url": "https://example.com/contact" }],
        "validation": { "deliverable": null }
      }
    ]
  }
}
```

</details>

Missing fields are null or empty lists. An empty field means that the information was not available in this run.

### Search and field limits

- Search and activity runs return up to `maxResults`. Fewer records can be available.
- Detail runs accept up to 1,000 URLs. Search limits do not apply to those supplied URLs.
- LinkedIn access limits can cause partial or failed results.
- A complete employee list or every profile field is not guaranteed.
- Email search collects available addresses. It does not verify mailbox delivery.
- Funding history and exact profile registration dates can be unavailable.
- Sales Navigator and filters for tenure, seniority, or job function are not supported.

# Actor input Schema

## `mode` (type: `string`):

Select a detail, search, or activity operation. No LinkedIn login or cookies required. Sales Navigator is not supported.

## `firstName` (type: `string`):

A name term for profileSearch. Directory search needs both firstName and lastName. For an exact member first-name filter, use searchOptions.filters.firstName.

## `lastName` (type: `string`):

A name term for profileSearch. Directory search needs both firstName and lastName. A name term is not an exact last-name filter.

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

Search text for profileSearch, companySearch, companyEmployees, profileServicesSearch, salesNavigatorSearch, or postSearch. Company search needs keywords unless member company filters are set. Profile search needs keywords or a name. Services and post search need keywords. Search text does not replace exact ID filters.

## `profileSearchSource` (type: `string`):

For profileSearch. The default is LinkedIn people search. It supports the exact filters in searchOptions. Public web search finds indexed profiles through DuckDuckGo. Directory search needs both firstName and lastName. No source guarantees all profiles.

## `employeeSource` (type: `string`):

For companyEmployees. The default is LinkedIn employee search with company URLs. It supports the exact filters in searchOptions. Select public web search to use company names. Featured cards read a small public company-page sample. LinkedIn can hide identities. No source guarantees all employees.

## `companySearchSource` (type: `string`):

Suggestions return company name matches with no pagination. Member search finds companies on LinkedIn and supports the exact filters in searchOptions.

## `includeActorOutput` (type: `boolean`):

Add compatible Actor field views with source data and field availability. Missing or unsupported values stay null. A matching field name does not establish complete Actor parity.

## `enrichment` (type: `object`):

Off by default. Read explicit official websites, supplied HTTPS source URLs, or a registry by exact ID. Keep contacts, company facts, funding facts, identity evidence, and errors separate from LinkedIn data. Company contacts are not assigned to individual profiles. Companies House requires COMPANIES\_HOUSE\_API\_KEY. The optional licensed Crunchbase adapter requires CRUNCHBASE\_API\_KEY. No key belongs in this input.

## `searchOptions` (type: `object`):

Optional startPage and exact LinkedIn filter IDs. Names are not converted to IDs. Company filters: companyIndustryIds and companySizeCodes. People filters: currentCompanyIds, peopleGeoIds, peopleIndustryIds, profileLanguages, firstName. Employee mode derives currentCompanyIds and rejects a supplied value. Services has no supported exact filters. A custom url is reserved for Sales Navigator, which currently returns an access gap.

## `companyNames` (type: `array`):

For companyEmployees with publicWeb. Each name starts a separate search. Names can be ambiguous. Use company URLs when possible.

## `jobTitles` (type: `array`):

Search terms for profileSearch or companyEmployees with the publicWeb or member source. These words are not exact LinkedIn job-title filters. Directory and featured sources do not support them.

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

Search terms for profileSearch or companyEmployees with the publicWeb or member source. For an exact member location filter, use searchOptions.filters.peopleGeoIds. Directory and featured sources do not support these terms.

## `profileUrls` (type: `array`):

HTTPS LinkedIn /in/ URLs for profileDetails, profilePosts, profileComments, or profileReactions. Duplicate input URLs are removed.

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

HTTPS LinkedIn /company/ URLs for companyDetails, companyEmployees, or companyPosts. Member employee search derives the company ID from each company page. Duplicate input URLs are removed.

## `postUrls` (type: `array`):

Required for postComments or postReactions. Use a full HTTPS LinkedIn /posts/ URL or /feed/update/urn:li:activity:/ URL from the post. The reader stops at access gates and does not claim a complete list.

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

Maximum result rows for a search, employee, or activity run. A source can return fewer rows or a partial result. Direct detail modes ignore this limit.

## `maxPages` (type: `integer`):

Maximum search pages or activity expansion groups. Activity modes accept at most 20. Company name suggestions have no pagination. Direct detail modes ignore this limit. A page limit does not establish a complete list.

## `fetchDetails` (type: `boolean`):

Get profile or company details after a supported search. Direct detail modes and companyEmployees read details regardless of this setting. Activity operations retain their own source records.

## `fetchProfileSections` (type: `boolean`):

Read up to 13 supported profile sections through their Show all links. Keep available data and report incomplete sections. This can increase the time to collect each profile.

## `fetchProfilePanels` (type: `boolean`):

Read Contact info, About this member, and available work and education skill panels. Read up to 24 skill panels per page. Keep the date detail supplied by LinkedIn and report incomplete or failed panels.

## `fetchStructuredData` (type: `boolean`):

Read extra profile and company details. Add fields only from the matching LinkedIn profile or company. Keep page data if the read fails. Stop when LinkedIn restricts access or requests.

## `requestDelayMs` (type: `integer`):

Minimum delay for LinkedIn requests. Member reads are bounded and run one at a time. Optional external sources have their own time, size, and source limits.

## `maxRetries` (type: `integer`):

Maximum retries for eligible failed HTTP requests. Access gates and rate limits stop the affected member read.

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

Leave this at its default for this Actor. A separate proxy setting cannot be combined with the configured proxy pool.

## Actor input object example

```json
{
  "profileSearchSource": "member",
  "employeeSource": "member",
  "companySearchSource": "suggestions",
  "includeActorOutput": true,
  "enrichment": {
    "officialWebsite": false,
    "emailDiscovery": false,
    "sourceUrls": [],
    "registries": [],
    "licensedProviders": [],
    "maxSources": 5,
    "timeoutMs": 15000,
    "maxBytes": 1000000
  },
  "searchOptions": {
    "startPage": 1,
    "filters": {}
  },
  "companyNames": [],
  "jobTitles": [],
  "locations": [],
  "profileUrls": [],
  "companyUrls": [],
  "postUrls": [],
  "maxResults": 25,
  "maxPages": 10,
  "fetchDetails": true,
  "fetchProfileSections": true,
  "fetchProfilePanels": true,
  "fetchStructuredData": true,
  "requestDelayMs": 1000,
  "maxRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

No description

## `additional` (type: `string`):

Comments, reactions, and other saved records.

## `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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaix/linkedin-profile-company-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 = { "proxyConfiguration": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("kaix/linkedin-profile-company-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 '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kaix/linkedin-profile-company-scraper --silent --output-dataset

```

## MCP server setup

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