# Sreality.cz Real Estate Scraper (`automation-lab/sreality-cz-real-estate-scraper`) Actor

Scrape public Czech property listings from Sreality.cz search pages with prices, locations, images, agency data, and detail URLs.

- **URL**: https://apify.com/automation-lab/sreality-cz-real-estate-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sreality.cz Real Estate Scraper

Scrape public Czech property listings from Sreality.cz search pages.

Use this actor to collect sale and rental listing data for apartments, houses, land, commercial properties, or any other Sreality.cz search result page you can open in your browser.

### What does Sreality.cz Real Estate Scraper do?

Sreality.cz Real Estate Scraper extracts structured listing data from public Sreality.cz search result pages.

It reads the listing data already embedded in the page and saves clean rows to an Apify dataset.

You can use it for market monitoring, lead generation, price analysis, and property inventory tracking.

Typical output includes:

- 🏠 listing title and property type
- 💰 price in CZK and price per square meter
- 📍 city, district, region, street, and coordinates
- 🖼️ listing images
- 🔗 detail page URL
- 🏢 agency or premise metadata
- 🎥 video and Matterport flags

### Who is it for?

This actor is useful for several real-estate workflows.

#### Property investors

Track asking prices by city, district, layout, or area.

#### Real-estate agents

Monitor competing listings and agency inventory on Sreality.cz.

#### Proptech teams

Build Czech market datasets for dashboards, valuation models, and alerting.

#### Market analysts

Collect repeatable snapshots of listings for trend analysis.

#### Lead generation teams

Find fresh properties and agencies from public search pages.

### Why use this actor?

Sreality.cz is one of the most important property portals in the Czech Republic.

Manual copying from search pages is slow and inconsistent.

This actor turns public search result pages into structured JSON, CSV, Excel, or API-ready data.

It is HTTP based and does not open a browser, so runs are fast and cost efficient.

### Data table

| Field | Description |
| --- | --- |
| `listingId` | Sreality listing ID |
| `title` | Listing title, including layout and area when present |
| `categoryType` | Sale or rent category |
| `categoryMain` | Main property type, for example Apartments or Houses |
| `categorySub` | Layout or subtype, for example 2+kk |
| `priceCzk` | Asking price in Czech crowns |
| `pricePerSqmCzk` | Price per square meter in CZK |
| `priceSummaryCzk` | Summary price value from Sreality |
| `priceUnit` | Price unit label |
| `localityText` | Human-readable locality summary |
| `city` | City |
| `cityPart` | City part or neighborhood |
| `district` | District |
| `region` | Region |
| `street` | Street when present |
| `country` | Country |
| `latitude` | Latitude when provided |
| `longitude` | Longitude when provided |
| `areaSqm` | Area parsed from title |
| `detailUrl` | Sreality detail page URL |
| `imageUrls` | Array of image URLs |
| `agencyId` | Agency or premise ID |
| `agencyName` | Agency SEO name when present |
| `agencyLogoUrl` | Agency logo URL |
| `hasVideo` | Whether Sreality marks the listing as having video |
| `hasMatterport` | Whether Sreality marks the listing as having Matterport |
| `sourceUrl` | Search page URL that produced the row |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape Sreality.cz listings?

The actor uses pay-per-event pricing.

You pay a small run-start event plus a per-listing event for every extracted result. The configured start event is **$0.005 per run**. The per-listing event is tiered by your Apify plan:

| Apify plan tier | Per listing |
| --- | ---: |
| FREE | $0.000077565 |
| BRONZE | $0.000067448 |
| SILVER | $0.000052609 |
| GOLD | $0.000040469 |
| PLATINUM | $0.000026979 |
| DIAMOND | $0.000018885 |

Example estimates before Apify platform usage costs:

| Run size | FREE estimate | BRONZE estimate |
| --- | ---: | ---: |
| 10 listings | $0.0058 | $0.0057 |
| 50 listings | $0.0089 | $0.0084 |
| 100 listings | $0.0128 | $0.0117 |
| 500 listings | $0.0438 | $0.0387 |

On the FREE tier, a small monitoring run with the prefilled `maxResults: 50` is about **$0.0089** in actor charge events. Because the actor uses HTTP page parsing instead of browser automation, it is designed to be inexpensive for routine monitoring.

For a cheap first run, keep the prefilled `maxResults` value and scrape a single search URL.

### How to use it

1. Open Sreality.cz in your browser.
2. Create the filters you need, such as sale apartments or rental flats.
3. Copy the search result URL.
4. Paste it into the `Sreality search URLs` input.
5. Set `Maximum listings`.
6. Start the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input

The input is intentionally simple.

```json
{
  "startUrls": [
    "https://www.sreality.cz/en/search/for-sale/apartments"
  ],
  "maxResults": 50,
  "maxRequestRetries": 3
}
````

#### Sreality search URLs

Paste one or more Sreality.cz search result URLs.

Examples:

- `https://www.sreality.cz/en/search/for-sale/apartments`
- `https://www.sreality.cz/en/search/to-rent/apartments`
- `https://www.sreality.cz/en/search/for-sale/houses`

#### Maximum listings

Controls the maximum number of rows saved across all start URLs.

Use a low number for testing.

Increase it for full market snapshots.

#### Request retries

Controls retry attempts for temporary request failures.

The default works for most runs.

### Output

Each dataset item is one property listing.

```json
{
  "listingId": 335327308,
  "title": "For sale apartment 3+1 66 m²",
  "categoryType": "Sale",
  "categoryMain": "Apartments",
  "categorySub": "3+1",
  "priceCzk": 5490000,
  "pricePerSqmCzk": 83182,
  "localityText": "tř. Míru, Nová Ulice, Olomouc, Olomouc region",
  "city": "Olomouc",
  "district": "Olomouc",
  "areaSqm": 66,
  "detailUrl": "https://www.sreality.cz/en/detail/sale/flat/...",
  "imageUrls": ["https://d18-a.sdn.cz/...jpeg"],
  "hasVideo": false,
  "hasMatterport": false,
  "sourceUrl": "https://www.sreality.cz/en/search/for-sale/apartments",
  "scrapedAt": "2026-05-17T08:09:00.530Z"
}
```

### Tips for best results

- ✅ Use Sreality.cz search URLs, not the homepage.
- ✅ Test with 20 listings before large jobs.
- ✅ Create separate runs for different cities or property categories.
- ✅ Keep the original search URL in your workflow so results are reproducible.
- ✅ Export as CSV for spreadsheet analysis.

### Common use cases

#### Monitor Prague apartment prices

Run the actor daily on a filtered apartment search URL.

Compare prices and price per square meter over time.

#### Track new rental listings

Run a rental apartment URL every hour or day.

Deduplicate listings by `listingId` in your own system.

#### Build regional inventory dashboards

Run several URLs for different regions.

Join the output into a BI dashboard using city, district, region, price, and area fields.

#### Analyze agency inventory

Use `agencyId` and `agencyName` to group listings by agency or premise.

### Integrations

You can connect the actor with common Apify workflows.

- Google Sheets: export CSV or use an integration tool.
- Make or Zapier: trigger workflows after each run.
- Webhooks: notify your system when new data is ready.
- Apify API: start runs and download datasets programmatically.
- Apify datasets: store historical snapshots and compare runs.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/sreality-cz-real-estate-scraper').call({
  startUrls: ['https://www.sreality.cz/en/search/for-sale/apartments'],
  maxResults: 50,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/sreality-cz-real-estate-scraper').call(run_input={
    'startUrls': ['https://www.sreality.cz/en/search/for-sale/apartments'],
    'maxResults': 50,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~sreality-cz-real-estate-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":["https://www.sreality.cz/en/search/for-sale/apartments"],"maxResults":50}'
```

### MCP usage

Use the actor through Apify MCP with Claude tools.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/sreality-cz-real-estate-scraper
```

Add it to Claude Code with:

```bash
claude mcp add --transport http apify-sreality "https://mcp.apify.com/?tools=automation-lab/sreality-cz-real-estate-scraper"
```

Claude Desktop MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-sreality": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sreality-cz-real-estate-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 Sreality.cz sale apartment listings and summarize median price per square meter."
- "Run the Sreality actor for this rental search URL and list the cheapest 10 apartments."
- "Compare listings from two Sreality.cz region URLs and group them by district."

### Pagination behavior

The actor paginates search results automatically.

It starts with the URL you provide and then requests `?page=2`, `?page=3`, and so on.

Pagination stops when one of these happens:

- the requested maximum listing count is reached
- Sreality returns no more listings
- the source pagination total is exhausted

### Performance

The actor reads data from server-rendered page JSON.

It does not open listing detail pages for every result.

This keeps runtime and network usage low.

A small run usually finishes quickly.

Large runs depend on the number of pages required.

### Data quality notes

Sreality listings may omit some fields.

For example, some listings may hide the exact street or coordinates.

The actor saves fields when they are present in public search-page data.

If Sreality changes its page structure, the actor may need an update.

### Limitations

This actor does not log in to Sreality.cz.

It does not bypass private data restrictions.

It does not scrape user accounts, saved searches, or private contact data.

It focuses on public listing data visible in search results.

### Troubleshooting

#### I got fewer listings than requested

The source search may have fewer available listings than your limit, or Sreality may return fewer listings on the final page.

Try a broader search URL or lower the max listing count.

#### The actor returned no listings

Check that your URL is a Sreality.cz search results page.

Open it in a browser and confirm that listings are visible.

#### Some fields are empty

Sreality does not expose every field on every listing.

For example, agency names, streets, or coordinates can be missing.

### Legality

This actor extracts publicly available property listing data.

You are responsible for using the output in compliance with applicable laws, platform terms, and privacy rules.

Do not use scraped data for unlawful spam, harassment, discrimination, or other prohibited activity.

### Related scrapers

Other Apify actors from automation-lab may pair well with real-estate workflows:

- https://apify.com/automation-lab/google-search-scraper
- https://apify.com/automation-lab/google-shopping-scraper
- https://apify.com/automation-lab/yellowpages-scraper

### FAQ

#### Can I scrape any Sreality.cz category?

Yes. Paste the public search result URL for the category or filter combination you need.

#### Does it support Czech and English URLs?

The actor is designed around public Sreality.cz search URLs and has been tested with English paths.

Czech URLs with the same server-rendered listing data should also work if they expose the same search data.

#### Does it scrape detail pages?

No. The current version focuses on search result pages to keep runs fast and inexpensive.

#### Can I schedule it?

Yes. Use Apify schedules to run the actor hourly, daily, or weekly.

#### Can I deduplicate listings?

Yes. Use `listingId` as the stable key for deduplication.

#### Does it need a proxy?

The tested MVP works with normal HTTP requests and does not require a proxy.

#### Can I export to Excel?

Yes. Apify datasets can be exported as Excel, CSV, JSON, XML, RSS, or HTML.

### Changelog

#### 0.1

Initial version with HTTP extraction from Sreality.cz search result pages.

# Actor input Schema

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

Sreality.cz search result URLs, for example apartments for sale in Czechia. The scraper paginates each URL until the max listing limit is reached.

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

Maximum number of property listings to save across all start URLs.

## `maxRequestRetries` (type: `integer`):

Retry attempts for temporary network or website errors.

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

Proxy is optional. The default direct connection is recommended for this HTTP scraper; enable Apify Proxy only if your environment needs it.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.sreality.cz/en/search/for-sale/apartments"
  ],
  "maxResults": 20,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.sreality.cz/en/search/for-sale/apartments"
    ],
    "maxResults": 20,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sreality-cz-real-estate-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://www.sreality.cz/en/search/for-sale/apartments"],
    "maxResults": 20,
    "maxRequestRetries": 3,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sreality-cz-real-estate-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://www.sreality.cz/en/search/for-sale/apartments"
  ],
  "maxResults": 20,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/sreality-cz-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sreality.cz Real Estate Scraper",
        "description": "Scrape public Czech property listings from Sreality.cz search pages with prices, locations, images, agency data, and detail URLs.",
        "version": "0.1",
        "x-build-id": "0znpZHTElX5Y7sSKr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sreality-cz-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sreality-cz-real-estate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~sreality-cz-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sreality-cz-real-estate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~sreality-cz-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sreality-cz-real-estate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Sreality search URLs",
                        "type": "array",
                        "description": "Sreality.cz search result URLs, for example apartments for sale in Czechia. The scraper paginates each URL until the max listing limit is reached.",
                        "default": [
                            "https://www.sreality.cz/en/search/for-sale/apartments"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to save across all start URLs.",
                        "default": 50
                    },
                    "maxRequestRetries": {
                        "title": "Request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for temporary network or website errors.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy is optional. The default direct connection is recommended for this HTTP scraper; enable Apify Proxy only if your environment needs it.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```