# CZ & SK Real Estate Aggregator (`pringlesbitch/cz-reality-aggregator`) Actor

Scrape 8 Czech and Slovak real estate portals (Sreality, Bezrealitky, iDNES, Nehnutelnosti.sk & more) into one deduplicated dataset with price history, new-listing and price-drop flags. EUR & CZK. Works as a batch scraper or a real-time HTTP API.

- **URL**: https://apify.com/pringlesbitch/cz-reality-aggregator.md
- **Developed by:** [Pringles Kamila](https://apify.com/pringlesbitch) (community)
- **Categories:** Real estate, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.002 / listing scraped

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## CZ/SK Real Estate Aggregator — Czech & Slovak property listings in one dataset

**English** · [Čeština](#-česky) · [Slovenčina](#-slovensky)

Scrape real estate listings from **8 Czech and Slovak property portals** in one run and get a single, normalized, deduplicated dataset with price history. Works as a classic batch scraper and as a **real-time HTTP API** (Actor Standby), so you can plug it into apps, dashboards, or AI agents via MCP.

### What does CZ/SK Real Estate Aggregator do?

One input, eight portals, one consistent output schema:

| Portal | Country | Currency | Note |
|--------|---------|----------|------|
| Sreality.cz | CZ | CZK | largest Czech portal |
| Reality.iDNES.cz | CZ | CZK | |
| Bezrealitky.cz | CZ | CZK | private listings without agencies |
| RealityMIX.cz | CZ | CZK | |
| Reality.cz | CZ | CZK | catalog of 1000+ agencies |
| Nehnutelnosti.sk | SK | EUR | largest Slovak portal |
| TopReality.sk | SK | EUR | |
| Reality.sk | SK | EUR | |

Every listing is normalized to the same fields: portal, external ID, title, transaction (sale/rent), category (flat/house/land/commercial), disposition, floor area, price, price per m², currency, locality, GPS (where available), canonical URL, images, and seller.

Because Czech agencies publish the same flat on several portals at once, the Actor **deduplicates across portals**: one apartment appears once, with an `also_on` list of the other portals where it was found. Between runs it keeps **price history** and flags every listing with `is_new` and `price_dropped` — useful for monitoring the market, hunting price cuts, or feeding analytics.

### Why use this Actor instead of a single-portal scraper?

A single-portal scraper shows you one shop window. This Actor covers the Czech and Slovak market in one dataset, removes the duplicates that agency exports create, and tells you what changed since your last run. You pay per unique listing delivered (pay-per-event), not per portal scraped.

### Input

All parameters are optional and have sensible defaults:

- **portals** — which portals to scrape (default: `sreality`)
- **transaction** — `sale` or `rent`
- **category** — `flat`, `house`, `land`, or `commercial`
- **region** — free-text locality filter, e.g. `Praha`, `Bratislava`, `Jihočeský kraj`
- **priceMin / priceMax** — price range; compared against CZK on Czech portals and EUR on Slovak portals
- **maxItems** — cap on collected listings (cost protection, default 200)

### Output

Structured dataset, one record per unique listing. Example:

```json
{
  "portal": "sreality",
  "external_id": "3893712204",
  "title": "Prodej bytu 2+kk 52 m²",
  "transaction": "sale",
  "category": "flat",
  "disposition": "2+kk",
  "area_m2": 52,
  "price": 9570000,
  "price_per_m2": 184038,
  "currency": "CZK",
  "locality": "Biskupcova, Praha 3 - Žižkov",
  "gps_lat": 50.09,
  "gps_lon": 14.47,
  "url": "https://www.sreality.cz/detail/...",
  "is_new": true,
  "price_dropped": false,
  "price_history": [{"date": "2026-07-11", "price": 9570000}],
  "also_on": ["idnes:https://reality.idnes.cz/..."]
}
````

### Real-time HTTP API (Standby mode)

The Actor also runs in [Standby mode](https://docs.apify.com/platform/actors/running/standby): no start button, just an HTTP endpoint that scrapes on demand.

```bash
curl -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  "https://<standby-hostname>/search?portals=sreality,bezrealitky&transaction=sale&category=flat&region=Praha&maxItems=20"
```

`GET /search` accepts the same parameters as the batch input and returns JSON with `query`, `count`, and `listings`. Default `maxItems` in Standby is 50 to keep responses fast. Through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) the same endpoint works as a tool for AI agents.

### Pricing

Pay-per-event: you are charged per **unique listing delivered** (`listing-scraped` event), after deduplication. Duplicates found on more portals cost nothing extra.

### Legal & GDPR

The Actor collects only publicly available listing data and respects source rate limits (delays between requests). Listings may contain personal data, such as a private seller's contact — you are responsible for processing the data in line with GDPR and the laws of your country. Price history is stored per listing ID, no personal data is logged.

***

### 🇨🇿 Česky

## CZ/SK Reality Agregátor — české a slovenské inzeráty v jednom datasetu

Stáhne realitní inzeráty z **8 českých a slovenských portálů** najednou a vrátí jeden normalizovaný, deduplikovaný dataset s historií cen. Funguje jako klasický scraper i jako **HTTP API v reálném čase** (Standby mode), takže ho zapojíte do aplikace, dashboardu nebo AI agenta přes MCP.

### Co Actor umí

Jeden vstup, osm portálů, jedno výstupní schéma. Pokryté portály: Sreality.cz, Reality.iDNES.cz, Bezrealitky.cz (soukromá inzerce bez RK), RealityMIX.cz a Reality.cz v Česku; Nehnutelnosti.sk, TopReality.sk a Reality.sk na Slovensku. České portály účtují v korunách, slovenské v eurech - pole `currency` u každého záznamu říká, ve které měně je cena.

Realitní kanceláře vystavují stejný byt na několika portálech naráz. Actor proto **deduplikuje napříč portály**: jeden byt najdete v datasetu jednou a v poli `also_on` vidíte, kde všude visel. Mezi běhy si Actor drží **historii cen** - každý inzerát nese `is_new` a `price_dropped`, takže zlevnění poznáte hned.

### Vstup

Všechny parametry jsou volitelné: `portals` (výběr portálů), `transaction` (sale/rent), `category` (flat/house/land/commercial), `region` (např. `Praha`, `Bratislava`, `Jihočeský kraj`), `priceMin`/`priceMax` (u českých portálů v Kč, u slovenských v €) a `maxItems` (strop nákladů, výchozí 200).

### Výstup

Jeden záznam = jeden unikátní inzerát: portál, ID, titulek, dispozice, plocha, cena, cena za m², měna, lokalita, GPS (kde portál uvádí), kanonická URL, obrázky, prodejce, historie cen a příznaky novinek a slev. Ukázka záznamu je v anglické části výše.

### HTTP API (Standby mode)

`GET /search` přijímá stejné parametry jako běžný vstup a vrací JSON s inzeráty do pár desítek sekund. Autentizace přes Apify token (`Authorization: Bearer …`). Ve Standby režimu je výchozí `maxItems` 50, aby odpověď stihla platformní limit 5 minut. Přes Apify MCP server poslouží stejný endpoint jako nástroj pro AI agenty.

### Cena

Platíte za **doručený unikátní inzerát** (event `listing-scraped`), počítá se až po deduplikaci. Duplicity z dalších portálů nic nestojí.

### Právní upozornění

Actor sbírá jen veřejně dostupná data a šetří zdrojové weby (prodlevy mezi požadavky). Inzeráty mohou obsahovat osobní údaje, třeba kontakt na soukromého prodejce - za zpracování v souladu s GDPR odpovídáte vy. Historie cen se ukládá podle ID inzerátu, osobní údaje se nelogují.

***

### 🇸🇰 Slovensky

## CZ/SK Reality Agregátor — české a slovenské inzeráty v jednom datasete

Stiahne realitné inzeráty z **8 českých a slovenských portálov** naraz a vráti jeden normalizovaný, deduplikovaný dataset s históriou cien. Funguje ako klasický scraper aj ako **HTTP API v reálnom čase** (Standby mode), takže ho zapojíte do aplikácie, dashboardu alebo AI agenta cez MCP.

### Čo Actor dokáže

Jeden vstup, osem portálov, jedna výstupná schéma. Pokryté portály: Nehnutelnosti.sk, TopReality.sk a Reality.sk na Slovensku; Sreality.cz, Reality.iDNES.cz, Bezrealitky.cz (súkromná inzercia bez RK), RealityMIX.cz a Reality.cz v Česku. Slovenské portály účtujú v eurách, české v korunách - pole `currency` pri každom zázname hovorí, v ktorej mene je cena.

Realitné kancelárie vystavujú ten istý byt na viacerých portáloch naraz. Actor preto **deduplikuje naprieč portálmi**: jeden byt nájdete v datasete raz a v poli `also_on` vidíte, kde všade visel. Medzi behmi si Actor drží **históriu cien** - každý inzerát nesie `is_new` a `price_dropped`, takže zľavu spoznáte hneď.

### Vstup

Všetky parametre sú voliteľné: `portals` (výber portálov), `transaction` (sale/rent), `category` (flat/house/land/commercial), `region` (napr. `Bratislava`, `Košice`, `Praha`), `priceMin`/`priceMax` (pri slovenských portáloch v €, pri českých v Kč) a `maxItems` (strop nákladov, predvolené 200).

### Výstup

Jeden záznam = jeden unikátny inzerát: portál, ID, titulok, dispozícia, plocha, cena, cena za m², mena, lokalita, GPS (kde portál uvádza), kanonická URL, obrázky, predajca, história cien a príznaky noviniek a zliav. Ukážka záznamu je v anglickej časti vyššie.

### HTTP API (Standby mode)

`GET /search` prijíma rovnaké parametre ako bežný vstup a vracia JSON s inzerátmi do pár desiatok sekúnd. Autentifikácia cez Apify token (`Authorization: Bearer …`). V Standby režime je predvolené `maxItems` 50, aby odpoveď stihla platformný limit 5 minút. Cez Apify MCP server poslúži rovnaký endpoint ako nástroj pre AI agentov.

### Cena

Platíte za **doručený unikátny inzerát** (event `listing-scraped`), počíta sa až po deduplikácii. Duplicity z ďalších portálov nič nestoja.

### Právne upozornenie

Actor zbiera len verejne dostupné dáta a šetrí zdrojové weby (prestávky medzi požiadavkami). Inzeráty môžu obsahovať osobné údaje, napríklad kontakt na súkromného predajcu - za spracovanie v súlade s GDPR zodpovedáte vy. História cien sa ukladá podľa ID inzerátu, osobné údaje sa nelogujú.

# Actor input Schema

## `portals` (type: `array`):

Které portály scrapovat.

## `transaction` (type: `string`):

Prodej nebo pronájem.

## `category` (type: `string`):

Druh nemovitosti.

## `region` (type: `string`):

Volitelný textový filtr lokality (např. 'Praha', 'Brno-město'). Prázdné = celá ČR.

## `priceMin` (type: `integer`):

Minimální cena (Kč).

## `priceMax` (type: `integer`):

Maximální cena (Kč).

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

Strop na počet stažených inzerátů (ochrana nákladů).

## Actor input object example

```json
{
  "portals": [
    "sreality"
  ],
  "transaction": "sale",
  "category": "flat",
  "maxItems": 200
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pringlesbitch/cz-reality-aggregator").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pringlesbitch/cz-reality-aggregator").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 '{}' |
apify call pringlesbitch/cz-reality-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CZ & SK Real Estate Aggregator",
        "description": "Scrape 8 Czech and Slovak real estate portals (Sreality, Bezrealitky, iDNES, Nehnutelnosti.sk & more) into one deduplicated dataset with price history, new-listing and price-drop flags. EUR & CZK. Works as a batch scraper or a real-time HTTP API.",
        "version": "0.1",
        "x-build-id": "rIZbl2PR67jWnyJwP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pringlesbitch~cz-reality-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pringlesbitch-cz-reality-aggregator",
                "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/pringlesbitch~cz-reality-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-pringlesbitch-cz-reality-aggregator",
                "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/pringlesbitch~cz-reality-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-pringlesbitch-cz-reality-aggregator",
                "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": [
                    "portals",
                    "transaction",
                    "category"
                ],
                "properties": {
                    "portals": {
                        "title": "Portály",
                        "type": "array",
                        "description": "Které portály scrapovat.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sreality",
                                "bezrealitky",
                                "idnes",
                                "realitymix",
                                "realitycz",
                                "nehnutelnosti",
                                "topreality",
                                "realitysk"
                            ],
                            "enumTitles": [
                                "Sreality.cz",
                                "Bezrealitky.cz",
                                "Reality.iDNES.cz",
                                "RealityMIX.cz",
                                "Reality.cz",
                                "Nehnutelnosti.sk (SK, EUR)",
                                "TopReality.sk (SK, EUR)",
                                "Reality.sk (SK, EUR)"
                            ]
                        },
                        "default": [
                            "sreality"
                        ]
                    },
                    "transaction": {
                        "title": "Typ transakce",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Prodej nebo pronájem.",
                        "default": "sale"
                    },
                    "category": {
                        "title": "Kategorie",
                        "enum": [
                            "flat",
                            "house",
                            "land",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Druh nemovitosti.",
                        "default": "flat"
                    },
                    "region": {
                        "title": "Region / lokalita",
                        "type": "string",
                        "description": "Volitelný textový filtr lokality (např. 'Praha', 'Brno-město'). Prázdné = celá ČR."
                    },
                    "priceMin": {
                        "title": "Cena od",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimální cena (Kč)."
                    },
                    "priceMax": {
                        "title": "Cena do",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximální cena (Kč)."
                    },
                    "maxItems": {
                        "title": "Max. počet inzerátů",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Strop na počet stažených inzerátů (ochrana nákladů).",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
