# LinkedIn Jobs Search Scraper (`jobsapi/linkedin-jobs-search-scraper`) Actor

Scrape job listings from LinkedIn Jobs. Extract job titles, companies, locations, salary ranges, seniority levels, employment types, and application insights from the world's largest professional network.

- **URL**: https://apify.com/jobsapi/linkedin-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Jobs Search Scraper

The latest and most advanced LinkedIn Jobs Search Scraper. Our LinkedIn Jobs Search Scraper extracts real-time job postings at scale from all over the world. A new research tool built for recruitment, insights and HR.

### Features

- **Keyword search** — find jobs by keyword, search term, or role
- **Location filtering** — narrow results to specific cities, regions, or countries

### Use Cases

- **Professional talent sourcing and recruitment analytics** — search and filter candidates by role, location, experience level, and remote preference
- **Skills gap analysis across industries** — analyze job descriptions to identify in-demand skills and emerging technology requirements
- **Competitive intelligence on company hiring strategies** — monitor hiring volume, role types, and seniority distribution for target companies
- **Labor market trend research at scale** — track employment types, salary ranges, and remote-work adoption across global markets

### Sample Input

```json
{
  "keywords": "software engineer",
  "location": "United States",
  "maxJobs": 50,
  "datePosted": "anyTime",
  "jobType": "",
  "experienceLevel": "",
  "remoteFilter": "",
  "scrapeJobDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "scrapeCompany": true,
  "count": 100,
  "splitByLocation": false
}
````

### Sample Output

```json
{
  "jobTitle": "Senior Software Engineer",
  "companyName": "Google",
  "location": "Mountain View, CA",
  "postedDate": "2025-06-15T00:00:00.000Z",
  "jobUrl": "https://www.linkedin.com/jobs/view/123456",
  "description": "Google is looking for a Senior Software Engineer to join our Cloud team...",
  "searchQuery": "software engineer",
  "searchLocation": "United States",
  "scrapedAt": "2025-06-16T07:45:00.000Z"
}
```

### Input

| Field | Type | Default | Required | Description |
|-------|------|---------|----------|-------------|
| `keywords` | string | - | ✓ | Job search keywords (e.g. 'software engineer', 'product manager', 'data scientist'). |
| `location` | string | `United States` |  | Job location (e.g. 'United States', 'San Francisco, CA', 'Remote', 'India'). |
| `maxJobs` | integer | `50` |  | Maximum number of job listings to scrape. |
| `datePosted` | string | `anyTime` |  | Filter by how recently the job was posted. |
| `jobType` | string | ``|  | Filter by employment type. |
| `experienceLevel` | string |`` |  | Filter by required experience level. |
| `remoteFilter` | string | \`\` |  | Filter by work location type. |
| `scrapeJobDetails` | boolean | `true` |  | Visit each job page to extract full description, requirements, salary, and more. |
| `proxyConfiguration` | object | - |  | Proxy settings. Residential proxies strongly recommended for LinkedIn. |
| `urls` | array | - |  | Go to linkedin jobs search page on incognito window (to access public version), search with required filters and once you are done, copy the full URL from address bar and pass it here. |
| `scrapeCompany` | boolean | `true` |  | This will require additional scraping requests for each job record and take longer to scrape |
| `count` | integer | - |  | Limit number of jobs scraped |
| `splitByLocation` | boolean | `false` |  | Enable this to split your search by cities within a country. This helps bypass LinkedIn's 1000 job limit per search URL by creating separate searches for each city. |
| `splitCountry` | string | - |  | Select the country whose cities will be used to split the search. Only used when 'Split search by city locations' is enabled. |
| `salaryMin` | integer | — |  | Minimum salary filter (in local currency). Only show jobs paying at least this amount. |
| `salaryMax` | integer | — |  | Maximum salary filter (in local currency). Only show jobs paying at most this amount. |
| `educationLevel` | string | — |  | Filter by minimum education level: High School, Associate Degree, Bachelor's, Master's, Doctorate. |

### Output

| Field | Description |
|-------|-------------|
| `jobId` | Job ID |
| `jobTitle` | Job Title |
| `company` | Company |
| `companyUrl` | Company URL |
| `companyLogo` | Company Logo |
| `location` | Location |
| `isRemote` | Remote |
| `postedDate` | Posted |
| `applicantCount` | Applicants |
| `jobUrl` | Job URL |
| `employmentType` | Type |
| `seniorityLevel` | Level |
| `industry` | Industry |
| `jobFunction` | Function |
| `description` | Description |
| `skills` | Skills |
| `searchKeywords` | Query |
| `searchLocation` | Search Location |
| `scrapedAt` | Scraped At |
| `salary` | Salary |
| `jobType` | Job Type |

### Notes

- **Proxy**: Residential proxy is highly recommended — set `proxyConfiguration: { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }`
- **Rate limits**: Keep result limits reasonable per run to avoid IP bans
- **Scheduling**: Use Apify Scheduler to run this actor on a recurring basis for a consistently fresh dataset

# Actor input Schema

## `keywords` (type: `string`):

Job search keywords (e.g. 'software engineer', 'product manager', 'data scientist').

## `location` (type: `string`):

Job location (e.g. 'United States', 'San Francisco, CA', 'Remote', 'India').

## `maxJobs` (type: `integer`):

Maximum number of job listings to scrape.

## `datePosted` (type: `string`):

Filter by how recently the job was posted.

## `jobType` (type: `string`):

Filter by employment type.

## `experienceLevel` (type: `string`):

Filter by required experience level.

## `remoteFilter` (type: `string`):

Filter by work location type.

## `scrapeJobDetails` (type: `boolean`):

Visit each job page to extract full description, requirements, salary, and more. Slower but much more data.

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

Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.

## `urls` (type: `array`):

Go to [linkedin jobs search page](https://www.linkedin.com/jobs/search/) on incognito window (to access public version), search with required filters and once you are done, copy the full URL from address bar and pass it here. You can pass multiple search URLs

## `scrapeCompany` (type: `boolean`):

This will require additional scraping requests for each job record and take longer to scrape

## `count` (type: `integer`):

Limit number of jobs scraped

## `splitByLocation` (type: `boolean`):

Enable this to split your search by cities within a country. This helps bypass LinkedIn's 1000 job limit per search URL by creating separate searches for each city. This will overwrite the location filter in input search URLs.

## `splitCountry` (type: `string`):

Select the country whose cities will be used to split the search. Only used when 'Split search by city locations' is enabled. Required to when 'Split search by city locations' is enabled.

## `salaryMin` (type: `integer`):

Minimum salary filter (in local currency). Only show jobs paying at least this amount.

## `salaryMax` (type: `integer`):

Maximum salary filter (in local currency). Only show jobs paying at most this amount.

## `educationLevel` (type: `string`):

Filter by minimum education level required.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "location": "United States",
  "maxJobs": 50,
  "datePosted": "anyTime",
  "jobType": "",
  "experienceLevel": "",
  "remoteFilter": "",
  "scrapeJobDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "urls": [
    "https://www.linkedin.com/jobs/search/?position=1&pageNum=0"
  ],
  "scrapeCompany": true,
  "count": 100,
  "splitByLocation": false,
  "educationLevel": ""
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": "software engineer",
    "location": "United States",
    "maxJobs": 50,
    "scrapeJobDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    },
    "urls": [
        "https://www.linkedin.com/jobs/search/?position=1&pageNum=0"
    ],
    "count": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/linkedin-jobs-search-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 = {
    "keywords": "software engineer",
    "location": "United States",
    "maxJobs": 50,
    "scrapeJobDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
    "urls": ["https://www.linkedin.com/jobs/search/?position=1&pageNum=0"],
    "count": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/linkedin-jobs-search-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 '{
  "keywords": "software engineer",
  "location": "United States",
  "maxJobs": 50,
  "scrapeJobDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "urls": [
    "https://www.linkedin.com/jobs/search/?position=1&pageNum=0"
  ],
  "count": 100
}' |
apify call jobsapi/linkedin-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Search Scraper",
        "description": "Scrape job listings from LinkedIn Jobs. Extract job titles, companies, locations, salary ranges, seniority levels, employment types, and application insights from the world's largest professional network.",
        "version": "0.0",
        "x-build-id": "8hhb2bpjQHQvZ9DDi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jobsapi~linkedin-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jobsapi-linkedin-jobs-search-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/jobsapi~linkedin-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jobsapi-linkedin-jobs-search-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/jobsapi~linkedin-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jobsapi-linkedin-jobs-search-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job Keywords",
                        "type": "string",
                        "description": "Job search keywords (e.g. 'software engineer', 'product manager', 'data scientist')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Job location (e.g. 'United States', 'San Francisco, CA', 'Remote', 'India').",
                        "default": "United States"
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape.",
                        "default": 50
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "anyTime",
                            "pastMonth",
                            "pastWeek",
                            "past24Hours"
                        ],
                        "type": "string",
                        "description": "Filter by how recently the job was posted.",
                        "default": "anyTime"
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "F",
                            "P",
                            "C",
                            "T",
                            "I",
                            "V",
                            "O"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6"
                        ],
                        "type": "string",
                        "description": "Filter by required experience level.",
                        "default": ""
                    },
                    "remoteFilter": {
                        "title": "Remote / On-site",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "Filter by work location type.",
                        "default": ""
                    },
                    "scrapeJobDetails": {
                        "title": "Scrape Full Job Details",
                        "type": "boolean",
                        "description": "Visit each job page to extract full description, requirements, salary, and more. Slower but much more data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    },
                    "urls": {
                        "title": "Linkedin jobs search URLs",
                        "type": "array",
                        "description": "Go to [linkedin jobs search page](https://www.linkedin.com/jobs/search/) on incognito window (to access public version), search with required filters and once you are done, copy the full URL from address bar and pass it here. You can pass multiple search URLs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeCompany": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "This will require additional scraping requests for each job record and take longer to scrape",
                        "default": true
                    },
                    "count": {
                        "title": "Number of jobs needed",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Limit number of jobs scraped"
                    },
                    "splitByLocation": {
                        "title": "Split search by city locations",
                        "type": "boolean",
                        "description": "Enable this to split your search by cities within a country. This helps bypass LinkedIn's 1000 job limit per search URL by creating separate searches for each city. This will overwrite the location filter in input search URLs.",
                        "default": false
                    },
                    "splitCountry": {
                        "title": "Country to split by",
                        "enum": [
                            "US",
                            "CA",
                            "MX",
                            "GB",
                            "DE",
                            "FR",
                            "NL",
                            "CH",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "IE",
                            "ES",
                            "IT",
                            "PT",
                            "BE",
                            "AT",
                            "PL",
                            "CZ",
                            "RO",
                            "HU",
                            "GR",
                            "BG",
                            "HR",
                            "RS",
                            "UA",
                            "SK",
                            "LT",
                            "LV",
                            "EE",
                            "SI",
                            "LU",
                            "MT",
                            "IS",
                            "CY",
                            "TR",
                            "RU",
                            "GE",
                            "AM",
                            "AZ",
                            "BY",
                            "BA",
                            "XK",
                            "MD",
                            "ME",
                            "MK",
                            "AL",
                            "MC",
                            "AD",
                            "LI",
                            "SM",
                            "VA",
                            "IN",
                            "CN",
                            "JP",
                            "KR",
                            "SG",
                            "HK",
                            "TW",
                            "TH",
                            "VN",
                            "ID",
                            "MY",
                            "PH",
                            "BD",
                            "PK",
                            "LK",
                            "NP",
                            "MM",
                            "KH",
                            "KZ",
                            "UZ",
                            "KG",
                            "TJ",
                            "TM",
                            "MN",
                            "BN",
                            "MV",
                            "BT",
                            "LA",
                            "TL",
                            "AF",
                            "KP",
                            "AE",
                            "SA",
                            "IL",
                            "QA",
                            "KW",
                            "BH",
                            "OM",
                            "JO",
                            "LB",
                            "IQ",
                            "IR",
                            "PS",
                            "SY",
                            "YE",
                            "AU",
                            "NZ",
                            "FJ",
                            "PG",
                            "WS",
                            "TO",
                            "VU",
                            "SB",
                            "KI",
                            "MH",
                            "FM",
                            "PW",
                            "NR",
                            "TV",
                            "BR",
                            "AR",
                            "CO",
                            "CL",
                            "PE",
                            "EC",
                            "UY",
                            "VE",
                            "BO",
                            "PY",
                            "GY",
                            "SR",
                            "CR",
                            "PA",
                            "GT",
                            "DO",
                            "PR",
                            "JM",
                            "TT",
                            "HN",
                            "SV",
                            "NI",
                            "BS",
                            "BB",
                            "CU",
                            "HT",
                            "BZ",
                            "AG",
                            "DM",
                            "GD",
                            "LC",
                            "KN",
                            "VC",
                            "ZA",
                            "NG",
                            "KE",
                            "EG",
                            "MA",
                            "GH",
                            "ET",
                            "TZ",
                            "RW",
                            "UG",
                            "SN",
                            "TN",
                            "CI",
                            "CM",
                            "DZ",
                            "AO",
                            "MU",
                            "ZM",
                            "ZW",
                            "MZ",
                            "CD",
                            "BW",
                            "NA",
                            "MG",
                            "LY",
                            "SD",
                            "SS",
                            "SO",
                            "ML",
                            "GA",
                            "BJ",
                            "BF",
                            "MW",
                            "NE",
                            "TD",
                            "SL",
                            "LR",
                            "ER",
                            "GM",
                            "GN",
                            "GW",
                            "TG",
                            "MR",
                            "SZ",
                            "LS",
                            "DJ",
                            "CG",
                            "CF",
                            "BI",
                            "CV",
                            "KM",
                            "GQ",
                            "ST",
                            "SC"
                        ],
                        "type": "string",
                        "description": "Select the country whose cities will be used to split the search. Only used when 'Split search by city locations' is enabled. Required to when 'Split search by city locations' is enabled."
                    },
                    "salaryMin": {
                        "title": "Minimum Salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum salary filter (in local currency). Only show jobs paying at least this amount."
                    },
                    "salaryMax": {
                        "title": "Maximum Salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum salary filter (in local currency). Only show jobs paying at most this amount."
                    },
                    "educationLevel": {
                        "title": "Education Level",
                        "enum": [
                            "",
                            "high_school",
                            "associate",
                            "bachelor",
                            "master",
                            "doctorate"
                        ],
                        "type": "string",
                        "description": "Filter by minimum education level required.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
