# AMS Austria Jobs Scraper (`automation-lab/ams-austria-jobs-scraper`) Actor

🇦🇹 Extract public AMS Austria job listings by keyword, location, or AMS URL. Get employers, locations, occupations, dates, and detail links.

- **URL**: https://apify.com/automation-lab/ams-austria-jobs-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

## AMS Austria Jobs Scraper

Extract current Austrian job listings from the public AMS portal at `jobs.ams.at`. The actor collects structured vacancies with job titles, employers, locations, occupations, working-time fields, update dates, detail URLs, and optional detail-page application/contact text.

### What does AMS Austria Jobs Scraper do?

AMS Austria Jobs Scraper turns public AMS search results into clean dataset rows. Give it a keyword, location, radius, or a direct AMS search URL and it opens the official jobs portal, waits for the public app to load, captures the same JSON responses used by the website, and saves normalized job records to your Apify dataset.

### Who is it for?

- Recruiters monitoring Austrian vacancies in specific regions.
- HR teams enriching ATS records with public AMS listings.
- Job boards and aggregators checking current public-market supply.
- Labor-market analysts tracking roles, employers, locations, and update dates.
- Sales teams building B2B lists from employers currently hiring in Austria.

### Why use this actor?

The AMS portal is useful but not designed for bulk export. This actor gives you repeatable Apify runs, API access, dataset exports, webhooks, schedules, and integrations without manually copying listings from the website.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId`, `uuid` | AMS identifiers |
| `title` | Job title |
| `employer` | Company or organization name |
| `location`, `postcode`, `municipality`, `federalState` | Austrian location fields |
| `occupation` | AMS occupation/classification when present |
| `employmentRelationship`, `workingTime`, `education` | Job condition fields |
| `salary` | Salary text when present |
| `description` | Search-result or detail description |
| `application`, `contact` | Extra detail text when detail mode is enabled |
| `detailUrl` | Public AMS job page |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape AMS Austria jobs?

The actor uses pay-per-event pricing: a small start charge plus a per-job result charge. You control spend with `maxItems`. Keep the default small for first tests, then raise it for production monitoring after you verify the output fields.

### Quick start

1. Open the actor on Apify.
2. Enter a keyword such as `Software`, `Pflege`, or `Buchhaltung`.
3. Optionally enter a location such as `1010`, `Wien`, `Graz`, or `Tirol`.
4. Set `maxItems`.
5. Run the actor and export the dataset as JSON, CSV, Excel, XML, or via API.

### Input options

#### `query`

Keyword, job title, skill, occupation, or company name to search on AMS.

#### `location`

Optional Austrian city, postcode, federal state, or locality text.

#### `radiusKm`

Optional distance around the location. Leave empty for the AMS default.

#### `startUrls`

Use direct `jobs.ams.at/public/emps/jobs?...` search URLs or detail URLs when you already built a specific AMS search in the browser.

#### `maxItems`

Maximum number of listings to save.

#### `includeDetails`

When enabled, the actor opens each job detail page and captures extra detail JSON. This is slower but can add application and contact text when AMS exposes it.

### Output example

```json
{
  "jobId": 22356789,
  "uuid": "20d86528-24e1-391d-bfad-815f8c526123",
  "title": "Senior Software Entwickler_in C# / .NET (m/w/x)",
  "employer": "Dorotheum GmbH & Co KG",
  "location": "1010, Wien,Innere Stadt",
  "occupation": "SoftwareentwicklerIn",
  "workingTime": "Vollzeit",
  "lastUpdatedAt": "2026-06-24T00:00:00Z",
  "detailUrl": "https://jobs.ams.at/public/emps/jobs/20d86528-24e1-391d-bfad-815f8c526123"
}
````

### Search examples

#### Software jobs in Vienna

```json
{
  "query": "Software",
  "location": "1010",
  "radiusKm": 25,
  "maxItems": 50
}
```

#### Nursing jobs in Graz

```json
{
  "query": "Pflege",
  "location": "Graz",
  "radiusKm": 50,
  "maxItems": 75
}
```

#### Direct AMS search URL

```json
{
  "startUrls": [
    { "url": "https://jobs.ams.at/public/emps/jobs?query=Buchhaltung&location=Wien&page=1&sortField=_SCORE" }
  ],
  "maxItems": 100
}
```

### Tips for best results

- Use German job titles or Austrian occupation terms for best AMS coverage.
- Start with `includeDetails: false` for fast monitoring.
- Enable detail mode for small high-value runs where application text matters.
- Use schedules for recurring job-market monitoring.
- Use direct start URLs when you need complex filters created in the AMS UI.

### Integrations

Send dataset rows to Google Sheets, Airtable, Make, Zapier, an ATS, a BI warehouse, or your own API. Apify webhooks can notify your system when a scheduled Austrian job-market monitor finishes.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ams-austria-jobs-scraper').call({
  query: 'Software',
  location: '1010',
  radiusKm: 25,
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ams-austria-jobs-scraper').call(run_input={
    'query': 'Pflege',
    'location': 'Graz',
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ams-austria-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"Software","location":"1010","maxItems":50}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through the Apify MCP server:

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

Claude Code setup:

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

Claude Desktop JSON configuration:

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

Example prompts:

- "Run the AMS Austria Jobs Scraper for Software jobs in Vienna and summarize hiring employers."
- "Monitor Pflege jobs in Graz on AMS and export new vacancies to a table."
- "Find Buchhaltung jobs in Wien and group them by employer."

### Scheduling

Create an Apify schedule to run daily or weekly. Combine schedules with a stable query/location pair to monitor Austrian hiring trends over time.

### Webhooks

Attach a webhook to run completion and push the default dataset URL to your CRM, ATS, Slack, or BI pipeline.

### Data quality notes

The actor captures public AMS website responses. Some fields are optional because not every listing includes salary, contact, or detailed application information. The `raw` field is included for audit and custom downstream mapping.

### Limitations

- The actor only extracts public listings available on the AMS site.
- It does not apply to private applicant accounts or saved-job features.
- Detail mode is slower because every listing opens an extra page.

### Legality and responsible use

This actor extracts publicly accessible job listing information. Make sure your use complies with applicable laws, AMS website terms, privacy rules, and your own compliance requirements. Do not use the data for spam or unlawful profiling.

### Related scrapers

Other automation-lab actors that may complement this one:

- `https://apify.com/automation-lab/jobindex-jobs-scraper`
- `https://apify.com/automation-lab/google-maps-lead-finder`
- `https://apify.com/automation-lab/website-contact-finder`

### FAQ

#### Does this require an AMS login?

No. The actor uses the public AMS jobs portal.

#### Why are some salary or contact fields empty?

AMS listings vary. Some records do not expose salary or contact fields in the public search response. Enable `includeDetails` for richer detail-page extraction.

#### Can I scrape a specific AMS URL?

Yes. Paste a search or detail URL into `startUrls`.

#### Can I monitor only one city?

Yes. Use `location` plus an optional `radiusKm`, or create a filtered URL in the AMS UI and paste it into `startUrls`.

### Troubleshooting

#### The run returns fewer jobs than `maxItems`

AMS returned fewer matching public listings for the query/location. Try a broader keyword, larger radius, or no location.

#### The run is slower in detail mode

Detail mode opens every job page to capture additional fields. Turn it off for large monitoring jobs.

### Changelog

- `0.1` Initial private build for AMS Austria public job listings.

### Support

If a run fails or you need an extra field, open an Apify issue with the run URL, input, and the specific field you expected.

# Actor input Schema

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

Search term used on jobs.ams.at, for example Software, Pflege, Buchhaltung or a company name.

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

Optional Austrian city, postcode or federal state, for example 1010, Wien, Graz or Tirol.

## `radiusKm` (type: `integer`):

Search radius around the location. Leave empty for the AMS default.

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

Optional jobs.ams.at search or job detail URLs. If set, these URLs are processed instead of query/location fields.

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

Maximum number of job records to save to the dataset.

## `includeDetails` (type: `boolean`):

Open each AMS job detail page for extra application/contact text. This is slower but richer.

## Actor input object example

```json
{
  "query": "Software",
  "location": "1010",
  "radiusKm": 25,
  "startUrls": [
    {
      "url": "https://jobs.ams.at/public/emps/jobs?query=Software&location=1010&page=1&sortField=_SCORE"
    }
  ],
  "maxItems": 20,
  "includeDetails": 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 = {
    "query": "Software",
    "location": "1010",
    "radiusKm": 25,
    "startUrls": [
        {
            "url": "https://jobs.ams.at/public/emps/jobs?query=Software&location=1010&page=1&sortField=_SCORE"
        }
    ],
    "maxItems": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ams-austria-jobs-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "query": "Software",
    "location": "1010",
    "radiusKm": 25,
    "startUrls": [{ "url": "https://jobs.ams.at/public/emps/jobs?query=Software&location=1010&page=1&sortField=_SCORE" }],
    "maxItems": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ams-austria-jobs-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "Software",
  "location": "1010",
  "radiusKm": 25,
  "startUrls": [
    {
      "url": "https://jobs.ams.at/public/emps/jobs?query=Software&location=1010&page=1&sortField=_SCORE"
    }
  ],
  "maxItems": 20,
  "includeDetails": false
}' |
apify call automation-lab/ams-austria-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AMS Austria Jobs Scraper",
        "description": "🇦🇹 Extract public AMS Austria job listings by keyword, location, or AMS URL. Get employers, locations, occupations, dates, and detail links.",
        "version": "0.1",
        "x-build-id": "K9BQk5Q4rhFBr4kRN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ams-austria-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ams-austria-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ams-austria-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ams-austria-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ams-austria-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ams-austria-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Keyword, job title or skill",
                        "type": "string",
                        "description": "Search term used on jobs.ams.at, for example Software, Pflege, Buchhaltung or a company name."
                    },
                    "location": {
                        "title": "Location / postcode / federal state",
                        "type": "string",
                        "description": "Optional Austrian city, postcode or federal state, for example 1010, Wien, Graz or Tirol."
                    },
                    "radiusKm": {
                        "title": "Radius in km",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Search radius around the location. Leave empty for the AMS default."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional jobs.ams.at search or job detail URLs. If set, these URLs are processed instead of query/location fields.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to save to the dataset.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Open each AMS job detail page for extra application/contact text. This is slower but richer.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```