# LinkedIn Company Search Scraper ✅ NO COOKIES (`atomus/linkedin-company-search`) Actor

🔍 Find companies by industry, location, size, revenue, funding, website tech and who works there. Each row is the full company record: website, HQ and offices, headcount, revenue estimate, funding rounds, technologies and email provider. Up to 5,000 companies per run, billed per company returned.

- **URL**: https://apify.com/atomus/linkedin-company-search.md
- **Developed by:** [Atomus APIs](https://apify.com/atomus) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 company founds

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 Search

<table width="100%" style="border:none;border-radius:10px;background:#120306">
<tr><td style="padding:34px;border:none">
<span style="color:#F59E0B;font-size:13px;font-weight:700;letter-spacing:2px">LINKEDIN COMPANY SEARCH &nbsp;&bull;&nbsp; COMPANY DATA API</span><br><br>
<span style="color:#F5F5F6;font-size:40px;font-weight:800;letter-spacing:-1.2px">Describe the company.<br>Get the whole record.</span><br><br>
<span style="color:#D6D3D1;font-size:16px">No list of company URLs to collect first. Say what the company does, its industry, where it is headquartered, its size, revenue, funding, the technologies on its website and who works there, and get one structured record per matching company: website and domain, LinkedIn page, headquarters and every office, head count, revenue estimate, funding rounds, website technologies, email provider and contact details. Every filter is free; you pay per company returned. No LinkedIn account, no login, no cookies.</span><br><br>
<span style="background:#10B981;color:#FFFFFF;font-size:13px;font-weight:700;padding:6px 13px;border-radius:5px">PAY ONLY FOR COMPANIES RETURNED</span>
<span style="background:#1C1917;color:#F59E0B;font-size:13px;font-weight:700;padding:6px 13px;border-radius:5px">&nbsp;UP TO 5,000 COMPANIES PER RUN&nbsp;</span>
</td></tr>
</table>

#### Copy to your AI assistant

Paste this into ChatGPT, Claude, Cursor, or any LLM to start using this Actor right away.

```
atomus/linkedin-company-search is an Apify Actor that finds companies from a description instead of from a list of company URLs: it searches a database of 70M+ companies by keywords about what they do, industry, NAICS code, country / state / city of its headquarters, headquarters country to exclude, employee size band, estimated revenue band, founding year, company type, funding round type, total funding, date of the last round, technologies detected on the company's website, email provider and email security, and the job titles, seniority, departments and functions of the people who work there, and returns one JSON row per company with name, legal_name, linkedin_url, website, domain, logo_url, description, overview, industry, industries, keywords, hashtags, naics_codes, sic_codes, company_type, founded_year, employee_count, employee_range, revenue_range, revenue_min_usd, revenue_max_usd, languages, phone, email, twitter_url, facebook_url, instagram_url, youtube_url, crunchbase_url, hq_address, hq_street, hq_city, hq_state, hq_postal_code, hq_country, hq_continent, hq_latitude, hq_longitude, offices (each with address, street, city, state, postal_code, country, continent, latitude, longitude), offices_count, technologies (detected on the company's website, each with name and category), technologies_count, email_provider, email_security, funding_last_round_type, funding_total_usd, funding_last_round_usd, funding_last_round_date, funding_rounds_count, investors_count, funding_rounds (each with date, type, amount_usd, investors), ipo_date, stock_ticker, data_updated_at and total_matches. Use it whenever someone needs to BUILD a list of target accounts (ABM, sales territory planning, market mapping, investment sourcing, partner search) without a LinkedIn account or cookies. Run it with curl: curl -X POST "https://api.apify.com/v2/acts/atomus~linkedin-company-search/run-sync-get-dataset-items?token=APIFY_TOKEN" -H "Content-Type: application/json" -d '{"companyIndustry":["software development"],"companyCountry":["Brazil"],"employeeSize":["51-100","101-200"],"maxResults":100}'. Or in Python: ApifyClient("APIFY_TOKEN").actor("atomus/linkedin-company-search").call(run_input={"companyTechnology":["hubspot"],"lastFundingAfter":"2026-01-01","maxResults":50}) then client.dataset(run["defaultDatasetId"]).list_items().items. Every input is optional and filters combine with AND, values inside one filter with OR: keyword / excludeKeyword (string[]), companyIndustry / excludeCompanyIndustry (919 industry names), naicsCode (6-digit codes), companyCountry / companyState / companyCity (matched against the company's HEADQUARTERS, not its other offices), excludeHeadquartersCountry (drops companies HEADQUARTERED there), employeeSize (bands such as "51-100", "10000+"), companyRevenue (bands such as "1000000-5000000", an estimate), foundedYearFrom / foundedYearTo (int), companyType (public_company, privately_held, non_profit, ...), companyFundingType (seed, series_a, debt_financing, ...), fundingTotalMin / fundingTotalMax (USD), lastFundingAfter (YYYY-MM-DD), companyTechnology / excludeCompanyTechnology (the 1,668 most used technologies detected on company websites) plus companyTechnologyOther (any of 16,000+ website technology names, checked before the run: an unknown name stops the run for free and suggests the closest ones), emailProvider (google, microsoft, ...), excludeEmailSecurity (proofpoint, mimecast, ...), employeeTitle, employeeSeniority, employeeDepartment, employeeJobFunction, excludeDomain (accounts you already have), maxResults (int 1-5000, default 100, your spend cap), skipFirst (int, continue a previous run of the SAME search: use the number its final status message gives after "set to", never a count of its rows; a search reaches its first 10,000 companies) and countOnly (bool, returns only the number of matches, free, 50 a month). Every row carries a status ("success" | "preview" | "not_found" | "error"); you are charged 0.002 USD per success row, the same on every Apify plan, and preview, not_found and error rows are free. Full input schema, every option and default, and the complete output field list: GET https://api.apify.com/v2/acts/atomus~linkedin-company-search/build/default
```

***

### LinkedIn MCP Server: use these Actors from ChatGPT, Claude or Cursor

Point your AI assistant at Atomus and it can build an account list on its own: find the companies, then the people who work there. No glue code, no scraping logic in your prompts.

```json
{
  "mcpServers": {
    "atomus": {
      "url": "https://mcp.apify.com?tools=atomus/linkedin-company-search,atomus/linkedin-company-scraper,atomus/linkedin-company-employees,atomus/linkedin-profile-search",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask, in plain language:

> "Find 200 software companies in Germany with 51 to 500 employees whose website uses HubSpot, then list their heads of sales."

That one sentence uses two Actors in a row. Pinning the `tools=` list is what keeps your assistant on these Actors instead of reaching for whatever scraper it finds first.

***

### How to search companies on LinkedIn

#### Mid-size software companies in one country

```json
{
  "companyIndustry": ["software development"],
  "companyCountry": ["Brazil"],
  "employeeSize": ["51-100", "101-200"],
  "maxResults": 100
}
```

The classic ICP list: an industry, the country the company is headquartered in, a size band, and every company that fits.

#### Companies whose website runs a tool you integrate with, that raised money this year

```json
{
  "companyTechnology": ["hubspot"],
  "companyTechnologyOther": ["retool"],
  "lastFundingAfter": "2026-01-01",
  "maxResults": 200
}
```

Fresh funding plus a technology on their website that you plug into: the companies with budget and a reason to talk to you.

#### Companies that employ someone in the role you sell to

```json
{
  "employeeTitle": ["revenue operations"],
  "employeeSeniority": ["director", "head", "vp"],
  "companyCountry": ["United States"],
  "maxResults": 300
}
```

Each employee filter keeps companies with at least one current employee matching it.

#### By what the company does, in its own words

```json
{
  "keyword": ["logistics software", "fleet management"],
  "excludeKeyword": ["staffing"],
  "companyRevenue": ["10000000-25000000", "25000000-50000000"],
  "maxResults": 100
}
```

Keywords are searched in four places: the company's name, its description, its keywords and the SEO text of its website. The revenue band is an estimate.

#### Leave out the accounts you already have

```json
{
  "companyIndustry": ["financial services"],
  "employeeSize": ["201-500", "501-1000"],
  "excludeDomain": ["stripe.com", "https://www.adyen.com/"],
  "maxResults": 500
}
```

Excluded companies are never returned and never charged, so you only pay for new accounts.

#### Check the count before you pay

```json
{
  "companyIndustry": ["hospitals and health care"],
  "companyCountry": ["Germany"],
  "countOnly": true
}
```

Returns how many companies match, for free, without returning any (50 previews a month).

#### Continue where the last run stopped

```json
{
  "companyIndustry": ["software development"],
  "companyCountry": ["Brazil"],
  "employeeSize": ["51-100", "101-200"],
  "skipFirst": 100,
  "maxResults": 100
}
```

Same filters, with `skipFirst` set to the number the previous run's final status message gives ("set to 100"). Copy that number rather than counting the rows you got, which can be fewer. Every row carries `total_matches`, so you know how many are left.

***

### Input

Every field is optional. Filters combine with AND; the values inside one field combine with OR. Every filter is free. A list field takes up to 300 values.

| Field | What to put in it |
|---|---|
| `maxResults` | How many companies to return, at most (1 to 5,000, default 100). Also your spend cap. |
| `countOnly` | `true` returns only the number of matches, free, 50 times a month. |
| `skipFirst` | Continue a previous run of the same search: the number its final status message gives (0 to 9,999). Copy it rather than counting rows. |
| `keyword`, `excludeKeyword` | Words about what the company does, searched in four places: its name, its description, its keywords and the SEO text of its website. |
| `companyIndustry`, `excludeCompanyIndustry` | Industries from the list of 919. |
| `naicsCode` | Full 6-digit NAICS codes, such as `541511`. A shorter sector code stops the run before it starts. |
| `companyCountry`, `companyState`, `companyCity` | Where the company is HEADQUARTERED; its other offices do not count. Combined into one place: city, state, country. |
| `excludeHeadquartersCountry` | Drops companies HEADQUARTERED in these countries. |
| `employeeSize` | Size bands, such as `51-100` or `10000+`. They do not need to be next to each other. |
| `companyRevenue` | Estimated yearly revenue bands in USD. |
| `foundedYearFrom`, `foundedYearTo` | Founding year range. |
| `companyType` | Public company, privately held, non-profit, educational, government agency and more. |
| `companyFundingType` | Round types such as seed, Series A, debt financing. |
| `fundingTotalMin`, `fundingTotalMax` | Total raised across all rounds, in USD. |
| `lastFundingAfter` | Most recent round announced on or after this date (`YYYY-MM-DD`). |
| `companyTechnology`, `excludeCompanyTechnology` | Technologies detected on the company's website, from the list of the 1,668 most used. |
| `companyTechnologyOther` | Any other website technology name. Checked before the run: an unknown name stops it for free and suggests the closest names. |
| `emailProvider`, `excludeEmailSecurity` | Who hosts the company's email; email security gateways to exclude. |
| `employeeTitle`, `employeeSeniority`, `employeeDepartment`, `employeeJobFunction` | Each one keeps companies with at least one current employee matching it. |
| `excludeDomain` | Domains of companies you already have. Full website addresses work too. |

***

### What data does the LinkedIn Company Search return?

One row per company. Every field is always present; a value the company does not have is `null`, and a list it does not have is `[]`.

| Group | Fields |
|---|---|
| Identity | `name`, `legal_name`, `linkedin_url`, `website`, `domain`, `logo_url`, `description`, `overview` |
| Classification | `industry`, `industries`, `keywords`, `hashtags`, `naics_codes`, `sic_codes`, `company_type`, `founded_year`, `languages` |
| Size and money | `employee_count`, `employee_range`, `revenue_range`, `revenue_min_usd`, `revenue_max_usd` (revenue is an estimate) |
| Contact and social | `phone`, `email`, `twitter_url`, `facebook_url`, `instagram_url`, `youtube_url`, `crunchbase_url` |
| Headquarters | `hq_address`, `hq_street`, `hq_city`, `hq_state`, `hq_postal_code`, `hq_country`, `hq_continent`, `hq_latitude`, `hq_longitude` |
| Offices | `offices` (address, street, city, state, postal_code, country, continent, latitude, longitude), `offices_count` |
| Website technologies and email | `technologies` (name, category), `technologies_count`, `email_provider`, `email_security` |
| Funding and listing | `funding_last_round_type`, `funding_total_usd`, `funding_last_round_usd`, `funding_last_round_date`, `funding_rounds_count`, `investors_count`, `funding_rounds` (date, type, amount_usd, investors), `ipo_date`, `stock_ticker` |
| Run | `status`, `total_matches`, `data_updated_at`, `_metadata.extracted_at` |

`employee_count` is the head count on record and is what the size filter matches; `employee_range` is the band LinkedIn shows, and the two can differ.

`technologies` and the technology filters read what is detected on the company's website (analytics, tag managers, CMS, advertising, hosting and similar tools). They do not see internal systems such as databases.

A row with a `status` other than `success` (a count-only answer, a search that found nothing or a Skip first that starts past the end of the matches, an error) carries a plain-language `reason`, and an `error` row also carries an `error_kind`. None of them is charged.

#### Example row

```json
{
  "status": "success",
  "name": "Insperity",
  "legal_name": "INSPERITY INC",
  "linkedin_url": "https://www.linkedin.com/company/insperity",
  "website": "https://www.insperity.com",
  "domain": "insperity.com",
  "industry": "human resources services",
  "industries": ["enterprise software", "service industry", "human resources", "human resources services"],
  "company_type": "public_company",
  "founded_year": 1986,
  "employee_count": 4995,
  "employee_range": "1001-5000",
  "revenue_range": "100000000-500000000",
  "hq_city": "Kingwood",
  "hq_state": "Texas",
  "hq_country": "United States",
  "offices": [{ "address": "19001 Crescent Springs Drive, Kingwood, Texas, United States, North America", "street": "19001 Crescent Springs Drive", "city": "Kingwood", "state": "Texas", "postal_code": "77339-3802", "country": "United States", "continent": "North America", "latitude": 29.757027, "longitude": -95.3556 }],
  "offices_count": 1,
  "technologies": [{ "name": "Google Tag Manager", "category": "Tag Management" }, { "name": "Hotjar", "category": "Analytics and Tracking" }],
  "technologies_count": 75,
  "email_provider": ["microsoft"],
  "funding_total_usd": null,
  "ipo_date": "2003-01-10",
  "stock_ticker": "NYSE:NSP",
  "data_updated_at": "2026-10-21",
  "total_matches": 40395
}
```

(Shortened: a real row carries every field in the table above.)

***

### How much does it cost to search LinkedIn companies?

**$2/1k companies returned**, the same on every Apify plan. You pay per company row delivered, never per search and never per filter.

- A search that matches nothing costs nothing.
- `countOnly` previews are free (50 a month per account).
- Error rows are free.
- A free Apify plan includes 10 companies a month, so you can check every field before paying for more. The counter resets on the 1st.
- Set `maxResults` and the run's maximum charge to control what you spend: the run never returns more companies than your maximum charge covers.

***

### What do people use LinkedIn Company Search for?

- **ABM and target account lists**: every company in your ICP, by industry, size, location and website technology.
- **Sales territory planning**: all the companies headquartered in a region, with their offices, head count and revenue band.
- **Finding companies by website technology**: whose website runs the tool you integrate with, or the competitor you replace.
- **Funding signals**: companies that just raised a round, with the round type, amount and investors.
- **Role-based targeting**: companies that already employ the role you sell to, before you look for the people.
- **Market mapping and research**: how many companies of a kind exist, and where, before you build anything.
- **CRM enrichment**: add the companies that fit your ICP and are not in your CRM yet, each with industry, size, revenue band, HQ and website technologies filled in, and list the accounts you already have in `excludeDomain` so they never come back.

***

### LinkedIn Company Search vs cookie-based tools vs the official LinkedIn API

| | This LinkedIn Company Search | Cookie-based scrapers | Official LinkedIn API |
|---|---|---|---|
| **LinkedIn account / cookies** | Not needed | Your session cookie required | OAuth app + LinkedIn approval |
| **Account / ban risk** | None (no account used) | High (your account can be restricted) | None |
| **What you start from** | A description: 28 filters, from industry and size to website technology, funding and who works there | The filters of the LinkedIn search page | Pages you administer |
| **Data per company** | 55 fields: every office, revenue estimate, funding rounds, website technologies, email provider | Usually the public page only | Pages you administer |
| **Bulk** | Up to 5,000 per run | Rate-limited by your account | Strict quotas |
| **Pricing** | Pay per company returned ($2/1k) | Subscription + your account | Gated / partner pricing |

***

### 🏆 Top LinkedIn Scrapers

### FAQ

#### What is a LinkedIn company search?

A search that returns companies matching a description (industry, location, size, revenue, funding, the technologies on their website, the people who work there) instead of a company you already know. This Actor returns each match as a full company record.

#### Does a country or city match the headquarters?

Yes, and only the headquarters: a company matches a country, state or city when its headquarters is there, and an office elsewhere does not count. `excludeHeadquartersCountry` works the same way, on the headquarters. Every row still lists all of the company's offices in `offices`.

#### Is the revenue exact?

No. Revenue is an estimated band for every company, not a reported figure, and it can be far off for very large companies.

#### How many companies can one run return?

Up to 5,000. A single search reaches its first 10,000 companies at most, so with `skipFirst` you can continue a search in later runs up to that point.

#### What happens if I misspell a technology?

Names typed into `companyTechnologyOther` are checked before the run starts. An unknown name stops the run, free, and the run tells you the closest names it knows.

#### Do I pay for a search that finds nothing?

No. You pay only for the companies returned. Previews (`countOnly`) and error rows are free too.

#### Can I use this from ChatGPT or Claude?

Yes. Add the Atomus MCP server shown above to ChatGPT, Claude or Cursor and ask in plain language; your assistant runs the search and reads the results.

#### How fresh is the data?

Every row carries `data_updated_at`, the date that company's record was last refreshed.

#### Can I run this on a schedule?

Yes. Save your filters and run them weekly with Apify Schedules. You can leave out up to 300 accounts you already have with `excludeDomain`; any company that is not in that list can come back on every run.

#### Is it legal to use?

This Actor returns professional and business data about companies from licensed and publicly available sources. You are responsible for using the output in line with applicable laws (GDPR/CCPA), platform terms, and your own compliance requirements. It is an independent tool, not affiliated with LinkedIn.

### All Atomus scrapers

<span style="background:#10B981;color:#FFFFFF;font-size:13px;font-weight:700;padding:6px 13px;border-radius:5px">2.4M+ RESULTS DELIVERED</span>

### Support

### ⚠️ Disclaimer

This Actor is not affiliated with, endorsed by, or connected to LinkedIn. It returns company information gathered from public sources. Use it in line with the terms of the services you work with and the laws that apply to you.

# Actor input Schema

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

How many companies to return, at most. This is also your spend cap: you pay per company returned. Up to 5,000 per run.

## `countOnly` (type: `boolean`):

Answer how many companies match these filters and stop, without returning any. Free: nothing is charged, and the count is the whole match total, not capped by Max results. Limited to 50 previews a month on a free Apify plan, 500 on a paid one.

## `skipFirst` (type: `integer`):

Continue an earlier run of this exact search: put the number its final status message gives ("set to 300"). Copy that number rather than counting the rows you got, which can be fewer. Keep the filters identical. A search reaches its first 10,000 companies at most, and every company comes back with total_matches, the size of the whole list.

## `keyword` (type: `array`):

Words that describe what the company does, e.g. "logistics software", "solar". A company matching any of them is kept. Write them in English.

## `excludeKeyword` (type: `array`):

Drop companies that match any of these in their name, description, keywords or the SEO text of their website, e.g. "staffing". Excluded companies are never returned and never charged.

## `companyIndustry` (type: `array`):

Keep only companies in these industries. Every option is an industry name the data uses, so nothing you pick can come back empty for not existing.

## `excludeCompanyIndustry` (type: `array`):

Drop companies in any of these industries.

## `naicsCode` (type: `array`):

Keep only companies with these 6-digit NAICS codes, e.g. "541511". A shorter sector code such as "54" stops the run before it starts, because it matches nothing.

## `companyCountry` (type: `array`):

Keep companies headquartered in these countries.

## `companyState` (type: `array`):

Keep companies headquartered in these states, provinces or regions. Combined with the country above.

## `companyCity` (type: `array`):

Keep companies headquartered in these cities. Combined with the country and state above, so "Austin" with state "Texas" searches Austin, Texas. Write the city out in English.

## `excludeHeadquartersCountry` (type: `array`):

Drop companies HEADQUARTERED in these countries. A company headquartered elsewhere with an office there is kept.

## `employeeSize` (type: `array`):

Tick every size you want. They do not have to be next to each other: "1 to 10" plus "201 to 500" returns exactly those two groups.

## `companyRevenue` (type: `array`):

Tick every revenue band you want, next to each other or not.

## `foundedYearFrom` (type: `integer`):

Keep companies founded in this year or later.

## `foundedYearTo` (type: `integer`):

Keep companies founded in this year or earlier.

## `companyType` (type: `array`):

Keep only companies of these types.

## `companyFundingType` (type: `array`):

Keep companies that raised any of these round types.

## `fundingTotalMin` (type: `integer`):

Keep companies that raised at least this much in total, across all rounds.

## `fundingTotalMax` (type: `integer`):

Keep companies that raised at most this much in total, across all rounds.

## `lastFundingAfter` (type: `string`):

Keep companies whose most recent round was announced on or after this date.

## `companyTechnology` (type: `array`):

Keep companies whose website uses any of these technologies. The list holds the 1,668 most used; type any other in the field below.

## `companyTechnologyOther` (type: `array`):

Website technologies the list above does not offer, e.g. "retool". Each name is checked before the run starts: one we do not know stops the run, free, and names the closest ones we do.

## `excludeCompanyTechnology` (type: `array`):

Drop companies whose website uses any of these technologies.

## `emailProvider` (type: `array`):

Keep companies whose email runs on any of these providers, e.g. Google Workspace or Microsoft 365.

## `excludeEmailSecurity` (type: `array`):

Drop companies whose email goes through any of these security gateways.

## `employeeTitle` (type: `array`):

Keep companies with at least one current employee holding any of these titles, e.g. "Head of Data". Write titles in English.

## `employeeSeniority` (type: `array`):

Keep companies with at least one current employee at any of these levels.

## `employeeDepartment` (type: `array`):

Keep companies with at least one current employee in these departments. Combined with job function below as OR: a company matching either is kept.

## `employeeJobFunction` (type: `array`):

Keep companies with at least one current employee in these specific functions. Every option starts with its department, so typing a department name narrows the list.

## `excludeDomain` (type: `array`):

Domains of companies you already have, e.g. "stripe.com". They are never returned and never charged. A full website address works too.

## Actor input object example

```json
{
  "maxResults": 100,
  "countOnly": false,
  "skipFirst": 0,
  "lastFundingAfter": "2026-01-01"
}
```

# Actor output Schema

## `companies` (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 = {
    "maxResults": 100,
    "skipFirst": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("atomus/linkedin-company-search").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 = {
    "maxResults": 100,
    "skipFirst": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("atomus/linkedin-company-search").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 '{
  "maxResults": 100,
  "skipFirst": 0
}' |
apify call atomus/linkedin-company-search --silent --output-dataset

```

## MCP server setup

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

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/aaG4eiwQaGAbC1CR8/builds/nQmAv3shIlfX7cIOw/openapi.json
