# Numbeo Cost of Living Scraper (`automation-lab/numbeo-scraper`) Actor

Scrape cost-of-living data from Numbeo.com — city rankings with indices, detailed price lists per city, and city-to-city comparisons. Covers 486+ cities with 93 price items each.

- **URL**: https://apify.com/automation-lab/numbeo-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, Business
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Numbeo Cost of Living Scraper

Scrape cost-of-living data from [Numbeo.com](https://www.numbeo.com/cost-of-living/) — the world's largest database of user-contributed data about cities and countries. Extract city rankings, detailed price lists, and city-to-city comparisons in structured JSON, CSV, or Excel format.

### What data can you scrape?

This actor supports three scraping modes:

#### 1. City Rankings

Scrape the global cost-of-living rankings table with indices for 486+ cities worldwide. Each city includes:

- **Cost of Living Index** — relative to New York City (100)
- **Rent Index** — apartment rent prices relative to NYC
- **Cost of Living + Rent Index** — combined metric
- **Groceries Index** — grocery prices relative to NYC
- **Restaurant Price Index** — dining costs relative to NYC
- **Local Purchasing Power Index** — relative purchasing power

#### 2. City Prices

Get detailed price breakdowns for specific cities. Each city page contains ~93 individual price items organized by category:

- **Restaurants** — meal prices, coffee, beer, water at restaurants
- **Markets** — grocery prices for milk, bread, eggs, cheese, fruits, vegetables, meat
- **Transportation** — public transit tickets, taxi fares, gasoline prices
- **Utilities** — electricity, water, heating, internet, mobile plans
- **Sports and Leisure** — gym memberships, cinema tickets, tennis court rentals
- **Childcare** — preschool, international school fees
- **Clothing and Shoes** — brand-name and mid-range clothing prices
- **Rent Per Month** — apartments (1-bedroom and 3-bedroom, city center and outside)
- **Buy Apartment Price** — price per square meter in and outside city center
- **Salaries and Financing** — average monthly salary, mortgage interest rates

#### 3. City Comparison

Compare two cities side by side. Get price differences for every item with percentage comparisons, making it easy to understand the relative cost of living.

### Use cases

#### Relocation research
Moving to a new city? Compare cost of living between your current city and potential destinations. Understand exactly how much more or less you will spend on rent, groceries, dining out, and transportation.

#### Salary benchmarking
HR teams and recruiters use cost-of-living data to set competitive salaries across different locations. Compare purchasing power indices to understand what equivalent salaries look like in different cities.

#### Remote work location planning
Digital nomads and remote workers can evaluate potential base cities by comparing living costs. Find cities with the best quality-of-life-to-cost ratio by analyzing purchasing power alongside rent and grocery indices.

#### Academic and economic research
Researchers studying urbanization, economic development, and quality of life use Numbeo data as a primary source. Export structured datasets for statistical analysis and cross-city modeling.

#### HR compensation planning
Build location-based compensation tiers backed by real data. Use rankings indices to create multipliers for different office locations and calculate equitable pay adjustments.

#### Market analysis
Companies evaluating expansion into new markets can use cost-of-living data to estimate operational costs, employee compensation requirements, and consumer purchasing power in target cities.

#### Real estate investment
Compare rent indices and apartment purchase prices across cities to identify markets with favorable rent-to-price ratios or emerging affordable markets.

### How to use

#### Rankings mode (default)

Scrape the global rankings table. Set `maxCities` to limit results.

```json
{
    "mode": "rankings",
    "maxCities": 20
}
````

**Output example:**

```json
{
    "rank": 1,
    "city": "Hamilton",
    "country": "Bermuda",
    "costOfLivingIndex": 148.17,
    "rentIndex": 95.38,
    "costOfLivingPlusRentIndex": 123.43,
    "groceriesIndex": 155.89,
    "restaurantPriceIndex": 138.22,
    "localPurchasingPowerIndex": 97.24,
    "url": "https://www.numbeo.com/cost-of-living/in/Hamilton"
}
```

#### City Prices mode

Scrape detailed prices for specific cities.

```json
{
    "mode": "city_prices",
    "cities": ["New York", "London", "Tokyo", "Berlin"]
}
```

**Output example:**

```json
{
    "city": "New York",
    "country": "United States",
    "category": "Restaurants",
    "item": "Meal, Inexpensive Restaurant",
    "price": 25.00,
    "currency": "USD",
    "range": "15.00-40.00",
    "url": "https://www.numbeo.com/cost-of-living/in/New-York",
    "scrapedAt": "2026-03-26T10:30:00.000Z"
}
```

#### Comparison mode

Compare two cities side by side.

```json
{
    "mode": "comparison",
    "cities": ["New York", "London"]
}
```

**Output example:**

```json
{
    "city1": "New York",
    "city2": "London",
    "category": "Restaurants",
    "item": "Meal, Inexpensive Restaurant",
    "city1Price": 25.00,
    "city2Price": 20.00,
    "difference": "-20.00%",
    "currency": "USD",
    "url": "https://www.numbeo.com/cost-of-living/compare_cities.jsp?city1=New+York&city2=London",
    "scrapedAt": "2026-03-26T10:30:00.000Z"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `rankings` | Scraping mode: `rankings`, `city_prices`, or `comparison` |
| `cities` | array | `[]` | List of city names (for `city_prices` and `comparison` modes) |
| `maxCities` | integer | `50` | Max cities to return in rankings mode |
| `year` | string | (current) | Year for historical data (e.g., `"2024"`) |
| `currency` | string | (local) | Display currency code (e.g., `"USD"`, `"EUR"`) |
| `language` | string | `en` | Language code |
| `requestDelay` | integer | `500` | Delay between requests in milliseconds |

### City name format

Use city names as they appear on Numbeo. Multi-word cities use spaces in the input and are automatically converted to URL slugs:

- `"New York"` becomes `/in/New-York`
- `"Buenos Aires"` becomes `/in/Buenos-Aires`
- `"Ho Chi Minh City"` becomes `/in/Ho-Chi-Minh-City`
- `"London"` becomes `/in/London`

### Output format

Data is stored in the default dataset and can be exported as:

- **JSON** — structured data for programmatic use
- **CSV** — spreadsheet-compatible format
- **Excel** — direct download as .xlsx
- **XML** — for data pipeline integration

Access results via the Apify API, Console UI, or integrate with tools like Google Sheets, Zapier, Make, or custom webhooks.

### Performance and limits

| Metric | Value |
|--------|-------|
| Memory | 256 MB |
| Rankings (all cities) | ~5 seconds |
| Per city (prices) | ~2 seconds |
| Default rate limit | 500ms between requests |
| Retry attempts | 3 with exponential backoff |

### Pricing

This actor uses pay-per-event pricing:

| Event | Price |
|-------|-------|
| Run started | $0.01 (one-time) |
| City scraped (FREE tier) | $0.005 per city |
| City scraped (BRONZE) | $0.0045 per city |
| City scraped (SILVER) | $0.004 per city |
| City scraped (GOLD) | $0.00325 per city |
| City scraped (PLATINUM) | $0.0025 per city |
| City scraped (DIAMOND) | $0.002 per city |

**Example costs:**

- Rankings (50 cities): $0.01 + 50 x $0.005 = $0.26
- City prices (10 cities): $0.01 + 10 x $0.005 = $0.06
- Comparison (2 cities): $0.01 + 2 x $0.005 = $0.02

### Integrations

Connect this actor to your existing workflows:

- **Google Sheets** — automatically export data to spreadsheets
- **Slack / Discord** — get notifications when scraping completes
- **Zapier / Make** — trigger downstream automations
- **Webhooks** — receive data via HTTP callbacks
- **API** — programmatic access to datasets and runs

### Tips

1. **Start with rankings** to identify cities of interest, then use city\_prices for detailed data.
2. **Use the currency parameter** to normalize all prices to a single currency for easier comparison.
3. **Historical data** is available by setting the year parameter — useful for tracking trends over time.
4. **Rate limiting** — the default 500ms delay works well. Increase if you encounter issues.
5. **Comparison mode** is ideal for quick A-vs-B decisions; use city\_prices for comprehensive data.

### Data freshness

Numbeo data is updated continuously by user contributions. The scraper extracts the latest available data at the time of each run. For historical analysis, use the `year` parameter to access archived data.

### Legal and ethical use

This actor scrapes publicly available data from Numbeo.com. Users are responsible for complying with Numbeo's Terms of Service and applicable data regulations. The actor implements polite scraping practices with rate limiting and retry backoff.

### Support

- **Bug reports**: Open an issue on the actor's Apify Store page
- **Feature requests**: Contact the author via Apify messaging
- **Documentation**: Refer to this README and the input schema tooltips

# Actor input Schema

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

Select the type of data to scrape:

- **rankings**: Global cost-of-living rankings table with indices for all cities
- **city\_prices**: Detailed price list for specific cities (set cities below)
- **comparison**: Side-by-side comparison of two cities (set exactly 2 cities below)

## `cities` (type: `array`):

List of city names to scrape prices for (used in city\_prices and comparison modes). Use the city name as it appears on Numbeo, e.g. "New York", "London", "Buenos Aires". For comparison mode, use "City, Country" format (e.g. "Prague, Czech Republic").

## `maxCities` (type: `integer`):

Maximum number of cities to return in rankings mode. Set to 0 or leave blank for all cities.

## `year` (type: `string`):

Specific year for historical data (e.g. "2024", "2023"). Leave empty for current data.

## `currency` (type: `string`):

Currency code to display prices in (e.g. "USD", "EUR", "GBP"). Leave empty for local currency.

## `language` (type: `string`):

Language code for the Numbeo interface.

## `requestDelay` (type: `integer`):

Delay between HTTP requests in milliseconds. Increase if you encounter rate limiting.

## Actor input object example

```json
{
  "mode": "rankings",
  "cities": [
    "New York",
    "London"
  ],
  "maxCities": 20,
  "language": "en",
  "requestDelay": 500
}
```

# 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 = {
    "cities": [
        "New York",
        "London"
    ],
    "maxCities": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/numbeo-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 = {
    "cities": [
        "New York",
        "London",
    ],
    "maxCities": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/numbeo-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 '{
  "cities": [
    "New York",
    "London"
  ],
  "maxCities": 20
}' |
apify call automation-lab/numbeo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Numbeo Cost of Living Scraper",
        "description": "Scrape cost-of-living data from Numbeo.com — city rankings with indices, detailed price lists per city, and city-to-city comparisons. Covers 486+ cities with 93 price items each.",
        "version": "0.1",
        "x-build-id": "Fcx54rPAEWi21Q0oD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~numbeo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-numbeo-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~numbeo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-numbeo-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~numbeo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-numbeo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "rankings",
                            "city_prices",
                            "comparison"
                        ],
                        "type": "string",
                        "description": "Select the type of data to scrape:\n- **rankings**: Global cost-of-living rankings table with indices for all cities\n- **city_prices**: Detailed price list for specific cities (set cities below)\n- **comparison**: Side-by-side comparison of two cities (set exactly 2 cities below)",
                        "default": "rankings"
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "List of city names to scrape prices for (used in city_prices and comparison modes). Use the city name as it appears on Numbeo, e.g. \"New York\", \"London\", \"Buenos Aires\". For comparison mode, use \"City, Country\" format (e.g. \"Prague, Czech Republic\").",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxCities": {
                        "title": "Max Cities (Rankings)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of cities to return in rankings mode. Set to 0 or leave blank for all cities.",
                        "default": 50
                    },
                    "year": {
                        "title": "Year",
                        "type": "string",
                        "description": "Specific year for historical data (e.g. \"2024\", \"2023\"). Leave empty for current data."
                    },
                    "currency": {
                        "title": "Display Currency",
                        "type": "string",
                        "description": "Currency code to display prices in (e.g. \"USD\", \"EUR\", \"GBP\"). Leave empty for local currency."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for the Numbeo interface.",
                        "default": "en"
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 100,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between HTTP requests in milliseconds. Increase if you encounter rate limiting.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
