# LinkedIn Company 360 — Firmographics + Hiring + Ads Fused (`foxlabs/linkedin-company-360`) Actor

One record per company fusing LinkedIn firmographics + live hiring signals (open roles, velocity, departments) + active advertising (ad count, formats, creatives) — entity-resolved by domain, provenance-tagged. The 360° company view no single-surface scraper gives. No login.

- **URL**: https://apify.com/foxlabs/linkedin-company-360.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $70.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

<p align="center"><a href="https://apify.com/foxlabs/linkedin-company-360"><img src="https://data.foxlabs.com.tr/img/linkedin-company-360-banner.svg" alt="LinkedIn Company 360" width="100%" /></a></p>

## LinkedIn Company 360 — Firmographics + Hiring + Ads, Fused

**Every other LinkedIn scraper gives you one surface. This returns the whole company** — its firmographics, whether it's scaling (live **hiring**), and whether it's in-market (active **advertising**) — fused into one domain-keyed, provenance-tagged record, with **no login and no cookies**.

- 🏢 **Firmographics** — size, industry, HQ, followers, website, founded, description
- 📈 **Live hiring signal** — open-role count, velocity (7d/30d), momentum, top departments
- 📣 **Advertising signal** — is it advertising, ad count, formats, sample creatives (LinkedIn Ad Library)
- 🔗 **One fused record per company** — entity-keyed by domain, every part tagged with its source

### Quick start (API)

Get a full 360° record for two companies in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~linkedin-company-360/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "companies": ["stripe", "https://www.linkedin.com/company/datadog/"], "includeHiring": true, "includeAdvertising": true }'
````

Prefer no code? Open the **Input** tab, paste your company URLs or slugs, toggle the signals you want, and click **Start** — then download the results.

### What you get

One clean, flat record per company:

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Company name as shown on LinkedIn |
| `companySlug` | string | LinkedIn company slug (e.g. `stripe`) |
| `companyId` | string | LinkedIn numeric organization id (used to resolve hiring & ads; absent if unresolved) |
| `companyLinkedInUrl` | string | Canonical company page URL |
| `domain` | string | Website domain — the entity key used to fuse signals |
| `employeeCount` | number | Employee count from LinkedIn |
| `industry` | string | Industry / sector |
| `hq` | string | Headquarters (city, region, country) |
| `followers` | number | LinkedIn follower count |
| `website` | string | Company website URL |
| `founded` | number | Founding year |
| `description` | string | Company "About" description |
| `hiring` | object | Fused hiring signal — see below (present when hiring is enabled and the company id resolves) |
| `advertising` | object | Fused advertising signal — see below |
| `signalSummary` | string | One-line human read, e.g. `hiring (high, 200 roles) · advertising (24 ads)` |
| `sources` | object | Provenance string for each fused part (`firmographics`, `hiring`, `advertising`) |
| `note` | string | Present only when the LinkedIn company id could not be resolved (firmographics only) |
| `scrapedAt` | string | ISO 8601 timestamp of the run |
| `error` | string | Present only on an unreachable company page; that record carries just `companySlug`, `error`, `scrapedAt` |

**`hiring`** object:

| Field | Type | Description |
|---|---|---|
| `openJobCount` | number | Distinct open roles found (capped at 200 per company) |
| `openJobCountIsCapped` | boolean | Present and `true` only when the 200-role cap was hit |
| `isHiring` | boolean | Whether any open roles were found |
| `hiringMomentum` | string | `high` / `medium` / `low` / `not-hiring`, from recent posting velocity |
| `postedLast7d` | number | Roles posted in the last 7 days |
| `postedLast30d` | number | Roles posted in the last 30 days |
| `topDepartments` | array | Up to 6 `{ name, count }` — e.g. Engineering, Sales, Data & AI, Marketing, Product |

**`advertising`** object:

| Field | Type | Description |
|---|---|---|
| `isAdvertising` | boolean | Whether any active ads were found in the LinkedIn Ad Library |
| `activeAdCount` | number | Distinct active ads found (capped at 60 per company) |
| `activeAdCountIsCapped` | boolean | Present and `true` only when the 60-ad cap was hit |
| `adFormats` | array | `{ format, count }` where format is `image` or `video`, tallied from a sample of the ads |
| `sampleAdCreatives` | array | Up to 3 short ad-copy snippets (≤140 chars each) |

> `adFormats` and `sampleAdCreatives` are drawn from a sample of up to 12 ad detail pages, so their counts can be lower than `activeAdCount` — they characterise the advertising, not enumerate every ad.

#### Sample output

*Illustrative record (field shapes are real; values are for illustration):*

```json
{
  "companyName": "Datadog",
  "companySlug": "datadog",
  "companyId": "1035334",
  "companyLinkedInUrl": "https://www.linkedin.com/company/datadog",
  "domain": "datadoghq.com",
  "employeeCount": 7000,
  "industry": "Software Development",
  "hq": "New York, New York, United States",
  "followers": 512340,
  "website": "https://www.datadoghq.com",
  "founded": 2010,
  "description": "The observability and security platform for cloud applications.",
  "hiring": {
    "openJobCount": 200,
    "openJobCountIsCapped": true,
    "isHiring": true,
    "hiringMomentum": "high",
    "postedLast7d": 18,
    "postedLast30d": 63,
    "topDepartments": [
      { "name": "Engineering", "count": 74 },
      { "name": "Sales", "count": 38 },
      { "name": "Data & AI", "count": 21 }
    ]
  },
  "advertising": {
    "isAdvertising": true,
    "activeAdCount": 24,
    "adFormats": [
      { "format": "image", "count": 7 },
      { "format": "video", "count": 3 }
    ],
    "sampleAdCreatives": [
      "See how leading teams cut MTTR with unified observability across metrics, traces and logs.",
      "Watch your whole stack in one place — start a 14-day free trial."
    ]
  },
  "signalSummary": "hiring (high, 200 roles) · advertising (24 ads)",
  "sources": {
    "firmographics": "LinkedIn company page",
    "hiring": "LinkedIn public jobs (f_C)",
    "advertising": "LinkedIn Ad Library (public)"
  },
  "scrapedAt": "2026-07-05T09:12:44.031Z"
}
```

### Input & filters

This is an **enrichment** Actor: you supply the companies, it returns one fused record for each. It does not discover or search for companies — pair it with a discovery source (or a LinkedIn search Actor) to build the list.

- **Companies** *(required)* — a list of LinkedIn company URLs or bare slugs, e.g. `stripe`, `https://www.linkedin.com/company/datadog/`. Duplicates and unparseable entries are dropped.
- **Include hiring signals** *(default on)* — fuse open-role count, 7d/30d velocity, momentum and department breakdown.
- **Include advertising signals** *(default on)* — fuse Ad Library activity: is-advertising, ad count, formats, sample creatives.
- **Proxy** *(default Residential)* — LinkedIn rate-limits and blocks datacenter/un-proxied traffic, so residential is strongly recommended.

Turning a signal off makes runs faster and cheaper when you only need part of the 360.

### Example inputs (copy & paste)

```jsonc
// 1) Full 360 on a target-account list — firmographics + hiring + ads
{ "companies": ["stripe", "datadog", "https://www.linkedin.com/company/notion/"],
  "includeHiring": true, "includeAdvertising": true }

// 2) Recruiting focus — firmographics + hiring only (skip ads — faster)
{ "companies": ["figma", "canva"], "includeHiring": true, "includeAdvertising": false }

// 3) ABM / in-market — advertising signals only (skip hiring)
{ "companies": ["hubspot", "salesforce"], "includeHiring": false, "includeAdvertising": true }

// 4) Pure firmographics enrichment — both signals off (fastest)
{ "companies": ["openai", "anthropic"], "includeHiring": false, "includeAdvertising": false }

// 5) Full 360 via exact LinkedIn URLs — dodge namesake slugs
{ "companies": ["https://www.linkedin.com/company/stripe/", "https://www.linkedin.com/company/datadog/"],
  "includeHiring": true, "includeAdvertising": true }
```

### Use cases

- **Account prioritisation.** Score a target list by size × hiring momentum × ad activity. `signalSummary` answers "is this account worth a call?" in one line — growing, in-market, or quiet — so reps work the live accounts first.
- **Competitive & market monitoring.** Schedule the same company list on a cadence and watch one record move as a rival ramps hiring or spins up ad campaigns — an early read on expansion and go-to-market pushes.
- **CRM enrichment.** Feed a list of company URLs or slugs → append current firmographics (size, industry, HQ, website, followers) plus hiring and advertising signals to records you already own.
- **Recruiting & talent intelligence.** `hiringMomentum` + `topDepartments` show who is scaling and where (Engineering vs. Sales vs. Data & AI) — target agencies, candidates and partnerships at companies that are actually hiring.
- **ABM / in-market detection.** `isAdvertising` and `activeAdCount` flag companies actively spending on LinkedIn — a buying-intent signal for ABM plays and timing.
- **Investment & competitor research.** Combine firmographics with hiring velocity and ad presence to gauge a company's momentum and commercial activity across a sector.

### Performance & throughput

Companies are processed a few at a time. For each one the Actor fetches the public company page (firmographics), then — if enabled — pages the public guest-jobs endpoint for open roles (capped at 200, in pages of 10) and fans the LinkedIn Ad Library out across country facets before pulling a sample of ad detail pages. All fetches go through a residential proxy with automatic retry/back-off on rate-limit responses.

Actual wall-clock time depends on your Apify plan, proxy latency and LinkedIn throttling, so it isn't fixed. Two levers control it directly: **turn off `includeAdvertising`** (the ad fan-out is the heaviest step) and/or **`includeHiring`** when you only need firmographics.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/linkedin-company-360').call({
  companies: ['stripe', 'datadog'], includeHiring: true, includeAdvertising: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/linkedin-company-360").call(run_input={
    "companies": ["stripe", "datadog"], "includeHiring": True, "includeAdvertising": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item.get("signalSummary"))
```

Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the **Apify MCP server** so AI agents can call it as a tool.

### Data quality

Firmographics are read from the public data LinkedIn embeds on each company page. Name and description are almost always present; `employeeCount`, `industry`, `hq`, `followers`, `website` and `founded` depend on what the company itself publishes. **Fields LinkedIn doesn't expose are omitted from the record — never guessed or fabricated.**

Hiring and advertising signals require the company's LinkedIn organization id to resolve from its page. When it can't, you still get firmographics plus a `note` explaining why. Hiring counts come from the public guest-jobs listing and advertising from the public Ad Library, each tagged in `sources`. Because these numbers reflect what LinkedIn exposes at run time (and are capped — see the field tables), treat them as strong directional signals rather than an exhaustive census.

### Pricing

**Pay per result** — you're billed per company record returned; firmographics, hiring and advertising are gathered in a single pass per company. There's an Apify **free tier** to evaluate the full feature set before you scale. See the **Pricing** tab on the Actor for current rates.

### FAQ

**Do I need a LinkedIn login or cookies?** No. The Actor reads only publicly visible pages and endpoints — it's cookieless and never signs in.

**Does LinkedIn have an official company API for this?** No public one. This Actor accesses public surfaces: the company page, the public guest-jobs listing, and the public LinkedIn Ad Library. See the legal note below.

**Can it discover or search for companies?** No — it enriches the companies you provide. Give it URLs or slugs and it returns one fused record each. Build the list with your CRM or a LinkedIn search/discovery Actor.

**A slug returned the wrong company — why?** A bare slug for a common name can match a namesake. Pass the exact `https://www.linkedin.com/company/…` URL, and verify the returned `domain` matches the company you meant.

**Why do some records have no `companyId`, hiring or advertising?** If the organization id can't be resolved from the page, you get firmographics only and a `note` field explains it. Both hiring and advertising need that id.

**How many roles and ads can it return?** Hiring is capped at **200 roles** per company (`openJobCountIsCapped` flags it); advertising at **60 ads** (`activeAdCountIsCapped`), with formats and sample creatives drawn from up to 12 of them.

**How fresh is the data?** Live — every run fetches the current pages. Schedule it to track accounts over time.

**What export formats are available?** JSON, CSV, Excel, or via the Apify API and integrations.

**Which proxy should I use?** Residential (the default). LinkedIn blocks datacenter and un-proxied traffic.

**Can I turn the signals off?** Yes — `includeHiring` and `includeAdvertising`. Off means faster, cheaper, firmographics-only runs.

### Troubleshooting

- **A record shows `error: "company page unreachable"`.** LinkedIn rate-limited or blocked that fetch even after retries. Keep the residential proxy and re-run — LinkedIn throttles bursts, so smaller batches and spacing help.
- **A record has firmographics only + a `note`.** The organization id didn't resolve from the page. Pass the exact company URL instead of a bare slug and re-run.
- **`hiring` / `advertising` missing though enabled.** Either `companyId` didn't resolve, or the company genuinely isn't hiring/advertising (`isHiring` / `isAdvertising` would be `false`). It's the signal, not a miss.
- **Runs feel slow.** The ad fan-out (country facets + detail pages) is the heaviest step. Set `includeAdvertising: false` for fast firmographics-and-hiring pulls.

### Notes, limits & legal (honest)

- **Public data only.** Every signal comes from publicly visible LinkedIn surfaces (company page, public guest-jobs listing, public Ad Library). The Actor is cookieless and never logs in, and it collects no personal profiles — hiring and advertising signals are company-level.
- **No official API; your responsibility.** LinkedIn provides no public API for this data, and its User Agreement restricts automated collection. This Actor only accesses publicly available information, but **you are responsible for your own use and for complying with LinkedIn's terms and applicable law**. Use it for legitimate B2B, recruiting and research.
- **Not affiliated** with, endorsed by, or sponsored by LinkedIn Corporation. "LinkedIn" is a trademark of its owner.
- **Namesake risk.** A bare slug for a common name can resolve to a different company — verify via the returned `domain`, or pass the exact LinkedIn URL.
- **Caps & scope.** Hiring is capped at 200 roles and advertising at 60 ads per company (formats/creatives from up to 12 sampled ads). Deep ad analytics (EU/DSA impressions & targeting) are out of scope — see the dedicated **LinkedIn Ad Tracker**. Revenue, funding and Glassdoor culture data come from other foXLabs Actors and can be layered on by domain.
- **Never fabricated.** Fields LinkedIn doesn't expose are omitted from the record, not guessed.

### Support

Questions, a field you'd like added, or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-05

- Reworked docs: API quick-start, full field tables (with `hiring` / `advertising` objects), illustrative sample output, example recipes, integration snippets (JS/Python/Make/MCP), FAQ, troubleshooting and honest legal notes.

#### 0.1

- Initial release. Domain-keyed fusion of firmographics + live hiring signals + active advertising into one record per company, with a one-line signal summary and provenance. Cookieless, no login.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — public-data company, contact, jobs, ads, procurement & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

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

LinkedIn company URLs or slugs — e.g. "stripe", "https://www.linkedin.com/company/datadog/". One fused 360° record is returned per company.

## `includeHiring` (type: `boolean`):

Fuse live hiring data: open-role count, velocity (last 7/30 days), momentum and department breakdown.

## `includeAdvertising` (type: `boolean`):

Fuse active advertising from the LinkedIn Ad Library: whether the company is advertising, ad count, formats and sample creatives.

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

Proxy configuration. Residential proxy (the default) is strongly recommended — LinkedIn rate-limits and blocks un-proxied and datacenter traffic.

## Actor input object example

```json
{
  "companies": [
    "stripe",
    "datadog"
  ],
  "includeHiring": true,
  "includeAdvertising": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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",
        "datadog"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/linkedin-company-360").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",
        "datadog",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/linkedin-company-360").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",
    "datadog"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call foxlabs/linkedin-company-360 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company 360 — Firmographics + Hiring + Ads Fused",
        "description": "One record per company fusing LinkedIn firmographics + live hiring signals (open roles, velocity, departments) + active advertising (ad count, formats, creatives) — entity-resolved by domain, provenance-tagged. The 360° company view no single-surface scraper gives. No login.",
        "version": "0.1",
        "x-build-id": "fiWzKlpHwIh1t1kny"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~linkedin-company-360/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-linkedin-company-360",
                "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/foxlabs~linkedin-company-360/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-linkedin-company-360",
                "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/foxlabs~linkedin-company-360/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-linkedin-company-360",
                "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",
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "LinkedIn company URLs or slugs — e.g. \"stripe\", \"https://www.linkedin.com/company/datadog/\". One fused 360° record is returned per company.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeHiring": {
                        "title": "Include hiring signals",
                        "type": "boolean",
                        "description": "Fuse live hiring data: open-role count, velocity (last 7/30 days), momentum and department breakdown.",
                        "default": true
                    },
                    "includeAdvertising": {
                        "title": "Include advertising signals",
                        "type": "boolean",
                        "description": "Fuse active advertising from the LinkedIn Ad Library: whether the company is advertising, ad count, formats and sample creatives.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy configuration. Residential proxy (the default) is strongly recommended — LinkedIn rate-limits and blocks un-proxied and datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```