# LinkedIn Company Scraper · No Cookies · $5/1k ✅ (`linkedintel/linkedin-company-scraper-no-cookies-5-1k`) Actor

LinkedIn company scraper with full firmographics. 41 fields per company plus optional posts, jobs, employee demographics. No login. $5/1k pay-per-result.

- **URL**: https://apify.com/linkedintel/linkedin-company-scraper-no-cookies-5-1k.md
- **Developed by:** [LinkedIntel](https://apify.com/linkedintel) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 77.8% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 record extracteds

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

## LinkedIn Company Scraper — No Login, No Cookies, Pay Per Result

Full LinkedIn company data — **41 firmographic fields per record** plus optional posts, jobs, and employee demographics — in clean structured JSON. **No LinkedIn login required. No cookies. No browser session. No account ban risk.**

The richest LinkedIn company scraper on Apify Store. Built for **B2B sales prospecting, CRM enrichment, account-based marketing (ABM), competitive intelligence, market research, and recruiting**.

---

### How this compares to other LinkedIn company scrapers

We benchmarked the direct competitors on Apify Store. Here's the honest landscape:

| | automation-lab/linkedin-company | scraperx/linkedin-company-about | bebity/linkedin-companies-profiles | **This actor** |
|---|---|---|---|---|
| **Pricing model** | $0.003-0.00345/co + $0.005 run fee | $19.99/month + usage | $29/month + usage | **Pay-per-result, $0.005/record** |
| **Hidden subscription fee?** | No, but per-run fee | ✅ Yes ($240/yr) | ✅ Yes ($348/yr) | ❌ **None** |
| **Fields per company** | 18 | 10 | ~10 | **41** |
| **Includes recent posts?** | ❌ | ❌ | ❌ | ✅ **(toggleable, +23 fields per post)** |
| **Includes open jobs?** | ❌ | ❌ | ❌ | ✅ **(toggleable, +13 fields per job)** |
| **Includes employee demographic breakdowns?** | ❌ | ❌ | ❌ | ✅ **7 groups: Location, School, Function, Skill, Service Category, Field of Study, Current Company** |
| **Similar/affiliated companies?** | ❌ | ❌ | Partial | ✅ **Top 10 embedded in company record** |
| **No login / no cookies** | ✅ | ✅ | ❓ | ✅ |
| **Source code visibility** | Public | Public | Public | **Hidden (paid-tier protection)** |

**Bottom line:** The richest LinkedIn company scraper on Apify Store. **2-4× more data per record** than competitors at a comparable per-record price — with no monthly subscription. You pay only for what you scrape.

### What you get — 4 record types per company

For each input company, the actor returns:

#### 1. `company` record (always — 41 fields)
- Core: id, name, universalName, linkedinUrl, description (full + preview), entityType (COMPANY / SCHOOL)
- Scale: staffCount, staffCountRange ("10,001+ employees"), followerCount
- Categorization: industriesV2[], industriesLegacy[], specialities[]
- Contact: website, callToActionUrl, callToActionType
- Founded: foundedYear, foundedMonth, foundedDay
- Location: hqCountry, hqCity, hqGeographicArea, hqLine1, hqPostalCode + full locations[] array (all worldwide offices) + locationsCount
- Brand: logoUrl (largest), coverImageUrl
- Verification: pageVerified, pageVerifiedAt, isClaimable
- Network: similarCompaniesCount + top 10 similarCompanies[] (id, name, industry, followerCount, url) + affiliatedByJobsCount + affiliatedByEmployeesCount + affiliatedByShowcasesCount
- Meta: availableTabs[], scrapedAt

#### 2. `companyPost` records (optional, includePosts=true — 23 fields per post)
- Post: urn, url, header ("Microsoft reposted this"), text + textPreview, isReshare, edited
- Timestamps: postedAt (ISO), postedAtMs (Unix)
- Engagement: totalReactions, commentsCount, repostsCount, reactionBreakdown[] (per-type)
- Media: mediaContent[] (image/video URLs), mediaCount
- Author: name, url, type (COMPANY or PERSON for reshared posts)

#### 3. `companyJob` records (optional, includeJobs=true — 13 fields per job)
- jobId, jobTitle, jobUrl
- jobLocation (e.g., "London, England, United Kingdom (Hybrid)")
- jobListedAt (ISO + Unix ms)
- jobVerified
- companyLogoUrl

#### 4. `companyEmployeeGroup` records (optional, includeEmployees=true — 7 records per company)
Employee demographic breakdowns straight from LinkedIn's "People insights" page:
- **Locations** — top 15 cities/countries with employee counts
- **Current company** — affiliated entities
- **School** — top 15 universities employees attended
- **Current Function** — Engineering, Sales, Marketing, etc.
- **Skill Explicit** — top 15 skills mentioned
- **Service categories** — for service-based companies
- **Field of Study** — Computer Science, Business Admin, etc.

Each record includes totalEmployees (the company's total LinkedIn-discoverable employee count).

### Top use cases

#### 1. CRM enrichment
Drop a list of LinkedIn company URLs into your HubSpot, Salesforce, Attio, or Pipedrive workflow. Back-fill **industry, headcount, HQ, founded year, specialities, website, follower count** in one batch. **Replaces $5,000/year Clearbit subscriptions for SMB-tier needs.**

#### 2. Account-based marketing (ABM) list building
Turn a static list of company URLs into a fully-resolved target-account universe with firmographic filters (size, industry, HQ region) ready to apply. **Build ICP-filtered ABM lists in one run.**

#### 3. Competitor headcount tracking
Snapshot employee counts and follower growth at a regular cadence to chart your competitor's trajectory. **Compare staff counts month-over-month — early warning for layoffs, hiring sprees, or product launches.**

#### 4. Competitor post engagement audit
Toggle `includePosts=true`. Pull every competitor's recent post with full engagement metrics. **Compare reaction counts, comment volume, and post velocity across your competitive set.**

#### 5. Open-roles intelligence
Toggle `includeJobs=true`. See every open role at a target company with location, posted date, and job URL. **Track hiring sprees as buying signals or sales triggers.**

#### 6. Employee demographic intelligence
Toggle `includeEmployees=true`. Get 7 distribution groups: where employees are located, what schools they attended, what functions they work in, what skills they list. **Powerful for sales targeting, recruiting strategy, and competitor analysis.**

#### 7. Recruiting / talent market research
Combine `includeEmployees=true` with `includeJobs=true`. Map a target company's talent landscape end-to-end — current employee distribution + active openings. **Build hiring competitor analyses in one run.**

#### 8. Investment due diligence
Pull firmographics + employee growth indicators + recent post momentum on potential acquisitions or investments. **Public LinkedIn data fast-tracks the company-data part of your CIM build.**

### Quick start (3 steps)

#### Step 1 — Get the company URL
Open the LinkedIn company page and copy the URL — `https://www.linkedin.com/company/<universal-name>/`. You can also pass just the slug (e.g., `microsoft`) via the **Company universal names** field.

#### Step 2 — Choose your toggles
- Default: just `company` records (1 per input, $0.005 each)
- `includePosts: true`: adds N recent posts per company
- `includeJobs: true`: adds N open jobs per company
- `includeEmployees: true`: adds 7 demographic groups per company

#### Step 3 — Run + export
Results stream into the **Dataset** tab. Each record has a `type` field — filter to whichever subset you need. Export JSON, CSV, or Excel, or pipe to HubSpot/Salesforce/Airtable/Zapier/Make/n8n.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companyUrls` | array of strings | `[]` | LinkedIn company page URLs. |
| `companyNames` | array of strings | `[]` | Alternative: pass universal-name slugs directly (e.g., `"microsoft"`). |
| `includePosts` | boolean | `false` | Adds recent posts as `companyPost` records. |
| `maxPostsPerCompany` | integer | `10` | Cap on posts (when enabled). |
| `includeJobs` | boolean | `false` | Adds open job listings as `companyJob` records. |
| `maxJobsPerCompany` | integer | `50` | Cap on jobs (when enabled). |
| `includeEmployees` | boolean | `false` | Adds 7 `companyEmployeeGroup` records per company. |
| `proxyConfiguration` | object | Apify residential | Defaults are correct. |

At least one of `companyUrls` or `companyNames` is required.

#### Example input

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/",
    "https://www.linkedin.com/company/openai/"
  ],
  "includePosts": true,
  "maxPostsPerCompany": 5,
  "includeEmployees": true
}
````

This run returns: 2 `company` records + 10 `companyPost` records + 14 `companyEmployeeGroup` records = **26 records total** = **$0.13**.

### Pricing — pay only for results

**$5.00 per 1,000 records. Pay-per-result.**

- ✅ No subscription
- ✅ No monthly minimum
- ✅ No per-run start fee
- ✅ No charge for failed runs or unresolvable companies (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) covers ~1,000 records to start

**No hidden costs vs competitors:**

- $0.005/record flat — no per-run fee like automation-lab ($0.003-0.00345 + $0.005/run fee)
- No $20-30 monthly subscription (scraperx, bebity)
- Far more data per dollar — 41 fields vs competitors' 10-18 means 2-4× more data per $1 spent
- One transparent price for every record type (company, post, job, employee group)

### Combine with other LinkedIn actors

Build a complete LinkedIn intelligence pipeline:

- Pipe `similarCompanies[].url` into another run to expand your target universe (network-walking)
- Pipe `companyPost.postUrn` into the **LinkedIn Post Comments Scraper** for full comment threads
- Pipe `companyPost.postUrn` into the **LinkedIn Post Reactions Scraper** for reactor lists
- Pipe `jobUrl` into LinkedIn jobs scrapers for full job descriptions

### FAQ

#### Do I need a LinkedIn account?

**No.** This actor reads public company-page data without any LinkedIn login, cookie, or browser session.

#### Will my LinkedIn account get banned?

**No — because we never use it.** Cookie-based scrapers risk your account every run. This actor doesn't.

#### Why is this cheaper than other LinkedIn company scrapers?

Direct competitors charge $0.003+/company plus run fees (automation-lab), or $20-30/month subscriptions (scraperx, bebity). We negotiated a managed data partnership that gives us cookieless LinkedIn access at lower vendor cost and pass the savings through. **Pure pay-per-result, no monthly fees.**

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

Yes. Paste a list of URLs into **Company URLs**. The actor processes them sequentially with built-in deduplication by universal name slug.

#### Can I scrape personal profiles too?

No — this actor only accepts company pages (`linkedin.com/company/<slug>/`). For personal profile data, see the LinkedIn Profile Engagement Scraper or LinkedIn Profile Reactions Scraper from linkedintel.

#### What's in `companyEmployeeGroup`?

It's **employee demographics**, not a list of individual employees. Seven aggregated groups per company: Locations (where employees live), Schools (where they studied), Current Function (their job categories), Skills, Service Categories, Fields of Study, and Current Company affiliations. Each group lists top 15 items with employee counts.

#### What's the maximum employees / posts / jobs per company?

- Posts: up to **500** per company (controlled by `maxPostsPerCompany`)
- Jobs: up to **1,000** per company (controlled by `maxJobsPerCompany`)
- Employee groups: always **7 records** per company (LinkedIn's fixed categorization)

#### How fast is it?

- Company only: 3-7 seconds per company
- With all toggles ON: 10-20 seconds per company (more API calls)

#### What if the company is private or doesn't exist?

The actor returns a clean diagnostic record and continues with the next company — never crashes mid-batch.

#### Can I integrate with Zapier / Make / n8n / HubSpot?

Yes — Apify integrates natively with all of them, plus Salesforce, Airtable, Google Sheets, and any webhook-compatible tool.

#### Can AI agents pay for and run this actor?

Yes — Agent Payments (x402 / USDC) are enabled.

### Legal & compliance

- Extracts **publicly available** data only — no logins, no access-control bypass, no private content
- You are responsible for complying with LinkedIn's Terms of Service, GDPR (EU), CCPA (California), and other applicable laws
- Personal data returned (employee counts, names in similar-company lists) may require a lawful basis (legitimate interest, consent) before outbound use
- This actor is **not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.** "LinkedIn" is a registered trademark of LinkedIn Corporation

### Changelog

#### v1.0.0 — 2026-05-17

- Initial release
- Cookieless architecture — zero account-ban risk
- **4 record types** in one actor: `company` (41 fields), `companyPost` (23 fields), `companyJob` (13 fields), `companyEmployeeGroup` (9 fields)
- Up to 500 posts, 1,000 jobs, and 7 employee demographic groups per company
- Multi-company batch with dedup by universal name slug
- Native Apify integrations + Agent Payments (x402 / USDC)
- **13/13 tests passed** across 3 tiers (correctness, toggle combinations, batch + dedup)

### Support

Questions, feature requests, or bug reports? Open an issue on the actor's **Issues** tab. We respond within 24 hours.

**Like this actor? Leave a review on the Apify Store — it helps other LinkedIn data teams find it.**

# Actor input Schema

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

LinkedIn company page URLs. Example: \["https://www.linkedin.com/company/microsoft/"]

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

Alternative to URLs: pass just the universal-name slugs (the part after /company/ in a LinkedIn URL). Example: \["microsoft", "google"]

## `includePosts` (type: `boolean`):

Scrape recent company posts. Each post is one extra `companyPost` record (billed at the same per-record rate).

## `maxPostsPerCompany` (type: `integer`):

Cap on company posts per company (when includePosts=true).

## `includeJobs` (type: `boolean`):

Scrape current open job listings. Each job is one extra `companyJob` record (billed at the same per-record rate).

## `maxJobsPerCompany` (type: `integer`):

Cap on jobs per company (when includeJobs=true).

## `includeEmployees` (type: `boolean`):

Adds 7 `companyEmployeeGroup` records per company with employee distribution by Location, School, Function, Skill, Service Category, Field of Study, Current Company. Each group billed at the same per-record rate.

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

Apify proxy settings. Residential proxies are recommended.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/"
  ],
  "includePosts": false,
  "maxPostsPerCompany": 10,
  "includeJobs": false,
  "maxJobsPerCompany": 50,
  "includeEmployees": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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/microsoft/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-company-scraper-no-cookies-5-1k").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/microsoft/"] }

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-company-scraper-no-cookies-5-1k").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/microsoft/"
  ]
}' |
apify call linkedintel/linkedin-company-scraper-no-cookies-5-1k --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Scraper · No Cookies · $5/1k ✅",
        "description": "LinkedIn company scraper with full firmographics. 41 fields per company plus optional posts, jobs, employee demographics. No login. $5/1k pay-per-result.",
        "version": "1.0",
        "x-build-id": "AAkWKAQmnL5Y8WNTJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-company-scraper-no-cookies-5-1k/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-company-scraper-no-cookies-5-1k",
                "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/linkedintel~linkedin-company-scraper-no-cookies-5-1k/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-company-scraper-no-cookies-5-1k",
                "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/linkedintel~linkedin-company-scraper-no-cookies-5-1k/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-company-scraper-no-cookies-5-1k",
                "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": {
                    "companyUrls": {
                        "title": "Company URLs",
                        "type": "array",
                        "description": "LinkedIn company page URLs. Example: [\"https://www.linkedin.com/company/microsoft/\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Company universal names",
                        "type": "array",
                        "description": "Alternative to URLs: pass just the universal-name slugs (the part after /company/ in a LinkedIn URL). Example: [\"microsoft\", \"google\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePosts": {
                        "title": "Include recent posts",
                        "type": "boolean",
                        "description": "Scrape recent company posts. Each post is one extra `companyPost` record (billed at the same per-record rate).",
                        "default": false
                    },
                    "maxPostsPerCompany": {
                        "title": "Max posts per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on company posts per company (when includePosts=true).",
                        "default": 10
                    },
                    "includeJobs": {
                        "title": "Include open jobs",
                        "type": "boolean",
                        "description": "Scrape current open job listings. Each job is one extra `companyJob` record (billed at the same per-record rate).",
                        "default": false
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on jobs per company (when includeJobs=true).",
                        "default": 50
                    },
                    "includeEmployees": {
                        "title": "Include employee demographic groups",
                        "type": "boolean",
                        "description": "Adds 7 `companyEmployeeGroup` records per company with employee distribution by Location, School, Function, Skill, Service Category, Field of Study, Current Company. Each group billed at the same per-record rate.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are recommended.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
