# LinkedIn Company Employees Scraper (`automation-lab/linkedin-company-employees-scraper`) Actor

Extract employee profiles from any LinkedIn company — name, title, location, and profile URL. Cookie-free mode uses Google SERP discovery; authenticated mode (li\_at cookie) returns full paginated employee lists.

- **URL**: https://apify.com/automation-lab/linkedin-company-employees-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 10 total users, 5 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Employees Scraper

Extract employee profiles from any LinkedIn company page — name, job title, headline, location, and profile URL. Works without a LinkedIn account via Google SERP discovery, or with your `li_at` session cookie for a complete paginated employee list.

### 🔍 What does it do?

LinkedIn Company Employees Scraper finds people who work (or have worked) at any LinkedIn company. It supports two modes:

- **🔐 Authenticated mode (li_at cookie)**: Accesses LinkedIn's Voyager API with your session cookie to return a complete, paginated list of current employees — hundreds or thousands of people, fully paginated.
- **🌐 Cookie-free mode (no login required)**: Uses Google SERP discovery to find LinkedIn profiles matching the company, typically returning 50–100 employees per company without any login.

Give it a list of company URLs or slugs — `https://www.linkedin.com/company/google/` or just `google` — and get back a structured dataset of employee profiles ready for CRM import, sales outreach, or competitive research.

### 👤 Who is it for?

#### Sales Development Representatives
Build targeted prospect lists from any competitor or partner company without manual LinkedIn browsing. Scrape 50+ contacts in the time it takes to find ten manually.

#### Recruiters and Talent Sourcers
Identify candidates at target companies. Input the company, set a reasonable limit, and get a shortlist of profiles to review — without LinkedIn Recruiter licenses.

#### Market Researchers and Analysts
Profile the workforce of companies you're analyzing. Understand headcount by role, identify key decision-makers, and track leadership changes over time.

#### Competitive Intelligence Teams
Monitor the teams behind competitors — who's hiring, who's leaving, which departments are growing. Track leadership changes by running the scraper periodically.

#### Lead Generation Agencies
Build account-based marketing contact lists at scale. Run multiple companies in a single job and export to CSV, Google Sheets, or your CRM.

### 💡 Why use this scraper?

- ✅ **No LinkedIn account required** — cookie-free mode uses public data via Google
- ✅ **Complete employee lists with your cookie** — hundreds of results via LinkedIn Voyager API
- ✅ **Works on any company** — Fortune 500, startups, agencies, non-profits
- ✅ **Clean structured output** — name, title, LinkedIn URL, location ready for CRM import
- ✅ **Batch mode** — scrape multiple companies in one run
- ✅ **Residential proxy included** — handles LinkedIn's aggressive anti-bot without extra setup
- ✅ **Pay only per result** — PPE pricing means you're charged per employee extracted, not per run

### 📊 Output data

Each extracted employee record contains:

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Employee full name |
| `headline` | string | LinkedIn headline (title and company) |
| `location` | string | Geographic region |
| `profileUrl` | string | Full LinkedIn profile URL |
| `companyUrl` | string | Source company page URL |
| `companyName` | string | Company display name |
| `companySlug` | string | LinkedIn company slug |
| `source` | string | `voyager` (cookie) or `serp` (Google discovery) |
| `scrapedAt` | string | ISO timestamp |

### 💰 How much does it cost to scrape LinkedIn company employees?

This actor uses **pay-per-event (PPE)** pricing — you pay per employee profile extracted, not per run. There is a small start fee per run.

| Plan | Start fee | Per employee |
|------|-----------|--------------|
| Free | $0.005 | $0.005 |
| Bronze | $0.005 | $0.005 |
| Silver | $0.005 | ~$0.004 |
| Gold | $0.005 | ~$0.003 |
| Platinum | $0.005 | ~$0.002 |
| Diamond | $0.005 | ~$0.0014 |

**Estimate your costs:**
- 50 employees (1 company): ~$0.255
- 200 employees (4 companies): ~$1.005
- 1,000 employees: ~$5.005

The **free plan** includes $5 of free usage each month. A scrape of 50 employees costs about $0.25, so you can run roughly 20 such jobs on the free tier before paying.

### 🚀 How to scrape LinkedIn company employees

#### Quick start (no cookie needed)

1. Open the actor at [apify.com/automation-lab/linkedin-company-employees-scraper](https://apify.com/automation-lab/linkedin-company-employees-scraper)
2. In **Company URLs or Slugs**, enter any company URL or slug:
   - Full URL: `https://www.linkedin.com/company/google/`
   - Slug only: `google`
3. Set **Max Employees per Company** (default 50, max 500)
4. Click **Start** — results appear in seconds

#### With li_at cookie for complete lists

1. Log into LinkedIn in your browser
2. Open DevTools (F12 or Cmd+Opt+I on Mac)
3. Go to **Application** → **Cookies** → `https://www.linkedin.com`
4. Copy the value of `li_at`
5. Paste it into the **li_at Cookie** field
6. Run — now gets fully paginated results including all current employees

#### Via API

```bash
curl -X POST https://api.apify.com/v2/acts/automation-lab~linkedin-company-employees-scraper/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyUrls": ["https://www.linkedin.com/company/stripe/"],
    "maxEmployees": 100
  }'
````

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `companyUrls` | array | required | LinkedIn company page URLs or slugs |
| `maxEmployees` | integer | 50 | Max profiles to extract per company (1–500) |
| `liAtCookie` | string | optional | Your LinkedIn `li_at` session cookie for authenticated access |

**Tips for `companyUrls`:**

- Both formats work: `https://www.linkedin.com/company/netflix/` or `netflix`
- Add multiple companies to scrape them all in a single run
- Company slug is the part after `/company/` in the URL

### 📤 Output example

```json
{
  "profileUrl": "https://www.linkedin.com/in/jeffreyliu",
  "name": "Jeffrey Liu",
  "headline": "Engineering Manager at Stripe",
  "location": "San Francisco Bay Area",
  "companyUrl": "https://www.linkedin.com/company/stripe/",
  "companySlug": "stripe",
  "companyName": "Stripe",
  "source": "voyager",
  "scrapedAt": "2026-05-01T10:00:00.000Z"
}
```

### 🔐 Two scraping modes explained

#### Cookie-free mode (default)

When no `li_at` cookie is provided, the scraper uses **Google SERP discovery**:

1. Fetches the company's LinkedIn page to identify the company name
2. Searches Google for `site:linkedin.com/in "company-name"` to discover employee profiles
3. Parses names and headlines from Google result titles
4. Returns 50–100 employees per company

**Pros:** No LinkedIn account needed, no risk of account action, works on any plan.\
**Cons:** Limited to ~100 results per company, includes current and former employees, no location data.

#### Authenticated mode (with li\_at cookie)

When a valid `li_at` cookie is provided, the scraper uses **LinkedIn's Voyager API**:

1. Fetches the company page with your session to get the internal company ID
2. Calls LinkedIn's internal people search API, filtered to current employees
3. Paginates through all results

**Pros:** Gets all current employees (hundreds or thousands), includes location, high accuracy.\
**Cons:** Requires your LinkedIn session cookie, rate limits apply, use responsibly.

### 💡 Tips and best practices

- **Start with a small limit** — set `maxEmployees: 20` for your first run to verify the company slug and check result quality before running at full scale
- **Use your li\_at cookie for accurate results** — Google SERP results include former employees; Voyager API returns only current employees
- **Your cookie expires periodically** — if you get "authentication failed" errors, re-copy your `li_at` from your browser
- **Multiple companies in one run** — scraping 10 companies with `maxEmployees: 50` each is more cost-efficient than 10 separate runs (only one start fee)
- **Export to CSV** — use Apify's built-in export to download results as CSV for CRM import
- **Company slug vs URL** — both work; the slug is just the readable identifier in the URL path

### 🔗 Integrations

#### CRM enrichment (Salesforce, HubSpot)

Scrape target account employees → export CSV → import to CRM. Map `name` to Contact Name, `headline` to Job Title, `profileUrl` to LinkedIn URL. Run weekly to catch new hires.

#### Google Sheets via Zapier

Connect with Zapier: trigger on "Apify run finished" → action "Add row to Google Sheet" → map fields. Result: every run automatically populates a shared prospecting sheet.

#### Webhook to Slack

Set an Apify webhook on run completion to POST results to a Slack channel. Your sales team gets notified the moment a new employee list is ready.

#### Scheduled competitive monitoring

Use Apify's [scheduled runs](https://docs.apify.com/platform/schedules) to scrape your top 5 competitors monthly. Export to BigQuery or Snowflake to track workforce trends over time.

#### Clay / Apollo enrichment pipeline

Export `profileUrl` as a column → import into Clay or Apollo for email finding and enrichment. Combine with the [LinkedIn Profile Scraper](https://apify.com/automation-lab/linkedin-profile-scraper) for full work history.

### 🛠️ API usage

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/linkedin-company-employees-scraper').call({
    companyUrls: ['https://www.linkedin.com/company/anthropic/'],
    maxEmployees: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/linkedin-company-employees-scraper').call(run_input={
    'companyUrls': ['https://www.linkedin.com/company/anthropic/'],
    'maxEmployees': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['name'], item['headline'])
```

#### cURL

```bash
## Start a run
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linkedin-company-employees-scraper/runs" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companyUrls":["https://www.linkedin.com/company/openai/"],"maxEmployees":50}'

## Get results (replace with your dataset ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

### 🤖 Use with AI (MCP / Claude)

This actor is available as an **MCP tool** for use with Claude and other AI assistants.

#### Claude Code (terminal)

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/linkedin-company-employees-scraper"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config file (`~/.claude/claude_desktop_config.json` or equivalent):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/linkedin-company-employees-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Example prompts

Once connected, ask Claude:

- *"Find me 50 employees at Stripe and save them to a CSV"*
- *"Scrape the employees of stripe and anthropic, give me a table with name and headline"*
- *"Who works at OpenAI? Scrape their employees and filter for engineering roles"*
- *"Get the LinkedIn profiles of Notion employees for sales outreach"*

### ⚖️ Legality and terms of service

This actor scrapes **publicly available LinkedIn data** in cookie-free mode, using data that Google indexes from LinkedIn's public pages. In authenticated mode, it uses your own session to access data you have personal access to.

**Cookie-free mode:** Data returned is the same data visible to anyone searching Google. LinkedIn profiles indexed by Google are public by default (users control this via privacy settings).

**Authenticated mode:** You use your own account credentials. You are responsible for complying with LinkedIn's [Terms of Service](https://www.linkedin.com/legal/user-agreement) regarding automated access.

Scraping publicly available data is generally considered lawful in most jurisdictions following the *hiQ Labs v. LinkedIn* (9th Circuit) ruling. This actor does not bypass authentication barriers or scrape private data.

**Use this data responsibly.** Do not use scraped employee data for spam, unsolicited mass messaging, or harassment. Always comply with applicable data protection laws (GDPR, CCPA) when storing and processing personal data.

### ❓ FAQ

#### Do I need a LinkedIn account?

No. The cookie-free mode works without any LinkedIn account using public search data from Google. For complete paginated employee lists, provide your `li_at` session cookie.

#### How many employees can I scrape?

- **Without cookie:** ~100 per company (limited by Google SERP results)
- **With li\_at cookie:** Up to `maxEmployees` (max 500 per run, no Google limit)

#### Why does Google SERP mode return fewer results than the company headcount?

Google's search index only surfaces a subset of LinkedIn profiles — typically the most active/visited ones. For a company with 10,000 employees, you'll get 50–100 via SERP. For complete lists, use authenticated mode.

#### The actor returns 0 results — what should I check?

1. Verify the company slug is correct — check the URL at `linkedin.com/company/SLUG`
2. If using cookie mode, your `li_at` may have expired — log in to LinkedIn and copy a fresh cookie
3. Some small companies have very few public profiles on Google — try increasing `maxEmployees` or switching to cookie mode
4. If SERP mode returns "Google search failed", the proxy may be rate-limited — wait a few minutes and retry

#### Can I scrape employees of multiple companies in one run?

Yes. Add multiple URLs or slugs to the `companyUrls` list. All companies are scraped in the same run.

#### Is the li\_at cookie safe to share with this actor?

Your `li_at` cookie is treated as a secret and never logged. However, your cookie gives access to your LinkedIn account — only use it on Apify's platform and rotate it if you have concerns. Apify runs in an isolated environment and your data is not stored beyond the run.

#### How fresh is the data?

Authenticated mode returns real-time data from LinkedIn's Voyager API. SERP mode returns data as indexed by Google, which may lag by days to weeks for newer profiles.

### 🔗 Related scrapers

- [LinkedIn Profile Scraper](https://apify.com/automation-lab/linkedin-profile-scraper) — Scrape full profile data (education, experience, skills, follower count) from LinkedIn profile pages
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — Extract company metadata: description, headcount, industries, website, specialties
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — Scrape job listings with filters for location, keyword, experience level
- [LinkedIn Company Posts Scraper](https://apify.com/automation-lab/linkedin-company-posts-scraper) — Scrape posts from company pages including likes, comments, and content

# Actor input Schema

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

LinkedIn company page URLs or slugs. Accepts full URLs (https://www.linkedin.com/company/google/) or just the slug (google).

## `maxEmployees` (type: `integer`):

Maximum number of employee profiles to extract per company. Keep low to control costs. With SERP mode, maximum is ~100 regardless of this setting.

## `liAtCookie` (type: `string`):

Your LinkedIn li\_at session cookie. When provided, the scraper uses LinkedIn's Voyager API for a complete, paginated employee list. Without it, Google SERP discovery is used (free but limited to ~100 results). To get your li\_at cookie: log into LinkedIn → open DevTools (F12) → Application → Cookies → copy the value of 'li\_at'.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/google/"
  ],
  "maxEmployees": 20
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-company-employees-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companyUrls": ["https://www.linkedin.com/company/google/"],
    "maxEmployees": 20,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Employees Scraper",
        "description": "Extract employee profiles from any LinkedIn company — name, title, location, and profile URL. Cookie-free mode uses Google SERP discovery; authenticated mode (li_at cookie) returns full paginated employee lists.",
        "version": "0.1",
        "x-build-id": "AJUppMApyooiB2Aeh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~linkedin-company-employees-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-linkedin-company-employees-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/automation-lab~linkedin-company-employees-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-linkedin-company-employees-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/automation-lab~linkedin-company-employees-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-linkedin-company-employees-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": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "🏢 Company URLs or Slugs",
                        "type": "array",
                        "description": "LinkedIn company page URLs or slugs. Accepts full URLs (https://www.linkedin.com/company/google/) or just the slug (google).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmployees": {
                        "title": "Max Employees per Company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of employee profiles to extract per company. Keep low to control costs. With SERP mode, maximum is ~100 regardless of this setting.",
                        "default": 50
                    },
                    "liAtCookie": {
                        "title": "li_at Cookie (optional — enables full employee list)",
                        "type": "string",
                        "description": "Your LinkedIn li_at session cookie. When provided, the scraper uses LinkedIn's Voyager API for a complete, paginated employee list. Without it, Google SERP discovery is used (free but limited to ~100 results). To get your li_at cookie: log into LinkedIn → open DevTools (F12) → Application → Cookies → copy the value of 'li_at'."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```