# Google Jobs Scraper - Salary, Boards & Descriptions (`webdatalabs/google-jobs-intelligence`) Actor

Scrape the Google Jobs vertical by keyword and location. Returns title, company, location, source board (LinkedIn, Stepstone, XING, company careers), posted date, salary and full description. Monitor mode returns only jobs you haven't seen. Null-honest output. Export CSV/JSON.

- **URL**: https://apify.com/webdatalabs/google-jobs-intelligence.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 job scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

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

## Google Jobs Scraper — aggregated postings, salary & source boards

Search Google Jobs by keyword and location and get clean, structured job data — including the
**job boards each posting came from**, the **full description**, and **normalised salary**.

Google Jobs aggregates postings from LinkedIn, Indeed, Stepstone, XING, ZipRecruiter, Monster,
Wellfound, BeBee and thousands of company career pages. This Actor turns that vertical into a
dataset. (Those are boards we have actually seen in live output — `sourceBoards` tells you which
carried each posting.)

### What you get

One flat record per job:

| Field | Example |
|---|---|
| `title` | `Associate Principal Software Engineer` |
| `companyName` | `Becton Dickinson & Company` |
| `location` / `isRemote` / `workMode` | `Berlin` / `false` / `onsite` |
| `postedAt` / `postedAgoLabel` | `2026-07-24` / `3 days ago` |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | `72800` / `130000` / `USD` / `year` |
| `salaryRaw` | `$72,800 - $130,000` — exactly as Google rendered it |
| `salaryDisclosed` | `true` — tells you the posting *actually stated* pay |
| `employmentType` / `seniority` | `Full-time` / `Senior` |
| `sourceBoards` / `primarySource` | `["LinkedIn","Stepstone"]` / `LinkedIn` |
| `descriptionSnippet` / `description` | first ~300 chars / full posting text |
| `jobUrl` / `googleJobId` | canonical link / stable id for deduplication |

#### Example output

A real record, unedited apart from truncating the long text:

```json
{
  "googleJobId": "9wIVddLFFxuq9d1AAAAAAA==",
  "title": "Data Analyst II, Office of Data Analytics",
  "companyName": "Optum",
  "location": "Chicago, IL",
  "isRemote": false,
  "workMode": "onsite",
  "postedAt": "2026-07-24",
  "postedAgoLabel": "3 days ago",
  "salaryDisclosed": true,
  "salaryMin": 72800,
  "salaryMax": 130000,
  "salaryCurrency": "USD",
  "salaryPeriod": null,
  "salaryRaw": "$72,800 - $130,000",
  "employmentType": "Full-time",
  "seniority": null,
  "sourceBoards": ["Built In Chicago"],
  "primarySource": "Built In Chicago",
  "jobUrl": "https://www.google.com/search?ibp=htl;jobs&q=data+analyst+Chicago&htidocid=…",
  "descriptionSnippet": "Requisition Number: 2370192At UnitedHealthcare, we're simplifying the health care experience…",
  "description": "Requisition Number: 2370192At UnitedHealthcare, we're simplifying the health care experience…",
  "query": "data analyst",
  "searchLocation": "Chicago",
  "scrapedAt": "2026-07-27T12:33:16.267Z",
  "isNew": null
}
````

Note `seniority` and `salaryPeriod` are `null` here — the title carried no seniority cue and the
posting did not state a pay period. That is the null-honest contract, not a parsing failure.

### Monitor mode — only get what's new

Turn on **"Only return jobs I haven't seen before"** and the Actor remembers every posting it has
delivered, per search. Schedule it hourly or daily and each run returns **only newly posted jobs** —
so you are never charged twice for the same posting, and you get a working job alert instead of a
list you have to diff yourself.

### How many jobs can I get?

Google's jobs vertical shows **about 10 jobs per search and has no "next page"**. There is no way
around this — it is how the vertical works, and any tool claiming unlimited depth from a single
query is not being straight with you.

You get more results by **searching more combinations**. Every job title is searched in every
location, so:

> jobs ≈ job titles × locations × 10

Want 100 jobs? Use 2 job titles across 5 cities. The Actor deduplicates across all searches, so the
same posting found twice is only returned (and only charged) once.

### Honest limits

We would rather tell you up front than have you discover it mid-run:

- **~10 jobs per search**, as above.
- **Filters are applied after fetching.** Google ignores its own date/type filter parameters on this
  vertical, so "Last 24 hours" filters the jobs we retrieved rather than asking Google for more.
  Because a search only returns ~10 jobs, **stacking filters empties a run fast** — combining
  remote-only + full-time + last-week on one city can legitimately return zero. The run log always
  prints exactly which filter dropped how many jobs, so an empty result is never a mystery. Note
  that employment type and posted date are excluded when the *employer* didn't state them.
- **Posted dates are day-accurate, not exact.** Google only publishes a relative label
  ("3 days ago"), which we convert to a date.
- **Salary is often absent** — most postings, and nearly all German ones, do not state pay. You get
  `salaryDisclosed: false` and `null` figures, never a fabricated `0`.
- **No apply link.** Google renders apply buttons in JavaScript, so no outbound URL exists in the
  results. `jobUrl` takes you to Google's posting with its apply options. We do not ship an
  always-empty `applyUrl` field to pad the schema.

### Input

| Field | Description |
|---|---|
| **Job titles or keywords** *(required)* | e.g. `software engineer`, `registered nurse` |
| **Locations** | e.g. `Berlin`, `Munich`, `United States` |
| **Maximum jobs** | cap on unique jobs returned |
| **Posted within** | Any / 24 hours / 3 days / week / month |
| **Employment type** | Full-time / Part-time / Contract / Internship |
| **Only return jobs I haven't seen before** | monitor mode |
| *Advanced* | country, remote-only, include full description, debug |

### Use cases

- **Recruiters & staffing** — track live openings across every board from one search.
- **Job boards & aggregators** — bootstrap inventory with source attribution.
- **Labour-market analytics** — hiring volume, salary bands and seniority mix by city and role.
- **Sales / GTM teams** — hiring is a buying signal; a company opening 5 DevOps roles is scaling.
- **Job seekers** — a scheduled monitor-mode run is a personal job alert across all boards at once.

### FAQ

**Which job boards does it cover?**
Whatever Google indexes for your query. Boards seen in live runs include LinkedIn, Indeed,
Stepstone, XING, ZipRecruiter, Monster, Wellfound, BeBee, JobLeads, Jobvector, Haystack, eFinancial
Careers, Built In and many company career sites. `sourceBoards` tells you which carried each
posting. Coverage varies by role and country — it is Google's index, not a fixed list.

**Does it work outside the US?**
Yes. Choose a country in Advanced settings — verified working for the US and Germany, with 14
countries available. Job titles come back in the local language; date and source labels are
normalised to English so the output is consistent across markets.

**Is the data deduplicated?**
Google itself collapses a posting carried by several boards into one entry and lists the boards it
found it on — we expose that as `sourceBoards`. On top of that, this Actor deduplicates across your
searches by `googleJobId`, and across runs when monitor mode is on.

**Why are some fields null?**
Because the posting did not state them. Null means "not published", never "we failed to read it".

***

Built by [WebDataLabs](https://apify.com/webdatalabs). Found it useful? A review genuinely helps.

# Actor input Schema

## `queries` (type: `array`):

What to search for on Google Jobs. Each entry runs its own search, e.g. "software engineer" or "registered nurse".

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

Cities, regions or countries to search in, e.g. "Berlin", "Munich", "United States". Every job title is searched in every location, so adding locations is how you get more results.

## `maxJobs` (type: `integer`):

Upper limit on unique jobs returned. Google shows about 10 jobs per search, so the realistic maximum is roughly (job titles x locations x 10).

## `postedWithin` (type: `string`):

Only return jobs published in this time window.

## `employmentType` (type: `array`):

Only return jobs matching these employment types. Leave empty for all types.

## `monitorMode` (type: `boolean`):

Remembers jobs across runs and returns only newly posted ones. Ideal for a scheduled job alert - you are never charged twice for the same posting.

## `country` (type: `string`):

Which country's Google results to use. Controls which local job boards appear.

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

Only return jobs Google flags as remote or work-from-home.

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

Include the complete job description text. Costs nothing extra - Google returns it with the listing.

## `debug` (type: `boolean`):

Log extra diagnostics, including per-field extraction rates.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "product manager"
  ],
  "locations": [
    "Berlin",
    "Munich",
    "Hamburg"
  ],
  "maxJobs": 100,
  "postedWithin": "any",
  "employmentType": [],
  "monitorMode": false,
  "country": "us",
  "remoteOnly": false,
  "includeDescription": true,
  "debug": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `salary` (type: `string`):

No description

## `full` (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 = {
    "queries": [
        "software engineer"
    ],
    "locations": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/google-jobs-intelligence").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 = {
    "queries": ["software engineer"],
    "locations": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/google-jobs-intelligence").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 '{
  "queries": [
    "software engineer"
  ],
  "locations": [
    "United States"
  ]
}' |
apify call webdatalabs/google-jobs-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Jobs Scraper - Salary, Boards & Descriptions",
        "description": "Scrape the Google Jobs vertical by keyword and location. Returns title, company, location, source board (LinkedIn, Stepstone, XING, company careers), posted date, salary and full description. Monitor mode returns only jobs you haven't seen. Null-honest output. Export CSV/JSON.",
        "version": "1.0",
        "x-build-id": "roySdKtZk4wio1fWe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~google-jobs-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-google-jobs-intelligence",
                "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/webdatalabs~google-jobs-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-google-jobs-intelligence",
                "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/webdatalabs~google-jobs-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-google-jobs-intelligence",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Job titles or keywords",
                        "type": "array",
                        "description": "What to search for on Google Jobs. Each entry runs its own search, e.g. \"software engineer\" or \"registered nurse\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions or countries to search in, e.g. \"Berlin\", \"Munich\", \"United States\". Every job title is searched in every location, so adding locations is how you get more results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobs": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper limit on unique jobs returned. Google shows about 10 jobs per search, so the realistic maximum is roughly (job titles x locations x 10).",
                        "default": 100
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "today",
                            "3days",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Only return jobs published in this time window.",
                        "default": "any"
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Only return jobs matching these employment types. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "parttime",
                                "contractor",
                                "internship"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Internship"
                            ]
                        },
                        "default": []
                    },
                    "monitorMode": {
                        "title": "Only return jobs I haven't seen before",
                        "type": "boolean",
                        "description": "Remembers jobs across runs and returns only newly posted ones. Ideal for a scheduled job alert - you are never charged twice for the same posting.",
                        "default": false
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "de",
                            "at",
                            "ch",
                            "ca",
                            "au",
                            "ie",
                            "nl",
                            "fr",
                            "es",
                            "it",
                            "in",
                            "sg"
                        ],
                        "type": "string",
                        "description": "Which country's Google results to use. Controls which local job boards appear.",
                        "default": "us"
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Only return jobs Google flags as remote or work-from-home.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Include the complete job description text. Costs nothing extra - Google returns it with the listing.",
                        "default": true
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Log extra diagnostics, including per-field extraction rates.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
