# Daft.ie Scraper — Ireland Property & Agent Leads (`logiover/daft-ie-scraper`) Actor

Daft.ie scraper and API alternative: export Irish property data to CSV/JSON with agent contacts. No login, no API key.

- **URL**: https://apify.com/logiover/daft-ie-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (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.99 / 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.

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

<div align="center">

<img src="https://cdn-icons-png.flaticon.com/128/619/619153.png" width="92" alt="Daft.ie Scraper"/>

## 🇮🇪 Daft.ie Scraper

#### Scrape Ireland real estate from **Daft.ie** — price, beds, baths, size, BER, geo **and the agent &amp; agency phone**

<p>
<img src="https://img.shields.io/badge/✓_NO_LOGIN-no_API_key-2ea44f?style=for-the-badge&labelColor=0b3d2e"/>
<img src="https://img.shields.io/badge/🎯_AGENT_LEADS-agency_+_phone-7c3aed?style=for-the-badge&labelColor=2e1065"/>
<img src="https://img.shields.io/badge/🏠_BUY_&_RENT-all_of_Ireland-1f6feb?style=for-the-badge&labelColor=0b2e6b"/>
</p>
<p>
<img src="https://img.shields.io/badge/🇮🇪_Ireland-daft.ie-169b62?style=flat-square"/>
<img src="https://img.shields.io/badge/BER-energy_rating-e91e63?style=flat-square"/>
<img src="https://img.shields.io/badge/Geo-lat_+_lon-00bcd4?style=flat-square"/>
<img src="https://img.shields.io/badge/Sale_&_Rent-supported-9c27b0?style=flat-square"/>
<img src="https://img.shields.io/badge/Export-JSON·CSV·Excel·API-f59e0b?style=flat-square"/>
</p>

<br/>

**The fastest way to turn any <a href="https://www.daft.ie">Daft.ie</a> search into a clean dataset.** 🏠 Price &amp; period · 🛏️ beds / baths / size · 🔋 BER rating · 📍 county + coordinates · 🧑‍💼 estate agent &amp; agency — **with their public phone number**.

</div>

---

### 🚀 Why scrape Daft.ie?

**Daft.ie is Ireland's #1 property portal** — tens of thousands of live homes for sale and to rent across Dublin, Cork, Galway, Limerick and every county. This **Daft.ie scraper** reads the site's own structured Next.js page data, so you get every field **with no login and no API key**, and it paginates through the entire result set of any search.

It's **two tools in one**:

> 🏠 an **Irish property dataset** — for market analytics, price &amp; rent tracking, comps, dashboards &amp; ML — and
> 🎯 a **real-estate agent lead engine** — every listing carries the **agent name, agency/branch and phone**, so one run becomes a targeted Irish agent outreach list.

---

### ✨ What you get

<table>
<tr>
  <td width="33%" valign="top">

#### 🏠 Property
Title &amp; full address, **price** + period (sale / monthly / weekly), property type, sale type (buy / to let), beds, baths, **floor area + size**, **BER energy rating**, stamp-duty &amp; price-per-m².

  </td>
  <td width="33%" valign="top">

#### 📍 Location &amp; geo
County / area, **latitude &amp; longitude**, Daft listing URL, shortcode, publish date, image count &amp; primary photo, video / virtual-tour flags.

  </td>
  <td width="33%" valign="top">

#### 🎯 Agent &amp; leads
Estate **agent name**, **agency / branch**, **phone + alternative phone**, office address, **PSRA licence number** and agency logo.

  </td>
</tr>
</table>

---

### ⚡ Quick start

Set your filters on Daft.ie, copy the URL from the address bar, paste it in:

```json
{
  "searchUrls": ["https://www.daft.ie/property-for-sale/dublin"],
  "maxResults": 500
}
````

Scrape **multiple counties / buy + rent** in one run:

```json
{
  "searchUrls": [
    "https://www.daft.ie/property-for-sale/cork",
    "https://www.daft.ie/property-for-rent/dublin-city",
    "https://www.daft.ie/property-for-sale/galway-county"
  ],
  "maxResults": 2000
}
```

***

### ⚙️ Input

<table>
<thead><tr><th align="left">Field</th><th align="left">What it does</th></tr></thead>
<tbody>
<tr><td><code>searchUrls</code></td><td>Daft.ie search URLs copied from the site (e.g. <code>property-for-sale/dublin</code>, <code>property-for-rent/cork-city</code>). All your filters — area, beds, price, buy/rent, property type — are read from the URL.</td></tr>
<tr><td><code>maxResults</code></td><td>Global cap across all searches. <code>0</code> = no limit.</td></tr>
<tr><td><code>maxResultsPerSearch</code></td><td>Per-search cap. <code>0</code> = no cap.</td></tr>
<tr><td><code>useProxy</code> / <code>proxyConfiguration</code></td><td>Apify Proxy — <b>residential (Ireland)</b> recommended &amp; default (Daft is Cloudflare-fronted).</td></tr>
<tr><td><code>maxConcurrency</code></td><td>How many search URLs to run in parallel.</td></tr>
</tbody>
</table>

***

### 📤 Output

One clean row per listing:

```json
{
  "id": "6590110",
  "daftShortcode": "16590110",
  "title": "51 & 51A Cill Cais, Old Bawn, Tallaght, Dublin 24",
  "address": "51 & 51A Cill Cais, Old Bawn, Tallaght, Dublin 24",
  "county": "Dublin 24",
  "url": "https://www.daft.ie/for-sale/house-51-51a-cill-cais-old-bawn-tallaght-dublin-24/6590110",
  "listingType": "sale",
  "saleType": "For Sale",
  "price": 795000, "priceRaw": "€795,000", "pricePeriod": "sale",
  "pricePerSqM": "€2,966", "stampDuty": "€7,950",
  "beds": 8, "baths": 5, "propertyType": "Detached",
  "propertySize": "268 m²", "floorAreaValue": "268", "floorAreaUnit": "METRES_SQUARED",
  "berRating": "D1",
  "latitude": 53.2781308, "longitude": -6.3721225,
  "agentName": "Ross McHugh", "agencyName": "Ray Cooke Auctioneers",
  "agentPhone": "087 1368084", "agentAltPhone": "016875800",
  "agentLicence": "002307", "sellerType": "BRANDED_AGENT",
  "scrapedAt": "2026-06-05T15:31:24.950Z"
}
```

The **Output** tab also ships a ready-made <kbd>Listings Overview</kbd> table — property, price, beds/baths, BER, location and agent + phone.

***

### 🎯 Use cases

| | Use case | How |
|---|---|---|
| 🎯 | **Irish estate-agent lead gen** | Build outreach lists of agents & agencies (name + phone + branch) by county, price band or property type. |
| 📊 | **Property & rent analytics** | Track asking prices, price-per-m², rent levels, BER mix, inventory across Irish counties. |
| 🏗️ | **Developer & investor research** | Map supply, new-vs-old and price trends by area in Dublin, Cork, Galway & beyond. |
| 🧮 | **Comps & valuation / AVM** | Feed beds, baths, floor area, BER, geo & price into Irish pricing models. |
| 🗂️ | **Portals & aggregators** | Power a property feed or dashboard from a scheduled Daft.ie run. |

***

### 🤖 Automate it

Put it on an **Apify Schedule** → a fresh Irish listings + agent-leads feed every morning, straight to the **Apify API, a webhook, Google Sheet, S3** or your warehouse. Chain it with a phone-validator or CRM import before outreach.

***

### ❓ FAQ

<details>
<summary><b>Does Daft.ie have a public API?</b></summary>
<br/>
Daft.ie has no open public listings API, so this actor reads the structured Next.js page data instead — you get full Irish property data with no API key.
</details>

<details>
<summary><b>Do I need a Daft.ie account or API key?</b></summary>
<br/>
No. The actor reads public listing data rendered into the page — no login, no token.
</details>

<details>
<summary><b>Does it scrape both for-sale and to-rent listings?</b></summary>
<br/>
Yes. Use a <code>property-for-sale/…</code> URL for buy and a <code>property-for-rent/…</code> URL for rent. Each row is tagged <code>listingType</code> = <code>sale</code> or <code>rent</code>, and rent prices keep their period (monthly / weekly).
</details>

<details>
<summary><b>How do I filter by county, area, price or beds?</b></summary>
<br/>
Apply the filters on Daft.ie itself, then copy the resulting URL into <code>searchUrls</code>. Every filter encoded in the URL is respected, and the actor paginates the whole result set.
</details>

<details>
<summary><b>Will every listing have the agent's phone?</b></summary>
<br/>
Whenever Daft.ie exposes the agent/agency publicly on the listing, yes — agent name, agency/branch, phone, alternative phone, office address and PSRA licence number come through. Private-seller listings expose less.
</details>

<details>
<summary><b>Daft.ie is behind Cloudflare — does this still work?</b></summary>
<br/>
Yes. The actor routes through Apify <b>residential (Ireland)</b> proxy and rotates a fresh session with hard retries on every request, so it reliably gets the real listing page even though Cloudflare is inconsistent.
</details>

<details>
<summary><b>Is scraping this allowed?</b></summary>
<br/>
The actor collects publicly available listing data. You are responsible for complying with Daft.ie's terms and your local regulations (including how you use agent contact details).
</details>

#### Is this a Daft.ie API alternative?

Yes. Daft.ie has no open public listings API, so this actor works as an unofficial Daft.ie API alternative — it reads the site's structured Next.js page data and returns full property data without an API key.

#### How do I export Daft.ie property data to CSV or JSON?

Run any Daft.ie search URL, then download the results from the dataset as JSON, CSV or Excel. Each listing is one clean row, so a single run gives you a ready Irish property data export.

#### Can I scrape Daft.ie without an API or login?

Yes. There is no Daft.ie account, token or API key required — the actor reads public listing data rendered into the page and paginates the whole result set.

#### Does it return Daft.ie estate agent contacts?

When Daft.ie shows the agent publicly, every row carries the estate agent name, agency/branch, phone, alternative phone, office address and PSRA licence number — a ready Irish estate-agent contact list.

<br/>

***

### 📝 Changelog

#### 2026-06-07

- Docs: added coverage for using the actor as a Daft.ie API alternative, exporting Irish property data to CSV/JSON, and pulling Daft.ie estate agent contacts.

***

<div align="center">

#### ▶️ Ready to run

<img src="https://img.shields.io/badge/Click_Start-and_get_Irish_listings_+_agent_leads-2ea44f?style=for-the-badge&labelColor=0b3d2e"/>

<sub>Daft.ie scraper · Ireland real estate data · Irish property + agent leads · No login · No API key · JSON · CSV · Excel · API · Daft.ie API alternative · scrape Daft.ie without API · Irish property data export · Daft.ie estate agent contacts</sub>

</div>

# Actor input Schema

## `searchUrls` (type: `array`):

Daft.ie search/result URLs copied straight from the site — e.g. https://www.daft.ie/property-for-sale/dublin (buy) or https://www.daft.ie/property-for-rent/dublin-city (rent). Set all your filters (county, area, price, beds, property type) on Daft.ie, then paste the resulting URL here. The actor paginates the whole result set.

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

Stop after this many listings across all search URLs. 0 = no limit (a single county search can span thousands of listings).

## `maxResultsPerSearch` (type: `integer`):

Cap listings per individual search URL. 0 = no per-search cap.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Daft.ie is Cloudflare-fronted, so RESIDENTIAL proxy (the default) is strongly recommended.

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

Apify Proxy settings. Residential (Ireland) gives the highest success rate against Daft.ie's Cloudflare layer.

## `maxConcurrency` (type: `integer`):

How many search URLs to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.daft.ie/property-for-sale/dublin"
  ],
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `id` (type: `string`):

Listing ID

## `daftShortcode` (type: `string`):

Daft shortcode

## `title` (type: `string`):

Title

## `address` (type: `string`):

Address

## `county` (type: `string`):

County / area

## `url` (type: `string`):

Listing URL

## `listingType` (type: `string`):

sale or rent

## `saleType` (type: `string`):

Sale type

## `category` (type: `string`):

Category

## `sellingType` (type: `string`):

Selling type

## `price` (type: `string`):

Price (numeric)

## `priceRaw` (type: `string`):

Price as shown

## `pricePeriod` (type: `string`):

sale / monthly / weekly

## `pricePerSqM` (type: `string`):

Price per square metre

## `stampDuty` (type: `string`):

Estimated stamp duty

## `beds` (type: `string`):

Bedrooms

## `bedsRaw` (type: `string`):

Bedrooms as shown

## `baths` (type: `string`):

Bathrooms

## `bathsRaw` (type: `string`):

Bathrooms as shown

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

Property type

## `propertySize` (type: `string`):

Property size

## `floorAreaValue` (type: `string`):

Floor area value

## `floorAreaUnit` (type: `string`):

Floor area unit

## `berRating` (type: `string`):

BER energy rating

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `publishDate` (type: `string`):

Publish date

## `featuredLevel` (type: `string`):

Featured level

## `totalImages` (type: `string`):

Total images

## `image` (type: `string`):

Primary image URL

## `hasVideo` (type: `string`):

Has video

## `hasVirtualTour` (type: `string`):

Has virtual tour

## `agentName` (type: `string`):

Agent name

## `agencyName` (type: `string`):

Agency / branch

## `agentPhone` (type: `string`):

Agent phone

## `agentAltPhone` (type: `string`):

Agent alternative phone

## `agentAddress` (type: `string`):

Agent office address

## `agentLicence` (type: `string`):

PSRA licence number

## `sellerType` (type: `string`):

Seller type

## `agentLogo` (type: `string`):

Agency logo URL

## `scrapedAt` (type: `string`):

Scraped at

# 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 = {
    "searchUrls": [
        "https://www.daft.ie/property-for-sale/dublin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/daft-ie-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 = { "searchUrls": ["https://www.daft.ie/property-for-sale/dublin"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/daft-ie-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 '{
  "searchUrls": [
    "https://www.daft.ie/property-for-sale/dublin"
  ]
}' |
apify call logiover/daft-ie-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Daft.ie Scraper — Ireland Property & Agent Leads",
        "description": "Daft.ie scraper and API alternative: export Irish property data to CSV/JSON with agent contacts. No login, no API key.",
        "version": "1.0",
        "x-build-id": "nVSf7Wz1d7iTghCrq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~daft-ie-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-daft-ie-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/logiover~daft-ie-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-daft-ie-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/logiover~daft-ie-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-daft-ie-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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Daft.ie search/result URLs copied straight from the site — e.g. https://www.daft.ie/property-for-sale/dublin (buy) or https://www.daft.ie/property-for-rent/dublin-city (rent). Set all your filters (county, area, price, beds, property type) on Daft.ie, then paste the resulting URL here. The actor paginates the whole result set.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many listings across all search URLs. 0 = no limit (a single county search can span thousands of listings).",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap listings per individual search URL. 0 = no per-search cap.",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Daft.ie is Cloudflare-fronted, so RESIDENTIAL proxy (the default) is strongly recommended.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential (Ireland) gives the highest success rate against Daft.ie's Cloudflare layer.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IE"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent searches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many search URLs to process in parallel.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
