# LinkedIn Schools Alumni Scraper (`crawlerbros/linkedin-schools-alumni-scraper`) Actor

Find alumni from any university or school on LinkedIn. Enter a school name or LinkedIn school URL to get alumni profiles with name, headline, current company, location, and more.

- **URL**: https://apify.com/crawlerbros/linkedin-schools-alumni-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Jobs
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Schools Alumni Scraper

Find alumni from any university or school on LinkedIn. Enter a school name or LinkedIn school URL and get alumni profiles with name, headline, location, connection degree, and profile picture.

### What it does

This actor uses LinkedIn's authenticated Voyager API to search for alumni of specific schools. It resolves school names or URLs to LinkedIn's internal school IDs, then uses the `currentSchool` search filter to retrieve matching alumni profiles.

### Why use it?

- **Recruitment**: Find graduates from specific universities for targeted outreach
- **Research**: Map alumni networks and career paths from top schools
- **Lead generation**: Identify alumni of schools matching your customer profile
- **Networking**: Find fellow alumni from your own school

---

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `schoolUrls` | array | One of these required | LinkedIn school page URLs, e.g. `https://www.linkedin.com/school/mit/` |
| `schoolNames` | array | One of these required | Plain school names, e.g. `"MIT"`, `"Harvard University"` |
| `cookie` | string | Yes | LinkedIn session cookie (li_at value or full JSON array) |
| `maxAlumniPerSchool` | integer | No | Max alumni per school. Default: 100, Max: 1000 |
| `fieldOfStudy` | string | No | Filter by field of study, e.g. `"Computer Science"`, `"MBA"` |
| `graduationYear` | string | No | Filter by graduation year, e.g. `"2020"` |
| `connectionDegree` | string | No | Filter by connection: `F` (1st), `S` (2nd), `O` (3rd+) |
| `proxyConfiguration` | object | No | Apify proxy configuration |

#### Getting your LinkedIn cookie

1. Log in to LinkedIn in your browser
2. Open Developer Tools (F12) → Application → Cookies → linkedin.com
3. Copy the value of `li_at`

Or use a browser extension like **Cookie-Editor** or **EditThisCookie** to export all cookies as a JSON array and paste the full JSON into the cookie field.

#### Example input

```json
{
  "schoolUrls": ["https://www.linkedin.com/school/mit/"],
  "cookie": "AQEDATVc5uM...",
  "maxAlumniPerSchool": 100,
  "fieldOfStudy": "Computer Science"
}
````

***

### Output

Each alumni profile is stored as one record in the dataset.

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Alumni's full name |
| `profileUrl` | string | LinkedIn profile URL |
| `headline` | string | Profile headline (job title / company) |
| `location` | string | Location shown on LinkedIn |
| `connectionDegree` | string | Connection degree: 1st, 2nd, 3rd+ |
| `profilePicture` | string | Profile photo CDN URL |
| `schoolName` | string | School that produced this result |
| `schoolUrl` | string | LinkedIn school page URL |
| `scrapedAt` | string | ISO 8601 UTC timestamp |

#### Example output record

```json
{
  "name": "Jane Doe",
  "profileUrl": "https://www.linkedin.com/in/janedoe/",
  "headline": "Software Engineer at Google",
  "location": "San Francisco Bay Area",
  "connectionDegree": "2nd",
  "profilePicture": "https://media.licdn.com/dms/image/...",
  "schoolName": "Massachusetts Institute of Technology",
  "schoolUrl": "https://www.linkedin.com/school/mit/",
  "scrapedAt": "2026-06-12T10:00:00+00:00"
}
```

***

### Notes on LinkedIn's limits

LinkedIn limits the number of search results visible per session. Typically:

- Up to **1,000 alumni** are surfaced per school depending on your LinkedIn plan
- Results depend on your network connections and LinkedIn's privacy settings
- Alumni who have set their profile to private will not appear

### Frequently Asked Questions

**Do I need a LinkedIn Premium account?**
No — a standard LinkedIn account works. However, Premium accounts may see more results.

**Why do I need to provide a cookie?**
LinkedIn's alumni search is only accessible to authenticated users. The cookie identifies your LinkedIn session and allows the actor to make authenticated API requests on your behalf.

**Is the cookie safe to provide?**
The cookie is marked as `isSecret` and is not stored in run logs. However, sharing your session cookie gives the actor full access to your LinkedIn session. Use a dedicated LinkedIn account if you are concerned.

**How many alumni can I scrape?**
LinkedIn surfaces between 200 and 1,000 alumni per school for most queries. Setting `maxAlumniPerSchool` higher than LinkedIn's visible limit will simply return all available results.

**Can I filter by graduation year?**
Yes — use the `graduationYear` field (e.g. `"2020"`). This adds the year as a keyword to the search, which LinkedIn uses to filter results.

**Can I scrape multiple schools at once?**
Yes — provide multiple URLs in `schoolUrls` and/or multiple names in `schoolNames`. Each school is scraped sequentially.

**Why are some fields missing from certain profiles?**
LinkedIn only returns fields that are publicly visible or visible to your network tier. Profiles with privacy settings may not expose headline, location, or profile picture.

**What happens if a school name cannot be resolved?**
The actor will attempt to look up the school ID using LinkedIn's typeahead API. If the ID cannot be found, it will still search using the school name as a keyword, which may return fewer or less precise results.

**Can I use a proxy?**
Yes — configure the `proxyConfiguration` field. Residential proxies are recommended for best results when scraping at scale.

### Explore the rest of the LinkedIn suite

Need a different LinkedIn surface? Pair this actor with any of the others in the LinkedIn Suite — all published under the same publisher and built to share the same cookie format and output conventions.

| Actor | What it scrapes |
|---|---|
| [LinkedIn Comments Scraper](https://apify.com/crawlerbros/linkedin-comments-scraper) | All comments + reply threads on a post |
| [LinkedIn Company Employees Scraper](https://apify.com/crawlerbros/linkedin-company-employees-scraper) | Employee list for any company (by URN) |
| [LinkedIn Company Info Scraper](https://apify.com/crawlerbros/linkedin-company-info-scraper) | Company About page (size, HQ, industry, specialties) |
| [LinkedIn Company Posts Scraper](https://apify.com/crawlerbros/linkedin-company-posts-scraper) | Posts published from a company page |
| [LinkedIn Events Scraper](https://apify.com/crawlerbros/linkedin-events-scraper) | Events by keyword/URL with full event detail |
| [LinkedIn Hashtag Posts Scraper](https://apify.com/crawlerbros/linkedin-hashtag-posts-scraper) | Posts ranked under a `#hashtag` |
| [LinkedIn Jobs Scraper](https://apify.com/crawlerbros/linkedin-jobs-scraper) | Job listings via the public jobs-guest API |
| [LinkedIn Jobs Scraper Ultra](https://apify.com/crawlerbros/linkedin-jobs-scraper-ultra) | Same as jobs-scraper + full detail enrichment |
| [LinkedIn Learning Courses Scraper](https://apify.com/crawlerbros/linkedin-learning-courses-scraper) | LinkedIn Learning course catalog by keyword |
| [LinkedIn People Search Scraper](https://apify.com/crawlerbros/linkedin-people-search-scraper) | People search with every LinkedIn facet (role, company, school, location, etc.) |
| [LinkedIn Post Reactions Scraper](https://apify.com/crawlerbros/linkedin-post-reactions-scraper) | Reactors on a post (name, headline, reaction type) |
| [LinkedIn Post Scraper](https://apify.com/crawlerbros/linkedin-post-scraper) | Full post (text, media, engagement counts, author) |
| [LinkedIn Post Search Scraper](https://apify.com/crawlerbros/linkedin-post-search-scraper) | Posts matching a keyword (with date/author/network filters) |
| [LinkedIn Profile Posts Scraper](https://apify.com/crawlerbros/linkedin-profile-posts-scraper) | All posts/reposts/articles for one profile |
| [LinkedIn Profile Scraper](https://apify.com/crawlerbros/linkedin-profile-scraper) | Public profile fields (name, headline, positions, education, skills) |
| [LinkedIn Profile Scraper Pro](https://apify.com/crawlerbros/linkedin-profile-scraper-pro) | Profile fields + extras (recommendations, organizations, languages) |
| [LinkedIn Profile Scraper Pro Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-pro-ultra) | Pro + premium fields (contact info, followers list when allowed) |
| [LinkedIn Profile Scraper Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-ultra) | Profile + the full upstream dash-120 surface |
| [LinkedIn Profile Search by Name](https://apify.com/crawlerbros/linkedin-profile-search-by-name) | Search profiles by person name (great for matching CSVs of names) |
| [LinkedIn Top Content Scraper](https://apify.com/crawlerbros/linkedin-top-content-scraper) | Trending / top-engagement posts by topic |
| [LinkedIn User Activity Scraper](https://apify.com/crawlerbros/linkedin-user-activity-scraper) | Reactions + comments + posts feed for one profile |

All actors share the same `cookie` input format (plain `li_at` OR full cookies JSON array) and the same omit-empty output convention.

# Actor input Schema

## `schoolUrls` (type: `array`):

LinkedIn school page URLs. Example: https://www.linkedin.com/school/mit/ or https://www.linkedin.com/school/harvard-university/

## `schoolNames` (type: `array`):

Plain school or university names when you don't have the LinkedIn URL. Example: 'MIT', 'Harvard University', 'Stanford University'.

## `cookie` (type: `string`):

Your LinkedIn session cookie. Accepts: (1) the li\_at value from browser DevTools → Application → Cookies, or (2) a full cookie JSON array exported from a browser extension such as EditThisCookie or Cookie-Editor.

## `maxAlumniPerSchool` (type: `integer`):

Maximum number of alumni profiles to scrape per school. LinkedIn surfaces alumni visible to your session.

## `fieldOfStudy` (type: `string`):

Optional keyword to narrow alumni results by field of study or specialization. Example: 'Computer Science', 'MBA', 'Engineering'.

## `graduationYear` (type: `string`):

Optional graduation year filter. Example: '2020', '2015'. Used as a keyword in the search.

## `graduationYearRange` (type: `object`):

Optional graduation year range with start and end (inclusive).

## `field` (type: `string`):

Field of study (e.g. 'Computer Science', 'Economics', 'Marketing').

## `degree` (type: `string`):

Degree filter.

## `currentLocation` (type: `string`):

Filter to alumni whose current location matches this text.

## `currentCompany` (type: `string`):

Filter to alumni currently working at this company.

## `language` (type: `string`):

Preferred LinkedIn locale.

## `connectionDegree` (type: `string`):

Filter alumni by LinkedIn connection degree: F = 1st degree, S = 2nd degree, O = 3rd degree+. Leave blank to include all.

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

Optional Apify proxy configuration. Residential proxy is recommended for best reliability.

## Actor input object example

```json
{
  "schoolUrls": [
    "https://www.linkedin.com/school/mit/"
  ],
  "schoolNames": [
    "MIT"
  ],
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
  "maxAlumniPerSchool": 100,
  "graduationYearRange": {
    "start": 2015,
    "end": 2024
  },
  "degree": "",
  "language": "en_US",
  "connectionDegree": ""
}
```

# 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 = {
    "schoolUrls": [
        "https://www.linkedin.com/school/mit/"
    ],
    "schoolNames": [
        "MIT"
    ],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
    "graduationYearRange": {
        "start": 2015,
        "end": 2024
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/linkedin-schools-alumni-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 = {
    "schoolUrls": ["https://www.linkedin.com/school/mit/"],
    "schoolNames": ["MIT"],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
    "graduationYearRange": {
        "start": 2015,
        "end": 2024,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/linkedin-schools-alumni-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 '{
  "schoolUrls": [
    "https://www.linkedin.com/school/mit/"
  ],
  "schoolNames": [
    "MIT"
  ],
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
  "graduationYearRange": {
    "start": 2015,
    "end": 2024
  }
}' |
apify call crawlerbros/linkedin-schools-alumni-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Schools Alumni Scraper",
        "description": "Find alumni from any university or school on LinkedIn. Enter a school name or LinkedIn school URL to get alumni profiles with name, headline, current company, location, and more.",
        "version": "0.39",
        "x-build-id": "iLfYWaNOY0ACftuGG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~linkedin-schools-alumni-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-linkedin-schools-alumni-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/crawlerbros~linkedin-schools-alumni-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-linkedin-schools-alumni-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/crawlerbros~linkedin-schools-alumni-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-linkedin-schools-alumni-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",
                "properties": {
                    "schoolUrls": {
                        "title": "School URLs",
                        "type": "array",
                        "description": "LinkedIn school page URLs. Example: https://www.linkedin.com/school/mit/ or https://www.linkedin.com/school/harvard-university/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "schoolNames": {
                        "title": "School Names",
                        "type": "array",
                        "description": "Plain school or university names when you don't have the LinkedIn URL. Example: 'MIT', 'Harvard University', 'Stanford University'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cookie": {
                        "title": "LinkedIn Cookie",
                        "type": "string",
                        "description": "Your LinkedIn session cookie. Accepts: (1) the li_at value from browser DevTools → Application → Cookies, or (2) a full cookie JSON array exported from a browser extension such as EditThisCookie or Cookie-Editor."
                    },
                    "maxAlumniPerSchool": {
                        "title": "Max Alumni Per School",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of alumni profiles to scrape per school. LinkedIn surfaces alumni visible to your session.",
                        "default": 100
                    },
                    "fieldOfStudy": {
                        "title": "Field of Study / Keywords",
                        "type": "string",
                        "description": "Optional keyword to narrow alumni results by field of study or specialization. Example: 'Computer Science', 'MBA', 'Engineering'."
                    },
                    "graduationYear": {
                        "title": "Graduation Year",
                        "type": "string",
                        "description": "Optional graduation year filter. Example: '2020', '2015'. Used as a keyword in the search."
                    },
                    "graduationYearRange": {
                        "title": "Graduation Year Range",
                        "type": "object",
                        "description": "Optional graduation year range with start and end (inclusive)."
                    },
                    "field": {
                        "title": "Field of Study",
                        "type": "string",
                        "description": "Field of study (e.g. 'Computer Science', 'Economics', 'Marketing')."
                    },
                    "degree": {
                        "title": "Degree",
                        "enum": [
                            "",
                            "Bachelor",
                            "Master",
                            "PhD",
                            "MBA",
                            "Associate",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Degree filter.",
                        "default": ""
                    },
                    "currentLocation": {
                        "title": "Current Location",
                        "type": "string",
                        "description": "Filter to alumni whose current location matches this text."
                    },
                    "currentCompany": {
                        "title": "Current Company",
                        "type": "string",
                        "description": "Filter to alumni currently working at this company."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en_US",
                            "en_GB",
                            "es_ES",
                            "fr_FR",
                            "de_DE",
                            "pt_BR",
                            "it_IT",
                            "nl_NL",
                            "ja_JP",
                            "zh_CN"
                        ],
                        "type": "string",
                        "description": "Preferred LinkedIn locale.",
                        "default": "en_US"
                    },
                    "connectionDegree": {
                        "title": "Connection Degree",
                        "enum": [
                            "",
                            "F",
                            "S",
                            "O"
                        ],
                        "type": "string",
                        "description": "Filter alumni by LinkedIn connection degree: F = 1st degree, S = 2nd degree, O = 3rd degree+. Leave blank to include all.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Residential proxy is recommended for best reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
