# Universal Career Site & ATS Jobs Scraper (`trakk/universal-career-site-jobs-scraper`) Actor

Scrape every available job from company career sites and ATS platforms, including Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee, Personio, and BambooHR. Get titles, locations, salaries, descriptions, apply URLs, and raw source fields. No ATS API key required.

- **URL**: https://apify.com/trakk/universal-career-site-jobs-scraper.md
- **Developed by:** [DataForge](https://apify.com/trakk) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## 💼 Universal Career Site Jobs Scraper

Collect complete, structured job data from company websites and leading applicant tracking systems — with one Actor and no ATS API keys.

Give the Actor a company homepage, a careers page, or a direct ATS board. It detects the source, follows every available result page, enriches job details when needed, removes duplicates, and returns one clean dataset row per vacancy.

### 💡 Why this Actor

- 🌐 **One Actor for every source** — company websites and native ATS platforms like Greenhouse, Lever, Ashby, Workday, and more
- 🔑 **No ATS API keys** — works from publicly exposed career pages and supported ATS boards
- 🧭 **Homepage-to-jobs discovery** — detects the source and finds the Careers or Jobs portal automatically
- 🧱 **Normalized, export-ready data** — consistent columns across platforms, downloadable as JSON, CSV, Excel, XML, or RSS
- 🧬 **Nothing silently discarded** — every native ATS field is preserved in `rawJson` and flattened `native__...` columns
- 🧾 **Transparent failures** — unreadable or empty sources become error rows while successful companies are kept

#### 📸 Sample output

![Universal Career Site Jobs Scraper sample output — real data fields](https://api.apify.com/v2/key-value-stores/sAkX2yFx0oRX6gf6p/records/universal-career-site-jobs-scraper-sample)

*A real run's output — exportable to JSON, CSV, or Excel.*

### 🚀 What this Actor can do

- Find a company’s Careers or Jobs portal from its normal website
- Detect supported ATS platforms automatically
- Collect every available job when both result limits are set to `0`
- Follow native pagination instead of stopping after the first page
- Fetch full descriptions and additional job-detail fields
- Normalize jobs from different platforms into consistent columns
- Preserve platform-specific fields in `rawJson` and flattened `native__...` columns
- Extract Schema.org `JobPosting` data from custom career pages
- Archive original source responses for audits and debugging
- Process multiple companies concurrently in one run
- Report unreadable or empty sources as transparent error rows

### ✅ Supported career platforms

| Platform | Coverage | Full descriptions | Native fields |
|---|---:|---:|---:|
| Greenhouse | Native, all jobs | ✅ | ✅ |
| Lever | Native, all pages | ✅ | ✅ |
| Ashby | Native, all jobs | ✅ | ✅ |
| Workable | Native + job details | ✅ | ✅ |
| SmartRecruiters | Native, all pages + details | ✅ | ✅ |
| Workday | Native, all pages + details | ✅ | ✅ |
| Recruitee | Native, all jobs | ✅ | ✅ |
| Personio | Native, all jobs | ✅ | ✅ |
| BambooHR | Native + job details | ✅ | ✅ |
| Custom career sites | Structured data + conservative HTML fallback | When exposed | ✅ |

The universal fallback can read other platforms and custom company sites when their public pages expose `JobPosting` structured data or server-rendered job details. Because custom sites vary, direct support depends on what the supplied page makes publicly available.

### 🧭 What URL should I enter?

Any of these can work:

```text
https://example.com
https://example.com/careers
https://boards.greenhouse.io/company
https://jobs.lever.co/company
https://jobs.ashbyhq.com/company
https://company.wd5.myworkdayjobs.com/External
````

A direct ATS or career-board URL is the fastest and most precise input. If you only know the company homepage, keep **Find career pages automatically** enabled.

### 🎛️ Input options

| Option | What it controls | Default |
|---|---|---:|
| `startUrls` | Company websites, career pages, or direct ATS boards | Required |
| `maxJobsPerSource` | Maximum jobs per supplied company; `0` means all | `0` |
| `maxJobsTotal` | Global cap across the whole run; `0` means unlimited | `0` |
| `includeDescriptions` | Fetch detail endpoints when a listing omits its description | `true` |
| `includeRawData` | Keep `rawJson` and flattened `native__...` fields | `true` |
| `saveRawResponses` | Archive successful source responses in key-value storage | `false` |
| `discoverFromCompanyWebsite` | Find the Careers or Jobs portal automatically | `true` |
| `maxDiscoveryPages` | Pages checked while discovering a career portal | `5` |
| `maxPagesPerSource` | Safety limit for unknown/custom career sites | `500` |
| `maxConcurrency` | Sources and job details processed in parallel | `10` |
| `maxRetries` | Attempts for temporary source or network failures | `5` |
| `proxyConfiguration` | Optional Apify or custom proxy configuration | Apify Proxy |

#### Collect every available job

```json
{
  "startUrls": [
    { "url": "https://jobs.ashbyhq.com/openai" },
    { "url": "https://boards.greenhouse.io/anthropic" },
    { "url": "https://adobe.wd5.myworkdayjobs.com/external_experienced" }
  ],
  "maxJobsPerSource": 0,
  "maxJobsTotal": 0,
  "includeDescriptions": true,
  "includeRawData": true
}
```

#### Create a lightweight monitoring feed

```json
{
  "startUrls": [
    { "url": "https://example.com/careers" }
  ],
  "maxJobsPerSource": 100,
  "includeDescriptions": false,
  "includeRawData": false,
  "saveRawResponses": false
}
```

#### Audit the exact source payloads

```json
{
  "startUrls": [
    { "url": "https://jobs.lever.co/company" }
  ],
  "includeRawData": true,
  "saveRawResponses": true
}
```

### 📦 Output data

Each vacancy is stored as one flat dataset item. Common fields include:

- **Identity:** `ats`, `company`, `companySlug`, `jobId`, `requisitionId`, `title`
- **Location:** `location`, `locations`, `city`, `region`, `country`, `postalCode`
- **Organization:** `department`, `departments`, `team`, `seniority`, `experienceLevel`
- **Work model:** `employmentType`, `workplaceType`, `remote`, `hybrid`, `onSite`
- **Compensation:** `salary`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`
- **Job content:** `descriptionHtml`, `descriptionText`, `requirements`, `responsibilities`, `qualifications`, `skills`, `benefits`
- **Links and dates:** `jobUrl`, `applyUrl`, `postedAt`, `updatedAt`, `expiresAt`
- **Traceability:** `inputUrl`, `sourceUrl`, `sourcePage`, `scrapedAt`

When **Include every native ATS field** is enabled:

- `rawJson` contains the complete source job object
- `native__...` columns expose nested source fields in a CSV- and Excel-friendly form

This dual format gives you consistent universal columns without silently discarding uncommon ATS-specific values.

#### Example job row

```json
{
  "recordType": "job",
  "ats": "ashby",
  "company": "Example Company",
  "jobId": "8d96c76b-1234-5678-9abc-e0f123456789",
  "title": "Senior Software Engineer",
  "location": "San Francisco, CA",
  "department": "Engineering",
  "employmentType": "FullTime",
  "workplaceType": "Hybrid",
  "remote": false,
  "descriptionText": "Build reliable products used by customers worldwide...",
  "jobUrl": "https://jobs.ashbyhq.com/example/8d96c76b-1234-5678-9abc-e0f123456789",
  "applyUrl": "https://jobs.ashbyhq.com/example/8d96c76b-1234-5678-9abc-e0f123456789/application",
  "postedAt": "2026-07-20T12:00:00Z",
  "inputUrl": "https://example.com",
  "scrapedAt": "2026-07-22T09:30:00Z",
  "rawJson": "{...}"
}
```

### 🗂️ Run results and storage

- **Jobs** output tab — clean vacancy rows only
- **Errors** output tab — sources that failed or returned no recognizable jobs
- **OUTPUT** key-value record — run status, counts, duration, ATS totals, limits, stop reason, and per-source statistics
- **RAW-...** key-value records — optional original JSON, HTML, or XML responses

Results can be downloaded as JSON, CSV, Excel, XML, or RSS, or consumed through the Apify API. The Actor also works with schedules, webhooks, Make, Zapier, n8n, and other Apify integrations.

### 💡 Popular use cases

- Build a multi-company job search database
- Monitor competitors’ hiring activity
- Power a niche job board or newsletter
- Track new roles, locations, teams, and salary ranges
- Feed recruiting, market intelligence, or workforce analytics pipelines
- Audit differences between normalized fields and the original ATS payload

### ⚡ Performance and cost control

Native platforms are read page by page and can return thousands of jobs in one run. Full descriptions may require additional detail requests on some platforms.

For quick tests, set a small `maxJobsPerSource` or `maxJobsTotal`. For production exports, leave both at `0`. Disable descriptions, native data, or raw-response archiving when you only need a compact listing feed.

### ❓ FAQ

#### Do users need to provide an ATS API key?

No. The Actor works with job data publicly exposed by company career sites and supported ATS boards.

#### Can I enter a normal company homepage?

Yes. The Actor can discover a linked Careers or Jobs portal. A direct career-board URL remains more reliable when you already have it.

#### Will it really return all jobs?

For supported native ATS platforms, the Actor follows every available result page when both job limits are `0`. Custom career sites are collected up to `maxPagesPerSource` and can only expose data present in their public, server-readable pages.

#### Why is one job missing a description or salary?

Some source records do not publish those values. The Actor preserves missing data as missing rather than inventing it. Enable native fields and raw-response archiving to verify exactly what the source returned.

#### What happens when a source has no jobs or changes its layout?

The dataset receives a `recordType: "error"` row and the run summary identifies the affected source. Successful companies in the same run are still preserved.

#### How are duplicates handled?

Jobs are deduplicated by their canonical job URL, ATS job ID, or a stable fallback made from company, title, and location.

# Actor input Schema

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

Add company homepages or direct Greenhouse, Lever, Ashby, Workday, Workable, SmartRecruiters, Recruitee, Personio, BambooHR, and other career-page URLs.

## `maxJobsPerSource` (type: `integer`):

Maximum jobs returned from each supplied company. Set to 0 to collect every available job.

## `maxJobsTotal` (type: `integer`):

Global cap across every source after deduplication. Set to 0 for no global limit.

## `includeDescriptions` (type: `boolean`):

Open job-detail endpoints when needed and include both clean text and source HTML descriptions.

## `includeRawData` (type: `boolean`):

Adds rawJson and flattened native\_\_ fields so platform-specific values are never silently discarded.

## `saveRawResponses` (type: `boolean`):

Save successful JSON, HTML, and XML responses in the run key-value store for auditing. Disabled by default to keep storage light.

## `discoverFromCompanyWebsite` (type: `boolean`):

When a normal company homepage is supplied, locate its Careers or Jobs page and detect the underlying ATS.

## `maxDiscoveryPages` (type: `integer`):

Maximum company-site pages checked while searching for its career portal.

## `maxPagesPerSource` (type: `integer`):

Safety limit for unknown or custom career sites. Native ATS integrations still request every available result page.

## `maxConcurrency` (type: `integer`):

Number of sources and job details processed in parallel. The default balances speed and reliability.

## `maxRetries` (type: `integer`):

Retry budget for temporary network and source-server failures.

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

Optional Apify or custom proxy configuration for career sites that restrict direct access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.anthropic.com"
    },
    {
      "url": "https://jobs.ashbyhq.com/openai"
    }
  ],
  "maxJobsPerSource": 0,
  "maxJobsTotal": 0,
  "includeDescriptions": true,
  "includeRawData": true,
  "saveRawResponses": false,
  "discoverFromCompanyWebsite": true,
  "maxDiscoveryPages": 5,
  "maxPagesPerSource": 500,
  "maxConcurrency": 10,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `errors` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.anthropic.com"
        },
        {
            "url": "https://jobs.ashbyhq.com/openai"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/universal-career-site-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 = { "startUrls": [
        { "url": "https://www.anthropic.com" },
        { "url": "https://jobs.ashbyhq.com/openai" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("trakk/universal-career-site-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 '{
  "startUrls": [
    {
      "url": "https://www.anthropic.com"
    },
    {
      "url": "https://jobs.ashbyhq.com/openai"
    }
  ]
}' |
apify call trakk/universal-career-site-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Universal Career Site & ATS Jobs Scraper",
        "description": "Scrape every available job from company career sites and ATS platforms, including Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee, Personio, and BambooHR. Get titles, locations, salaries, descriptions, apply URLs, and raw source fields. No ATS API key required.",
        "version": "0.1",
        "x-build-id": "QSKUIwX2j1PQL7PIi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~universal-career-site-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-universal-career-site-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/trakk~universal-career-site-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-universal-career-site-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/trakk~universal-career-site-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-universal-career-site-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Company or career-page URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add company homepages or direct Greenhouse, Lever, Ashby, Workday, Workable, SmartRecruiters, Recruitee, Personio, BambooHR, and other career-page URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxJobsPerSource": {
                        "title": "🎯 Maximum jobs per source",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum jobs returned from each supplied company. Set to 0 to collect every available job.",
                        "default": 0
                    },
                    "maxJobsTotal": {
                        "title": "🧮 Maximum jobs in the entire run",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Global cap across every source after deduplication. Set to 0 for no global limit.",
                        "default": 0
                    },
                    "includeDescriptions": {
                        "title": "📝 Fetch full job descriptions",
                        "type": "boolean",
                        "description": "Open job-detail endpoints when needed and include both clean text and source HTML descriptions.",
                        "default": true
                    },
                    "includeRawData": {
                        "title": "🧬 Include every native ATS field",
                        "type": "boolean",
                        "description": "Adds rawJson and flattened native__ fields so platform-specific values are never silently discarded.",
                        "default": true
                    },
                    "saveRawResponses": {
                        "title": "🗄️ Archive complete source responses",
                        "type": "boolean",
                        "description": "Save successful JSON, HTML, and XML responses in the run key-value store for auditing. Disabled by default to keep storage light.",
                        "default": false
                    },
                    "discoverFromCompanyWebsite": {
                        "title": "🧭 Find career pages automatically",
                        "type": "boolean",
                        "description": "When a normal company homepage is supplied, locate its Careers or Jobs page and detect the underlying ATS.",
                        "default": true
                    },
                    "maxDiscoveryPages": {
                        "title": "🔎 Discovery pages per website",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum company-site pages checked while searching for its career portal.",
                        "default": 5
                    },
                    "maxPagesPerSource": {
                        "title": "📄 Universal fallback page limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety limit for unknown or custom career sites. Native ATS integrations still request every available result page.",
                        "default": 500
                    },
                    "maxConcurrency": {
                        "title": "⚡ Maximum concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of sources and job details processed in parallel. The default balances speed and reliability.",
                        "default": 10
                    },
                    "maxRetries": {
                        "title": "🔁 Request attempts",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Retry budget for temporary network and source-server failures.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify or custom proxy configuration for career sites that restrict direct access.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
