# Otodom Scraper – Polish Real Estate Listings (Sale & Rent) (`haketa/otodom-scraper`) Actor

Extract sale and rental listings from Otodom.pl, Poland's #1 property portal. Price, m² price, rooms, area, floor, owner vs agency, agent contact, coordinates & more.

- **URL**: https://apify.com/haketa/otodom-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Otodom Scraper – Polish Real Estate Listings (Sale & Rent)

Extract **sale (sprzedaż)** and **rental (wynajem)** property listings from [Otodom.pl](https://www.otodom.pl) — Poland's largest and most-used real estate marketplace. Pull clean, structured JSON, CSV, or Excel data with prices in PLN, price per m², rooms, area, floor, location, agent contact, and a **private-owner vs. agency** flag for lead generation.

Whether you are building a property search product, tracking the Polish housing and rental market, sourcing owner (FSBO) leads, or feeding a valuation model — this scraper turns Otodom into a reliable, on-demand data feed. **No code, no infrastructure, no maintenance.**

> 🇵🇱 Covers **all of Poland** — every voivodeship and city, for both **sale and rent**, across apartments, houses, plots, commercial units, garages and rooms.

---

### ⭐ Why this Otodom scraper?

- ✅ **Sale & rent in one actor** — scrape `sprzedaż` or `wynajem` with the same simple input.
- ✅ **Owner vs. agency detection** — a built-in `isPrivateOwner` flag, or scrape **private owners only** for direct FSBO lead generation.
- ✅ **Nationwide coverage** — target a single city, a full region path, or all of Poland (`cala-polska`).
- ✅ **Powerful filters** — price range, area (m²), number of rooms, and listing source (private / agency).
- ✅ **20+ structured fields** — price, PLN/m², rent fee, area, rooms, floor, market type, location breakdown, coordinates and agent contact.
- ✅ **Reliable at scale** — automatic pagination and de-duplication across thousands of listings.
- ✅ **Any format** — export to JSON, CSV, Excel, XML, or pull via API.

---

### 📋 Table of contents

1. [What is Otodom?](#-what-is-otodom)
2. [What data can you extract?](#-what-data-can-you-extract)
3. [Use cases](#-use-cases--who-is-this-for)
4. [How to use the Otodom scraper](#-how-to-use-the-otodom-scraper)
5. [Input examples](#-input-examples)
6. [Output example](#-output-example)
7. [Output fields reference](#-output-fields-reference)
8. [Tips for best results](#-tips-for-best-results)
9. [FAQ](#-frequently-asked-questions)
10. [Integrations](#-integrations--exporting-your-data)

---

### 🏠 What is Otodom?

[Otodom](https://www.otodom.pl) is Poland's #1 real estate portal — the main marketplace where Poles buy, sell and rent property. It lists millions of properties across all 16 voivodeships and every major city, including:

- 🏢 **Mieszkanie** (apartments)
- 🏡 **Dom** (houses)
- 🌳 **Działka** (plots of land)
- 🏬 **Lokal** (commercial units)
- 🏭 **Hala / magazyn** (warehouses)
- 🚗 **Garaż** (garages)
- 🛏️ **Pokój** (rooms)

Otodom is the single richest source of Polish residential and rental market data. This scraper unlocks it for analysis, automation, lead generation and product building.

---

### 📦 What data can you extract?

For every listing the scraper returns a clean, structured record:

- **Pricing** — total price (PLN), price per square meter, and rent fee for rentals.
- **Property specs** — area (m²), number of rooms, floor, property type and market type (primary/secondary).
- **Location** — city, district, province, street and GPS coordinates.
- **Seller** — whether the listing is from a **private owner** or an **agency**, plus agency/agent name.
- **Meta** — listing title, direct URL, publish date, promotion flag and thumbnail.

This combination is ideal for market analysis, price benchmarking, and — thanks to the owner/agency flag — **direct lead generation**.

---

### 🎯 Use cases — who is this for?

#### 🏦 Real estate investors & analysts
Track asking prices and price-per-m² across cities and districts to spot opportunities and benchmark the market.

#### 🏘️ Real estate agencies & brokers
Find **private-owner (FSBO) listings** to win new mandates, and monitor competitor pricing in your area.

#### 💼 PropTech & startups
Power your search product, valuation model, or comparison site with fresh Polish listing data — without building and maintaining a scraper yourself.

#### 📊 Market researchers & journalists
Analyze rent vs. buy trends, price-per-m² by region, and supply across Poland over time.

#### 🎯 Lead generation
Scrape **private owners only** and feed direct seller/landlord leads straight into your CRM.

#### 🤖 Data products & AI
Build training datasets and feeds for real-estate machine learning models, chatbots, and analytics dashboards.

---

### 🚀 How to use the Otodom scraper

You don't need any coding skills. Just configure the input and click **Start**.

1. **Choose a deal type** — *For sale* (sprzedaż) or *For rent* (wynajem).
2. **Choose a property type** — apartment, house, plot, commercial, etc.
3. **Set the region** — a city like `warszawa`, a full path like `mazowieckie/warszawa/warszawa`, or `cala-polska` for all of Poland.
4. **(Optional) filter** — by price, area, rooms, and listing source (private owners only / agencies only).
5. **Set Max items**, then click **Start**.
6. **Export** to JSON, CSV, Excel, or pull via the API.

> 💡 Prefer full control? Set up your exact search on otodom.pl, copy the URL, and paste it into **Start URLs** — the scraper crawls it directly and handles pagination.

---

### 📝 Input examples

#### Example 1 — Apartments for sale in Warsaw
```json
{
  "dealType": "sprzedaz",
  "propertyType": "mieszkanie",
  "region": "warszawa",
  "maxItems": 200
}
````

#### Example 2 — Apartments for rent in Kraków, private owners only 🎯

```json
{
  "dealType": "wynajem",
  "propertyType": "mieszkanie",
  "region": "krakow",
  "ownerType": "PRIVATE",
  "maxItems": 300
}
```

#### Example 3 — Houses for sale nationwide under 1,500,000 PLN

```json
{
  "dealType": "sprzedaz",
  "propertyType": "dom",
  "region": "cala-polska",
  "priceMax": 1500000,
  "maxItems": 1000
}
```

#### Example 4 — Crawl a ready-made Otodom search URL

```json
{
  "startUrls": [
    { "url": "https://www.otodom.pl/pl/wyniki/wynajem/mieszkanie/mazowieckie/warszawa/warszawa" }
  ],
  "maxItems": 300
}
```

***

### 📤 Output example

```json
{
  "dealType": "sale",
  "id": "66012345",
  "url": "https://www.otodom.pl/pl/oferta/przestronne-2-pokoje-mokotow-ID4abcd",
  "title": "Przestronne 2 pokoje, Mokotów",
  "price": 899000,
  "currency": "PLN",
  "pricePerSquareMeter": 18729,
  "rentFee": null,
  "area": 48,
  "rooms": 2,
  "floor": "2",
  "propertyType": "APARTMENT",
  "transactionType": "SELL",
  "market": "SECONDARY",
  "city": "Warszawa",
  "district": "Mokotów",
  "province": "mazowieckie",
  "street": "ul. Puławska",
  "latitude": 52.1924,
  "longitude": 21.0312,
  "isPrivateOwner": false,
  "agencyName": "Example Nieruchomości",
  "isPromoted": true,
  "dateCreated": "2026-05-21",
  "thumbnail": "https://ireland.apollo.olxcdn.com/v1/files/...",
  "scrapedAt": "2026-06-03T10:00:00.000Z"
}
```

***

### 📚 Output fields reference

| Field | Description |
|---|---|
| `dealType` | `sale` or `rent` |
| `id` | Otodom listing ID |
| `url` | Direct link to the listing |
| `title` | Listing title |
| `price` | Price in PLN (monthly rent for rentals) |
| `currency` | Currency (usually PLN) |
| `pricePerSquareMeter` | Price per square meter (PLN/m²) |
| `rentFee` | Additional rent fee / czynsz (when present) |
| `area` | Living area in m² |
| `rooms` | Number of rooms |
| `floor` | Floor |
| `propertyType` | Apartment, house, plot, etc. |
| `transactionType` | Sell / rent |
| `market` | Primary (new) or secondary market |
| `city` / `district` / `province` / `street` | Location breakdown |
| `latitude` / `longitude` | GPS coordinates |
| `isPrivateOwner` | `true` for private owners, `false` for agencies |
| `agencyName` | Agency name (when posted by an agency) |
| `agentName` | Agent contact name (when available) |
| `isPromoted` | Whether the listing is a promoted/featured ad |
| `dateCreated` | When the listing was published |
| `thumbnail` | Primary image URL |
| `scrapedAt` | When the record was collected (ISO 8601) |

***

### 💡 Tips for best results

- 📍 **Narrow by region** for faster, more focused runs — a single city like `warszawa` returns far quicker than `cala-polska`.
- 🎯 **Use `ownerType: PRIVATE`** to collect only owner/FSBO listings — perfect for lead generation.
- 🏷️ **Property type slugs:** `mieszkanie` (apartment), `dom` (house), `dzialka` (plot), `lokal` (commercial), `haleimagazyny` (warehouse), `garaz` (garage), `pokoj` (room).
- 🔗 **Use Start URLs for complex searches.** Build your filters on otodom.pl, copy the URL, and paste it in — the scraper handles the rest.
- 🔢 **Set Max items** to keep runs fast and predictable, especially for nationwide searches.

***

### ❓ Frequently asked questions

#### Can I scrape both sale and rental listings?

Yes. Set `dealType` to `sprzedaz` for sale or `wynajem` for rent. Each run focuses on one deal type; run the actor twice to get both.

#### Can I get only private-owner (FSBO) listings?

Yes — set `ownerType` to `PRIVATE`. Every record also carries an `isPrivateOwner` flag so you can filter afterwards too. This is ideal for agencies and lead-gen teams looking for direct sellers and landlords.

#### How do I target a specific city or district?

Set the `region` field to a city slug (e.g. `warszawa`, `krakow`, `wroclaw`) or a full path (e.g. `mazowieckie/warszawa/warszawa`). For anything more specific, build the search on otodom.pl and paste the URL into **Start URLs**.

#### How many listings can I scrape?

As many as you need. Use **Max items** to cap a run, and narrow by region to keep runs fast.

#### What formats can I export to?

JSON, CSV, Excel, XML, RSS, or programmatically via the Apify API. The data also includes a clean tabular **overview** view in the dataset.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run the scraper daily or weekly and keep your dataset fresh — great for monitoring new listings and price changes.

#### Can I get notified of new listings?

Combine scheduled runs with Apify integrations (webhooks, Make, Zapier, Slack, email) to get alerts whenever new properties match your criteria.

***

### 🔌 Integrations & exporting your data

This actor works seamlessly with the Apify ecosystem:

- **API** — pull results programmatically with a single HTTP request.
- **Webhooks** — trigger downstream workflows when a run finishes.
- **Make / Zapier** — connect Otodom data to thousands of apps with no code.
- **Google Sheets, Slack, email** — push results where your team works.
- **Schedules** — automate recurring runs to keep data fresh.

Results can be downloaded as JSON, CSV, Excel, XML, or RSS at any time.

***

### 🆘 Support

Found a bug or need a new field or filter? Open an issue on the actor's **Issues** tab. Feedback and feature requests are welcome — this scraper is actively maintained.

**Happy scraping! 🏠🇵🇱**

# Actor input Schema

## `dealType` (type: `string`):

Scrape properties FOR SALE (sprzedaż) or FOR RENT (wynajem).

## `propertyType` (type: `string`):

Type of property to scrape.

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

Otodom region slug. Use "cala-polska" for all of Poland, a city like "warszawa" / "krakow" / "wroclaw", or a full path like "mazowieckie/warszawa/warszawa". Ignored when Start URLs are provided.

## `ownerType` (type: `string`):

Filter by who posted the listing. "Private only" is great for owner/FSBO lead generation.

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

Minimum price in Polish złoty.

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

Maximum price in Polish złoty.

## `areaMin` (type: `integer`):

Minimum living area in square meters.

## `areaMax` (type: `integer`):

Maximum living area in square meters.

## `roomsMin` (type: `integer`):

Minimum number of rooms.

## `roomsMax` (type: `integer`):

Maximum number of rooms.

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

Optional. Paste ready-made Otodom search result URLs (https://www.otodom.pl/pl/wyniki/...). When provided, these take priority and the filters above are ignored. Pagination is handled automatically.

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

Stop after collecting this many listings (0 = no limit).

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

Recommended. A Polish (PL) residential proxy gives the most reliable results on Otodom.

## Actor input object example

```json
{
  "dealType": "sprzedaz",
  "propertyType": "mieszkanie",
  "region": "warszawa",
  "ownerType": "ALL",
  "startUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Sale and rental listings collected from Otodom.

# 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 = {
    "region": "warszawa",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "PL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/otodom-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 = {
    "region": "warszawa",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/otodom-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 '{
  "region": "warszawa",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PL"
  }
}' |
apify call haketa/otodom-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Otodom Scraper – Polish Real Estate Listings (Sale & Rent)",
        "description": "Extract sale and rental listings from Otodom.pl, Poland's #1 property portal. Price, m² price, rooms, area, floor, owner vs agency, agent contact, coordinates & more.",
        "version": "0.1",
        "x-build-id": "uBeHn9tTKHnfqlfnO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~otodom-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-otodom-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/haketa~otodom-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-otodom-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/haketa~otodom-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-otodom-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": {
                    "dealType": {
                        "title": "Deal type",
                        "enum": [
                            "sprzedaz",
                            "wynajem"
                        ],
                        "type": "string",
                        "description": "Scrape properties FOR SALE (sprzedaż) or FOR RENT (wynajem).",
                        "default": "sprzedaz"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "mieszkanie",
                            "dom",
                            "dzialka",
                            "lokal",
                            "haleimagazyny",
                            "garaz",
                            "pokoj"
                        ],
                        "type": "string",
                        "description": "Type of property to scrape.",
                        "default": "mieszkanie"
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Otodom region slug. Use \"cala-polska\" for all of Poland, a city like \"warszawa\" / \"krakow\" / \"wroclaw\", or a full path like \"mazowieckie/warszawa/warszawa\". Ignored when Start URLs are provided.",
                        "default": "cala-polska"
                    },
                    "ownerType": {
                        "title": "Listed by",
                        "enum": [
                            "ALL",
                            "PRIVATE",
                            "AGENCY"
                        ],
                        "type": "string",
                        "description": "Filter by who posted the listing. \"Private only\" is great for owner/FSBO lead generation.",
                        "default": "ALL"
                    },
                    "priceMin": {
                        "title": "Min price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Polish złoty."
                    },
                    "priceMax": {
                        "title": "Max price (PLN)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Polish złoty."
                    },
                    "areaMin": {
                        "title": "Min area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum living area in square meters."
                    },
                    "areaMax": {
                        "title": "Max area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum living area in square meters."
                    },
                    "roomsMin": {
                        "title": "Min rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of rooms."
                    },
                    "roomsMax": {
                        "title": "Max rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rooms."
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Optional. Paste ready-made Otodom search result URLs (https://www.otodom.pl/pl/wyniki/...). When provided, these take priority and the filters above are ignored. Pagination is handled automatically.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many listings (0 = no limit).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Recommended. A Polish (PL) residential proxy gives the most reliable results on Otodom.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "PL"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
