# Arbeit.Swiss Scraper | 1$/1k Cheap (`trev0n/arbeit-swiss-scraper`) Actor

Scrapes job listings from arbeit.swiss / Job-Room.ch - Switzerland's official public employment service (SECO/RAV). API-based, fast and reliable.

- **URL**: https://apify.com/trev0n/arbeit-swiss-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## 🇨🇭 Arbeit.Swiss Scraper — Job-Room.ch Job Listings Extractor

> Pull thousands of live job listings straight from **arbeit.swiss / Job-Room.ch**, Switzerland's official public employment service — complete with company, location, workload, contact details and apply links.

Search by keyword, filter by canton and workload, and export clean, structured data ready for your spreadsheet, CRM or job board. Fast, reliable and built on the portal's official data feed.

---

### 💡 What Does It Do?

This scraper collects job advertisements published on **arbeit.swiss** (the public face of Job-Room.ch, run by SECO and the regional employment centres / RAV). For every listing it returns a clean, flat record containing the job title, employer, location, canton, workload range, full description, recruiter contact details and the direct application link.

You can scrape by **search keywords**, restrict results to specific **Swiss cantons**, or feed it a list of **direct job URLs** to re-check whether a listing is still online — perfect for monitoring and keeping a job database up to date.

---

### 👥 Who Is This For?

| 🎯 User                           | 💼 Use Case                                            |
| --------------------------------- | ------------------------------------------------------ |
| 🧑‍💼 Recruiters & staffing agencies | Build a live pipeline of open roles across Switzerland |
| 📊 Market researchers             | Track hiring trends by canton, industry and workload   |
| 🏢 HR & competitive intelligence  | Monitor which companies are hiring and for what        |
| 🌐 Job board operators            | Aggregate Swiss listings into your own platform        |
| 🤖 Data & AI teams                | Feed structured Swiss labour-market data into models   |

---

### ✨ Features

- 🔍 **Keyword search** — run several search terms in one go, results de-duplicated automatically
- 🗺️ **Canton filtering** — narrow down to ZH, BE, GE, VD, TI and any other Swiss canton
- ⚙️ **Workload filter** — keep only roles within a chosen workload percentage range (e.g. 80–100%)
- 🗓️ **Freshness control** — include only jobs published within the last X days
- 🔗 **Direct URL mode** — re-check specific listings and detect online / offline status
- 📇 **Rich contact data** — recruiter name, e-mail and phone where the employer provides them
- 🧭 **Sorting** — newest first, oldest first, or default relevance
- 🚀 **Fast & lightweight** — runs comfortably on the smallest memory tier
- 🧹 **Clean output** — ready-to-use flat records, no HTML noise in titles

---

### 🎛️ Filters & Options

| ⚙️ Option                     | 📝 Description                                                                        |
| ----------------------------- | ------------------------------------------------------------------------------------- |
| 🔍 Search queries             | One or more keywords; each runs as a separate search and results merge & de-duplicate |
| 🗺️ Canton codes               | Limit to specific Swiss cantons (e.g. ZH, BE, GE). Leave empty for all of Switzerland |
| 🔗 Direct job URLs            | Re-scrape or status-check specific listings by their arbeit.swiss / job-room.ch URL   |
| ⚙️ Minimum / maximum workload | Keep only jobs within a workload percentage range (0–100)                             |
| 🗓️ Online since (days)        | Include only jobs published within the last X days (1–60)                             |
| 📌 Permanent only             | Restrict to permanent positions, or include temporary roles too                       |
| 🧭 Sort by                    | Newest first, oldest first, or default relevance                                      |
| 🔢 Max results per query      | Cap the number of jobs collected per keyword                                          |
| 🔢 Max results (total)        | Overall cap across all keywords                                                       |

---

### 📦 Output Fields

#### Job

| Field           | Description                                         |
| --------------- | --------------------------------------------------- |
| id              | Unique job advertisement identifier                 |
| title           | Job title                                           |
| company         | Employer / company name                             |
| location        | City or town of the workplace                       |
| canton          | Swiss canton code (e.g. ZH, BE)                     |
| employment_type | `permanent` or `temporary`                          |
| workload_min    | Minimum workload percentage                         |
| workload_max    | Maximum workload percentage                         |
| remote_option   | Whether remote / home-office is offered             |
| job_status      | `online` / `offline` (populated in direct URL mode) |

#### Description

| Field               | Description                           |
| ------------------- | ------------------------------------- |
| description_snippet | Short preview of the job description  |
| description_full    | Full job description text             |
| requirements        | List of requirements (when available) |

#### Dates

| Field      | Description                                |
| ---------- | ------------------------------------------ |
| posted_at  | Publication date                           |
| expires_at | Date the listing is scheduled to come down |
| scraped_at | Timestamp of when the record was collected |

#### Contact & Application

| Field              | Description                |
| ------------------ | -------------------------- |
| contact_salutation | Recruiter salutation       |
| contact_firstname  | Recruiter first name       |
| contact_lastname   | Recruiter last name        |
| contact_email      | Recruiter e-mail           |
| contact_phone      | Recruiter phone number     |
| apply_url          | Direct link to apply       |
| apply_email        | Application e-mail address |
| company_url        | Employer website           |

#### Source

| Field           | Description                         |
| --------------- | ----------------------------------- |
| source_url      | Original listing URL on job-room.ch |
| source_platform | Always `arbeit.swiss`               |
| search_query    | Keyword that produced this hit      |

---

### 📄 Example Output

```json
{
    "id": "83de804e-2f8a-4814-bac0-691c547f5621",
    "title": "Fachmann / Fachfrau Gesundheit EFZ (m/w/d) (80-100%) in Wohlen gesucht",
    "company": "MediPersonal",
    "location": "Wohlen",
    "canton": "BE",
    "job_status": null,
    "employment_type": "permanent",
    "workload_min": 100,
    "workload_max": 100,
    "remote_option": false,
    "description_snippet": "Med Ipersonal ist ein Temporärbüro, das sich auf die spezialisierte Vermittlung von Fachkräften in der Medizinbranche konzentriert …",
    "description_full": "Fachmann / Fachfrau Gesundheit EFZ (m/w/d) (80-100%) in Wohlen gesucht …",
    "requirements": [],
    "posted_at": "2026-06-22",
    "expires_at": "2026-07-22",
    "scraped_at": "2026-06-22T19:08:54.364Z",
    "source_url": "https://www.job-room.ch/job-search/83de804e-2f8a-4814-bac0-691c547f5621",
    "source_platform": "arbeit.swiss",
    "contact_salutation": "MS",
    "contact_firstname": "Barbara",
    "contact_lastname": "Schmucki",
    "contact_email": "info@med-ipersonal.ch",
    "contact_phone": "+41445155761",
    "apply_url": "https://med-ipersonal.ch/jobs/fachmann-fachfrau-gesundheit-efz-m-w-d-80-100-in-wohlen-gesucht/",
    "apply_email": "info@med-ipersonal.ch",
    "company_url": "med-ipersonal.ch",
    "search_query": "fachfrau gesundheit"
}
````

***

### 📊 Dataset Views

- 🗂️ **Job listings** — a clean table of every scraped role: title, company, location, canton, workload, dates, status and apply link.

Export to **JSON, CSV, Excel, HTML or XML** with one click, or pull results through the API into your own systems.

***

### ❓ FAQ

**🌍 What exactly does this scrape?**
Public job advertisements from arbeit.swiss / Job-Room.ch, Switzerland's official public employment service.

**🔑 Do I need an account or login?**
No. The scraper works against publicly available listings — no credentials required.

**🗺️ Can I limit results to one canton?**
Yes. Provide one or more canton codes (e.g. ZH, GE, TI) and only jobs in those cantons are returned.

**🔁 Can I check if a job I found earlier is still online?**
Yes. Use direct URL mode: paste the listing URLs and each record will report whether it is `online` or `offline`.

**💼 Does it return salary information?**
The portal does not publish salary figures for most listings, so this field is generally not available. Workload percentage is provided instead.

**⚡ How fast is it and how much does it cost to run?**
It uses the portal's official data feed, so it is fast and inexpensive — large pulls of thousands of listings finish in minutes on the smallest memory tier.

**📅 Can I get only recent jobs?**
Yes. Set the "online since" option to only include jobs published within the last N days.

***

### 🛠️ Need Something Custom?

Need extra fields, a different country's job portal, scheduled daily exports, or integration into your own database? **Reach out** — custom scraping and automation work is welcome, and this actor can be tailored to your exact workflow.

***

### ⚖️ Legal

This tool collects only publicly available information. You are responsible for using the scraped data in compliance with applicable laws (including data-protection regulations such as the GDPR and the Swiss FADP) and the source website's terms. Use responsibly.

# Actor input Schema

## `directUrls` (type: `array`):

List of arbeit.swiss / job-room.ch job URLs to re-scrape or check for a still-alive status. Each URL is resolved individually and its job\_status (online/offline) is populated. Use this for monitoring previously found listings.

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

One or more search keywords. Each keyword runs as a separate search and results are de-duplicated across all queries. Leave empty to scrape all currently published jobs.

## `keywords` (type: `array`):

Legacy alias for Search queries. Use 'searchQueries' instead. Both are merged if provided.

## `cantonCodes` (type: `array`):

Swiss canton codes to filter by (e.g. ZH, BE, GE, VD, SG, TI, BS). Leave empty for all of Switzerland.

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

Result ordering. 'date\_desc' = newest first, 'date\_asc' = oldest first, empty = default relevance.

## `workloadMin` (type: `integer`):

Minimum workload percentage (0-100). Filters out part-time jobs below this threshold.

## `workloadMax` (type: `integer`):

Maximum workload percentage (0-100).

## `onlineSinceDays` (type: `integer`):

Include only jobs published within the last X days (1-60). The portal removes ads after 60 days, so 60 is the maximum.

## `permanent` (type: `boolean`):

Leave unchecked for both permanent and temporary positions. Check to restrict to permanent positions only.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of jobs to scrape per search keyword. Set to 0 for unlimited per query.

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

Maximum total number of jobs across all queries. Set to 0 for unlimited.

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

Maximum number of parallel requests.

## `maxRequestRetries` (type: `integer`):

Maximum number of retries for failed requests (exponential backoff).

## `maxRequestsPerMinute` (type: `integer`):

Throttle to avoid rate limiting.

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

Proxy settings. The API is usually reachable without a proxy, but Swiss residential proxies improve reliability for large runs.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "sortBy": "",
  "workloadMin": 10,
  "workloadMax": 100,
  "onlineSinceDays": 60,
  "permanent": false,
  "maxResultsPerQuery": 100,
  "maxResults": 0,
  "maxConcurrency": 10,
  "maxRequestRetries": 3,
  "maxRequestsPerMinute": 120,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "software engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/arbeit-swiss-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchQueries": ["software engineer"] }

# Run the Actor and wait for it to finish
run = client.actor("trev0n/arbeit-swiss-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "software engineer"
  ]
}' |
apify call trev0n/arbeit-swiss-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arbeit.Swiss Scraper | 1$/1k Cheap",
        "description": "Scrapes job listings from arbeit.swiss / Job-Room.ch - Switzerland's official public employment service (SECO/RAV). API-based, fast and reliable.",
        "version": "1.0",
        "x-build-id": "TGbeHidgSOE83gvKi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~arbeit-swiss-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-arbeit-swiss-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/trev0n~arbeit-swiss-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-arbeit-swiss-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/trev0n~arbeit-swiss-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-arbeit-swiss-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": {
                    "directUrls": {
                        "title": "Direct job URLs",
                        "type": "array",
                        "description": "List of arbeit.swiss / job-room.ch job URLs to re-scrape or check for a still-alive status. Each URL is resolved individually and its job_status (online/offline) is populated. Use this for monitoring previously found listings.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more search keywords. Each keyword runs as a separate search and results are de-duplicated across all queries. Leave empty to scrape all currently published jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords (legacy)",
                        "type": "array",
                        "description": "Legacy alias for Search queries. Use 'searchQueries' instead. Both are merged if provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cantonCodes": {
                        "title": "Canton codes",
                        "type": "array",
                        "description": "Swiss canton codes to filter by (e.g. ZH, BE, GE, VD, SG, TI, BS). Leave empty for all of Switzerland.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "date_desc",
                            "date_asc"
                        ],
                        "type": "string",
                        "description": "Result ordering. 'date_desc' = newest first, 'date_asc' = oldest first, empty = default relevance.",
                        "default": ""
                    },
                    "workloadMin": {
                        "title": "Minimum workload (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum workload percentage (0-100). Filters out part-time jobs below this threshold.",
                        "default": 10
                    },
                    "workloadMax": {
                        "title": "Maximum workload (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum workload percentage (0-100).",
                        "default": 100
                    },
                    "onlineSinceDays": {
                        "title": "Online since (days)",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Include only jobs published within the last X days (1-60). The portal removes ads after 60 days, so 60 is the maximum.",
                        "default": 60
                    },
                    "permanent": {
                        "title": "Permanent positions only",
                        "type": "boolean",
                        "description": "Leave unchecked for both permanent and temporary positions. Check to restrict to permanent positions only.",
                        "default": false
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of jobs to scrape per search keyword. Set to 0 for unlimited per query.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum total number of jobs across all queries. Set to 0 for unlimited.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of parallel requests.",
                        "default": 10
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of retries for failed requests (exponential backoff).",
                        "default": 3
                    },
                    "maxRequestsPerMinute": {
                        "title": "Max requests per minute",
                        "minimum": 10,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Throttle to avoid rate limiting.",
                        "default": 120
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The API is usually reachable without a proxy, but Swiss residential proxies improve reliability for large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
