# Numbeo Scraper (`solidcode/numbeo-scraper`) Actor

\[💰 $1.8 / 1K] Extract Numbeo cost-of-living data without an API key — 55+ itemized prices per city plus crime, health care, pollution, traffic, property and quality-of-life indices in any of 24 currencies.

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

## Pricing

from $1.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Scraper

Pull cost-of-living and quality-of-life data from Numbeo at scale — 55+ itemized prices per city, six quality-of-life indices, full worldwide rankings, and nationwide country averages, reported in any of 24 currencies. No API key, no manual copy-paste, no account. Built for relocation analysts, remote-work salary planners, real-estate researchers, and HR and fintech comp teams who need clean, structured cost-of-living benchmarks without rebuilding Numbeo's tables by hand.

### Why This Scraper?

- **55+ itemized prices per city** — rent, groceries, restaurants, transport, utilities, clothing, leisure, and net salary, each with a crowd-sourced average plus a low-to-high range, not just a single headline number.
- **Seven data categories in one run** — Cost of Living, Property Prices & Investment, Quality of Life, Crime, Health Care, Pollution, and Traffic, selectable per location.
- **Six quality-of-life indices** — Quality of Life, Crime, Health Care, Pollution, Traffic, and Property scores returned as clean numeric values ready for dashboards and models.
- **24 reporting currencies** — every price converted and stamped with its currency code (USD, EUR, GBP, JPY, CNY, INR, AED, and 17 more), so you can benchmark cities apples-to-apples in one denomination.
- **Full worldwide city rankings, every sub-index included** — pull Numbeo's complete ranked tables (500+ cities per category, e.g. the entire 543-city cost-of-living ladder ranked 1 through 543) or cap them to the top N. Each ranked city ships all its named sub-indices, not just the headline score — for cost-of-living that's Cost of Living, Rent, Cost of Living Plus Rent, Groceries, Restaurant Price, and Local Purchasing Power Index in one row.
- **US-city auto-disambiguation** — type "Austin, United States" or "Austin, TX" and it resolves to the right metro automatically, no hunting for the correct page.
- **Paste a name or a URL** — feed plain "City, Country" names, "City, State" for US metros, or a full Numbeo page URL; all three resolve to the same structured output.
- **Flat, BI-ready rows** — one row per price item, index, or ranking entry with a `type` discriminator, so the output drops straight into spreadsheets, SQL, and analytics tools.
- **Country-level averages** — nationwide cost-of-living figures for whole countries alongside city-level detail in the same dataset.

### Use Cases

**Relocation & Global Mobility**
- Compare living costs between a current and prospective home city before a move
- Build relocation cost calculators for employees and expats
- Estimate the rent, groceries, and transport budget needed in a new city
- Rank candidate destinations by quality of life, safety, and affordability

**Salary & Compensation Benchmarking**
- Anchor cost-of-living adjustments to local net-salary and price data
- Set location-based pay bands for remote and distributed teams
- Compare purchasing power across offices in one common currency
- Justify relocation stipends with itemized local price evidence

**Real Estate & Market Research**
- Track apartment buy and rent prices in city centre vs. outside centre
- Compare price-to-income and rental-yield indicators across markets
- Surface the most and least expensive cities for property investment
- Feed local market context into property valuation models

**Travel & Lifestyle Planning**
- Budget daily costs for trips using restaurant, transport, and grocery prices
- Compare destinations on safety, pollution, and healthcare quality
- Build "cost of a week here" estimates for travel content and tools

**Academic & Economic Research**
- Assemble cross-country cost-of-living and purchasing-power datasets
- Study price dispersion across hundreds of cities at once
- Combine crime, health, pollution, and traffic indices for liveability studies

### Getting Started

#### Cost of Living for One City

The simplest run — a single city, default category and currency:

```json
{
    "cities": ["London, United Kingdom"]
}
````

#### Multiple Cities and Categories

Collect cost of living plus crime and pollution indices for several cities, priced in euros:

```json
{
    "cities": ["Berlin", "Paris", "Madrid"],
    "categories": ["cost-of-living", "crime", "pollution"],
    "currency": "EUR"
}
```

#### Countries, Cities, and a Currency Switch

Mix city-level detail with nationwide country averages, reported in Japanese yen:

```json
{
    "cities": ["Tokyo", "Osaka"],
    "countries": ["Japan", "South Korea"],
    "categories": ["cost-of-living", "quality-of-life"],
    "currency": "JPY"
}
```

#### Worldwide Rankings

Leave cities and countries empty and turn on rankings to pull the top 50 cities per category:

```json
{
    "categories": ["cost-of-living", "quality-of-life"],
    "includeRankings": true,
    "maxCities": 50
}
```

### Input Reference

#### What to Collect

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `cities` | array | `["London, United Kingdom", "Berlin"]` | City names, one per line. Add a country or US state when a name is shared (e.g. "London, United Kingdom", "Austin, TX"). You can also paste a full Numbeo city URL. |
| `countries` | array | `[]` | Country names for nationwide average data, one per line (e.g. "Germany", "Japan"). A full Numbeo country URL also works. |
| `categories` | array | `["cost-of-living"]` | Which kinds of data to collect per location. Options: **Cost of Living (itemized prices)**, **Property Prices & Investment**, **Quality of Life**, **Crime**, **Health Care**, **Pollution**, **Traffic**. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | string | `"US Dollar (USD)"` | Currency to report all prices in. 24 options including Euro, British Pound, Canadian Dollar, Japanese Yen, Chinese Yuan, Indian Rupee, UAE Dirham, and Singapore Dollar. |
| `includeRankings` | boolean | `false` | Also collect Numbeo's worldwide ranked city table for each selected category. When cities and countries are both empty, this becomes the only thing collected. |
| `maxCities` | integer | `100` | When rankings are on, the maximum number of ranked cities per category. Set to `0` to collect every ranked city. Has no effect on cities or countries you type in yourself. |

### Output

Each result is one flat row. The `type` field tells you what kind of row it is — `city_price`, `country_price`, `city_index`, or `ranking` — so you can split, filter, or join the dataset cleanly. The shared envelope (`location`, `category`, `currency`, `url`, `scrapedAt`) is identical across every row.

#### Itemized City Price (`city_price`)

```json
{
    "type": "city_price",
    "location": "London, United Kingdom",
    "city": "London",
    "country": "United Kingdom",
    "category": "cost-of-living",
    "categoryGroup": "Restaurants",
    "itemName": "Meal, Inexpensive Restaurant",
    "avgPrice": 20.0,
    "lowestPrice": 15.0,
    "highestPrice": 30.0,
    "indexValue": null,
    "subIndices": null,
    "rank": null,
    "currency": "GBP",
    "url": "https://www.numbeo.com/cost-of-living/in/London",
    "scrapedAt": "2026-06-10T12:00:00Z"
}
```

#### Quality-of-Life Index (`city_index`)

```json
{
    "type": "city_index",
    "location": "London, United Kingdom",
    "city": "London",
    "country": "United Kingdom",
    "category": "crime",
    "categoryGroup": null,
    "itemName": "Safety Index",
    "avgPrice": null,
    "lowestPrice": null,
    "highestPrice": null,
    "indexValue": 55.42,
    "subIndices": null,
    "rank": null,
    "currency": null,
    "url": "https://www.numbeo.com/crime/in/London",
    "scrapedAt": "2026-06-10T12:00:00Z"
}
```

#### Country Average (`country_price`)

```json
{
    "type": "country_price",
    "location": "Germany",
    "city": null,
    "country": "Germany",
    "category": "cost-of-living",
    "categoryGroup": "Markets",
    "itemName": "Milk (regular), (1 liter)",
    "avgPrice": 1.05,
    "lowestPrice": 0.75,
    "highestPrice": 1.50,
    "indexValue": null,
    "subIndices": null,
    "rank": null,
    "currency": "EUR",
    "url": "https://www.numbeo.com/cost-of-living/country_result.jsp?country=Germany",
    "scrapedAt": "2026-06-10T12:00:00Z"
}
```

#### Global Ranking (`ranking`)

```json
{
    "type": "ranking",
    "location": "Zurich, Switzerland",
    "city": "Zurich",
    "country": "Switzerland",
    "category": "cost-of-living",
    "categoryGroup": null,
    "itemName": "Cost of Living Index",
    "avgPrice": null,
    "lowestPrice": null,
    "highestPrice": null,
    "indexValue": 125.4,
    "subIndices": {
        "Cost of Living Index": 125.4,
        "Rent Index": 73.8,
        "Cost of Living Plus Rent Index": 101.8,
        "Groceries Index": 129.5,
        "Restaurant Price Index": 121.8,
        "Local Purchasing Power Index": 156.0
    },
    "rank": 1,
    "currency": null,
    "url": "https://www.numbeo.com/cost-of-living/in/Zurich",
    "scrapedAt": "2026-06-10T12:00:00Z"
}
```

#### Field Reference

| Field | Type | Description |
|-------|------|-------------|
| `type` | string | Row kind: `city_price`, `country_price`, `city_index`, or `ranking`. |
| `location` | string | Full place label, e.g. "London, United Kingdom". |
| `city` | string | null | City name when the row is city-scoped. |
| `country` | string | null | Country name. |
| `category` | string | Numbeo section: cost-of-living, quality-of-life, crime, health-care, pollution, traffic, or property-investment. |
| `categoryGroup` | string | null | Price group for price rows (Restaurants, Markets, Transportation, Rent, Salaries, and more). |
| `itemName` | string | Price item ("Meal, Inexpensive Restaurant") or index name ("Safety Index"). |
| `avgPrice` | number | null | Average reported price (price rows). |
| `lowestPrice` | number | null | Low end of the reported range. |
| `highestPrice` | number | null | High end of the reported range. |
| `indexValue` | number | null | Index or ranking score value (the primary, sorted-by index on ranking rows). |
| `subIndices` | object | null | On ranking rows, every named sub-index for that city keyed by column name — e.g. for cost-of-living: Cost of Living Index, Rent Index, Cost of Living Plus Rent Index, Groceries Index, Restaurant Price Index, Local Purchasing Power Index. Null on non-ranking rows. |
| `rank` | integer | null | Global rank position (ranking rows). |
| `currency` | string | null | Currency code of the prices on this row. |
| `url` | string | Source Numbeo page URL. |
| `scrapedAt` | string | Extraction timestamp (ISO 8601, UTC). |

### Tips for Best Results

- **Qualify ambiguous city names.** Bare "London" can resolve to London, Canada — add the country or US state ("London, United Kingdom", "Austin, TX") to pin the exact metro you want.
- **Paste the Numbeo URL for guaranteed targeting.** If you already have the city's Numbeo page open, pasting its URL skips name resolution entirely and goes straight to that page.
- **Pick one currency for cross-city comparisons.** Setting a single currency (e.g. EUR) converts every city's prices into the same denomination so you can rank them directly.
- **Use rankings + `maxCities` to bulk-pull the cheapest or safest N cities.** Turn on rankings, leave cities empty, and set `maxCities` to grab the top N cities for any category in one run — set it to `0` for the entire ranked table.
- **Cost of Living returns the richest detail.** It yields all 55+ itemized prices; the index categories (crime, pollution, traffic, etc.) return a handful of summary scores each, so combine both for full coverage.
- **Expect sparse rows for smaller cities.** Cities with thin crowd-sourced data return fewer price items, and some salary rows carry an average but no low/high range — that is normal, not an error.
- **Filter by `type` after the run.** Split prices from indices and rankings using the `type` field for clean, purpose-built tables in your destination tool.

### Pricing

**From $1.80 per 1,000 results** — pay only for the rows you collect, undercutting comparable Numbeo data tools. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.215 | $0.20 | $0.19 | $0.18 |
| 1,000 | $2.15 | $2.00 | $1.90 | $1.80 |
| 10,000 | $21.50 | $20.00 | $19.00 | $18.00 |
| 100,000 | $215.00 | $200.00 | $190.00 | $180.00 |

A "result" is one dataset row — a single price item, index value, or ranking entry. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available cost-of-living and quality-of-life information for research, analysis, and benchmarking. Use it responsibly: respect Numbeo's terms of service, avoid excessive request volumes, and comply with all applicable laws and regulations in your jurisdiction. Do not use collected data to harm individuals or for any unlawful purpose. You are responsible for how you use the data you collect.

# Actor input Schema

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

City names to collect data for, one per line (e.g. 'Tokyo', 'Berlin'). When a city name is shared by several places, add the country or US state to pick the right one (e.g. 'London, United Kingdom' or 'Austin, TX'). You can also paste a full Numbeo city URL.

## `countries` (type: `array`):

Country names to collect nationwide average data for, one per line (e.g. 'Germany', 'Japan'). You can also paste a full Numbeo country URL.

## `categories` (type: `array`):

Which kinds of data to collect for each city or country. 'Cost of Living' returns ~55 itemized prices (rent, groceries, restaurants, transport, utilities, salaries). The index categories return summary scores. Leave empty to default to Cost of Living.

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

Currency to report all prices in. Numbeo converts to this currency. Defaults to US Dollar.

## `includeRankings` (type: `boolean`):

Also collect Numbeo's worldwide ranked city table for each selected category (e.g. most expensive cities, highest quality of life). Useful for market research and comparisons. When cities and countries are both empty, this becomes the only thing collected.

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

When Global Rankings is on, the maximum number of ranked cities to collect per category. Set to 0 to collect every ranked city. Has no effect on cities or countries you typed in yourself.

## Actor input object example

```json
{
  "cities": [
    "London, United Kingdom",
    "Berlin"
  ],
  "countries": [],
  "categories": [
    "cost-of-living"
  ],
  "currency": "USD",
  "includeRankings": false,
  "maxCities": 100
}
```

# Actor output Schema

## `prices` (type: `string`):

Itemized cost-of-living prices per city or country (average, low, and high).

## `indices` (type: `string`):

Quality-of-life, crime, health-care, pollution, traffic, property and cost-of-living indices, plus global ranking rows with named sub-indices.

# 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": [
        "London, United Kingdom",
        "Berlin"
    ],
    "countries": [],
    "categories": [
        "cost-of-living"
    ],
    "currency": "USD",
    "includeRankings": false,
    "maxCities": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": [
        "London, United Kingdom",
        "Berlin",
    ],
    "countries": [],
    "categories": ["cost-of-living"],
    "currency": "USD",
    "includeRankings": False,
    "maxCities": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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": [
    "London, United Kingdom",
    "Berlin"
  ],
  "countries": [],
  "categories": [
    "cost-of-living"
  ],
  "currency": "USD",
  "includeRankings": false,
  "maxCities": 100
}' |
apify call solidcode/numbeo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Numbeo Scraper",
        "description": "[💰 $1.8 / 1K] Extract Numbeo cost-of-living data without an API key — 55+ itemized prices per city plus crime, health care, pollution, traffic, property and quality-of-life indices in any of 24 currencies.",
        "version": "1.0",
        "x-build-id": "YxPWlFAOgAwaokfFQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~numbeo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~numbeo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~numbeo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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",
                "properties": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names to collect data for, one per line (e.g. 'Tokyo', 'Berlin'). When a city name is shared by several places, add the country or US state to pick the right one (e.g. 'London, United Kingdom' or 'Austin, TX'). You can also paste a full Numbeo city URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Country names to collect nationwide average data for, one per line (e.g. 'Germany', 'Japan'). You can also paste a full Numbeo country URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Data Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which kinds of data to collect for each city or country. 'Cost of Living' returns ~55 itemized prices (rent, groceries, restaurants, transport, utilities, salaries). The index categories return summary scores. Leave empty to default to Cost of Living.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cost-of-living",
                                "property-investment",
                                "quality-of-life",
                                "crime",
                                "health-care",
                                "pollution",
                                "traffic"
                            ],
                            "enumTitles": [
                                "Cost of Living (itemized prices)",
                                "Property Prices & Investment",
                                "Quality of Life",
                                "Crime",
                                "Health Care",
                                "Pollution",
                                "Traffic"
                            ]
                        },
                        "default": [
                            "cost-of-living"
                        ]
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "CNY",
                            "INR",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "TRY",
                            "RUB",
                            "BRL",
                            "MXN",
                            "ZAR",
                            "AED",
                            "SGD",
                            "HKD",
                            "KRW",
                            "THB",
                            "IDR"
                        ],
                        "type": "string",
                        "description": "Currency to report all prices in. Numbeo converts to this currency. Defaults to US Dollar.",
                        "default": "USD"
                    },
                    "includeRankings": {
                        "title": "Include Global Rankings",
                        "type": "boolean",
                        "description": "Also collect Numbeo's worldwide ranked city table for each selected category (e.g. most expensive cities, highest quality of life). Useful for market research and comparisons. When cities and countries are both empty, this becomes the only thing collected.",
                        "default": false
                    },
                    "maxCities": {
                        "title": "Max Cities from Rankings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When Global Rankings is on, the maximum number of ranked cities to collect per category. Set to 0 to collect every ranked city. Has no effect on cities or countries you typed in yourself.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
