# Nehnutelnosti Scraper - Slovak Real Estate Data (`studio-amba/nehnutelnosti-scraper`) Actor

Scrape real estate listings from Nehnutelnosti.sk -- Slovakia's #1 property portal with 15,000+ listings. Search apartments, houses, and land for sale or rent. Get prices, areas, rooms, locations, and agency details. No login needed.

- **URL**: https://apify.com/studio-amba/nehnutelnosti-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 57.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Nehnutelnosti Scraper

Extract real estate listings from [Nehnutelnosti.sk](https://www.nehnutelnosti.sk) -- Slovakia's largest property portal with over 15,000 active listings -- into structured JSON with prices, areas, room counts, locations, and agency details.

### What is Nehnutelnosti Scraper?

**Nehnutelnosti Scraper** extracts structured property data from Nehnutelnosti.sk, helping you monitor the Slovak real estate market, compare prices across cities, and automate property research -- all without manual browsing or login.

- **Track property prices by city and district:** extract listings with prices, area in m2, price per m2, and room counts to build price maps across Bratislava, Kosice, Zilina, Nitra, and every Slovak city
- **Monitor new listings automatically:** schedule daily runs and catch new apartments or houses the moment they appear on Nehnutelnosti.sk
- **Build property datasets for analysis:** export thousands of listings with seller type, location, and property details for valuation models, academic research, or investment screening
- **Compare sale vs. rental markets:** switch between predaj (sale) and prenajom (rent) to analyse yield gaps and rental demand across Slovak regions
- **Feed your CRM or dashboard:** export structured data to Google Sheets, Airtable, or any BI tool via Apify integrations

Nehnutelnosti.sk has **no public API and no bulk export**. This scraper renders pages in a real browser and extracts clean, structured data at scale. No login, no cookies, no browser extensions needed.

### What data does Nehnutelnosti Scraper extract?

Each listing includes the following fields:

- **propertyTitle** -- listing title in Slovak, e.g. "Predaj 3-izboveho bytu v Bratislave"
- **propertyType** -- apartment, house, or land
- **transactionType** -- sale or rent
- **price** -- asking price in EUR
- **currency** -- always "EUR"
- **pricePerSqm** -- price per square meter in EUR
- **area** -- property area in square meters
- **rooms** -- number of rooms (e.g. "2", "3", "4")
- **floor** -- floor number (e.g. "2/5" or "0" for ground floor)
- **location** -- city or locality name
- **district** -- district (okres) name
- **sellerType** -- "agency" or "private"
- **imageUrl** -- main property photo URL
- **url** -- direct link to the listing on Nehnutelnosti.sk
- **scrapedAt** -- ISO 8601 timestamp

### How to scrape Nehnutelnosti data

The input is simple: choose your **property type**, **transaction type**, and optional filters, then hit run. You can configure the scraper through the Apify Console UI or programmatically via the API.

#### Input fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| **propertyType** | String | `"byty"` | `"byty"` (apartments), `"domy"` (houses), or `"pozemky"` (land) |
| **transactionType** | String | `"predaj"` | `"predaj"` (sale) or `"prenajom"` (rent) |
| **location** | String | -- | Slovak city or region, e.g. `"bratislava"`, `"kosice"`, `"zilina"` |
| **priceFrom** | Integer | -- | Minimum price in EUR |
| **priceTo** | Integer | -- | Maximum price in EUR |
| **maxResults** | Integer | `50` | Maximum listings to return (0 = unlimited) |
| **proxyConfiguration** | Object | -- | Proxy settings (Slovak residential recommended) |

#### Tips for best results

- **Default input works out of the box** -- running with empty `{}` input returns apartments for sale across all of Slovakia
- **Use `location` for city-level filtering** -- set it to `"bratislava"` or `"kosice"` to narrow results geographically
- **Use price filters for budget ranges** -- set `priceFrom` and `priceTo` to focus on your target segment
- **Slovak residential proxy recommended** -- Nehnutelnosti.sk works best with Slovak IP addresses. The default proxy config handles this automatically on Apify
- **Start small** -- test with `maxResults: 10` first, then scale up once you verify the output matches your needs

#### Example input

```json
{
    "propertyType": "byty",
    "transactionType": "predaj",
    "location": "bratislava",
    "priceFrom": 80000,
    "priceTo": 200000,
    "maxResults": 100
}
````

### Output

Results are stored in a **dataset** that you can download in JSON, CSV, Excel, XML, or HTML format directly from the Apify Console.

#### JSON example

```json
{
    "propertyTitle": "Predaj 3-izboveho bytu s balkonom",
    "propertyType": "apartment",
    "transactionType": "sale",
    "price": 164900,
    "currency": "EUR",
    "pricePerSqm": 2486.5,
    "area": 66.3,
    "rooms": "3",
    "floor": "2/5",
    "location": "Bratislava-Ruzinov",
    "district": "Bratislava II",
    "sellerType": "agency",
    "imageUrl": "https://img.unitedclassifieds.sk/foto/...",
    "url": "https://www.nehnutelnosti.sk/detail/abc123/predaj-3-izb-bytu",
    "scrapedAt": "2026-06-09T10:00:00.000Z"
}
```

### How much does it cost to scrape Nehnutelnosti.sk?

Nehnutelnosti Scraper uses Playwright (headless browser) for reliable extraction. Browser-based scraping costs more than plain HTTP but ensures consistent results.

| Scenario | Est. cost | Time |
|----------|-----------|------|
| 50 listings | ~$0.15 | ~2 min |
| 200 listings | ~$0.50 | ~8 min |
| 1,000 listings | ~$2.00 | ~30 min |

### Can I integrate Nehnutelnosti Scraper with other apps?

Yes. Nehnutelnosti Scraper connects with any tool through [Apify integrations](https://apify.com/integrations):

- **Google Sheets** -- automatically export property data to a spreadsheet
- **Slack / Email** -- get notified when new listings match your criteria
- **Zapier / Make** -- trigger workflows when data is ready
- **Airtable** -- build a searchable property database
- **REST API** -- call the scraper programmatically from any language
- **Webhooks** -- get notified when a run finishes

### Can I use Nehnutelnosti Scraper as an API?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) to run Nehnutelnosti Scraper programmatically.

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("studio-amba/nehnutelnosti-scraper").call(run_input={
    "propertyType": "byty",
    "transactionType": "predaj",
    "location": "bratislava",
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['propertyTitle']} -- EUR {item['price']:,} -- {item['location']}")
```

**JavaScript:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('studio-amba/nehnutelnosti-scraper').call({
    propertyType: 'byty',
    transactionType: 'predaj',
    location: 'bratislava',
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Check the [API tab](https://apify.com/studio-amba/nehnutelnosti-scraper/api) for full documentation.

### FAQ

#### What is Nehnutelnosti.sk?

Nehnutelnosti.sk is Slovakia's largest and most-visited real estate portal, part of the United Classifieds group. It lists over 15,000 active properties including apartments (byty), houses (domy), and land (pozemky) for both sale (predaj) and rent (prenajom) across all Slovak regions. Prices are in EUR since Slovakia adopted the euro in 2009.

#### How does Nehnutelnosti Scraper work?

It renders the Nehnutelnosti.sk search results pages in a headless Chromium browser using Playwright, then extracts listing data from the rendered DOM. The scraper handles pagination automatically and deduplicates listings to ensure clean output.

#### What property types can I scrape?

Three types: **byty** (apartments -- the most common), **domy** (houses), and **pozemky** (land/plots). Set the `propertyType` input to filter.

#### Can I scrape both sale and rental listings?

Yes. Set `transactionType` to `"predaj"` for sales or `"prenajom"` for rentals.

#### Can I filter by price range?

Yes. Use `priceFrom` and `priceTo` to set a EUR price range. For example, apartments between 80K and 200K EUR: `priceFrom: 80000, priceTo: 200000`.

#### Is it legal to scrape Nehnutelnosti.sk?

This scraper extracts publicly available listing data that Nehnutelnosti.sk displays to all visitors. The data is factual (prices, addresses, property specifications) and does not contain private personal information. As with any scraping tool, use the data responsibly and in compliance with applicable laws.

### Limitations

- **Slovakia only.** Nehnutelnosti.sk covers exclusively Slovak real estate.
- **Browser-based scraping.** Uses Playwright which is slower than HTTP-only scrapers but provides reliable results on JavaScript-rendered pages.
- **Slovak residential proxy recommended.** Best results with Slovak IP addresses. The default proxy configuration handles this automatically on Apify.
- **Some fields may be null.** Not all sellers provide complete information -- `floor`, `district`, or `sellerType` may be missing on some listings.

### Other European real estate scrapers

Combine Nehnutelnosti Scraper with these actors for comprehensive European property market coverage:

- [Sreality Scraper](https://apify.com/studio-amba/sreality-scraper) -- Czech Republic real estate (Sreality.cz)
- [Immoweb Scraper](https://apify.com/studio-amba/immoweb-scraper) -- Belgian real estate listings
- [Otodom Scraper](https://apify.com/studio-amba/otodom-scraper) -- Polish property listings
- [Willhaben Scraper](https://apify.com/studio-amba/willhaben-scraper) -- Austrian real estate
- [ImmoScout24 Scraper](https://apify.com/studio-amba/immoscout24-scraper) -- German real estate
- [Immobiliare Scraper](https://apify.com/studio-amba/immobiliare-scraper) -- Italian real estate
- [Zimmo Scraper](https://apify.com/studio-amba/zimmo-scraper) -- Belgian property portal

### Your feedback

Found a bug or have a feature request? Please open an issue on the [Issues tab](https://apify.com/studio-amba/nehnutelnosti-scraper/issues). We actively maintain this scraper and respond to all reports.

# Actor input Schema

## `propertyType` (type: `string`):

Type of property to search for. 'byty' = apartments, 'domy' = houses, 'pozemky' = land/plots.

## `transactionType` (type: `string`):

Type of listing. 'predaj' = for sale, 'prenajom' = for rent.

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

Location to search in (Slovak city or region), e.g. 'bratislava', 'kosice', 'zilina', 'nitra'. Leave empty to search all of Slovakia.

## `priceFrom` (type: `integer`):

Minimum price in EUR. For sales: e.g. 50000. For rent: e.g. 300.

## `priceTo` (type: `integer`):

Maximum price in EUR. For sales: e.g. 200000. For rent: e.g. 1500.

## `maxResults` (type: `integer`):

Maximum number of listings to return. Set to 0 for unlimited.

## `proxyConfiguration` (type: `object`):

Proxy settings. Slovak residential proxy recommended for best results.

## Actor input object example

```json
{
  "propertyType": "byty",
  "transactionType": "predaj",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SK"
  }
}
```

# 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 = {
    "propertyType": "byty",
    "transactionType": "predaj",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "SK"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/nehnutelnosti-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 = {
    "propertyType": "byty",
    "transactionType": "predaj",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "SK",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/nehnutelnosti-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 '{
  "propertyType": "byty",
  "transactionType": "predaj",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "SK"
  }
}' |
apify call studio-amba/nehnutelnosti-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nehnutelnosti Scraper - Slovak Real Estate Data",
        "description": "Scrape real estate listings from Nehnutelnosti.sk -- Slovakia's #1 property portal with 15,000+ listings. Search apartments, houses, and land for sale or rent. Get prices, areas, rooms, locations, and agency details. No login needed.",
        "version": "0.1",
        "x-build-id": "tTh9P5w0clvcsgtXr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~nehnutelnosti-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-nehnutelnosti-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/studio-amba~nehnutelnosti-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-nehnutelnosti-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/studio-amba~nehnutelnosti-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-nehnutelnosti-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": {
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "byty",
                            "domy",
                            "pozemky"
                        ],
                        "type": "string",
                        "description": "Type of property to search for. 'byty' = apartments, 'domy' = houses, 'pozemky' = land/plots.",
                        "default": "byty"
                    },
                    "transactionType": {
                        "title": "Transaction Type",
                        "enum": [
                            "predaj",
                            "prenajom"
                        ],
                        "type": "string",
                        "description": "Type of listing. 'predaj' = for sale, 'prenajom' = for rent.",
                        "default": "predaj"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search in (Slovak city or region), e.g. 'bratislava', 'kosice', 'zilina', 'nitra'. Leave empty to search all of Slovakia."
                    },
                    "priceFrom": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR. For sales: e.g. 50000. For rent: e.g. 300."
                    },
                    "priceTo": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR. For sales: e.g. 200000. For rent: e.g. 1500."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of listings to return. Set to 0 for unlimited.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Slovak residential proxy recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
