# Sreality scraper (`bebich/sreality-scraper`) Actor

Fast and efficient sreality.cz actor. The script get all offers (according to the selected input).

- **URL**: https://apify.com/bebich/sreality-scraper.md
- **Developed by:** [ALi](https://apify.com/bebich) (community)
- **Categories:** Real estate
- **Stats:** 55 total users, 2 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 2.17 out of 5 stars

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

Scrape real estate listings from [Sreality.cz](https://www.sreality.cz/) into a structured Apify dataset.

This actor reads Sreality search data from the site, follows pagination, normalizes listing fields, and can optionally enrich each listing with detail-page data such as description, seller, premise, videos, and listing parameters.

### What You Can Scrape

- Flats, houses, land, commercial properties, and other real estate
- Sale, rental, auction, and share listings
- Listings by Czech region
- Detailed property types such as apartment layouts, family houses, building plots, offices, warehouses, garages, and more
- English or Czech Sreality URL variants
- Optional detail data from individual listing pages

### Common Use Cases

- Track real estate prices across Czech regions
- Build a dataset of active Sreality listings
- Monitor sale and rental inventory by category
- Enrich market analysis with location, price, image, and seller data
- Validate listing detail URLs during scraper QA runs

### Input

The actor accepts slug-based inputs. Empty arrays mean "all supported values".

#### Basic Example

```json
{
  "AREA": ["praha"],
  "CATEGORIES": ["for-sale"],
  "SUBCATEGORIES": ["apartments"],
  "PROPERTY_TYPES": ["1+kt", "2+kt"],
  "maxPages": 5,
  "LANGUAGE_EN": true,
  "GET_DETAILS": false,
  "IGNORE": ["raw", "images", "pagination", "searchUrl", "searchPage"],
  "TEST_URL_DETAIL": false,
  "DEBUG": false
}
````

#### Scrape All Supported Searches For One Page for every area

```json
{
  "AREA": [],
  "CATEGORIES": [],
  "SUBCATEGORIES": [],
  "PROPERTY_TYPES": [],
  "maxPages": 1,
  "LANGUAGE_EN": true,
  "GET_DETAILS": false,
  "IGNORE": [
    "pagination",
    "searchPage",
    "searchUrl",
    "raw",
    "images",
    "premiseLogo",
    "hasMatterport",
    "hasVideo",
    "discountShow",
    "seller.image",
    "premise.retargetingId",
    "premise.askId",
    "premise.isSosCustomAdvertCard",
    "premise.logo",
    "premise.webVisibleUrl",
    "premise.premisePaidFirmy",
    "premise.companySubjectId",
    "videos"
  ]
}
```

#### Czech Example

```json
{
  "AREA": ["praha", "jihomoravsky-kraj"],
  "CATEGORIES": ["prodej", "pronajem"],
  "SUBCATEGORIES": ["byty", "domy"],
  "PROPERTY_TYPES": ["1+kk", "2+kk"],
  "maxPages": 3,
  "LANGUAGE_EN": false
}
```

### Input Fields

| Field | Type | Description |
| --- | --- | --- |
| `AREA` | array | Region slugs to scrape. Leave empty to scrape all supported regions. |
| `CATEGORIES` | array | Listing categories. Supports English and Czech slugs. Leave empty for all categories. |
| `SUBCATEGORIES` | array | Main real estate categories. Supports English and Czech slugs. Leave empty for all subcategories. |
| `PROPERTY_TYPES` | array | Detailed property types such as apartment layouts, family houses, building plots, offices, or garages. Supports English and Czech slugs. Leave empty for all supported property types. |
| `maxPages` | integer | Maximum number of search result pages per generated search. Use `0` to scrape all available pages reported by Sreality. |
| `LANGUAGE_EN` | boolean | `true` requests English Sreality pages and outputs English detail URLs. `false` requests Czech pages and outputs Czech detail URLs. |
| `GET_DETAILS` | boolean | Fetch each listing detail JSON and append detail fields. |
| `IGNORE` | array | Dot-separated output paths to remove from each dataset item before saving. |

### Supported Values

#### Areas

```text
praha
stredocesky-kraj
jihocesky-kraj
jihomoravsky-kraj
karlovarsky-kraj
kralovehradecky-kraj
liberecky-kraj
moravskoslezsky-kraj
olomoucky-kraj
pardubicky-kraj
plzensky-kraj
ustecky-kraj
vysocina-kraj
zlinsky-kraj
```

#### Categories

| English | Czech |
| --- | --- |
| `for-sale` | `prodej` |
| `to-rent` | `pronajem` |
| `auction` | `drazby` |
| `shares` | `podily` |

#### Subcategories

| English | Czech |
| --- | --- |
| `apartments` | `byty` |
| `houses` | `domy` |
| `lands` | `pozemky` |
| `commercial-properties` | `komercni` |
| `other-real-estates` | `ostatni` |

#### Property Types

`PROPERTY_TYPES` supports both English and Czech Sreality slugs. Examples:

```text
1+kt / 1+kk
2+kt / 2+kk
family-houses / rodinne-domy
building-plots / stavebni-parcely
office-spaces / kancelare
warehouses / sklady
garages / garaze
parking-places / garazova-stani
```

Leave `PROPERTY_TYPES` empty to include all supported detailed property types for the selected subcategories.

### Output

The actor saves one dataset item per listing. The exact fields depend on `IGNORE` and whether `GET_DETAILS` is enabled.

#### Example Output Item

```json
{
  "id": 1896579148,
  "date": "2026-06-13",
  "url": "https://www.sreality.cz/en/detail/sale/land/field/oslavicka-oslavicka-/1896579148",
  "name": "For sale farm lands 7413 m2",
  "priceCzk": 363237,
  "priceCzkPerSqM": 49,
  "priceSummaryCzk": 363237,
  "priceUnit": "per property",
  "priceSummaryUnit": "per property",
  "categoryType": "Sale",
  "categoryTypeValue": 1,
  "categoryMain": "Land",
  "categoryMainValue": 3,
  "categorySub": "Fields",
  "categorySubValue": 20,
  "city": "Oslavicka",
  "cityPart": "Oslavicka",
  "district": "Zdar nad Sazavou",
  "region": "Vysocina region",
  "street": "",
  "houseNumber": null,
  "streetNumber": null,
  "latitude": 49.3154067822499,
  "longitude": 15.9668425899982,
  "premiseId": 33825,
  "imageUrls": [
    "https://d18-a.sdn.cz/d_18/c_img_qB_E/kQMlcCt5zmBDp4maqGuWudT/be45.jpeg?fl=res,1200,1200,1|wrm,/watermark/sreality.png,10|shr,,20|webp,80"
  ]
}
```

#### Main Output Fields

- `id`, `date`, `url`, `name`
- `priceCzk`, `priceCzkPerSqM`, `priceSummaryCzk`, `priceUnit`, `priceSummaryUnit`
- `categoryType`, `categoryMain`, `categorySub` and their numeric values
- `city`, `cityPart`, `district`, `region`, `street`, `houseNumber`, `streetNumber`
- `latitude`, `longitude`, `locality`
- `premiseId`, `premiseLogo`
- `images`, `imageUrls`
- `searchPage`, `searchUrl`, `pagination`
- `raw`, containing the original listing object from Sreality

When `GET_DETAILS` is enabled, the actor can also append:

- `dataUpdatedAt`
- `description`
- `premise`
- `seller`
- `rus`
- `videos`
- `isExclusively`
- `params`

### Field Filtering With IGNORE

Use `IGNORE` to remove fields from the dataset before saving.

Examples:

- `raw` removes the original Sreality listing object.
- `images` removes normalized image objects while keeping `imageUrls` if you do not ignore it.
- `pagination` removes pagination metadata.
- `seller.image` removes only the nested seller image when `GET_DETAILS` is enabled.
- `premise.logo` removes only the nested premise logo.

If a rule enters an array, the remaining path is applied to every object in that array.

### Pagination And Empty Searches

Missing arrays and empty arrays mean all supported values. For broad searches, the actor splits requests by area and subcategory instead of sending one huge combined search. This helps avoid Sreality result limits and keeps pagination more predictable.

`maxPages` applies per generated search. For example, `AREA: []`, `SUBCATEGORIES: []`, and `maxPages: 1` can still produce many requests because the actor creates separate searches for each area and subcategory pair.

### Detail Enrichment Notes

`GET_DETAILS` gives richer data but increases request volume. If Sreality rate-limits or blocks detail requests, reduce `GET_DETAILS_CONCURRENCY`.

When detail fetching is enabled, listings whose detail JSON request fails are skipped instead of being saved without details.

### Migration Notes

Version `v1.3` uses the current Sreality and a new slug-based input model.

Legacy fields such as `CITY`, `PROPERTY_TYPE`, `APARTMENTS`, `HOUSES`, `LANDS`, `SELLING`, `LANGUAGE_CZ`, `DATASET_NAME`, `DROP_DATASET`, `SAVE_ALL_TEXTS`, and `ENRICHER_TEXTS` are not part of the current Store input. Use `AREA`, `CATEGORIES`, `SUBCATEGORIES`, `PROPERTY_TYPES`, `LANGUAGE_EN`, `IGNORE`, and `GET_DETAILS` instead.

Legacy output fields such as `Hash_id`, `Datum`, `Cena`, and `URL_AD` were replaced with normalized API-oriented fields such as `id`, `date`, `priceCzk`, and `url`.

### Notes And Limitations

- The actor scrapes data available from Sreality web.
- Available fields can vary by listing category and by what Sreality returns for a specific ad.
- Broad searches can create many page requests. Use `maxPages` for sampling or controlled runs.
- URL validation is intended for debugging and QA. It adds extra network requests.

### Legal

This actor is not affiliated with Sreality.cz. Use it responsibly and make sure your usage complies with applicable laws, Sreality's terms, and Apify's platform rules.

# Actor input Schema

## `AREA` (type: `array`):

Sreality area slugs to scrape. Leave empty to scrape all supported areas.

## `CATEGORIES` (type: `array`):

Listing categories. English and Czech Sreality slugs are accepted. Leave empty to include all categories.

## `SUBCATEGORIES` (type: `array`):

Main property categories. English and Czech Sreality slugs are accepted. Leave empty to include all property categories.

## `PROPERTY_TYPES` (type: `array`):

Detailed property type slugs, such as apartment layouts, house types, land types, and commercial property types. English and Czech Sreality slugs are accepted. Leave empty to include all supported property types for the selected categories.

## `GET_DETAILS` (type: `boolean`):

Fetch each listing detail JSON and append fields such as description, premise, seller, videos, rus, isExclusively, and params.

## `LANGUAGE_EN` (type: `boolean`):

When true, request English Sreality search pages and output English detail URLs. When false, request Czech pages and output Czech detail URLs.

## `IGNORE` (type: `array`):

Dot-separated output field paths to remove from each saved dataset item.

## `TELEGRAM_BOT_TOKEN` (type: `string`):

Optional Telegram bot token. When provided with TELEGRAM\_CHAT\_ID, the actor sends a scrape completion message.

## `TELEGRAM_CHAT_ID` (type: `string`):

Optional Telegram chat ID. When provided with TELEGRAM\_BOT\_TOKEN, the actor sends a scrape completion message.

## Actor input object example

```json
{
  "AREA": [],
  "CATEGORIES": [],
  "SUBCATEGORIES": [],
  "PROPERTY_TYPES": [],
  "GET_DETAILS": false,
  "LANGUAGE_EN": true,
  "IGNORE": [
    "pagination",
    "searchPage",
    "images.restbType",
    "videos"
  ]
}
```

# Actor output Schema

## `results` (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 = {
    "AREA": [],
    "CATEGORIES": [],
    "SUBCATEGORIES": [],
    "PROPERTY_TYPES": [],
    "IGNORE": [
        "pagination",
        "searchPage",
        "images.restbType",
        "videos"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bebich/sreality-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 = {
    "AREA": [],
    "CATEGORIES": [],
    "SUBCATEGORIES": [],
    "PROPERTY_TYPES": [],
    "IGNORE": [
        "pagination",
        "searchPage",
        "images.restbType",
        "videos",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("bebich/sreality-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 '{
  "AREA": [],
  "CATEGORIES": [],
  "SUBCATEGORIES": [],
  "PROPERTY_TYPES": [],
  "IGNORE": [
    "pagination",
    "searchPage",
    "images.restbType",
    "videos"
  ]
}' |
apify call bebich/sreality-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sreality scraper",
        "description": "Fast and efficient sreality.cz actor. The script get all offers (according to the selected input).",
        "version": "0.0",
        "x-build-id": "zZC57d2k6sY6olfFp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bebich~sreality-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bebich-sreality-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/bebich~sreality-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bebich-sreality-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/bebich~sreality-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bebich-sreality-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": {
                    "AREA": {
                        "title": "Areas (optional)",
                        "type": "array",
                        "description": "Sreality area slugs to scrape. Leave empty to scrape all supported areas.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "praha",
                                "stredocesky-kraj",
                                "jihocesky-kraj",
                                "jihomoravsky-kraj",
                                "karlovarsky-kraj",
                                "kralovehradecky-kraj",
                                "liberecky-kraj",
                                "moravskoslezsky-kraj",
                                "olomoucky-kraj",
                                "pardubicky-kraj",
                                "plzensky-kraj",
                                "ustecky-kraj",
                                "vysocina-kraj",
                                "zlinsky-kraj"
                            ]
                        }
                    },
                    "CATEGORIES": {
                        "title": "Categories (optional)",
                        "type": "array",
                        "description": "Listing categories. English and Czech Sreality slugs are accepted. Leave empty to include all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "to-rent",
                                "for-sale",
                                "auction",
                                "shares"
                            ]
                        }
                    },
                    "SUBCATEGORIES": {
                        "title": "Property categories (optional)",
                        "type": "array",
                        "description": "Main property categories. English and Czech Sreality slugs are accepted. Leave empty to include all property categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartments",
                                "houses",
                                "commercial-properties",
                                "lands",
                                "other-real-estates"
                            ]
                        }
                    },
                    "PROPERTY_TYPES": {
                        "title": "Property types (optional)",
                        "type": "array",
                        "description": "Detailed property type slugs, such as apartment layouts, house types, land types, and commercial property types. English and Czech Sreality slugs are accepted. Leave empty to include all supported property types for the selected categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1+1",
                                "1+kt",
                                "2+1",
                                "2+kt",
                                "3+1",
                                "3+kt",
                                "4+1",
                                "4+kt",
                                "5+1",
                                "5+kt",
                                "6-and-more",
                                "apartment-buildings",
                                "apartments",
                                "attics",
                                "pudni-prostory",
                                "building-plots",
                                "commercial-parcels",
                                "cottages",
                                "chalupy",
                                "family-houses",
                                "farm-buildings",
                                "farm-lands",
                                "farms",
                                "flatshare",
                                "forests",
                                "garages",
                                "gardens",
                                "historical-properties",
                                "hotels-accommodation-businesses",
                                "huts",
                                "meadows",
                                "mobile-homes",
                                "multi-family-houses",
                                "office-spaces",
                                "other-commercial-buildings",
                                "other-lands",
                                "other-properties",
                                "parking-places",
                                "ponds",
                                "production-halls",
                                "projects",
                                "restaurants",
                                "retail-spaces",
                                "surgeries",
                                "unusual",
                                "villas",
                                "vineyards",
                                "virtual-offices",
                                "warehouses",
                                "wine-cellars"
                            ]
                        }
                    },
                    "GET_DETAILS": {
                        "title": "Fetch listing details (optional)",
                        "type": "boolean",
                        "description": "Fetch each listing detail JSON and append fields such as description, premise, seller, videos, rus, isExclusively, and params.",
                        "default": false
                    },
                    "LANGUAGE_EN": {
                        "title": "Use English URLs",
                        "type": "boolean",
                        "description": "When true, request English Sreality search pages and output English detail URLs. When false, request Czech pages and output Czech detail URLs.",
                        "default": true
                    },
                    "IGNORE": {
                        "title": "Ignored output fields",
                        "type": "array",
                        "description": "Dot-separated output field paths to remove from each saved dataset item.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "TELEGRAM_BOT_TOKEN": {
                        "title": "Telegram bot token (optional)",
                        "type": "string",
                        "description": "Optional Telegram bot token. When provided with TELEGRAM_CHAT_ID, the actor sends a scrape completion message."
                    },
                    "TELEGRAM_CHAT_ID": {
                        "title": "Telegram chat ID (optional)",
                        "type": "string",
                        "description": "Optional Telegram chat ID. When provided with TELEGRAM_BOT_TOKEN, the actor sends a scrape completion message."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
