# Jobsite Scraper (`maximedupre/jobsite-scraper`) Actor

Scrape Jobsite jobs by keyword, location, filters, or pasted URLs. Get full descriptions, salaries, employers, locations, apply links, listing metadata, contact hints, and scrape metadata in clean dataset items.

- **URL**: https://apify.com/maximedupre/jobsite-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 1,000 scraped jobs

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

### 🔎 Jobsite scraper for UK job listings

Jobsite Scraper collects public jobs from [Jobsite](https://www.jobsite.co.uk/) and saves them as structured data you can export, schedule, or send through the Apify API. Use this Jobsite scraper to build searches from keywords and locations, or paste Jobsite search URLs and direct job URLs when you already know the pages you want.

Start with a small run such as `software engineer` in `London`, keep the default full-detail mode, and review the dataset before scaling up. Each saved item is one job with employer, location, salary, apply, listing, detail, contact, and scrape metadata groups.

### ✅ What this Jobsite scraper does

- Searches Jobsite by keyword and optional UK locations.
- Accepts pasted Jobsite search pages and direct Jobsite job URLs.
- Supports Jobsite filters for job type, advertiser type, minimum salary, salary period, posted date, and sort order.
- Saves one dataset item per accepted job.
- Fetches full job details by default, including descriptions, apply data, valid-through dates, employment type, industry, and location coordinates when Jobsite shows them.
- Offers a fast listings mode when you want listing-page fields without visiting every job page.
- Adds best-effort contact hints from visible job description text and links when those hints are present.
- Works with Apify exports, schedules, webhooks, integrations, and API clients.

This Actor focuses on public Jobsite job data. It does not log in, submit applications, scrape candidate data, or collect private recruiter pages.

### 📦 What data you get

Each dataset item is one Jobsite job. Some fields can be empty when Jobsite does not show that value for a specific posting.

- `rowType`, `sourceSite`, `jobId`, `harmonisedId`, and `externalId`: source identity fields
- `jobUrl` and `sourceSearchUrl`: source links and search context
- `title`, `datePosted`, `publishFromDate`, and `validThrough`: core job details
- `detailFetched` and `detailUnavailableReason`: whether full details were fetched
- `employer`: employer name, source ID, logo URL, and profile URL when available
- `location`: location text, locality, region, postal code, country, latitude, and longitude
- `salary`: raw salary text plus normalized min, max, currency, period, and confidence
- `apply`: apply URL, apply type, and direct-apply signal
- `listing`: skills, snippet, work-from-home signal, sponsorship flags, cross-posting data, partnership data, and source labels
- `details`: description HTML and text, employment type, industry, job location type, and applicant location requirements
- `contacts`: visible emails, phone numbers, and source snippets when found in public job text
- `metadata`: scrape timestamp, input target, page, position, and search context

### 🧭 Common use cases

- Track UK hiring demand by role, location, employer, salary band, or posting date.
- Build repeatable Jobsite exports for recruiting, market research, or job-board analysis.
- Monitor public competitor hiring in software engineering, sales, operations, care, logistics, finance, and other UK roles.
- Create structured job feeds for dashboards, alerts, CRMs, spreadsheets, or data warehouses.
- Compare salary ranges, employer names, work-from-home signals, and apply flows across Jobsite search results.
- Save direct Jobsite job pages into one consistent dataset for later review.

### 🚀 How to run it

For the easiest first run:

1. Set `How to choose jobs` to `Build a search`.
2. Enter a role or skill in `Keywords`, such as `software engineer`.
3. Add one or more UK locations in `Locations`, such as `London`.
4. Set `Maximum jobs` to a small number such as `25`.
5. Keep `Detail mode` set to `Full details`.
6. Run the Actor and open the dataset.

You can also choose `Use pasted URLs` and add Jobsite search pages or direct Jobsite job pages in `Jobsite URLs`. Direct job URLs normally save one job each.

### 🎛️ Input options

- `How to choose jobs`: build a Jobsite search from form fields or use pasted Jobsite URLs.
- `Keywords`: role, skill, company, or job terms for built searches.
- `Locations`: UK locations for built searches.
- `Job type`: optional Jobsite job-type filter.
- `Advertiser`: optional direct employer or recruitment agency filter.
- `Minimum salary` and `Salary period`: optional salary filter for built searches.
- `Posted within`: optional freshness filter for built searches.
- `Sort by`: result order to request from Jobsite.
- `Jobsite URLs`: Jobsite search pages or direct job pages for URL runs.
- `Detail mode`: `Full details` fetches each job page; `Fast listings` saves listing-page fields faster.
- `Include contact hints`: captures visible public emails and phone numbers when they appear in job text or links.
- `Maximum jobs`: total jobs to save across the run.
- `Maximum pages per search`: result pages to read for built searches and pasted search URLs.

You do not need Jobsite cookies, a Jobsite account, or a separate API key.

### 🧾 Output example

```json
{
  "rowType": "job",
  "sourceSite": "jobsite.co.uk",
  "jobId": "107494478",
  "jobUrl": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478",
  "sourceSearchUrl": "https://www.jobsite.co.uk/jobs/software-engineer/in-london",
  "title": "Software Engineer",
  "datePosted": "2026-06-09",
  "validThrough": "2026-07-09",
  "detailFetched": true,
  "detailUnavailableReason": null,
  "employer": {
    "id": "123456",
    "name": "Example Employer",
    "url": "https://www.jobsite.co.uk/jobs/example-employer",
    "logoUrl": "https://www.jobsite.co.uk/company-logo.png"
  },
  "location": {
    "text": "London, GB",
    "locality": "London",
    "country": "GB",
    "latitude": 51.5072,
    "longitude": -0.1276
  },
  "salary": {
    "raw": "£55,000 - £70,000",
    "min": 55000,
    "max": 70000,
    "currency": "GBP",
    "period": "year",
    "confidence": "json-ld"
  },
  "apply": {
    "url": "https://www.jobsite.co.uk/apply/107494478",
    "type": "direct",
    "isDirect": true,
    "originalJobUrl": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478"
  },
  "listing": {
    "skills": ["TypeScript", "AWS"],
    "textSnippet": "Build and maintain customer-facing services.",
    "workFromHome": false,
    "isSponsored": false,
    "isHighlighted": false,
    "isTopJob": false,
    "labels": []
  },
  "details": {
    "descriptionText": "Full public job description text...",
    "employmentType": "FULL_TIME",
    "industry": "Technology"
  },
  "contacts": {
    "emails": [],
    "phones": [],
    "evidence": []
  },
  "metadata": {
    "sourcePage": 1,
    "sourceRank": 1,
    "sourceInput": "software engineer in London",
    "searchKeyword": "software engineer",
    "searchLocation": "London",
    "scrapedAt": "2026-06-10T12:00:00.000Z"
  }
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged `$0.0008` for each job saved to the dataset, which is `$0.80 per 1,000 saved jobs`. Runs that find no matching jobs do not create paid job items.

### ⚠️ Limits and caveats

- Jobsite can omit salary, location coordinates, employment type, apply data, or employer details on some postings.
- Contact hints are best-effort and only come from visible public job text or links. They may be empty.
- `Fast listings` mode is faster, but it does not fetch the full job page for every item.
- Pasted URLs should be public Jobsite search pages or direct Jobsite job pages.
- Stale, removed, or unsupported Jobsite pages can be skipped instead of saved as placeholder items.
- This Actor is built for public Jobsite data, not private recruiter dashboards or job application workflows.

### ❓ FAQ

#### 🔐 Can I scrape Jobsite without a login?

Yes. This Actor works with public Jobsite pages and does not ask for Jobsite cookies, passwords, or API keys.

#### 🔗 Can I paste Jobsite URLs?

Yes. Choose `Use pasted URLs` and add Jobsite search pages or direct job pages. Direct job pages normally save one job each.

#### 📄 What does full details mode add?

`Full details` visits each job page and saves richer fields when available, such as full descriptions, apply metadata, employment type, valid-through dates, coordinates, and visible contact hints.

#### ⚡ When should I use fast listings mode?

Use `Fast listings` when you want a quicker overview from listing pages and do not need full descriptions or detail-page fields.

#### 💷 Why is a salary field empty?

Some Jobsite postings do not show salary details. When salary text is visible, the Actor saves the raw text and tries to normalize numeric min and max values.

#### 📬 Are contact hints guaranteed?

No. Contact hints are saved only when public job text or links visibly include an email address or phone number.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~jobsite-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [CWjobs Scraper ↗](https://apify.com/maximedupre/cwjobs-scraper) - Scrape UK tech job listings with employer, salary, location, and apply data.
- [Goodmoves Jobs Scraper ↗](https://apify.com/maximedupre/goodmoves-jobs-scraper) - Collect Scottish charity and social-impact job listings.
- [Welcome to the Jungle Jobs Extractor ↗](https://apify.com/maximedupre/welcometothejungle-jobs-extractor) - Extract job listings from Welcome to the Jungle.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Collect public company profile data for lead lists and market research.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Find public emails from websites for lead and recruiting workflows.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `mode` (type: `string`):

Choose which target section this run should use.

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

Use when How to choose jobs is Build a search.

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

Locations for the built Jobsite search.

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

Search target only. Filter by Jobsite job type.

## `advertiserType` (type: `string`):

Search target only. Filter by employer source.

## `minSalary` (type: `integer`):

Search target only. Minimum advertised salary.

## `salaryPeriod` (type: `string`):

Search target only. Period for the salary filter.

## `postedWithinDays` (type: `string`):

Search target only. Posted date window.

## `sortBy` (type: `string`):

Search target only. Result order to request.

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

Use when How to choose jobs is Use pasted URLs.

## `detailMode` (type: `string`):

Full details fetches each job page. Fast listings saves listing-page fields.

## `includeContactHints` (type: `boolean`):

Add visible company and recruiter contact hints.

## `maxItems` (type: `integer`):

Total jobs to save across the whole run.

## `maxPagesPerSearch` (type: `integer`):

Result pages for built searches and pasted search URLs.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": "software engineer",
  "locations": [
    "London"
  ],
  "jobType": "any",
  "advertiserType": "any",
  "salaryPeriod": "annual",
  "postedWithinDays": "7",
  "sortBy": "relevance",
  "startUrls": [
    {
      "url": "https://www.jobsite.co.uk/jobs/in-london"
    },
    {
      "url": "https://www.jobsite.co.uk/jobs/software-engineer/in-london"
    },
    {
      "url": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478"
    }
  ],
  "detailMode": "fullDetails",
  "includeContactHints": true,
  "maxItems": 25,
  "maxPagesPerSearch": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with job, employer, location, salary, apply, listing, detail, contact, and scrape metadata.

# 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 = {
    "keywords": "software engineer",
    "locations": [
        "London"
    ],
    "postedWithinDays": "7",
    "startUrls": [
        {
            "url": "https://www.jobsite.co.uk/jobs/in-london"
        },
        {
            "url": "https://www.jobsite.co.uk/jobs/software-engineer/in-london"
        },
        {
            "url": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478"
        }
    ],
    "maxItems": 25,
    "maxPagesPerSearch": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/jobsite-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 = {
    "keywords": "software engineer",
    "locations": ["London"],
    "postedWithinDays": "7",
    "startUrls": [
        { "url": "https://www.jobsite.co.uk/jobs/in-london" },
        { "url": "https://www.jobsite.co.uk/jobs/software-engineer/in-london" },
        { "url": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478" },
    ],
    "maxItems": 25,
    "maxPagesPerSearch": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/jobsite-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 '{
  "keywords": "software engineer",
  "locations": [
    "London"
  ],
  "postedWithinDays": "7",
  "startUrls": [
    {
      "url": "https://www.jobsite.co.uk/jobs/in-london"
    },
    {
      "url": "https://www.jobsite.co.uk/jobs/software-engineer/in-london"
    },
    {
      "url": "https://www.jobsite.co.uk/delivery-driver/ikea-job107494478"
    }
  ],
  "maxItems": 25,
  "maxPagesPerSearch": 2
}' |
apify call maximedupre/jobsite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobsite Scraper",
        "description": "Scrape Jobsite jobs by keyword, location, filters, or pasted URLs. Get full descriptions, salaries, employers, locations, apply links, listing metadata, contact hints, and scrape metadata in clean dataset items.",
        "version": "0.1",
        "x-build-id": "jrRP5KfR7IYsnUjFI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~jobsite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-jobsite-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/maximedupre~jobsite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-jobsite-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/maximedupre~jobsite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-jobsite-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "How to choose jobs",
                        "enum": [
                            "search",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Choose which target section this run should use.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Use when How to choose jobs is Build a search."
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations for the built Jobsite search.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "London"
                        ]
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "any",
                            "permanent",
                            "contract",
                            "temporary",
                            "partTime",
                            "workFromHome"
                        ],
                        "type": "string",
                        "description": "Search target only. Filter by Jobsite job type.",
                        "default": "any"
                    },
                    "advertiserType": {
                        "title": "Advertiser",
                        "enum": [
                            "any",
                            "employer",
                            "agency"
                        ],
                        "type": "string",
                        "description": "Search target only. Filter by employer source.",
                        "default": "any"
                    },
                    "minSalary": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Search target only. Minimum advertised salary."
                    },
                    "salaryPeriod": {
                        "title": "Salary period",
                        "enum": [
                            "annual",
                            "daily",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Search target only. Period for the salary filter.",
                        "default": "annual"
                    },
                    "postedWithinDays": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Search target only. Posted date window.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date",
                            "salary-desc",
                            "salary-asc",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Search target only. Result order to request.",
                        "default": "relevance"
                    },
                    "startUrls": {
                        "title": "Jobsite URLs",
                        "type": "array",
                        "description": "Use when How to choose jobs is Use pasted URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "detailMode": {
                        "title": "Detail mode",
                        "enum": [
                            "fullDetails",
                            "fastListings"
                        ],
                        "type": "string",
                        "description": "Full details fetches each job page. Fast listings saves listing-page fields.",
                        "default": "fullDetails"
                    },
                    "includeContactHints": {
                        "title": "Include contact hints",
                        "type": "boolean",
                        "description": "Add visible company and recruiter contact hints.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Total jobs to save across the whole run.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Result pages for built searches and pasted search URLs.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```