# Arbetsformedlingen Jobs Search Scraper (`automation-lab/arbetsformedlingen-jobs-search-scraper`) Actor

Extract Swedish job ads from Arbetsförmedlingen / JobTech with employer, location, occupation, deadline, and application data.

- **URL**: https://apify.com/automation-lab/arbetsformedlingen-jobs-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Arbetsformedlingen Jobs Search Scraper

Extract Swedish job ads from Arbetsförmedlingen and the official JobTech public search API.

Use this actor to monitor hiring demand in Sweden, collect job leads, enrich labor-market dashboards, and export structured job records with employer, location, occupation, deadline, salary, and application details.

### What does Arbetsformedlingen Jobs Search Scraper do?

Arbetsformedlingen Jobs Search Scraper searches Sweden's official public job-search data source and saves matching ads as structured dataset rows.

It works through the JobTech API endpoint behind Arbetsförmedlingen job search, so runs are fast, stable, and inexpensive.

The actor can collect broad keyword searches such as `developer`, location-focused searches such as Stockholm developer roles, occupation taxonomy searches, employer-focused lists, and date-bounded monitoring exports.

### Who is it for?

Recruiters use it to identify active employers, open roles, and application deadlines.

Staffing agencies use it to monitor demand by municipality, occupation group, and employer organization number.

Sales and lead-generation teams use it to find companies hiring in Sweden and prioritize outreach.

Labor-market analysts use it to export repeatable hiring snapshots for dashboards.

Job-board operators use it to compare fresh public listings by region, skills, and occupation.

### Why use this actor?

It avoids brittle browser scraping and calls the public API directly.

It saves normalized fields that are easy to filter in CSV, Excel, Google Sheets, BI tools, and databases.

It includes Swedish-specific fields such as municipality codes, region codes, employer organization numbers, occupation taxonomy labels, scope of work, and Arbetsförmedlingen listing URLs.

It can be scheduled to build daily or weekly job-market monitors.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Job identity | JobTech ID, headline, Arbetsförmedlingen URL |
| Dates | publication date, last publication date, application deadline |
| Employer | employer name, workplace, organization number, employer URL |
| Location | municipality, region, city, street, postcode, coordinates |
| Occupation | occupation label, concept ID, group, field |
| Work terms | employment type, duration, working hours, scope, vacancies |
| Application | application URL, email, reference |
| Description | plain text and optional formatted HTML |
| Search metadata | query, total found, scrape timestamp |

### How much does it cost to scrape Arbetsformedlingen jobs?

This actor uses pay-per-event pricing.

There is a small start charge for each run and a per-job charge for every saved job ad.

The default pricing is designed for low-cost Swedish job monitoring and will be recalculated from cloud test runs before publication.

For a quick test, keep `maxItems` at 100 or lower.

For a production export, raise `maxItems` to the number of listings you need.

### Input options

`query` is the main search phrase.

`locations` accepts Swedish municipality or region names for post-filtering and official numeric codes for API filtering.

`employer` filters saved results by employer name, workplace name, or organization number.

`publishedAfter` and `publishedBefore` limit jobs by publication date.

`occupationIds`, `occupationFields`, and `occupationGroups` accept JobTech taxonomy concept IDs.

`includeDescriptionHtml` adds formatted HTML descriptions when you need rich text.

`includeStats` adds the total count returned by the search.

### Example input

```json
{
  "query": "developer",
  "locations": ["Stockholm"],
  "publishedAfter": "2026-06-01",
  "maxItems": 100,
  "includeDescriptionHtml": false,
  "includeStats": true
}
````

### Example output

```json
{
  "jobId": "31200838",
  "headline": "Fullstack.NET Developer",
  "webpageUrl": "https://arbetsformedlingen.se/platsbanken/annonser/31200838",
  "employerName": "BidWise Consulting AB",
  "employerOrganizationNumber": "5595789016",
  "workplaceMunicipality": "Stockholm",
  "workplaceRegion": "Stockholms län",
  "occupationLabel": "Systemutvecklare/Programmerare",
  "employmentType": "Tillsvidareanställning (inkl. eventuell provanställning)",
  "applicationEmail": "jobb@example.com",
  "searchQuery": "developer",
  "searchTotal": 712
}
```

### How to scrape Swedish job ads

1. Open the actor on Apify.

2. Enter a keyword in `query`.

3. Optionally add locations, employer filters, occupation filters, or publication dates.

4. Choose the maximum number of job ads.

5. Run the actor.

6. Download the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Location filtering tips

Use official municipality codes when you know them, for example `0180` for Stockholm municipality.

Use official region codes when you want broader API-side filtering, for example `01` for Stockholms län.

Use location names such as `Stockholm`, `Göteborg`, or `Malmö` when you prefer simple post-filtering.

Post-filtering is useful when you do not know the exact JobTech code.

### Occupation filtering tips

The JobTech taxonomy uses concept IDs.

For example, the Data/IT occupation field can be filtered with `apaJ_2ja_LuF`.

If you do not know concept IDs, start with a keyword query and use the output occupation fields to discover the right IDs for future scheduled runs.

### Employer monitoring workflow

Set `query` to a broad role or skill.

Set `employer` to a company name, workplace name, or Swedish organization number.

Schedule the actor daily.

Export new rows into your CRM, spreadsheet, or data warehouse.

This gives sales teams and recruiters a repeatable way to track named accounts that are hiring.

### Labor-market analytics workflow

Run the same query across multiple municipality or region filters.

Keep `includeStats` enabled.

Load the dataset into a dashboard.

Compare vacancy counts, occupation groups, employers, and application deadlines over time.

Use Apify schedules to generate a consistent time series.

### Lead generation workflow

Search for roles that imply active budgets, such as developers, warehouse workers, nurses, sales managers, or electricians.

Use employer names and organization numbers as lead identifiers.

Prioritize companies with many vacancies, urgent deadlines, or repeated postings.

Export the dataset to CSV or connect it to a CRM through Apify integrations.

### Integrations

Send results to Google Sheets for recruiter review.

Send results to Make or Zapier to trigger notifications when a target employer posts a role.

Store results in BigQuery, Snowflake, PostgreSQL, or S3 for analytics.

Use webhooks to notify Slack or email when scheduled monitoring finds new jobs.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/arbetsformedlingen-jobs-search-scraper').call({
  query: 'developer',
  locations: ['Stockholm'],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/arbetsformedlingen-jobs-search-scraper').call(run_input={
    'query': 'developer',
    'locations': ['Stockholm'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~arbetsformedlingen-jobs-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"developer","locations":["Stockholm"],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/arbetsformedlingen-jobs-search-scraper
```

Claude Code quick setup:

```bash
claude mcp add apify-arbetsformedlingen-jobs "https://mcp.apify.com/?tools=automation-lab/arbetsformedlingen-jobs-search-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-arbetsformedlingen-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/arbetsformedlingen-jobs-search-scraper"
    }
  }
}
```

Example prompts:

- "Run the Arbetsformedlingen jobs scraper for developer jobs in Stockholm and summarize the top employers."
- "Find Swedish job ads mentioning data engineer and return employer organization numbers."
- "Monitor nurse job postings in Skåne and show application deadlines."

### Scheduling and monitoring

Create an Apify schedule for daily or weekly monitoring.

Use the same input each time to build comparable snapshots.

Keep `publishedAfter` aligned with your schedule window when you only want new ads.

Store historical datasets if you need trend analysis.

### Data quality notes

The actor returns fields supplied by the official JobTech API.

Some employers hide company details or application URLs.

Some jobs provide application emails instead of application links.

Descriptions are in the language used by the employer, often Swedish or English.

Location and occupation taxonomy fields depend on the source ad quality.

### Limitations

This actor does not apply for jobs.

It does not scrape private applicant data.

It does not bypass login pages or collect non-public employer systems.

It returns public job-ad metadata and descriptions available through the official search API.

### Legality

This actor extracts public job ads from a public API endpoint.

You are responsible for using the data lawfully and respecting applicable privacy, database, employment, and marketing rules.

Avoid collecting or using personal contact details in ways that violate GDPR or other laws.

If in doubt, consult legal counsel for your use case.

### FAQ

#### Can I scrape Arbetsförmedlingen without a browser?

Yes. This actor uses the public JobTech API and does not launch Playwright.

#### Why did my employer filter return no rows?

Employer filtering is a post-filter against employer name, workplace name, and organization number. Broaden the query first, then add a more precise employer value.

### Troubleshooting

If you get no results, broaden the query or remove location and employer filters.

If a location name does not match expected rows, try an official municipality or region code.

If descriptions are too large for your export, keep `includeDescriptionHtml` disabled.

If you need more rows, increase `maxItems` and rerun.

### Related scrapers

Use other Automation Lab job and business-data actors when you need markets outside Sweden.

Related options may include Google Jobs, StepStone, company registry, and business directory scrapers depending on your workflow.

All related actors should use `https://apify.com/automation-lab/` actor links after publication.

### Support

If the actor stops returning expected public job ads, open an Apify issue with your input and run ID.

Include the query, filters, expected result, and a sample Arbetsförmedlingen listing if possible.

### Changelog

Initial version extracts job ads from the public Arbetsförmedlingen / JobTech search API.

### Output schema stability

Output field names are designed to remain stable after publication.

New fields may be added in later versions, but existing names should not be renamed without notice.

### Performance

The actor is API-only and usually finishes quickly.

No browser is launched.

No proxy is required for the public API path.

Pagination runs in bounded batches to keep memory usage low.

# Actor input Schema

## `query` (type: `string`):

Keyword, role, skill, company, or phrase to search in Swedish job ads (for example developer, sjuksköterska, sales, Volvo).

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

Optional municipality/region names for post-filtering (Stockholm, Göteborg) or official numeric codes for API filtering (0180 municipality, 01 region).

## `employer` (type: `string`):

Optional post-filter for employer name, workplace name, or organization number.

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

Maximum number of job ads to save. Keep this low for tests and raise it for production exports.

## `publishedAfter` (type: `string`):

Only include ads published after this date/time. Use YYYY-MM-DD or an ISO timestamp.

## `publishedBefore` (type: `string`):

Only include ads published before this date/time. Use YYYY-MM-DD or an ISO timestamp.

## `occupationIds` (type: `array`):

Optional JobTech occupation field concept IDs, sent as occupation-field API filters (example Data/IT: apaJ\_2ja\_LuF).

## `occupationFields` (type: `array`):

Optional additional JobTech occupation-field concept IDs.

## `occupationGroups` (type: `array`):

Optional JobTech occupation-group concept IDs.

## `includeDescriptionHtml` (type: `boolean`):

Add formatted HTML job descriptions in addition to plain text. Leave off for lean CSV exports.

## `includeStats` (type: `boolean`):

Add JobTech total result count to each output item.

## Actor input object example

```json
{
  "query": "developer",
  "locations": [
    "Stockholm"
  ],
  "maxItems": 20,
  "publishedAfter": "2026-06-01",
  "includeDescriptionHtml": false,
  "includeStats": true
}
```

# Actor output Schema

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

No description

## `stats` (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 = {
    "query": "developer",
    "locations": [
        "Stockholm"
    ],
    "maxItems": 20,
    "publishedAfter": "2026-06-01",
    "includeDescriptionHtml": false,
    "includeStats": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/arbetsformedlingen-jobs-search-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 = {
    "query": "developer",
    "locations": ["Stockholm"],
    "maxItems": 20,
    "publishedAfter": "2026-06-01",
    "includeDescriptionHtml": False,
    "includeStats": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/arbetsformedlingen-jobs-search-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 '{
  "query": "developer",
  "locations": [
    "Stockholm"
  ],
  "maxItems": 20,
  "publishedAfter": "2026-06-01",
  "includeDescriptionHtml": false,
  "includeStats": true
}' |
apify call automation-lab/arbetsformedlingen-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arbetsformedlingen Jobs Search Scraper",
        "description": "Extract Swedish job ads from Arbetsförmedlingen / JobTech with employer, location, occupation, deadline, and application data.",
        "version": "0.1",
        "x-build-id": "OGfHMIOyjGJnGN2KM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~arbetsformedlingen-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-arbetsformedlingen-jobs-search-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/automation-lab~arbetsformedlingen-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-arbetsformedlingen-jobs-search-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/automation-lab~arbetsformedlingen-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-arbetsformedlingen-jobs-search-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword, role, skill, company, or phrase to search in Swedish job ads (for example developer, sjuksköterska, sales, Volvo).",
                        "default": "developer"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional municipality/region names for post-filtering (Stockholm, Göteborg) or official numeric codes for API filtering (0180 municipality, 01 region).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "employer": {
                        "title": "Employer contains",
                        "type": "string",
                        "description": "Optional post-filter for employer name, workplace name, or organization number."
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job ads to save. Keep this low for tests and raise it for production exports.",
                        "default": 100
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Only include ads published after this date/time. Use YYYY-MM-DD or an ISO timestamp."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Only include ads published before this date/time. Use YYYY-MM-DD or an ISO timestamp."
                    },
                    "occupationIds": {
                        "title": "Occupation field concept IDs",
                        "type": "array",
                        "description": "Optional JobTech occupation field concept IDs, sent as occupation-field API filters (example Data/IT: apaJ_2ja_LuF).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "occupationFields": {
                        "title": "Occupation field IDs",
                        "type": "array",
                        "description": "Optional additional JobTech occupation-field concept IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "occupationGroups": {
                        "title": "Occupation group IDs",
                        "type": "array",
                        "description": "Optional JobTech occupation-group concept IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Add formatted HTML job descriptions in addition to plain text. Leave off for lean CSV exports.",
                        "default": false
                    },
                    "includeStats": {
                        "title": "Include search stats",
                        "type": "boolean",
                        "description": "Add JobTech total result count to each output item.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
