# ✅ ATS Jobs Scraper - Greenhouse, Ashby, Lever + Remote API (`k1ra/ats-jobs-scraper`) Actor

ATS jobs scraper for Greenhouse, Ashby & Lever applicant tracking systems plus remote job boards in one run. Give a company name or domain — we auto-detect the ATS and slug. Reliable, full descriptions & salary, flat schema. Multi-ATS jobs API for n8n, Make & Zapier. Pay per job, $0 on empty.

- **URL**: https://apify.com/k1ra/ats-jobs-scraper.md
- **Developed by:** [Kevin Savani](https://apify.com/k1ra) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## ✅ ATS Jobs Scraper — Greenhouse, Ashby, Lever + Remote Jobs API

**Scrape jobs from Greenhouse, Ashby, and Lever — the three major Applicant Tracking Systems (ATS) — plus open remote job boards, all in one run.** Reliable and fast, with no broken runs. Just give a **company name or domain** and this ATS jobs scraper finds the right ATS and board for you, then returns clean, structured jobs with full descriptions and salary.

> **Just give a company name — we find the ATS.** Reliable by design, never breaks, full descriptions + salary, pay only for jobs delivered.

---

### Why Choose This ATS Jobs Scraper

- **All 3 major ATS in one actor** — Greenhouse, Ashby, and Lever, plus remote boards (RemoteOK, Remotive, We Work Remotely). One flat schema, one run.
- **Name or domain input — automatic ATS slug discovery.** Most ATS scrapers force you to already know each company's exact ATS *and* slug. This one resolves it for you (the hard part of the niche).
- **Built for reliability** — no broken runs, no flaky HTML parsing, no "whole run died because one company was wrong."
- **Full descriptions + compensation** where the source exposes it (Ashby and Lever structured salary; Greenhouse best-effort).
- **Pay per unique job, $0 on empty** — never charged for an empty run, no per-run floor.
- **n8n, Make & Zapier ready** — clean JSON for AI agents, job boards, and automation.

---

### How It Compares

| Feature | **This Scraper** | Typical ATS scrapers |
|---|:---:|:---:|
| Greenhouse **+ Ashby + Lever** in one run | ✅ | ⚠️ usually one ATS each |
| Remote boards folded in | ✅ RemoteOK, Remotive, WWR | ❌ |
| **Company name or domain** input | ✅ auto-resolves the ATS + slug | ❌ require exact slug |
| Auto ATS detection from a domain | ✅ | ❌ |
| Per-company resilience | ✅ one bad company ≠ dead run | ❌ whole run dies |
| Full descriptions & salary | ✅ included | ⚠️ partial / extra step |
| Exact `maxResults` honored | ✅ | ❌ over-fetch & overcharge |
| Pricing | ✅ pay per job, **$0 on empty, no floor** | ❌ per-run minimums |

---

### Use Cases

#### Greenhouse Jobs Scraper & API
Pull every open role from any company on **Greenhouse** with full descriptions, departments, locations, and posting dates. This **Greenhouse ATS scraper** is great for ATS aggregators, sourcing tools, and hiring-signal monitoring.

#### Ashby Jobs Scraper & API
Use the **Ashby jobs API** to scrape **Ashby** job boards including structured **compensation / salary ranges**, employment type, remote flags, and full descriptions — the data most Ashby scrapers leave out.

#### Lever Jobs Scraper
Extract postings from any **Lever** board with team, commitment (employment type), location, and description. Companies with zero current openings are handled cleanly — you are never charged for empty results.

#### Multi-ATS Job Scraper (Greenhouse + Lever + Ashby)
Feed a list of companies and let this **multi ATS job scraper** fan out across **all three ATS at once**, deduplicate, and return one unified feed of **company job listings** — a **career site jobs** feed and the spine of any multi-board job aggregator.

#### Remote Jobs Scraper & API
Add keyword-driven **remote job boards** (RemoteOK, Remotive, We Work Remotely) to the same run for a combined ATS + remote jobs feed.

#### Company Name or Domain → ATS Slug Discovery
Don't know which ATS a company uses? Paste the **company name or domain** (e.g. `ramp.com`) and the actor figures out the right ATS and board for you automatically — no manual lookup, no slug hunting.

#### ATS Jobs Scraper API for n8n, Make & Zapier
Run on a schedule and pipe clean JSON into **n8n, Make, Zapier**, Google Sheets, your database, or an AI agent. Perfect for job boards, ATS/HR-tech products, recruiting, and lead enrichment.

---

### Who Uses This

- **Job boards & aggregators** building a multi-ATS company-jobs feed.
- **HR-tech & ATS products** enriching company hiring data.
- **Recruiters & sourcers** tracking openings at target companies.
- **Founders & sales teams** using hiring signals for lead enrichment.
- **AI agents & automations** that need a reliable, flat jobs API.

---

### Input

| Field | Type | Description |
|---|---|---|
| `companies` | array | Company **names, slugs, or domains** (e.g. `stripe`, `openai`, `ramp.com`). Auto-resolved to an ATS board. |
| `ats` | array | `greenhouse` / `ashby` / `lever` / `auto` (default `auto` — discover automatically). |
| `remoteBoards` | array | `remoteok` / `remotive` / `wwr`. Keyword-driven, no slug needed. |
| `keywords` | string | Filter on title/description/skills + search term for remote boards. |
| `location` | string | Location substring filter. |
| `remoteOnly` | boolean | Keep only remote roles. |
| `postedAfter` | string | Only jobs posted on/after this ISO date. |
| `includeDescription` | boolean | Full descriptions (default `true`). |
| `includeCompensation` | boolean | Salary where exposed (default `true`). |
| `maxResults` | integer | Exact cap — no over-fetch (default 200). |
| `dedupe` | boolean | Remove duplicates (default `true`). |

At least one of `companies` or `remoteBoards` is required.

#### Example input

```json
{
  "companies": ["stripe", "openai", "palantir", "ramp.com"],
  "ats": ["auto"],
  "remoteBoards": ["remoteok"],
  "keywords": "backend engineer",
  "includeCompensation": true,
  "maxResults": 500
}
````

***

### Output

Each row is one job posting with a clean, flat schema:

| Field | Description |
|---|---|
| `title` | Job title |
| `company` | Hiring company |
| `companyDomain` | Company domain (when resolved via domain) |
| `location` | Job location |
| `remote` | Whether the role is remote |
| `postedAt` | ISO posting date |
| `jobUrl` | Public job / apply URL |
| `sourceBoard` | greenhouse, ashby, lever, remoteok, remotive, or wwr |
| `sourceAts` | The ATS, for ATS-sourced jobs |
| `description` | Full job description |
| `salaryMin` / `salaryMax` / `currency` / `salaryText` | Compensation, when exposed |
| `jobType` | Employment type (full time / contract …) |
| `seniority` | Seniority inferred from the title |
| `industry` | Department / team |
| `skills` | Tags (remote boards) |
| `scrapedAt` | ISO scrape timestamp |

#### Example output

```json
{
  "title": "Security Engineer, Cloud",
  "company": "ramp",
  "companyDomain": "ramp.com",
  "location": "New York",
  "remote": false,
  "postedAt": "2026-05-21T00:00:00.000Z",
  "jobUrl": "https://jobs.ashbyhq.com/ramp/…",
  "sourceBoard": "ashby",
  "sourceAts": "ashby",
  "salaryText": "$211.4K - $290.6K",
  "salaryMin": 211400,
  "salaryMax": 290600,
  "currency": "USD",
  "jobType": "full time",
  "seniority": "senior",
  "scrapedAt": "2026-06-16T09:00:00.000Z"
}
```

***

### Just Give a Company — We Find the ATS

Most ATS scrapers make you already know each company's exact ATS *and* its board slug — the single biggest source of friction in this niche. This actor removes it: provide a **company name, slug, or domain** and it resolves the right ATS and board for you, then returns the jobs.

Each company is handled independently, so one company that can't be resolved never affects the rest of your run.

***

### Pricing

- **$0.002 per unique job delivered** (post-dedupe).
- **$0 on an empty run** — no per-run minimum, no charge for empty boards.

***

### Integrations & Automation

- **n8n / Make / Zapier** — trigger runs and consume the dataset via webhook or the Apify API.
- **Google Sheets / Airtable / database** — export jobs on a schedule.
- **AI agents** — flat JSON is ideal for LLM tools and the Apify MCP server.
- **Apify API & SDK** — call from Node.js or Python.

***

### FAQ

**Which ATS platforms are supported?**
Greenhouse, Ashby, and Lever, plus remote boards RemoteOK, Remotive, and We Work Remotely.

**Do I need to know each company's ATS or slug?**
No. Provide a company name, slug, or domain — the actor auto-detects the ATS and resolves the slug.

**Do I need a proxy or any setup?**
No. The actor handles everything for you — just add companies (or remote boards) and run.

**Does it include salary / compensation?**
Yes, where the source exposes it. Ashby and Lever roles often include structured ranges; otherwise compensation is parsed best-effort from the description.

**Will it break when sites change?**
It's built for reliability and designed to keep working where fragile HTML scrapers break.

**Can I use it with n8n, Make, or Zapier?**
Yes. The output is clean flat JSON, ready for n8n, Make, Zapier, Google Sheets, and AI agents.

**Is it legal to scrape ATS job listings?**
This actor reads publicly available job postings from public job boards. As always, review the relevant terms and your own use case.

***

### ⭐ Bookmark this Actor & Leave a Review

If this **ATS jobs scraper** saves you time:

- **⭐ Star it** at the top of the page to bookmark it and help other Apify users find it.
- **📝 Leave a review** — one sentence on your use case helps us prioritize the next ATS, board, or field (Workday, SmartRecruiters, Recruitee, extra filters).

Your bookmarks and reviews directly improve this actor's discoverability across the Apify Store.

***

### Related Apify Actors

- [ATS Scrapers](https://apify.com/store?search=ats%20jobs%20scraper) — Greenhouse, Ashby, Lever and more
- [Greenhouse Scrapers](https://apify.com/store?search=greenhouse%20jobs) — Greenhouse job boards
- [Job Scrapers](https://apify.com/store?search=job%20scraper) — LinkedIn, Indeed, Naukri, and more
- [All Jobs Actors](https://apify.com/store?category=JOBS) — the full Apify jobs catalog

***

### Support & Feedback

Found a bug or want a new ATS, board, or field?

- **Open an issue** on the actor's Issues tab in the Apify Console.
- **Feature requests** are welcome — especially more ATS platforms (Workday, SmartRecruiters, Recruitee), extra filters, and richer company data.

# Actor input Schema

## `companies` (type: `array`):

Company names, ATS slugs, OR domains (e.g. "stripe", "openai", "ramp.com"). We auto-detect the ATS and slug for each. Leave empty to scrape only remote boards.

## `ats` (type: `array`):

Which ATS to query per company: greenhouse, ashby, lever, or auto (discover automatically). Default: auto.

## `remoteBoards` (type: `array`):

Optional keyword-driven open remote boards to fold in: remoteok, remotive, wwr. No company/slug needed.

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

Optional filter applied to title/description/skills (AND match), and the search term for remote boards.

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

Optional location substring filter (e.g. "San Francisco", "London").

## `remoteOnly` (type: `boolean`):

Keep only roles detected as remote.

## `postedAfter` (type: `string`):

Only return jobs posted on/after this date (ISO, e.g. 2026-05-01).

## `includeDescription` (type: `boolean`):

Include each job's full description (free, on by default).

## `includeCompensation` (type: `boolean`):

Include salary range where the ATS exposes it (Ashby/Lever structured; Greenhouse best-effort from text).

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

Maximum unique jobs to return. Enforced exactly — no over-fetch, no overcharge.

## `dedupe` (type: `boolean`):

Remove duplicate postings by apply URL / title+company+location.

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

Optional. Proxy is handled automatically — leave as is. Advanced users may supply their own proxy.

## Actor input object example

```json
{
  "companies": [
    "stripe",
    "openai",
    "palantir"
  ],
  "ats": [
    "auto"
  ],
  "remoteBoards": [],
  "remoteOnly": false,
  "includeDescription": true,
  "includeCompensation": true,
  "maxResults": 200,
  "dedupe": true
}
```

# Actor output Schema

## `jobId` (type: `string`):

Stable per-source job id.

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

Job title.

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

Hiring company.

## `companyDomain` (type: `string`):

Company domain (when resolved from a domain).

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

Job location.

## `remote` (type: `string`):

True when the role looks remote.

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

ISO date the job was posted.

## `jobUrl` (type: `string`):

Public job / apply URL.

## `sourceBoard` (type: `string`):

greenhouse, ashby, lever, remoteok, remotive, or wwr.

## `sourceAts` (type: `string`):

The ATS, for ATS-sourced jobs.

## `description` (type: `string`):

Job description text (on by default).

## `salaryMin` (type: `string`):

Minimum salary, when exposed.

## `salaryMax` (type: `string`):

Maximum salary, when exposed.

## `currency` (type: `string`):

Salary currency.

## `salaryText` (type: `string`):

Salary label as shown.

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

Full time / part time / contract, when present.

## `seniority` (type: `string`):

Seniority inferred from the title.

## `industry` (type: `string`):

Department / team, when present.

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

Tags for the role (remote boards).

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

ISO 8601 timestamp of scrape.

# 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 = {
    "companies": [
        "stripe",
        "openai",
        "palantir"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("k1ra/ats-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 = { "companies": [
        "stripe",
        "openai",
        "palantir",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("k1ra/ats-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 '{
  "companies": [
    "stripe",
    "openai",
    "palantir"
  ]
}' |
apify call k1ra/ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ ATS Jobs Scraper - Greenhouse, Ashby, Lever + Remote API",
        "description": "ATS jobs scraper for Greenhouse, Ashby & Lever applicant tracking systems plus remote job boards in one run. Give a company name or domain — we auto-detect the ATS and slug. Reliable, full descriptions & salary, flat schema. Multi-ATS jobs API for n8n, Make & Zapier. Pay per job, $0 on empty.",
        "version": "0.1",
        "x-build-id": "LRAtDMg6FXqCDXFSD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/k1ra~ats-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-k1ra-ats-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/k1ra~ats-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-k1ra-ats-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/k1ra~ats-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-k1ra-ats-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": {
                    "companies": {
                        "title": "Companies (name, slug, or domain)",
                        "type": "array",
                        "description": "Company names, ATS slugs, OR domains (e.g. \"stripe\", \"openai\", \"ramp.com\"). We auto-detect the ATS and slug for each. Leave empty to scrape only remote boards.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ats": {
                        "title": "ATS to search",
                        "type": "array",
                        "description": "Which ATS to query per company: greenhouse, ashby, lever, or auto (discover automatically). Default: auto.",
                        "default": [
                            "auto"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteBoards": {
                        "title": "Remote job boards",
                        "type": "array",
                        "description": "Optional keyword-driven open remote boards to fold in: remoteok, remotive, wwr. No company/slug needed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Optional filter applied to title/description/skills (AND match), and the search term for remote boards."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location substring filter (e.g. \"San Francisco\", \"London\")."
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only roles detected as remote.",
                        "default": false
                    },
                    "postedAfter": {
                        "title": "Posted after",
                        "type": "string",
                        "description": "Only return jobs posted on/after this date (ISO, e.g. 2026-05-01)."
                    },
                    "includeDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Include each job's full description (free, on by default).",
                        "default": true
                    },
                    "includeCompensation": {
                        "title": "Include compensation",
                        "type": "boolean",
                        "description": "Include salary range where the ATS exposes it (Ashby/Lever structured; Greenhouse best-effort from text).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum unique jobs to return. Enforced exactly — no over-fetch, no overcharge.",
                        "default": 200
                    },
                    "dedupe": {
                        "title": "Deduplicate",
                        "type": "boolean",
                        "description": "Remove duplicate postings by apply URL / title+company+location.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Proxy is handled automatically — leave as is. Advanced users may supply their own proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
