# Reality iDNES Property Scraper (`solidcode/reality-idnes-cz-scraper`) Actor

\[💰 $5.0 / 1K] Extract detailed property records from reality.idnes.cz, the Czech real-estate portal. Paste property URLs or a search page to get full data per property: price, location, GPS, areas, condition, energy class, broker and agency contacts, facilities, photos, and description.

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

## Pricing

from $5.00 / 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

## Reality iDNES Property Scraper

Pull detailed property records from reality.idnes.cz at scale — price, full location with GPS coordinates, three separate area measurements, energy class, facility flags, and verified broker and agency contacts for every apartment, house, land plot, and commercial listing across the Czech Republic, for sale and for rent. Built for Czech real-estate investors, property-tech teams, and lead-generation agencies who need clean, structured iDNES data without copying listings off the page one at a time.

### Why This Scraper?

- **GPS latitude and longitude on every listing** — exact `latitude`/`longitude` coordinates on each property, ready to drop straight onto a map or into a geo-analytics pipeline.
- **Verified broker and agency contacts** — `brokerName`, `brokerPhone`, `brokerEmail`, `agencyName`, and `agencyAddress` captured per listing, turning a search into a ready-made lead list.
- **Energy-performance class (PENB A–G)** — the official Czech energy certificate rating on each property, a field most CZK-market scrapers skip entirely.
- **Three distinct area measurements** — `landAreaSqm`, `builtUpAreaSqm`, and `usableAreaSqm` parsed as clean numbers, so you can compute true price-per-m² without guessing which "size" the listing meant.
- **Both sale and rent listings** — `dealType` flags `sale` (prodej) or `rent` (pronajem) on every record; one actor covers the whole market.
- **Auto-paginated search seeding** — paste a single search-results URL with your filters already applied and the actor walks every page and scrapes each matching property automatically — no hand-collecting detail links.
- **40+ structured fields per property** — one flat row per listing covering price, location, layout, building, energy, contacts, and media. No nested objects to flatten downstream.
- **Facilities breakdown** — a structured `facilities` map for elevator (výtah), gas (plyn), water (voda), cellar (sklep), terrace (terasa), sewerage (kanalizace), and electricity (elektřina).
- **Czech-locale-correct number parsing** — prices and areas written with Czech thousands separators (non-breaking spaces, narrow spaces) are normalized to plain numbers, so `4 250 000` arrives as `4250000`.

### Use Cases

**Real-Estate Market Research**
- Map inventory by city, district, and region across the Czech Republic
- Compare price-per-m² between apartments, houses, and land
- Track new-build (novostavba) supply against existing stock
- Benchmark asking prices for sale versus rent in the same locality

**Real-Estate Investment**
- Build comparables from `usableAreaSqm`, `price`, and GPS clusters
- Spot under-priced listings by condition and building material
- Screen rental yield by pairing rent listings with nearby sale prices
- Filter candidates by energy class to anticipate renovation cost

**Lead Generation for Agents**
- Build broker contact lists with name, phone, and email in one run
- Map agency coverage by `agencyName` and `agencyAddress`
- Identify the most active agencies in a target district
- Source listings to pitch for co-brokerage or buyer representation

**Price & Area Analytics**
- Feed clean `price` and area fields into pricing models and dashboards
- Compute true price-per-m² across three area definitions
- Track price movements by re-running saved search URLs on a schedule
- Segment a market by `propertyType`, `condition`, and `ownership`

**Property-Tech Data Feeds**
- Power a CZK-market listings portal or aggregator
- Enrich an existing property database with GPS, energy class, and contacts
- Drive map-based search with per-listing coordinates
- Supply structured inputs to valuation and mortgage tools

### Getting Started

#### Scrape a Single Property

Paste one property detail URL:

```json
{
    "startUrls": [
        "https://reality.idnes.cz/detail/prodej/dum/radkov/69bc059a4eb2eab6bb0b9a66/"
    ]
}
````

#### Scrape Several Properties

Mix any number of detail URLs in one run:

```json
{
    "startUrls": [
        "https://reality.idnes.cz/detail/prodej/byt/praha/68eb78df54abc4122504fc60/",
        "https://reality.idnes.cz/detail/pronajem/byt/brno/67aa12cd54abc4122504aa01/",
        "https://reality.idnes.cz/detail/prodej/pozemek/zlin/66cc34ef54abc4122504bb02/"
    ]
}
```

#### Follow a Search and Cap the Results

Apply your filters on reality.idnes.cz, copy the search-results URL, and let the actor follow it to every matching property:

```json
{
    "startUrls": [
        "https://reality.idnes.cz/s/prodej/byty/praha/"
    ],
    "maxResults": 250,
    "includeImages": true
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | reality.idnes.cz links. Each can be an individual property detail page (scraped directly) or a search-results page (followed automatically to every property it lists). Add as many as you like. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of properties to return across all your URLs. Set to `0` for unlimited (a 50,000 safety ceiling always applies). Start with 10–50 to test, then increase. |
| `includeImages` | boolean | `true` | Include the full list of property photo URLs in each record. Turn off for leaner results when you only need the structured details. |

### Output

Each property is one flat record. Here's a representative result with photos enabled:

```json
{
    "url": "https://reality.idnes.cz/detail/prodej/byt/praha/68eb78df54abc4122504fc60/",
    "propertyId": "68eb78df54abc4122504fc60",
    "orderNumber": "IDNES-N00476",
    "title": "Prodej bytu 3+kk 78 m², Praha 4 - Podolí",
    "dealType": "sale",
    "propertyType": "apartment",
    "price": 9450000,
    "currency": "CZK",
    "priceNote": null,
    "location": "Podolí, Praha 4, Praha, Hlavní město Praha",
    "city": "Praha 4",
    "district": "Praha",
    "region": "Hlavní město Praha",
    "latitude": 50.0451,
    "longitude": 14.4123,
    "landAreaSqm": null,
    "builtUpAreaSqm": null,
    "usableAreaSqm": 78,
    "rooms": 3,
    "category": "3+kk",
    "condition": "Velmi dobrý",
    "buildingMaterial": "Cihla",
    "ownership": "Osobní",
    "floor": "3. podlaží",
    "buildingFloors": "5",
    "energyClass": "C - Úsporná",
    "furnishing": "Částečně",
    "moveInDate": "Ihned",
    "isNewBuilding": false,
    "description": "Nabízíme k prodeji světlý byt 3+kk v žádané lokalitě Praha - Podolí...",
    "facilities": { "výtah": "Ano", "sklep": "Ano", "terasa": "Ano" },
    "features": ["Parkování: Garážové stání"],
    "brokerName": "Mgr. Rudolf Čumpelík",
    "brokerPhone": "420776123456",
    "brokerEmail": "r.cumpelik@example.cz",
    "agencyName": "Example Reality s.r.o.",
    "agencyAddress": "Podolská 12, Praha",
    "status": "active",
    "images": [
        "https://sta-reality2.1gr.cz/sta/example-01.jpg",
        "https://sta-reality2.1gr.cz/sta/example-02.jpg"
    ]
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical property detail URL |
| `propertyId` | string | iDNES internal listing identifier |
| `orderNumber` | string | Human-readable order number (e.g. "IDNES-N00476") |
| `title` | string | Listing headline |
| `dealType` | string | `sale` or `rent` |
| `propertyType` | string | apartment, house, land, commercial, etc. |
| `price` | number | Numeric price; `null` when "price on request" |
| `currency` | string | Currency code (CZK) |
| `priceNote` | string | Free-text price note when present (e.g. `/měsíc` on rentals, `Cena na vyžádání` when the price is on request) |
| `status` | string | Listing status (active, reserved, etc.) |

#### Location & GPS

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Full human-readable locality string |
| `city` | string | City or municipality |
| `district` | string | District |
| `region` | string | Region |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |

#### Area & Layout

| Field | Type | Description |
|-------|------|-------------|
| `usableAreaSqm` | number | Usable floor area in m² |
| `landAreaSqm` | number | Land/plot area in m² |
| `builtUpAreaSqm` | number | Built-up area in m² |
| `rooms` | number | Room count |
| `category` | string | Layout category (e.g. "3+kk", "2+1") |
| `floor` | string | Floor the unit is on |
| `furnishing` | string | Furnishing level |
| `moveInDate` | string | Move-in availability |

#### Building & Energy

| Field | Type | Description |
|-------|------|-------------|
| `condition` | string | Property condition |
| `buildingMaterial` | string | Construction material (brick, panel, etc.) |
| `ownership` | string | Ownership type |
| `buildingFloors` | string | Number of floors in the building |
| `energyClass` | string | Energy-performance class (PENB A–G, Czech label) |
| `isNewBuilding` | boolean | New-build (novostavba) flag |
| `facilities` | object | Facility flags (elevator, gas, water, cellar, terrace, sewerage, electricity) |
| `features` | string\[] | Additional feature tags |
| `description` | string | Full property description |

#### Contacts

| Field | Type | Description |
|-------|------|-------------|
| `brokerName` | string | Listing broker/agent name |
| `brokerPhone` | string | Broker phone number |
| `brokerEmail` | string | Broker email |
| `agencyName` | string | Agency name |
| `agencyAddress` | string | Agency address |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Deduplicated property photo URLs (included when "Include Property Photos" is on) |

### Tips for Best Results

- **Start small** — set `maxResults` to 10–50 on your first run to confirm the data matches your needs, then scale up.
- **Seed from a search URL** — instead of collecting detail links by hand, apply your filters (deal type, locality, property type, price) on reality.idnes.cz, then paste the resulting search-results URL. The actor follows every page automatically.
- **Mix URL types freely** — combine individual detail pages and search-results pages in one `startUrls` list; each is handled correctly.
- **Turn off photos for lean lead lists** — when you only need price, area, location, and broker contacts, set `includeImages` to `false` for smaller, faster results.
- **Use a tight locality for comparables** — a search URL scoped to one district returns the cleanest set of comps for price-per-m² analysis.
- **Both deal types in one pass** — run a sale search and a rent search for the same area to compute rental yield side by side using `usableAreaSqm` and `price`.
- **Re-run saved search URLs on a schedule** — point a daily run at the same search-results URL to track new listings and price changes over time.

### Pricing

**From $5.00 per 1,000 results** — roughly 44% below the prevailing market rate for iDNES property data. 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.60 | $0.565 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is one property record in the output dataset. 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 is designed for legitimate real-estate research, market analysis, and lead generation. You are responsible for complying with applicable laws and reality.idnes.cz's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as broker contact details) in accordance with applicable privacy regulations. </content> </invoke>

# Actor input Schema

## `startUrls` (type: `array`):

Paste reality.idnes.cz links. These can be individual property pages (e.g. a /detail/... page) to scrape directly, or a search results page (with your filters already applied in the browser) to follow automatically to every property it lists. Add as many as you like.

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

Maximum number of properties to return across all your URLs. Set to 0 for unlimited. A 50,000 safety ceiling always applies. Tip: start with 10-50 to test, then increase. Lists of detail pages are naturally limited to the number of links you paste.

## `includeImages` (type: `boolean`):

Include the full list of property photo URLs in each record. Turn this off for leaner results when you only need the structured details (price, area, location, contacts).

## Actor input object example

```json
{
  "startUrls": [
    "https://reality.idnes.cz/detail/prodej/dum/radkov/69bc059a4eb2eab6bb0b9a66/"
  ],
  "maxResults": 100,
  "includeImages": true
}
```

# Actor output Schema

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

Table of scraped properties with key fields.

# 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 = {
    "startUrls": [
        "https://reality.idnes.cz/detail/prodej/dum/radkov/69bc059a4eb2eab6bb0b9a66/"
    ],
    "maxResults": 100,
    "includeImages": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/reality-idnes-cz-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 = {
    "startUrls": ["https://reality.idnes.cz/detail/prodej/dum/radkov/69bc059a4eb2eab6bb0b9a66/"],
    "maxResults": 100,
    "includeImages": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/reality-idnes-cz-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 '{
  "startUrls": [
    "https://reality.idnes.cz/detail/prodej/dum/radkov/69bc059a4eb2eab6bb0b9a66/"
  ],
  "maxResults": 100,
  "includeImages": true
}' |
apify call solidcode/reality-idnes-cz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reality iDNES Property Scraper",
        "description": "[💰 $5.0 / 1K] Extract detailed property records from reality.idnes.cz, the Czech real-estate portal. Paste property URLs or a search page to get full data per property: price, location, GPS, areas, condition, energy class, broker and agency contacts, facilities, photos, and description.",
        "version": "1.0",
        "x-build-id": "38UjDEQhU5zsVOIg0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~reality-idnes-cz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-reality-idnes-cz-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~reality-idnes-cz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-reality-idnes-cz-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~reality-idnes-cz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-reality-idnes-cz-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": {
                    "startUrls": {
                        "title": "Property or Search URLs",
                        "type": "array",
                        "description": "Paste reality.idnes.cz links. These can be individual property pages (e.g. a /detail/... page) to scrape directly, or a search results page (with your filters already applied in the browser) to follow automatically to every property it lists. Add as many as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of properties to return across all your URLs. Set to 0 for unlimited. A 50,000 safety ceiling always applies. Tip: start with 10-50 to test, then increase. Lists of detail pages are naturally limited to the number of links you paste.",
                        "default": 100
                    },
                    "includeImages": {
                        "title": "Include Property Photos",
                        "type": "boolean",
                        "description": "Include the full list of property photo URLs in each record. Turn this off for leaner results when you only need the structured details (price, area, location, contacts).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```