# Linkedin Job Scraper - Safe & Affordable (`patrickvicente/linkedin-job-scraper`) Actor

A powerful LinkedIn job scraper built with Playwright and designed to run on the Apify platform. This actor can scrape job listings from LinkedIn based on various search keywords and search criterias and filters. Fast and cheap!

- **URL**: https://apify.com/patrickvicente/linkedin-job-scraper.md
- **Developed by:** [John Patrick Vicente](https://apify.com/patrickvicente) (community)
- **Categories:** Jobs, Automation, Open source
- **Stats:** 98 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 1.00 out of 5 stars

## 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 Job Scraper - Professional Job Data Extraction

**Extract comprehensive job listings from LinkedIn with enterprise-grade reliability and seamless automation integration.**

[![Apify](https://img.shields.io/badge/Apify-Platform-blue)](https://apify.com)
[![MCP](https://img.shields.io/badge/MCP-Compatible-green)](https://modelcontextprotocol.io)
[![n8n](https://img.shields.io/badge/n8n-Integration-orange)](https://n8n.io)
[![AI Agents](https://img.shields.io/badge/AI%20Agents-Ready-purple)](https://modelcontextprotocol.io)

### 🚀 **Perfect for Automation & AI Workflows**

Transform your recruitment, market research, and competitive intelligence with our professional LinkedIn job scraper. Built for seamless integration with modern automation platforms and AI agents.

#### **🎯 Key Use Cases**
- **Recruitment Automation** - Automate job market monitoring and candidate sourcing
- **Competitive Intelligence** - Track competitor hiring patterns and salary trends
- **Market Research** - Analyze job market trends and industry demands
- **AI Agent Integration** - Power your AI assistants with real-time job data
- **Workflow Automation** - Connect with n8n, Zapier, and other automation platforms

### 🔗 **Seamless Integration Options**

#### **🤖 MCP (Model Context Protocol) Integration**
Connect directly to AI agents and LLMs using the MCP protocol:

```javascript
// MCP Server Configuration
{
  "mcpServers": {
    "linkedin-scraper": {
      "command": "apify",
      "args": ["call", "YOUR_USERNAME~linkedin-job-scraper"],
      "env": {
        "APIFY_TOKEN": "your_apify_token"
      }
    }
  }
}
````

**Benefits:**

- Direct AI agent access to LinkedIn job data
- Real-time job market insights for AI assistants
- Structured data perfect for LLM consumption
- No additional API development required

#### **⚡ n8n Workflow Integration**

Integrate job scraping into your n8n automation workflows:

```json
{
  "node": "Apify",
  "parameters": {
    "resource": "actor",
    "operation": "callActor",
    "actorId": "YOUR_USERNAME~linkedin-job-scraper",
    "input": {
      "keywords": "software engineer",
      "location": "San Francisco, CA",
      "maxJobs": 50
    }
  }
}
```

**Workflow Examples:**

- **Recruitment Pipeline**: Auto-scrape → Filter candidates → Send to ATS
- **Market Analysis**: Daily job monitoring → Trend analysis → Report generation
- **Competitor Tracking**: Monitor competitor jobs → Alert on new positions
- **Salary Research**: Extract salary data → Update compensation databases

#### **🧠 AI Agent Integration**

Perfect for AI assistants and autonomous agents:

```python
## Example AI Agent Integration
import requests

def get_linkedin_jobs(keywords, location):
    response = requests.post(
        "https://api.apify.com/v2/acts/YOUR_USERNAME~linkedin-job-scraper/runs",
        headers={"Authorization": f"Bearer {APIFY_TOKEN}"},
        json={
            "keywords": keywords,
            "location": location,
            "maxJobs": 25
        }
    )
    return response.json()
```

### 📊 **Rich Data Extraction**

Extract comprehensive job information including:

| Field | Description | Example |
|-------|-------------|---------|
| **Job Details** | Title, description, requirements, benefits | "Senior Software Engineer" |
| **Location & Type** | Location, remote options, contract type | "San Francisco, CA" |
| **Compensation** | Salary ranges, benefits packages | "$120K - $180K" |
| **Timing** | Posted date, application count | "2 hours ago" |
| **Application** | Apply URL, application type | "Easy Apply" |

### ⚙️ **Flexible Configuration**

#### **Search Parameters**

```json
{
  "keywords": "software engineer, developer",
  "location": "San Francisco, CA",
  "experienceLevels": ["entry", "associate", "mid-senior"],
  "jobTypes": ["full-time", "part-time"],
  "remoteOptions": ["remote", "hybrid", "on-site"],
  "maxJobs": 100,
  "maxPages": 10
}
```

#### **URL-Based Scraping**

```json
{
  "url": "https://www.linkedin.com/jobs/search?keywords=react&location=New%20York",
  "maxJobs": 50
}
```

#### **Advanced Options**

- **Proxy Support**: Built-in residential proxy rotation
- **Rate Limiting**: Configurable delays to avoid detection
- **Production Optimized**: Always runs in headless mode for maximum reliability
- **Custom Timeouts**: Adjustable for different network conditions

### 🎯 **Why Choose Our LinkedIn Scraper?**

#### **✅ Enterprise Features**

- **Reliable Extraction**: 99%+ success rate with advanced error handling
- **Scalable Architecture**: Handle thousands of jobs per run
- **Professional Support**: Enterprise-grade documentation and support
- **Compliance Ready**: Built with respect for LinkedIn's terms of service

#### **✅ Automation Ready**

- **REST API**: Simple HTTP endpoints for easy integration
- **Webhook Support**: Real-time notifications when scraping completes
- **Structured Output**: JSON format perfect for automation workflows
- **Rate Limiting**: Built-in protection against API abuse

#### **✅ AI & MCP Optimized**

- **Structured Data**: Clean, consistent format for AI consumption
- **Rich Metadata**: Comprehensive job information for AI analysis
- **Real-time Access**: Live data for AI agents and assistants
- **MCP Protocol**: Native support for Model Context Protocol

### 🚀 **Quick Start**

#### **1. Get Your Apify Token**

- Sign up at [apify.com](https://apify.com)
- Go to Account Settings → Integrations → API tokens
- Create a new token with appropriate permissions

#### **2. Configure Your Integration**

**For MCP:**

```json
{
  "mcpServers": {
    "linkedin-scraper": {
      "command": "apify",
      "args": ["call", "YOUR_USERNAME~linkedin-job-scraper"]
    }
  }
}
```

**For n8n:**

- Add Apify node to your workflow
- Configure with your actor ID
- Set up input parameters
- Connect to your automation logic

**For AI Agents:**

```python
## Simple Python integration
import requests

def scrape_jobs(keywords, location):
    return requests.post(
        "https://api.apify.com/v2/acts/YOUR_USERNAME~linkedin-job-scraper/runs",
        json={"keywords": keywords, "location": location}
    ).json()
```

#### **3. Start Scraping**

- Configure your search parameters
- Run the actor
- Access results via API or download from Apify console

### 📈 **Use Cases & Examples**

#### **Recruitment Automation**

```javascript
// Automated candidate sourcing
const jobs = await scrapeLinkedIn({
  keywords: "react developer",
  location: "New York, NY",
  experienceLevels: ["mid-senior", "senior"]
});

// Filter and process candidates
const qualifiedCandidates = jobs.filter(job => 
  job.experienceLevel === "senior" && 
  job.location.includes("New York")
);
```

#### **Market Intelligence**

```python
## Competitive analysis
def analyze_competitor_hiring(company_name):
    jobs = scrape_linkedin({
        "keywords": company_name,
        "maxJobs": 50
    })
    
    return {
        "total_positions": len(jobs),
        "locations": list(set(job.location for job in jobs)),
        "experience_levels": analyze_experience_distribution(jobs)
    }
```

#### **AI Agent Integration**

```javascript
// AI assistant job search
async function aiJobSearch(userQuery) {
  const { keywords, location } = parseUserQuery(userQuery);
  
  const jobs = await callLinkedInScraper({
    keywords,
    location,
    maxJobs: 25
  });
  
  return formatJobsForAI(jobs);
}
```

### 🔧 **Technical Specifications**

- **Platform**: Apify Cloud
- **Technology**: Playwright (Chromium)
- **Output Format**: JSON
- **Rate Limits**: Configurable
- **Proxy Support**: Built-in residential proxies
- **API**: RESTful endpoints
- **Authentication**: Apify API tokens

### 📞 **Support & Documentation**

- **📖 [Full Documentation](https://docs.apify.com)**
- **🔧 [API Reference](https://docs.apify.com/api/v2)**
- **💬 [Community Support](https://forum.apify.com)**
- **📧 [Enterprise Support](mailto:support@apify.com)**

### ⚖️ **Legal & Compliance**

This tool is designed for legitimate business purposes and complies with:

- LinkedIn's Terms of Service
- Data protection regulations
- Ethical scraping practices

**Use responsibly and respect rate limits.**

***

**Ready to automate your job market intelligence?** 🚀

[Get Started](https://apify.com) | [View Documentation](https://docs.apify.com) | [Get Support](https://forum.apify.com)

# Actor input Schema

## `userUrls` (type: `array`):

Paste LinkedIn job search URLs here, you need to open an incognito window and search on LinkedIn

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

Enter job keywords, titles, or skills to search for (e.g., 'software engineer', 'data scientist', 'marketing manager')

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

Enter the location where you want to find jobs (e.g., 'San Francisco, CA', 'New York, NY', 'Remote')

## `experienceLevels` (type: `array`):

Select the experience levels you're interested in

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

Filter jobs by when they were posted

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

Limit the number of jobs to scrape

## `slowMo` (type: `integer`):

Delay between operations in milliseconds (higher values are slower but more reliable)

## `timeout` (type: `integer`):

Timeout for page operations in milliseconds

## `avoidDuplicates` (type: `boolean`):

Skip duplicate job postings

## `proxy` (type: `object`):

Configure proxy settings for the scraper

## Actor input object example

```json
{
  "userUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search?trk=guest_homepage-basic_guest_nav_menu_jobs&position=1&pageNum=0"
    }
  ],
  "maxJobs": 100,
  "slowMo": 100,
  "timeout": 30000,
  "avoidDuplicates": true
}
```

# Actor output Schema

## `id` (type: `string`):

Unique LinkedIn job posting ID

## `title` (type: `string`):

Title of the job position

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

Job location (city, state, country)

## `salaryInfo` (type: `string`):

Salary information as comma-separated values

## `postedTime` (type: `string`):

Relative time when job was posted (e.g., '3 hours ago')

## `postedAt` (type: `string`):

Date when job was posted

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

ISO date when job was published

## `dateExpiring` (type: `string`):

ISO date when job posting expires

## `link` (type: `string`):

Direct URL to the job posting

## `companyName` (type: `string`):

Name of the hiring company

## `companyLinkedinUrl` (type: `string`):

URL to the company's LinkedIn page

## `descriptionText` (type: `string`):

Full job description and requirements as text

## `descriptionHtml` (type: `string`):

Full job description and requirements as HTML

## `applicantsCount` (type: `string`):

Number of applications or application status

## `employmentType` (type: `string`):

Type of employment contract (Full-time, Part-time, Contract, etc.)

## `seniorityLevel` (type: `string`):

Required experience level (Entry Level, Associate, Mid-Senior Level, Senior, Executive)

## `jobFunction` (type: `string`):

Primary job function or category

## `industries` (type: `string`):

Industry sectors relevant to the job

## `jobPosterName` (type: `string`):

Full name of the person who posted the job

## `jobPosterTitle` (type: `string`):

Job title of the person who posted the job

## `jobPosterPhoto` (type: `string`):

URL to the job poster's profile photo

## `jobPosterProfileUrl` (type: `string`):

URL to the poster's LinkedIn profile

## `applyUrl` (type: `string`):

Direct URL to apply for the job

## `benefits` (type: `string`):

List of benefits offered with the position

## `educationalRequirements` (type: `string`):

Required educational credential category

## `skills` (type: `string`):

Required skills for the job position

## `scrapedAt` (type: `string`):

Timestamp when the data was scraped

# 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 = {
    "userUrls": [
        {
            "url": "https://www.linkedin.com/jobs/search?trk=guest_homepage-basic_guest_nav_menu_jobs&position=1&pageNum=0"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("patrickvicente/linkedin-job-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 = { "userUrls": [{ "url": "https://www.linkedin.com/jobs/search?trk=guest_homepage-basic_guest_nav_menu_jobs&position=1&pageNum=0" }] }

# Run the Actor and wait for it to finish
run = client.actor("patrickvicente/linkedin-job-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 '{
  "userUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search?trk=guest_homepage-basic_guest_nav_menu_jobs&position=1&pageNum=0"
    }
  ]
}' |
apify call patrickvicente/linkedin-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Job Scraper - Safe & Affordable",
        "description": "A powerful LinkedIn job scraper built with Playwright and designed to run on the Apify platform. This actor can scrape job listings from LinkedIn based on various search keywords and search criterias and filters. Fast and cheap!",
        "version": "1.0",
        "x-build-id": "irLOu6NmnumkeFYAf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/patrickvicente~linkedin-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-patrickvicente-linkedin-job-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/patrickvicente~linkedin-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-patrickvicente-linkedin-job-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/patrickvicente~linkedin-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-patrickvicente-linkedin-job-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": {
                    "userUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste LinkedIn job search URLs here, you need to open an incognito window and search on LinkedIn",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Job Keywords",
                        "pattern": "^.+$",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Enter job keywords, titles, or skills to search for (e.g., 'software engineer', 'data scientist', 'marketing manager')"
                    },
                    "location": {
                        "title": "Job Location",
                        "pattern": "^.+$",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Enter the location where you want to find jobs (e.g., 'San Francisco, CA', 'New York, NY', 'Remote')"
                    },
                    "experienceLevels": {
                        "title": "Experience Levels",
                        "minItems": 1,
                        "maxItems": 6,
                        "type": "array",
                        "description": "Select the experience levels you're interested in",
                        "items": {
                            "type": "string",
                            "enum": [
                                "entry level",
                                "associate",
                                "mid-senior level",
                                "senior",
                                "executive",
                                "internship"
                            ],
                            "enumTitles": [
                                "Entry Level",
                                "Associate",
                                "Mid-Senior Level",
                                "Senior",
                                "Executive",
                                "Internship"
                            ]
                        }
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any time",
                            "past 24 hours",
                            "past week",
                            "past month",
                            "past 3 months"
                        ],
                        "type": "string",
                        "description": "Filter jobs by when they were posted"
                    },
                    "maxJobs": {
                        "title": "Maximum Jobs to Scrape",
                        "minimum": 100,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Limit the number of jobs to scrape",
                        "default": 100
                    },
                    "slowMo": {
                        "title": "Operation Delay",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between operations in milliseconds (higher values are slower but more reliable)",
                        "default": 100
                    },
                    "timeout": {
                        "title": "Page Timeout",
                        "minimum": 10000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Timeout for page operations in milliseconds",
                        "default": 30000
                    },
                    "avoidDuplicates": {
                        "title": "Avoid Duplicates",
                        "type": "boolean",
                        "description": "Skip duplicate job postings",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings for the scraper"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```