# LinkedIn Jobs API | Search Job Listings & Salaries (`johnvc/linkedin-jobs-api`) Actor

Search public LinkedIn job listings as clean, structured JSON. Find jobs by keyword, location, seniority, and job type, or fetch specific job URLs. Get title, company, location, salary, description, and apply links. Pay per job, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/linkedin-jobs-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 💼 LinkedIn Jobs API | Search Job Listings & Salaries

The **LinkedIn Jobs API** turns public [LinkedIn](https://www.linkedin.com) job listings into clean, structured JSON. Use this actor with Claude, Cursor, or any MCP-compatible AI agent to find jobs by keyword, location, seniority, and job type, and get title, company, salary, description, and apply links, on reliable infrastructure and billed per job.

Run a keyword-and-location search, or fetch specific job posting URLs directly. It works as a straightforward **LinkedIn jobs scraper** for recruiting, market and salary research, and lead generation, and it is built API-first and MCP-ready so AI agents can call it as a tool.

---

### 📋 What this API returns

| Field | Description |
|---|---|
| `jobUrl`, `jobId` | The job posting's public URL and identifier. |
| `title` | The job title. |
| `companyName`, `companyUrl`, `companyLogo` | The hiring company. |
| `location`, `countryCode` | Where the job is based. |
| `description` | The full job description text. |
| `seniorityLevel`, `employmentType`, `jobFunction` | Role level, type, and function. |
| `industries` | Industries associated with the role. |
| `salary` | The listed pay range or base salary, when present. |
| `postedDate`, `numApplicants` | When it was posted and how many have applied. |
| `applyUrl` | The direct application link, when available. |
| `jobPoster` | The recruiter / person who posted the job, when available. |
| `summary` | A plain-language one-line interpretation of the job. |

---

### 🎯 Use cases

- **Recruiting & sourcing.** Track open roles at target companies by keyword and location.
- **Market & salary research.** Analyze demand, seniority mix, and pay ranges across a role or region.
- **Lead generation.** Companies that are hiring are buying, find them by search and reach out.
- **Job aggregators.** Feed fresh, structured LinkedIn listings into a job board or newsletter.
- **Competitive hiring intelligence.** Watch which teams a competitor is building out.
- **AI agent workflows.** Drive this API over MCP from Claude to search and summarize jobs in-conversation.

---

### 🔁 Use it as a LinkedIn jobs scraper at scale

Point this LinkedIn jobs scraper at a role and a location and it returns one clean row per listing, with the same flat, predictable fields every time, which is what makes the output easy to load into a sheet, a database, or an ATS. Cap each search with `maxJobs` so a broad query never overshoots your budget, and narrow it with the seniority, job type, remote, and date filters to get exactly the roles you want.

The output doubles as **recruitment data** and **hiring signals**: which companies are staffing up, which teams they are building, and what they pay. If a search returns nothing, you get a clear error row for that search instead of a failed run, so one empty query never sinks the batch. Whether you run LinkedIn jobs scraping once or across thousands of listings, the shape of the data stays the same.

---

### ⚙️ Input examples

#### Search by keyword and location

```json
{
  "keyword": "python developer",
  "location": "New York",
  "maxJobs": 25
}
````

#### Search with filters

```json
{
  "keyword": "product manager",
  "location": "London",
  "experienceLevel": "mid-senior",
  "jobType": "full-time",
  "remote": true,
  "timeRange": "past-week",
  "maxJobs": 50
}
```

#### Fetch specific jobs by URL

```json
{
  "jobUrls": [
    "https://www.linkedin.com/jobs/view/4286961888"
  ]
}
```

`maxJobs` caps how many jobs are returned per search, so you control cost. The API returns one row per job.

***

### 📤 Example output

Each job is returned as one JSON row:

```json
{
  "result_type": "job",
  "jobId": "4286961888",
  "jobUrl": "https://www.linkedin.com/jobs/view/4286961888",
  "title": "Senior Python Developer",
  "companyName": "GlossGenius",
  "companyUrl": "https://www.linkedin.com/company/glossgenius",
  "location": "New York, NY",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering and Information Technology",
  "salary": "$150,000 - $190,000",
  "postedDate": "2026-06-20",
  "numApplicants": 47,
  "summary": "Senior Python Developer, at GlossGenius, New York, NY, Full-time, $150,000 - $190,000"
}
```

***

### 💰 Pricing (pay-per-event)

You pay per job returned. There is no per-run setup fee. The current per-event price is shown on the Store card and in the Actor's Monetization details. Because billing is per job, you only pay for the jobs actually delivered, and `maxJobs` lets you cap the volume of each search.

***

### 🔌 Use the LinkedIn Jobs API from Claude (MCP)

This Actor is MCP-server-compatible, so [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), Claude (desktop and web), Cursor, and other MCP clients can call it as a tool through Apify's hosted MCP server.

Add it with this Actor-specific URL:

`https://mcp.apify.com/?tools=actors,docs,johnvc/linkedin-jobs-api`

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

**New to Claude Code or Claude Cowork?** Start a [free trial](https://claude.ai/referral/uIlpa7nPLg).

Then ask Claude:

> *"Use the LinkedIn Jobs API to find remote senior product manager roles in the US posted this week and summarize the salary ranges."*

***

### 🔌 Integrations: run job monitoring on a schedule

This API earns its keep as a recurring step in a pipeline, not a one-off run:

- **Tasks and Schedules.** Save a keyword-and-location search as a Task, then attach a Schedule to refresh that job feed daily, weekly, or monthly with no code, so new roles land automatically.
- **n8n, Make, and Zapier.** Trigger a run on a schedule or an event, then route fresh listings into your ATS, CRM, or a Slack channel. Apify has native connectors for each.
- **Supabase, Google Sheets, and databases.** Send the dataset straight to storage with a webhook or the Apify API so the rows land where your team already works.
- **MCP.** Call the API as a tool from Claude and other AI agents (see the section above) to search and summarize jobs inside an agent workflow.
- **Webhooks.** Fire a webhook on run completion to kick off the next step in your own system, such as scoring or de-duping new roles.

***

### 🔗 Related Tools

Build a full picture of who is hiring, the companies behind the roles, and the people posting them by pairing this with the rest of the LinkedIn suite:

- [LinkedIn Company API](https://apify.com/johnvc/linkedin-company-api?fpr=9n7kx3) - firmographics and sales intelligence for the companies that are hiring.
- [LinkedIn Profile API](https://apify.com/johnvc/linkedin-profile-api?fpr=9n7kx3) - structured data on the recruiters and people behind a posting.
- [LinkedIn Posts API](https://apify.com/johnvc/linkedin-posts-api?fpr=9n7kx3) - a company's or person's public posts and engagement, for hiring signals and outreach.

Comparison point: some LinkedIn job scrapers on the Store are unmaintained or low-rated (for example [worldunboxer/rapid-linkedin-scraper](https://apify.com/worldunboxer/rapid-linkedin-scraper?fpr=9n7kx3), rated under 4 stars). This API is built for reliability, pay-per-job billing, and MCP access from AI agents.

***

### 📎 Applications

Ready-made task pages for common jobs. Open one, run it, or duplicate it as a starting point:

#### [Scrape LinkedIn Jobs to Structured JSON](https://apify.com/johnvc/linkedin-jobs-api/examples/scrape-linkedin-jobs-to-structured-json?fpr=9n7kx3)

Turn a keyword and location into clean JSON: title, company, location, salary, seniority, and apply link.

#### [Search LinkedIn Jobs by Keyword and Location](https://apify.com/johnvc/linkedin-jobs-api/examples/search-linkedin-jobs-by-keyword-and-location?fpr=9n7kx3)

Run a keyword-and-location search and get one structured row per job.

#### [LinkedIn Jobs Data API for Python](https://apify.com/johnvc/linkedin-jobs-api/examples/linkedin-jobs-data-api-for-python?fpr=9n7kx3)

Call the API from Python: a keyword and location in, structured job rows out.

#### [Scrape LinkedIn Jobs in an n8n Workflow](https://apify.com/johnvc/linkedin-jobs-api/examples/scrape-linkedin-jobs-in-an-n8n-workflow?fpr=9n7kx3)

Add job listings to an n8n workflow: pass a keyword and location, get structured rows back.

#### [Monitor Company Hiring on LinkedIn](https://apify.com/johnvc/linkedin-jobs-api/examples/monitor-company-hiring-on-linkedin?fpr=9n7kx3)

Track which roles a target company is opening by filtering on company and date.

#### [Track Remote LinkedIn Jobs by Keyword](https://apify.com/johnvc/linkedin-jobs-api/examples/track-remote-linkedin-jobs-by-keyword?fpr=9n7kx3)

Pull only remote roles posted recently, filtered by keyword, remote, and date window.

#### [Get LinkedIn Jobs in Claude via MCP](https://apify.com/johnvc/linkedin-jobs-api/examples/get-linkedin-jobs-in-claude-via-mcp?fpr=9n7kx3)

Use job search as a tool in Claude and other AI agents over MCP.

#### [Collect LinkedIn Jobs from a URL List](https://apify.com/johnvc/linkedin-jobs-api/examples/collect-linkedin-jobs-from-a-url-list?fpr=9n7kx3)

Paste up to 1000 LinkedIn job URLs and get one clean row each.

***

### 🚀 How to get started

1. Open the Actor and enter a `keyword` and `location` (or paste job URLs into `jobUrls`).
2. Set `maxJobs` to bound the volume, then run it and read the results from the dataset (JSON, CSV, Excel, or API).

[View on Apify Store](https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3)

**Example code:** [Python quick-start + MCP setup on GitHub](https://github.com/johnisanerd/Apify-LinkedIn-Jobs-API) - call the API from Python, or install it as a tool in Claude, Cursor, and ChatGPT.

***

### ❓ FAQ

#### Is this a LinkedIn Jobs API or a LinkedIn jobs scraper?

Both descriptions fit. You call it like an API (a keyword and location in, structured JSON out), and under the hood it is a LinkedIn jobs scraper that reads public job listings. You never touch scraping infrastructure; you get clean, one-row-per-job data back.

#### What input should I provide?

A `keyword` and/or `location` (plus optional filters like `experienceLevel`, `jobType`, `remote`, and `timeRange`) to search, or specific LinkedIn job URLs in `jobUrls` (e.g. `https://www.linkedin.com/jobs/view/4286961888`). Supply a keyword, a location, a company, or at least one URL.

#### How do I search for remote jobs?

Set `remote` to true and add a `keyword` and `location`. Combine it with `timeRange` (past 24 hours, past week, past month) to pull only recently posted remote roles.

#### Do you return salaries?

Yes, when LinkedIn lists a pay range or base salary for the role, it is returned in the `salary` field. This makes the output a useful source of pay-range and recruitment data across a role or region.

#### Is it legal to scrape public LinkedIn job listings?

This actor collects only public job posting data. Public-data scraping has been addressed in court cases such as [hiQ Labs v. LinkedIn](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn), but you are responsible for your own use, including [GDPR](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation) and platform terms. Consult your own counsel for your use case.

#### Can I run it from Claude or another AI agent over MCP?

Yes. The Actor is MCP-server-compatible, so [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) and other MCP clients call it as a tool. See the MCP section above for the setup URL.

#### Can I schedule it or connect it to my other apps?

Yes. Save your search as a Task and attach a Schedule for recurring runs, and connect the output to n8n, Make, Zapier, Supabase, or your own system by webhook. See the Integrations section above.

#### How many jobs do I get per search?

As many as `maxJobs` (default 25, up to 500 per search). Raise it for broader searches; each returned job is billed, so `maxJobs` is also your cost cap.

#### What if a search returns no jobs?

The API returns a clear error row for that search explaining why, so an empty search does not fail the whole run.

***

Last Updated: 2026.07.10

# Actor input Schema

## `keyword` (type: `string`):

Job title or keyword to search for, e.g. 'python developer'. Combine with Location and filters.

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

Location to search within, e.g. 'New York' or 'United Kingdom'.

## `country` (type: `string`):

Two-letter country code to scope the search, e.g. 'US', 'GB', 'DE'.

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

Employment type filter.

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

Seniority filter.

## `remote` (type: `boolean`):

Return only remote jobs.

## `company` (type: `string`):

Filter to a specific company name.

## `timeRange` (type: `string`):

Only jobs posted within this window.

## `jobUrls` (type: `array`):

One or more specific LinkedIn job posting URLs, e.g. https://www.linkedin.com/jobs/view/4286961888. Each returns one row. Use instead of, or in addition to, the keyword search above. Up to 1000 per run. Need larger batches? Contact us and we can raise this limit for your account.

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

Maximum number of jobs to return for each keyword search or search URL. Caps upstream cost. Ignored for specific job URLs.

## Actor input object example

```json
{
  "keyword": "python developer",
  "location": "New York",
  "remote": false,
  "maxJobs": 25
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: collected jobs and any error rows.

## `overview` (type: `string`):

Tabular overview of every dataset item using the dataset schema's default view. Columns: logo, title, company, location, type, salary, URL, summary.

## `compensation` (type: `string`):

Salary, seniority, applicant count, and direct apply link per job.

# 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 = {
    "keyword": "python developer",
    "location": "New York"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/linkedin-jobs-api").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 = {
    "keyword": "python developer",
    "location": "New York",
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/linkedin-jobs-api").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 '{
  "keyword": "python developer",
  "location": "New York"
}' |
apify call johnvc/linkedin-jobs-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs API | Search Job Listings & Salaries",
        "description": "Search public LinkedIn job listings as clean, structured JSON. Find jobs by keyword, location, seniority, and job type, or fetch specific job URLs. Get title, company, location, salary, description, and apply links. Pay per job, MCP-ready for Claude and AI agents.",
        "version": "0.0",
        "x-build-id": "N1JcwHSYgQJ1zHRPY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~linkedin-jobs-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-linkedin-jobs-api",
                "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/johnvc~linkedin-jobs-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-linkedin-jobs-api",
                "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/johnvc~linkedin-jobs-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-linkedin-jobs-api",
                "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": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job title or keyword to search for, e.g. 'python developer'. Combine with Location and filters."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search within, e.g. 'New York' or 'United Kingdom'."
                    },
                    "country": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code to scope the search, e.g. 'US', 'GB', 'DE'."
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "full-time",
                            "part-time",
                            "contract",
                            "temporary",
                            "internship",
                            "volunteer"
                        ],
                        "type": "string",
                        "description": "Employment type filter."
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "internship",
                            "entry",
                            "associate",
                            "mid-senior",
                            "director",
                            "executive"
                        ],
                        "type": "string",
                        "description": "Seniority filter."
                    },
                    "remote": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Return only remote jobs.",
                        "default": false
                    },
                    "company": {
                        "title": "Company",
                        "type": "string",
                        "description": "Filter to a specific company name."
                    },
                    "timeRange": {
                        "title": "Date posted",
                        "enum": [
                            "past-day",
                            "past-week",
                            "past-month"
                        ],
                        "type": "string",
                        "description": "Only jobs posted within this window."
                    },
                    "jobUrls": {
                        "title": "Job URLs",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "One or more specific LinkedIn job posting URLs, e.g. https://www.linkedin.com/jobs/view/4286961888. Each returns one row. Use instead of, or in addition to, the keyword search above. Up to 1000 per run. Need larger batches? Contact us and we can raise this limit for your account.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobs": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of jobs to return for each keyword search or search URL. Caps upstream cost. Ignored for specific job URLs.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
