# LinkedIn Jobs Scraper — Salary, Skills, Seniority & Easy Apply (`khadinakbar/linkedin-jobs-scraper`) Actor

Extract LinkedIn jobs by keyword + location. Returns job title, company, parsed salary (min/max), skills, seniority, employment type, work type, easy-apply flag, applicant count & full description. No login required. Supports filters and bulk queries.

- **URL**: https://apify.com/khadinakbar/linkedin-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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.

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 Scraper — Skills, Salary & B2B Hiring Signals

Extract LinkedIn job listings by keyword + location — no login, no cookies, no manual URL building required. Returns fully structured data including parsed salary (min/max numbers), required skills array, easy-apply flag, applicant count, seniority level, and full job description.

The only LinkedIn jobs actor with a documented output schema — making it the best choice for AI agents (Claude, ChatGPT) and automated pipelines.

Export scraped data, run via API, schedule recurring runs, or integrate with other tools.

---

### Why This Actor?

Most LinkedIn scrapers either require you to manually build search URLs, return raw unstructured text, or cost 5-10x more per result. This actor is different:

- **Simple input** — just type your job title and location. No URL building in incognito windows.
- **Multi-query + multi-location** — run `["Software Engineer", "ML Engineer"]` × `["New York", "London"]` in one run
- **Parsed salary** — returns `salary_min: 180000` and `salary_max: 240000`, not just a raw string
- **Skills as array** — `required_skills: ["Python", "PyTorch"]` for easy filtering
- **B2B hiring signals** — find companies actively hiring to power sales prospecting and competitive intel
- **Built-in deduplication** — cross-query runs never return the same job twice
- **Full output schema** — every field documented for AI agent compatibility

---

### Use Cases

**For recruiters and talent teams:** Aggregate open roles across companies and locations. Monitor competitors' hiring activity. Build sourcing pipelines for specific skill sets.

**For B2B sales teams:** Identify companies hiring for roles that signal budget and buying intent. Find hiring managers and decision-makers. Use job postings as warm outreach triggers.

**For job seekers and market researchers:** Track salary trends across roles and geographies. Analyze which skills are most in-demand. Compare remote vs on-site availability by location.

**For developers and data teams:** Feed structured job data into dashboards, CRMs, ATS systems, or AI pipelines. Schedule daily monitoring runs for specific searches.

---

### Input Parameters

#### Simple keyword search (recommended)

```json
{
  "searchQueries": ["Software Engineer", "Product Manager"],
  "locations": ["San Francisco, CA", "Remote"],
  "maxResults": 100,
  "datePosted": "r604800"
}
````

This runs 4 searches: each query × each location. Results are automatically deduplicated.

#### Direct URL mode (advanced)

Open `linkedin.com/jobs` in an incognito window, apply your filters, copy the URL, and paste it here:

```json
{
  "startUrls": [
    { "url": "https://www.linkedin.com/jobs/search/?keywords=data+scientist&location=New+York&f_E=4&f_WT=2" }
  ],
  "maxResults": 200
}
```

#### With filters

```json
{
  "searchQueries": ["DevOps Engineer"],
  "locations": ["United States"],
  "maxResults": 50,
  "experienceLevel": ["4", "5"],
  "workType": ["2", "3"],
  "jobType": ["F"],
  "salaryBase": "100000"
}
```

***

### Output Fields

Each result is a JSON object with the following fields:

| Field | Type | Description |
|---|---|---|
| `job_id` | string | LinkedIn's unique job ID |
| `job_title` | string | null | Full job title |
| `company_name` | string | null | Hiring company name |
| `company_url` | string | null | LinkedIn company profile URL |
| `company_size` | string | null | Employee count range |
| `company_industry` | string | null | Industry category |
| `location` | string | null | City, state, work arrangement |
| `work_type` | string | null | Remote / Hybrid / On-site |
| `employment_type` | string | null | Full-time / Part-time / Contract |
| `seniority_level` | string | null | Entry / Mid-Senior / Director etc. |
| `salary_range` | string | null | Raw salary string from LinkedIn |
| `salary_min` | number | null | Parsed minimum salary (USD) |
| `salary_max` | number | null | Parsed maximum salary (USD) |
| `required_skills` | string\[] | Extracted skills list |
| `is_easy_apply` | boolean | True if LinkedIn Easy Apply is enabled |
| `applicant_count` | string | null | e.g. "142 applicants" |
| `posted_at` | string | null | Relative posting time |
| `job_description` | string | null | Full plain-text description |
| `job_url` | string | Direct link to the job posting |
| `search_query` | string | null | Query that found this job |
| `scraped_at` | string | ISO timestamp of extraction |

#### Example output record

```json
{
  "job_id": "3812749302",
  "job_title": "Senior Machine Learning Engineer",
  "company_name": "Anthropic",
  "company_url": "https://www.linkedin.com/company/anthropic",
  "company_size": "201-500 employees",
  "company_industry": "Artificial Intelligence",
  "location": "San Francisco, CA (Hybrid)",
  "work_type": "Hybrid",
  "employment_type": "Full-time",
  "seniority_level": "Mid-Senior level",
  "salary_range": "$200,000–$280,000/yr",
  "salary_min": 200000,
  "salary_max": 280000,
  "required_skills": ["Python", "PyTorch", "RLHF", "Distributed Systems"],
  "is_easy_apply": false,
  "applicant_count": "142 applicants",
  "posted_at": "2 days ago",
  "job_description": "We are looking for a Senior ML Engineer...",
  "job_url": "https://www.linkedin.com/jobs/view/3812749302/",
  "search_query": "Machine Learning Engineer",
  "source_url": "https://www.linkedin.com/jobs/view/3812749302/",
  "scraped_at": "2026-03-31T14:22:00.000Z"
}
```

***

### Cost & Performance

**Pricing:** $0.0005 per job result (PAY\_PER\_EVENT). No actor start fee.

| Scenario | Jobs | Estimated Cost |
|---|---|---|
| Quick search | 50 | ~$0.025 |
| Standard batch | 200 | ~$0.10 |
| Large scrape | 1,000 | ~$0.50 |
| Daily monitoring (50/day) | 1,500/month | ~$0.75/month |

Compare: the dominant competitor charges $0.001/result (2x more). Premium competitors charge up to $0.005/result (10x more).

**Performance:** ~25–50 jobs/minute depending on LinkedIn's response times and proxy routing. 50 jobs typically takes 2–4 minutes.

***

### Filters Reference

| Filter | Values |
|---|---|
| `datePosted` | `r86400` (24h), `r604800` (week), `r2592000` (month) |
| `jobType` | `F` (Full-time), `P` (Part-time), `C` (Contract), `T` (Temporary), `I` (Internship) |
| `experienceLevel` | `1` (Intern), `2` (Entry), `3` (Associate), `4` (Mid-Senior), `5` (Director), `6` (Executive) |
| `workType` | `1` (On-site), `2` (Remote), `3` (Hybrid) |
| `salaryBase` | `40000`, `60000`, `80000`, `100000`, `120000` |

***

### Limitations

- LinkedIn limits each search URL to ~1,000 results. Use multiple search queries to get more.
- Salary data is only available on job postings where the employer has added it (typically 30–40% of postings in the US).
- Skills extraction requires LinkedIn to expose the skills section on the public job page. For some postings, skills will be empty.
- LinkedIn may show an auth wall on some requests. The actor retries with a fresh session when this happens.

***

### No Login Required

This actor operates entirely on LinkedIn's public job search pages, which are accessible without an account. No cookies, no session tokens, no LinkedIn credentials needed.

***

### Support & Feedback

Found a bug or want a new feature? Open an issue on this actor's page. We respond within 48 hours and typically ship fixes within a week.

Works great with our [Google Jobs Scraper](https://apify.com/khadinakbar/google-jobs-scraper) for cross-platform job market research.

***

### Changelog

**v0.1** — Initial release. Keyword + location search, multi-query cross-product, full detail page extraction, salary parsing, skills extraction, PPE pricing.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this field when the user provides job titles, roles, or keywords to search. E.g. \['Software Engineer', 'Product Manager']. Use startUrls instead when the user provides direct LinkedIn search URLs. Supports multiple queries — each is run against every location.

## `locations` (type: `array`):

List of locations to search in. Each query is cross-searched against each location. Use city names, states, or countries. E.g. \['New York', 'Remote', 'London']. Use 'United States' for nationwide US results.

## `startUrls` (type: `array`):

Use this field instead of searchQueries when the user provides direct LinkedIn job search URLs (e.g. copied from linkedin.com/jobs/search). Open linkedin.com/jobs in an incognito window, apply your filters, and paste the URL here. Overrides searchQueries + locations when provided.

## `maxResults` (type: `integer`):

Maximum number of job listings to return across all queries and locations combined. LinkedIn limits each search to ~1000 results. Use multiple queries to get more.

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

Filter jobs by how recently they were posted. 'Any time' returns all available jobs. Use 'Past 24 hours' for fresh postings.

## `jobType` (type: `array`):

Filter by employment contract type. Leave empty to return all types. F=Full-time, P=Part-time, C=Contract, T=Temporary, I=Internship.

## `experienceLevel` (type: `array`):

Filter by required experience level. Leave empty to return all levels. 1=Internship, 2=Entry level, 3=Associate, 4=Mid-Senior, 5=Director, 6=Executive.

## `workType` (type: `array`):

Filter by on-site, remote, or hybrid work arrangement. Leave empty to return all. 1=On-site, 2=Remote, 3=Hybrid.

## `salaryBase` (type: `string`):

Filter to only show jobs above a minimum annual salary. Note: LinkedIn only shows salary on a subset of postings.

## Actor input object example

```json
{
  "searchQueries": [
    "Software Engineer"
  ],
  "locations": [
    "United States"
  ],
  "startUrls": [],
  "maxResults": 50,
  "datePosted": "any"
}
```

# Actor output Schema

## `job_id` (type: `string`):

LinkedIn's unique numeric job posting identifier. Use this to deduplicate across runs.

## `job_title` (type: `string`):

Full job title as listed by the employer on LinkedIn.

## `company_name` (type: `string`):

Name of the hiring company.

## `company_url` (type: `string`):

URL to the company's LinkedIn profile.

## `company_size` (type: `string`):

Employee count range for the hiring company, e.g. '1,001-5,000 employees'.

## `company_industry` (type: `string`):

Industry category of the hiring company.

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

City, state/country of the job as listed on LinkedIn.

## `work_type` (type: `string`):

Work arrangement: Remote, Hybrid, or On-site.

## `employment_type` (type: `string`):

Contract type: Full-time, Part-time, Contract, Temporary, Internship, or Volunteer.

## `seniority_level` (type: `string`):

Required experience level: Internship, Entry level, Associate, Mid-Senior level, Director, Executive.

## `salary_range` (type: `string`):

Raw salary string exactly as shown on LinkedIn, e.g. '$120,000-$160,000/yr'. Null if not listed.

## `salary_min` (type: `string`):

Parsed minimum annual salary as a plain number in USD. Null if salary is not listed.

## `salary_max` (type: `string`):

Parsed maximum annual salary as a plain number in USD. Null if salary is not listed.

## `required_skills` (type: `string`):

Skills extracted from the LinkedIn skills section or parsed from the job description requirements section.

## `is_easy_apply` (type: `string`):

True if the job supports LinkedIn one-click Easy Apply. False means applicants are redirected to an external site.

## `applicant_count` (type: `string`):

Number of applicants as shown by LinkedIn, e.g. '142 applicants' or 'Over 200 applicants'.

## `posted_at` (type: `string`):

When the job was posted, in LinkedIn's relative format (e.g. '2 days ago') or absolute date.

## `job_description` (type: `string`):

Full plain-text job description including responsibilities, requirements, and benefits.

## `job_url` (type: `string`):

Direct URL to the LinkedIn job posting.

## `search_query` (type: `string`):

The keyword query used to find this job.

## `source_url` (type: `string`):

The URL that was scraped to extract this record.

## `scraped_at` (type: `string`):

ISO 8601 timestamp of when this record was extracted.

# 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 = {
    "searchQueries": [
        "Software Engineer"
    ],
    "locations": [
        "United States"
    ],
    "startUrls": [],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/linkedin-jobs-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 = {
    "searchQueries": ["Software Engineer"],
    "locations": ["United States"],
    "startUrls": [],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/linkedin-jobs-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 '{
  "searchQueries": [
    "Software Engineer"
  ],
  "locations": [
    "United States"
  ],
  "startUrls": [],
  "maxResults": 50
}' |
apify call khadinakbar/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper — Salary, Skills, Seniority & Easy Apply",
        "description": "Extract LinkedIn jobs by keyword + location. Returns job title, company, parsed salary (min/max), skills, seniority, employment type, work type, easy-apply flag, applicant count & full description. No login required. Supports filters and bulk queries.",
        "version": "0.1",
        "x-build-id": "d3kiDg8qbc4ePhH60"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-linkedin-jobs-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/khadinakbar~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-linkedin-jobs-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/khadinakbar~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-linkedin-jobs-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": {
                    "searchQueries": {
                        "title": "Job Search Queries",
                        "type": "array",
                        "description": "Use this field when the user provides job titles, roles, or keywords to search. E.g. ['Software Engineer', 'Product Manager']. Use startUrls instead when the user provides direct LinkedIn search URLs. Supports multiple queries — each is run against every location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "List of locations to search in. Each query is cross-searched against each location. Use city names, states, or countries. E.g. ['New York', 'Remote', 'London']. Use 'United States' for nationwide US results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this field instead of searchQueries when the user provides direct LinkedIn job search URLs (e.g. copied from linkedin.com/jobs/search). Open linkedin.com/jobs in an incognito window, apply your filters, and paste the URL here. Overrides searchQueries + locations when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to return across all queries and locations combined. LinkedIn limits each search to ~1000 results. Use multiple queries to get more.",
                        "default": 50
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "r86400",
                            "r604800",
                            "r2592000"
                        ],
                        "type": "string",
                        "description": "Filter jobs by how recently they were posted. 'Any time' returns all available jobs. Use 'Past 24 hours' for fresh postings.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job Type",
                        "type": "array",
                        "description": "Filter by employment contract type. Leave empty to return all types. F=Full-time, P=Part-time, C=Contract, T=Temporary, I=Internship.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "F",
                                "P",
                                "C",
                                "T",
                                "I",
                                "O"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship",
                                "Other"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "type": "array",
                        "description": "Filter by required experience level. Leave empty to return all levels. 1=Internship, 2=Entry level, 3=Associate, 4=Mid-Senior, 5=Director, 6=Executive.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "Internship",
                                "Entry level",
                                "Associate",
                                "Mid-Senior level",
                                "Director",
                                "Executive"
                            ]
                        }
                    },
                    "workType": {
                        "title": "Work Type",
                        "type": "array",
                        "description": "Filter by on-site, remote, or hybrid work arrangement. Leave empty to return all. 1=On-site, 2=Remote, 3=Hybrid.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        }
                    },
                    "salaryBase": {
                        "title": "Minimum Salary (USD/yr)",
                        "enum": [
                            "40000",
                            "60000",
                            "80000",
                            "100000",
                            "120000"
                        ],
                        "type": "string",
                        "description": "Filter to only show jobs above a minimum annual salary. Note: LinkedIn only shows salary on a subset of postings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
