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

Enrich LinkedIn company URLs or domains into structured firmographic records: industry, employee count, revenue band, funding rounds, HQ, and full tech stack. Submit up to 5,000 inputs per run, one record each. Pay only for companies found; not-found and errors are free. No login needed.

- **URL**: https://apify.com/atomus/linkedin-company-scraper.md
- **Developed by:** [Atomus APIs](https://apify.com/atomus) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 20 total users, 4 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.80 / 1,000 company enricheds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

**LinkedIn Company Scraper** turns a LinkedIn company URL or a bare domain into a structured company record: industry, employee count, revenue band, funding history, HQ address, and full technology stack. Backed by a database of over **70 million companies**, it returns one clean JSON record per input. **No LinkedIn account, login, or cookies required.**

Submit up to **5,000 companies in a single run**, **pay only for companies found** (not-found and errors are always free), and get a predictable 1:1 mapping back to your input list.

> 💡 **More LinkedIn tools by Atomus:** https://apify.com/atomus

---

### What does this LinkedIn Company Scraper do?

Give it a list of LinkedIn company URLs or bare domains and it returns a structured JSON record for each one, ready to load into a CRM, spreadsheet, or AI agent.

| Feature | Description |
|---------|-------------|
| 🏢 **Deep firmographics** | Industry, company type, founded year, employee count, revenue band, and HQ address. |
| 💰 **Funding history** | Total funding raised and number of funding rounds in the summary, plus every individual round (type, amount, date) in the full record. |
| 🧰 **Full technology stack** | Every technology detected, categorized, plus a quick `technologies_count` in the summary. |
| 🌍 **Global office locations** | Every office the company has, not just headquarters. |
| 🔗 **Cross-platform links** | Website, Crunchbase, Twitter/X, and Facebook URLs when discoverable. |
| 📇 **Contact details** | Public contact email and phone number when available. |
| 🎯 **Smart domain matching** | Submit a bare domain and the Actor disambiguates automatically: it prefers an exact domain match and falls back to the largest company by employee count. |
| 💵 **Pay only for results** | You are charged **only when a company is found**. `not_found` and `error` responses are always free. |
| 📦 **Batch processing** | Submit up to 5,000 companies in a single run. |
| ⚡ **1:1 input-to-output** | One input (URL or domain) produces exactly one output record, predictable and easy to join back to your data. |
| 🔐 **No cookies needed** | No LinkedIn account, cookies, or login risk. |

---

### How do I scrape LinkedIn company data?

1. **Open the Actor** and paste LinkedIn company URLs and/or bare domains into the `companies` field (format: `https://www.linkedin.com/company/<slug>` or `example.com`).
2. **Click Start.** The Actor looks up each company and pushes one record to the dataset.
3. **Read the results.** Each record has a `status` (`success` | `not_found` | `error`); successful records carry a curated `summary` plus the full `company` object.
4. **Export or pipe the data.** Pull the dataset via the Apify API or Console, or feed it straight into an AI agent over MCP.

No login, no browser session, no cookies, just company URLs or domains in and structured data out.

---

### Input

#### Basic Usage

Mix LinkedIn company URLs and bare domains freely:

```json
{
  "companies": [
    "https://www.linkedin.com/company/stripe",
    "microsoft.com"
  ]
}
````

#### All Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `companies` | string\[] | ✅ Yes | (none) | LinkedIn company URLs or bare domains. Up to 5,000 per run. |

#### Supported Formats

Use the **canonical company URL** (the readable `/company/name` form) or a plain domain:

```
✅ https://www.linkedin.com/company/stripe
✅ https://www.linkedin.com/company/stripe/
✅ stripe.com
✅ www.stripe.com
```

**Not supported:** numeric LinkedIn company IDs (the `/company/12345` form) and raw LinkedIn URNs / internal IDs:

```
❌ https://www.linkedin.com/company/1035
❌ urn:li:organization:1035
```

The data source only resolves the canonical company slug (or a domain). Numeric IDs return
an `error` record and are **never charged**. Open the company page in a browser and copy the
`/company/name` URL from the address bar, or just pass the domain.

LinkedIn URLs with tracking parameters (e.g. `?trk=...`) are handled automatically. Personal profile URLs (`/in/...`) are not supported here; for those, use our [LinkedIn Profile Scraper](https://apify.com/atomus/linkedin-profile-scraper), which turns any profile URL into a full structured record (name, title, skills, education, work history, and current company).

***

### Output

Each input produces exactly one record in the dataset. The `status` field tells you what happened:

| Status | Charged? | Description |
|--------|----------|-------------|
| `success` | ✅ Yes | Company found, curated `summary` plus the full `company` object. |
| `not_found` | ❌ No | Company not present in the data source. |
| `error` | ❌ No | Invalid input format or an upstream network failure. |

#### Success Record

```json
{
  "input": "https://www.linkedin.com/company/stripe",
  "status": "success",
  "summary": {
    "name": "Stripe",
    "domain": "stripe.com",
    "linkedin_url": "https://www.linkedin.com/company/stripe",
    "industry": "Financial Services",
    "type": "PRIVATELY_HELD",
    "founded_year": 2010,
    "staff_total": 8000,
    "revenue_band": "1000000000-5000000000",
    "funding_total": 8700000000,
    "funding_rounds": 21,
    "hq": { "city": "San Francisco", "state": "California", "country": "United States" },
    "technologies_count": 71,
    "last_updated": "2026-06-30"
  },
  "company": {
    "summary": {
      "name": "Stripe",
      "legal_name": "Stripe, Inc.",
      "description": "Stripe builds economic infrastructure for the internet...",
      "founded_year": 2010,
      "type": "PRIVATELY_HELD",
      "industry": "Financial Services",
      "staff": { "total": 8000, "range": { "start": 5001, "end": 10000 } }
    },
    "link": {
      "website": "https://stripe.com",
      "domain": "stripe.com",
      "linkedin": "https://www.linkedin.com/company/stripe",
      "twitter": "https://x.com/stripe",
      "crunchbase": "https://www.crunchbase.com/organization/stripe"
    },
    "contact": { "email": "support@stripe.com", "phone": { "raw": null, "sanitized": null } },
    "financial": {
      "revenue": { "annual": { "amount": "1000000000-5000000000" } },
      "funding": {
        "total_amount": 8700000000,
        "num_funding_rounds": 21,
        "rounds": [
          { "type": "series_h", "amount": 6500000000, "date": "2023-03-14" }
        ]
      }
    },
    "location": {
      "headquarter": { "city": "San Francisco", "state": "California", "country": "United States" },
      "locations": [
        { "city": "San Francisco", "country": "United States" }
      ]
    },
    "technologies": [
      { "name": "React", "category": "frontend framework" }
    ],
    "industries": ["Financial Services", "Software Development"],
    "naics": ["522320"],
    "sic": ["6199"],
    "last_updated": "2026-06-30"
  },
  "_metadata": { "extracted_at": "2026-07-02T12:00:00.000Z" }
}
```

*(`financial.funding.rounds`, `technologies`, and `location.locations` are truncated above for readability; the live record for this company carries all 21 funding rounds, all 71 technologies, and all 15 office locations.)*

#### Not Found Record

```json
{
  "input": "https://www.linkedin.com/company/some-unknown-startup",
  "status": "not_found",
  "_metadata": { "extracted_at": "2026-07-02T12:00:00.000Z" }
}
```

#### Error Record

```json
{
  "input": "not-a-url-or-domain",
  "status": "error",
  "error_kind": "actor_error",
  "reason": "Not a LinkedIn company URL or a domain. Expected https://www.linkedin.com/company/<slug> or example.com",
  "_metadata": { "extracted_at": "2026-07-02T12:00:00.000Z" }
}
```

#### Output Fields Reference

**Summary (curated, stable):**

| Field | Type | Description |
|-------|------|-------------|
| `summary.name` | string | null | Company name. |
| `summary.domain` | string | null | Root domain. |
| `summary.linkedin_url` | string | null | Canonical LinkedIn company URL. |
| `summary.industry` | string | null | Industry classification. |
| `summary.type` | string | null | `PUBLIC_COMPANY`, `PRIVATELY_HELD`, `NON_PROFIT`, etc. |
| `summary.founded_year` | integer | null | Year founded. |
| `summary.staff_total` | integer | null | Total employee count. |
| `summary.revenue_band` | string | null | Annual revenue range. |
| `summary.funding_total` | integer | null | Total funding raised (USD). |
| `summary.funding_rounds` | integer | null | Number of funding rounds. |
| `summary.hq.city` / `state` / `country` | string | null | Headquarters location. |
| `summary.technologies_count` | integer | Number of technologies detected. |
| `summary.last_updated` | string | null | ISO date the upstream source last refreshed this company. |

**Full company object (`company`, complete passthrough):**

| Field | Type | Description |
|-------|------|-------------|
| `company.summary.legal_name` | string | null | Registered legal name. |
| `company.summary.description` | string | null | Long-form company description. |
| `company.summary.overview` | string | null | Short overview. |
| `company.summary.staff.range` | object | Employee range (`start`, `end`). |
| `company.link.website` | string | null | Company website URL. |
| `company.link.domain` / `domain_ltd` | string | null | Root domain / domain with TLD. |
| `company.link.linkedin` / `facebook` / `twitter` / `crunchbase` | string | null | Social and Crunchbase URLs when discoverable. |
| `company.contact.email` | string | null | Public contact email. |
| `company.contact.phone.raw` / `sanitized` | string | null | Public contact phone number. |
| `company.financial.revenue.annual` | object | Revenue range and band. |
| `company.financial.funding.total_amount` | integer | null | Total funding raised. |
| `company.financial.funding.num_funding_rounds` | integer | null | Number of funding rounds. |
| `company.financial.funding.rounds` | object\[] | Every funding round: type, amount, date. |
| `company.location.headquarter` | object | Full HQ address. |
| `company.location.locations` | object\[] | Every global office location. |
| `company.technologies` | object\[] | Full technology stack, categorized. |
| `company.industries` | string\[] | Industry tags. |
| `company.naics` / `company.sic` | string\[] | NAICS and SIC classification codes. |
| `company.last_updated` | string | null | ISO date this record was last refreshed. |

***

### How much does it cost to scrape LinkedIn company data?

This Actor uses **pay-per-result** pricing. You are charged only when a company is found; check the **Pricing** tab on this Actor's page for the current rate.

**What you are NOT charged for:**

- Companies that returned `not_found` (not in the data source)
- Companies that returned `error` (invalid input or network failure)
- Apify platform compute time (memory/CPU)

#### Free plan limit

Apify Free plan users can look up **up to 20 companies per calendar month** so you can validate the output and field shape before paying. The cap resets on the 1st of each month and only counts successful lookups, `not_found` and `error` results never count against it. To run unlimited companies, upgrade to any paid Apify plan. Free-tier overflow within a batch returns a `status: "error"` record with `error_kind: "free_tier_limit"` and is not charged.

> 💡 Companies that aren't found cost nothing, there's no penalty for trying.

***

### Platform limits and gotchas

- **Batch size:** up to 5,000 companies per run.
- **Large batches checkpoint automatically.** Runs with more than 50 companies save progress as they go, so if Apify has to restart the container mid-run, the Actor resumes instead of starting over and re-charging you.
- **Mixed input is fine.** You can combine LinkedIn URLs and bare domains in the same `companies` list.
- **Domain matching is best-effort.** For a bare domain with multiple similarly named entries in the data source, the Actor picks the exact domain match when one exists, otherwise the largest company by employee count.

***

### Use it with AI agents and MCP

This Actor is built for AI agents and LLMs via the Apify MCP server. Each record has a `status` field (`success` | `not_found` | `error`) and a flat, predictable `summary` object when status is `success`, ideal for agent post-processing.

**Key fields for agents:**

- `summary.name` + `summary.domain`: Which company this is
- `summary.industry` + `summary.type`: What the company does and how it's structured
- `summary.staff_total`: Company size for ICP / segmentation
- `summary.revenue_band` + `summary.funding_total` + `summary.funding_rounds`: Financial profile
- `summary.hq`: Where the company is based
- `summary.technologies_count` (and `company.technologies` for the full list): Tech stack signals
- `company.financial.funding.rounds`: Full funding history for investment or account research

**Example agent prompt:**

> "Look up these 10 companies and summarize each one's industry, headcount, and funding stage in a table."

The agent passes the domain or LinkedIn URL list as `companies` and processes the structured `summary` output directly, no scraping logic, no HTML parsing.

***

### Use Cases

- **🎯 Account-based marketing**: Enrich target account lists with industry, size, and revenue before outreach.
- **💼 Sales prospecting**: Qualify inbound leads by company size, funding, and tech stack.
- **📈 Investment research**: Pull funding history and round-by-round detail for companies you're tracking.
- **🧩 Recruiting**: Size up a prospective employer's headcount, industry, and stability before a candidate conversation.
- **🏢 Account research**: Understand a target company's HQ, offices, and technology footprint.
- **📋 Data pipelines**: Feed structured firmographic data into a CRM or data warehouse.
- **🤖 AI agent context**: Give AI agents structured company background before a meeting, call, or outreach sequence.

***

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

| | This LinkedIn Company Scraper | Cookie-based scrapers | Official LinkedIn API |
|---|---|---|---|
| **LinkedIn account / cookies** | Not needed | Your logged-in cookies required | OAuth app + LinkedIn approval |
| **Account / ban risk** | None (no account used) | High (your account can be restricted) | None |
| **Setup** | Paste company URLs or domains | Extract and paste your session cookie | Partner application + review |
| **Data depth** | Full firmographics, funding history, tech stack, offices | Varies, often overview-only | Limited, mostly company page basics |
| **Input flexibility** | LinkedIn URL or bare domain | Usually LinkedIn URL only | Company page ID |
| **Bulk** | Up to 5,000 companies per run | Rate-limited by your account | Strict quotas |
| **Pricing** | Pay per company found | Subscription + your account | Gated / partner pricing |

For most teams that just have a list of company URLs or domains to enrich, the cookieless approach returns full structured data with zero account risk, no session to maintain, and no partner approval to wait on.

***

### Other LinkedIn scrapers by Atomus

| Actor | What it does |
|-------|--------------|
| [LinkedIn Profile Scraper](https://apify.com/atomus/linkedin-profile-scraper) | Turn any LinkedIn profile URL into a full structured record: name, title, skills, education, and work history. |
| [LinkedIn Post Reactions Scraper Pro](https://apify.com/atomus/linkedin-reactions-scraper-pro) | Extract every reactor on a LinkedIn post (name, headline, profile URL, reaction type). |
| [LinkedIn Posts Scraper](https://apify.com/atomus/linkedin-posts-scraper-pro) | Scrape posts, text, media, and engagement counts from any LinkedIn profile or company. |
| [LinkedIn Post Comments & Replies Scraper Pro](https://apify.com/atomus/linkedin-comments-scraper-pro) | Extract every comment and reply on a LinkedIn post, with reaction counts and reply tracking. |

See all tools at [apify.com/atomus](https://apify.com/atomus).

***

### FAQ

#### What is LinkedIn company scraping?

LinkedIn company scraping turns a company's LinkedIn URL or domain into a full structured record, industry, employee count, revenue band, funding history, HQ address, and technology stack, without opening a browser or logging in. This Actor takes a list of company URLs or domains and returns one clean JSON record per company, ready for a CRM, spreadsheet, or AI agent.

#### How do I look up a company without an account or cookies?

Paste the company's LinkedIn URL or domain (or up to 5,000 of them) into `companies` and run the Actor. It resolves each company through a cookieless data source, so you never connect a LinkedIn account, paste a session cookie, or risk a ban. Each input returns exactly one record.

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

For each found company: a curated summary (industry, type, founded year, employee count, revenue band, total funding, funding round count, HQ, technologies count, last updated) plus the full record, legal name, description, every funding round, the full categorized technology stack, all global office locations, NAICS and SIC codes, industry tags, contact email and phone, and Crunchbase / Twitter / Facebook links.

#### Can I look up a company by domain instead of a LinkedIn URL?

Yes. Submit a bare domain like `stripe.com` and the Actor matches it against the data source, preferring an exact domain match and falling back to the largest company by employee count if there's ambiguity. LinkedIn URLs and domains can be mixed in the same run.

#### How much does it cost?

Pay-per-result: you're charged only for companies that are found, `not_found` and `error` results are free. Check the Pricing tab for the current rate. Free Apify plans include 20 successful company lookups per month so you can test before paying.

#### Is there an official LinkedIn API for company data?

LinkedIn's official APIs (Marketing, Talent Solutions) are partner-gated, require an approved OAuth app, and don't expose arbitrary company data for enrichment at scale. For turning a list of company URLs or domains into structured firmographic records, a cookieless scraper like this one is the practical path.

#### Is it legal to scrape LinkedIn company data?

This Actor reads publicly available company information through a third-party data source. You are responsible for using the output in line with applicable laws (GDPR/CCPA), LinkedIn's terms, and your own compliance requirements. It is an independent tool, not affiliated with LinkedIn.

#### How fresh is the data?

Each record includes a `last_updated` field showing when the upstream source last refreshed that company, so you always know how recent the data is.

#### What happens if a company isn't found?

You get a record with `status: "not_found"` (not present in the data source) or `status: "error"` (invalid input or upstream failure). Neither is charged, so there is no penalty for trying a company that doesn't resolve.

#### Can I enrich a CRM or spreadsheet in bulk?

Yes. Export company URLs or domains from your CRM or spreadsheet, paste them into `companies` (up to 5,000 per run), and run. The output maps 1:1 to your input, so it's easy to rejoin in any spreadsheet tool or database.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation. LinkedIn® is a registered trademark of LinkedIn Corporation. All trademarks are property of their respective owners.

# Actor input Schema

## `companies` (type: `array`):

List of LinkedIn company URLs (https://www.linkedin.com/company/<slug>) or bare domains (stripe.com). One record per input. Up to 5,000 companies per run.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "https://www.linkedin.com/company/anthropicresearch"
  ]
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("atomus/linkedin-company-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "stripe.com",
    "https://www.linkedin.com/company/anthropicresearch"
  ]
}' |
apify call atomus/linkedin-company-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=atomus/linkedin-company-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Scraper ✅ NO COOKIES",
        "description": "Enrich LinkedIn company URLs or domains into structured firmographic records: industry, employee count, revenue band, funding rounds, HQ, and full tech stack. Submit up to 5,000 inputs per run, one record each. Pay only for companies found; not-found and errors are free. No login needed.",
        "version": "1.0",
        "x-build-id": "JQ2L2JgUnxPbJeKbr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/atomus~linkedin-company-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-atomus-linkedin-company-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/atomus~linkedin-company-scraper/runs": {
            "post": {
                "operationId": "runs-sync-atomus-linkedin-company-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/atomus~linkedin-company-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-atomus-linkedin-company-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Company LinkedIn URLs or Domains",
                        "minItems": 1,
                        "maxItems": 5000,
                        "type": "array",
                        "description": "List of LinkedIn company URLs (https://www.linkedin.com/company/<slug>) or bare domains (stripe.com). One record per input. Up to 5,000 companies per run.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```