# Bezrealitky Real Estate Scraper (`automation-lab/bezrealitky-real-estate-scraper`) Actor

Scrape direct-owner property listings from Bezrealitky search pages with prices, locations, photos, amenities, and listing URLs.

- **URL**: https://apify.com/automation-lab/bezrealitky-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

## Bezrealitky Real Estate Scraper

Scrape public direct-owner real estate listings from Bezrealitky search pages into clean, analysis-ready data.

Use this actor when you need current Czech, Slovak, or German property inventory from Bezrealitky without copying listings by hand. It accepts one or more public search URLs, follows listing pagination, normalizes pricing and property attributes, and returns one dataset row per listing.

### What does Bezrealitky Real Estate Scraper do?

Bezrealitky Real Estate Scraper extracts structured data from public Bezrealitky listing/search pages.

It is designed for repeatable monitoring, spreadsheet exports, and API workflows:

- 🏠 Scrapes public sale and rental search URLs.
- 📍 Captures address text and GPS coordinates when Bezrealitky exposes them.
- 💰 Normalizes price, currency, monthly charges, original price, and discount flags.
- 📐 Extracts floor area, land area, disposition, estate type, and offer type.
- 🖼️ Returns main image and image gallery URLs.
- 🔁 Follows pagination until `maxResults` is reached.
- ⚡ Uses HTTP extraction from server-rendered page data, so runs are fast and inexpensive.

### Who is it for?

#### Real estate investors

Track direct-owner apartments and houses before they are manually entered into your own valuation model.

Typical investor questions:

- Which Prague 2+kk listings were newly added this week?
- Which apartments have a lower price than similar units in the same district?
- Which listings include parking, balcony, terrace, or garden tags?

#### Brokers and buyer agents

Monitor owner-listed inventory and keep clients informed about new opportunities that are not always visible in agency feeds.

Useful broker workflows:

- Daily watchlists for client search criteria.
- Quick exports for comparable listings.
- Lead prioritization based on price, surface, location, and listing age signals.

#### Proptech and analytics teams

Feed public listing data into dashboards, pricing models, internal APIs, or market intelligence products.

Common proptech use cases:

- Inventory trend tracking by offer type and city.
- Direct-owner supply monitoring.
- Geo-analysis using latitude and longitude.
- Enrichment pipelines that combine listings with neighborhood or transport data.

#### Relocation consultants and researchers

Create repeatable snapshots of rental or sale markets for specific regions, budgets, and property types.

Research examples:

- Compare rental availability across Prague, Brno, Bratislava, or Berlin-focused pages.
- Track surface and price distribution by disposition.
- Build recurring datasets for market reports.

### Why use this actor?

Manual copy-paste from real estate portals is slow, inconsistent, and hard to repeat. This actor gives you a stable dataset structure that works in exports, APIs, and scheduled runs.

Key benefits:

- ✅ **Fast HTTP runs** — no browser is launched for normal search scraping.
- ✅ **Normalized output** — numbers are numbers, booleans are booleans, and URLs are complete.
- ✅ **Direct-owner focus** — Bezrealitky specializes in owner-to-buyer/renter listings.
- ✅ **Pagination support** — start from a search URL and let the actor collect more rows.
- ✅ **Optional detail pages** — enable richer descriptions only when you need them.
- ✅ **Low-cost monitoring** — pay per run and per listing, with tiered per-result discounts.

### What data can you extract?

The default dataset contains one row per property listing.

| Field | Type | Description |
|---|---:|---|
| `id` | string | Bezrealitky listing identifier |
| `url` | string | Canonical listing URL |
| `title` | string | Listing title as shown by Bezrealitky |
| `offerType` | string | Sale/rent offer type, for example `PRODEJ` |
| `estateType` | string | Property category, for example apartment or house |
| `disposition` | string | Layout/disposition value when available |
| `address` | string | Public address/locality text |
| `price` | number | Asking price |
| `originalPrice` | number | Previous/original price when exposed |
| `currency` | string | Currency code, usually `CZK` |
| `charges` | number | Monthly charges/fees when exposed |
| `surface` | number | Interior floor area in square meters |
| `surfaceLand` | number | Land area in square meters when available |
| `latitude` | number | Latitude when available |
| `longitude` | number | Longitude when available |
| `tags` | array | Listing tags such as parking, furnished, new building |
| `imageUrls` | array | Image gallery URLs |
| `mainImageUrl` | string | Primary listing image URL |
| `isNew` | boolean | Whether Bezrealitky marks the listing as new |
| `isReserved` | boolean | Whether the listing is reserved |
| `isHighlighted` | boolean | Whether Bezrealitky highlights the listing |
| `isDiscounted` | boolean | Whether the listing is discounted |
| `description` | string | Detail-page text when `includeDetails` is enabled |
| `scrapedAt` | string | ISO timestamp of extraction |

### How much does it cost to scrape Bezrealitky listings?

This actor uses Apify pay-per-event pricing:

- Start event: **$0.005 per run**.
- Result event: charged once for each listing extracted.
- Bronze per-listing price: **$0.00007641**.
- Free tier per-listing price: **$0.000087872**.
- Higher Apify subscription tiers receive lower per-listing prices.

Approximate user-facing cost examples before any Apify platform credits or discounts:

| Run size | Formula at Free tier | Estimated charge |
|---:|---|---:|
| 20 listings | $0.005 + 20 × $0.000087872 | $0.0068 |
| 100 listings | $0.005 + 100 × $0.000087872 | $0.0138 |
| 500 listings | $0.005 + 500 × $0.000087872 | $0.0489 |
| 1,000 listings | $0.005 + 1,000 × $0.000087872 | $0.0929 |

If you are on Apify's Free plan, your included platform credits should cover many small monitoring runs. For example, a 100-listing run is roughly one to two cents at the Free-tier event price. Your final bill can also include Apify platform usage according to your account plan.

### Pricing tiers

Per-listing result prices currently configured for this actor:

| Tier | Price per listing |
|---|---:|
| FREE | $0.000087872 |
| BRONZE | $0.00007641 |
| SILVER | $0.0000596 |
| GOLD | $0.000045846 |
| PLATINUM | $0.000030564 |
| DIAMOND | $0.000021395 |

The actor also charges the fixed $0.005 start event once per run.

### How to use

1. Open Bezrealitky and create the search you want to monitor.
2. Copy the public search/listing URL from your browser.
3. Paste it into `startUrls`.
4. Set `maxResults` to control run size and cost.
5. Keep `includeDetails` disabled for broad, fast monitoring.
6. Enable `includeDetails` only if you need long descriptions from detail pages.
7. Run the actor.
8. Download results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Input configuration

| Input | Type | Default | Description |
|---|---:|---:|---|
| `startUrls` | array | sample sale URL | One or more public Bezrealitky search URLs |
| `maxResults` | integer | 50 | Maximum listings to return across all URLs |
| `includeDetails` | boolean | false | Open listing detail pages for richer text |
| `maxRequestRetries` | integer | 3 | Retry count for transient HTTP failures |

Example input:

```json
{
  "startUrls": [
    "https://www.bezrealitky.cz/vypis/nabidka-prodej/byt"
  ],
  "maxResults": 100,
  "includeDetails": false,
  "maxRequestRetries": 3
}
````

### Search URL examples

Use URLs copied from Bezrealitky after applying your filters.

Good inputs include:

- Public sale apartment search pages.
- Public rental apartment search pages.
- City or region filtered searches.
- Search pages with price, layout, or surface filters already applied.

Avoid inputs that require login, saved-account state, or private user sessions.

### Output example

A typical dataset item looks like this:

```json
{
  "id": "1015032",
  "url": "https://www.bezrealitky.cz/nemovitosti-byty-domy/1015032-nabidka-prodej-bytu-holeckova-praha",
  "title": "Prodej bytu 2+kk 38 m², Holečkova, Praha",
  "offerType": "PRODEJ",
  "estateType": "BYT",
  "disposition": "DISP_2_KK",
  "address": "Holečkova, Praha - Košíře",
  "price": 7290000,
  "currency": "CZK",
  "charges": 0,
  "surface": 38,
  "latitude": 50.0722981,
  "longitude": 14.3881939,
  "tags": ["Novostavba", "Částečně vybaveno", "Parkování"],
  "mainImageUrl": "https://api.bezrealitky.cz/media/cache/record_thumb/data/images/advert/1015k/1015032/1776776931-agvowzcuqc-7-2.jpg",
  "isNew": false,
  "isReserved": false,
  "isDiscounted": false,
  "scrapedAt": "2026-05-21T12:24:05.616Z"
}
```

### Tips for better results

- Start with a filtered Bezrealitky search URL instead of a broad homepage URL.
- Use smaller `maxResults` values for daily monitoring and larger values for one-off market snapshots.
- Keep `includeDetails` off unless descriptions are required; search pages already contain most structured fields.
- Use multiple start URLs when you want to compare different cities, offer types, or property categories.
- Schedule the actor daily or weekly and compare datasets over time.
- Export CSV for quick spreadsheet work; use JSON for downstream APIs.

### Integrations

Apify datasets can be sent into the tools your team already uses.

Common integration patterns:

- 📊 **Google Sheets** — export current listings for analysts and agents.
- 🧱 **BigQuery / Snowflake** — append recurring snapshots for market analytics.
- 🐘 **PostgreSQL** — store normalized rows for internal applications.
- ⚙️ **Make or Zapier** — trigger notifications when new listings match your filters.
- 🔔 **Slack or email alerts** — send summaries for newly scraped listings.
- 🗺️ **GIS tools** — map latitude and longitude for location analysis.

### API usage

You can run this actor from the Apify Console, API, CLI, or official clients. The actor ID is:

```text
automation-lab/bezrealitky-real-estate-scraper
```

### Node.js example

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

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

const input = {
  startUrls: ['https://www.bezrealitky.cz/vypis/nabidka-prodej/byt'],
  maxResults: 50,
  includeDetails: false,
};

const run = await client.actor('automation-lab/bezrealitky-real-estate-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 50 });

console.log(`Scraped ${items.length} Bezrealitky listings`);
console.log(items[0]);
```

### Python example

```python
import os
from apify_client import ApifyClient

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

run = client.actor('automation-lab/bezrealitky-real-estate-scraper').call(run_input={
    'startUrls': ['https://www.bezrealitky.cz/vypis/nabidka-prodej/byt'],
    'maxResults': 50,
    'includeDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items(limit=50).items
print(f'Scraped {len(items)} Bezrealitky listings')
print(items[0] if items else 'No listings returned')
```

### cURL example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bezrealitky-real-estate-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": ["https://www.bezrealitky.cz/vypis/nabidka-prodej/byt"],
    "maxResults": 50,
    "includeDetails": false
  }'
```

After the run finishes, download dataset items with the `defaultDatasetId` from the run response:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json&token=$APIFY_TOKEN"
```

### MCP usage

Use Apify MCP to let Claude run the scraper and inspect fresh listing data.

Claude Code command:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/bezrealitky-real-estate-scraper
```

Claude Desktop configuration:

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

Example MCP prompts:

- "Scrape 50 sale apartment listings from this Bezrealitky URL and summarize median price per square meter."
- "Find listings with parking or terrace tags and return a table with price, surface, and URL."
- "Compare two Bezrealitky search URLs and tell me which one has cheaper apartments by m²."

### Data quality and limitations

The actor extracts data that Bezrealitky exposes publicly in page data and listing/detail pages.

Quality notes:

- Missing source values are omitted rather than guessed.
- Numeric values are parsed into numbers when possible.
- Image URLs are returned as absolute URLs.
- Detail descriptions require `includeDetails: true`.
- Results depend on the filters and availability of the Bezrealitky URL you provide.

### Performance notes

For broad monitoring, use search-page extraction only. It is faster and cheaper because it avoids one request per detail page.

Recommended settings:

- Daily monitoring: `maxResults` 20–100, `includeDetails` false.
- Weekly market snapshot: `maxResults` 100–500, `includeDetails` false.
- Enriched lead list: `maxResults` 20–100, `includeDetails` true.

### Legality

This actor is intended for scraping publicly available listing data. You are responsible for using the output lawfully, respecting privacy rights, and complying with applicable terms, regulations, and internal policies.

Do not use scraped data for spam, harassment, discrimination, or unlawful profiling. If you store or share personal data, make sure your workflow has an appropriate legal basis.

### FAQ

#### Why did my run return fewer listings than `maxResults`?

The source search may have fewer public listings than requested, or filters may be very narrow. Try a broader Bezrealitky search URL and run again.

#### Should I enable `includeDetails`?

Enable it when you need long descriptions or extra detail-page attributes. Leave it disabled for fast, low-cost market monitoring.

#### Can I scrape multiple cities in one run?

Yes. Add multiple filtered Bezrealitky search URLs to `startUrls`. The actor collects listings across all URLs until `maxResults` is reached.

#### Can I schedule recurring runs?

Yes. Use Apify schedules to run the actor daily, weekly, or monthly, then compare datasets over time.

### Troubleshooting

#### The run returns no listings

Check that the URL is a public Bezrealitky search/listing URL. If the page requires login or only works with private account state, the actor cannot access it.

#### Prices or locations look different from the website

Bezrealitky can update listings between runs. Re-run the actor with a small `maxResults` value and compare the item URL directly with the live page.

#### The run is slower than expected

Disable `includeDetails`, reduce `maxResults`, or split very broad monitoring into multiple scheduled runs.

### Related scrapers

Other Automation Lab real-estate actors that may complement this one:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — US property listings and property detail data.
- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) — accommodation and hospitality market data.
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — local business and location lead generation.

For more actors, visit [Automation Lab on Apify](https://apify.com/automation-lab).

### Changelog

- Initial version extracts public Bezrealitky listing/search data with normalized property, pricing, location, image, and status fields.

# Actor input Schema

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

One or more Bezrealitky listing/search URLs to scrape, such as sale apartments or rental houses.

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

Maximum number of listings to return across all start URLs.

## `includeDetails` (type: `boolean`):

Fetch each listing detail page to include long descriptions and additional property attributes. Slower but richer.

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

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.bezrealitky.cz/vypis/nabidka-prodej/byt"
  ],
  "maxResults": 20,
  "includeDetails": false,
  "maxRequestRetries": 3
}
```

# 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.bezrealitky.cz/vypis/nabidka-prodej/byt"
    ],
    "maxResults": 20,
    "includeDetails": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bezrealitky-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.bezrealitky.cz/vypis/nabidka-prodej/byt"],
    "maxResults": 20,
    "includeDetails": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bezrealitky-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.bezrealitky.cz/vypis/nabidka-prodej/byt"
  ],
  "maxResults": 20,
  "includeDetails": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/bezrealitky-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bezrealitky Real Estate Scraper",
        "description": "Scrape direct-owner property listings from Bezrealitky search pages with prices, locations, photos, amenities, and listing URLs.",
        "version": "0.1",
        "x-build-id": "NGtYGzBnIFxY3riwr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bezrealitky-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bezrealitky-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~bezrealitky-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bezrealitky-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~bezrealitky-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bezrealitky-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",
                "properties": {
                    "startUrls": {
                        "title": "Bezrealitky search URLs",
                        "type": "array",
                        "description": "One or more Bezrealitky listing/search URLs to scrape, such as sale apartments or rental houses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all start URLs.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Fetch each listing detail page to include long descriptions and additional property attributes. Slower but richer.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```