# Idealista Scraper — Spain, Italy & Portugal Real Estate (`khadinakbar/idealista-scraper`) Actor

Scrape property listings from Idealista.com, Idealista.it, and Idealista.pt. Get prices, GPS, agent contacts, amenities, energy ratings, and 28+ fields. Bypasses DataDome. Supports location search and direct URLs. MCP-ready.

- **URL**: https://apify.com/khadinakbar/idealista-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 scraped properties

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 🏠 Idealista Scraper — Spain, Italy & Portugal Real Estate

Extract property listings from **Idealista.com**, Europe's largest real estate platform. Scrape prices, specs, GPS coordinates, agent contacts, amenities, energy ratings, and 28+ structured fields per listing — across Spain, Italy, and Portugal.

### What does Idealista Scraper do?

Idealista Scraper is an Apify actor that collects structured property data from [idealista.com](https://www.idealista.com) (Spain), [idealista.it](https://www.idealista.it) (Italy), and [idealista.pt](https://www.idealista.pt) (Portugal). It handles DataDome bot protection automatically using residential proxies and optional CapSolver integration, supports search queries and direct URLs, paginates through all result pages, and returns clean, analysis-ready JSON.

### Why use Idealista Scraper?

- **Pay only for what you scrape** — PAY_PER_EVENT pricing at $0.003/property (no flat monthly fee)
- **Supports all 3 Idealista domains** — Spain, Italy, Portugal in one actor
- **Two input modes** — search by location name OR paste any direct Idealista search URL
- **Full pagination** — automatically navigates all result pages up to your limit
- **MCP-ready** — semantic field names, fully compatible with Claude, ChatGPT, and Cursor via Apify's MCP server
- **28+ structured fields** per property including GPS coordinates, amenity flags, and energy ratings
- **DataDome bypass** — residential proxy + CapSolver integration for reliable access

### ⚠️ DataDome Bot Protection — Important Note

Idealista uses **DataDome** bot protection. To scrape reliably:

1. **Residential proxies are required** (included in default proxy configuration — do not switch to datacenter proxies)
2. **A CapSolver API key is strongly recommended** for handling visual CAPTCHA challenges. Without it, some runs may be blocked. Get your key at [capsolver.com](https://capsolver.com) — DatadomeSliderTask costs ~$0.004 per solve.

Add your CapSolver key to the `capsolverApiKey` field in the actor input. The actor will automatically detect and solve challenges during the run.

### What data does Idealista Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `property_id` | string | Idealista unique ID |
| `url` | string | Direct link to property page |
| `title` | string | Listing title |
| `property_type` | string | homes / offices / premises / etc. |
| `operation` | string | sale or rent |
| `price` | number | Price in EUR |
| `price_per_sqm` | number | Computed €/m² for market comparison |
| `size_sqm` | number | Area in square meters |
| `rooms` | number | Number of bedrooms |
| `bathrooms` | number | Number of bathrooms |
| `floor` | string | Floor level |
| `address` | string | Street address |
| `neighborhood` | string | Neighborhood/district |
| `city` | string | City |
| `province` | string | Province/region |
| `country` | string | Country code (es/it/pt) |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `description` | string | Full listing description |
| `thumbnail_url` | string | Primary photo URL |
| `images` | array | All photo URLs |
| `amenities` | object | terrace, lift, pool, AC, garage, garden, storage |
| `energy_rating` | string | EU energy certificate (A–G) |
| `agent_name` | string | Agency or seller name |
| `agent_type` | string | Professional or private |
| `agent_phone` | string | Contact phone number |
| `is_new_development` | boolean | New construction flag |
| `publication_date` | string | Listing publication date (ISO 8601) |
| `scraped_at` | string | Extraction timestamp |
| `source_url` | string | Source search page URL |

### How to use Idealista Scraper

#### Option 1 — Search by location (recommended)

1. Set **Country** (Spain / Italy / Portugal)
2. Set **Operation** (For Sale or For Rent)
3. Set **Property Type** (Homes, Offices, Garages, etc.)
4. Set **Location** — use the location slug from the Idealista URL (e.g. `madrid`, `barcelona`, `roma`, `lisboa`)
5. Set **Max Results** — how many properties to return
6. (Optional) Add your **CapSolver API Key** for reliable DataDome bypass
7. Click Run

#### Option 2 — Paste a direct search URL

1. Go to [idealista.com](https://www.idealista.com) and configure your search with filters (price range, bedrooms, amenities, etc.)
2. Copy the URL from your browser — e.g. `https://www.idealista.com/venta-viviendas/madrid/con-terraza/?ordenado-por=precio-asc`
3. Paste it into **Start URLs**
4. Set **Max Results** and click Run

#### Code example — via Apify API

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('khadinakbaronline/idealista-scraper').call({
    operation: 'sale',
    propertyType: 'homes',
    location: 'madrid',
    country: 'es',
    maxResults: 100,
    capsolverApiKey: 'YOUR_CAPSOLVER_KEY',
});

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

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('khadinakbaronline/idealista-scraper').call(run_input={
    'operation': 'sale',
    'propertyType': 'homes',
    'location': 'barcelona',
    'country': 'es',
    'maxResults': 200,
    'capsolverApiKey': 'YOUR_CAPSOLVER_KEY',
})
items = list(client.dataset(run['defaultDatasetId']).iterate_items())
```

### 🤖 MCP Server Integration (AI Agents)

Idealista Scraper is fully compatible with the **[Apify MCP Server](https://apify.com/apify/actors-mcp-server)**, which lets AI agents like Claude, ChatGPT, and Cursor directly call Apify actors as tools.

#### Connect via Apify MCP Server

Add the following to your MCP client configuration (e.g. Claude Desktop `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN",
        "ACTORS": "khadinakbaronline/idealista-scraper"
      }
    }
  }
}
```

Once connected, your AI agent can call the scraper with natural language:

> "Scrape 50 homes for sale in Madrid from Idealista and return properties under €400,000"

#### MCP Tool Schema

The actor exposes these input parameters as MCP tool arguments:

| Parameter | Type | Description |
|-----------|------|-------------|
| `location` | string | City slug (e.g. `madrid`, `roma`, `lisboa`) |
| `country` | string | `es`, `it`, or `pt` |
| `operation` | string | `sale` or `rent` |
| `propertyType` | string | `homes`, `offices`, `garages`, etc. |
| `maxResults` | number | Max properties to return (1–10,000) |
| `startUrls` | array | Direct Idealista search URLs (optional) |
| `capsolverApiKey` | string | CapSolver key for CAPTCHA bypass (recommended) |

#### Apify MCP Server — Actors Directory

Find this actor and thousands more at the **[Apify MCP Server Actors Directory](https://apify.com/store)**. The MCP server supports dynamic actor discovery — you can list available actors, check their schemas, and call them without writing any code.

Install the MCP server:

```bash
npx @apify/actors-mcp-server
```

### Key-Value Store Output

In addition to the main dataset, each run writes a `SCRAPE_STATS` summary to the default Key-Value Store:

```json
{
  "totalScraped": 50,
  "targetLocation": "madrid",
  "country": "es",
  "operation": "sale",
  "propertyType": "homes",
  "capsolverUsed": true,
  "captchasSolved": 2,
  "pagesScraped": 3,
  "durationSeconds": 145,
  "startedAt": "2025-01-15T10:00:00.000Z",
  "finishedAt": "2025-01-15T10:02:25.000Z"
}
```

### Pricing

This actor uses **PAY\_PER\_EVENT** billing — you only pay for actual properties scraped.

| Apify Plan | Price per property |
|------------|-------------------|
| FREE | $0.003 |
| BRONZE | $0.003 |
| SILVER | $0.0025 |
| GOLD | $0.002 |
| PLATINUM | $0.0015 |
| DIAMOND | $0.001 |

**Example costs:**

- 100 properties ≈ $0.30
- 1,000 properties ≈ $3.00
- 10,000 properties ≈ $30.00

Much cheaper than flat monthly subscriptions ($15–$19/month) if you scrape fewer than 5,000 properties/month.

### Use cases

- **Real estate investors** — identify undervalued properties by price-per-m² across neighborhoods
- **Market analysts** — track price trends over time across cities or provinces
- **Real estate agencies** — competitive monitoring and lead generation
- **Property developers** — build valuation tools, market dashboards, or investment scoring models
- **AI pipelines** — feed structured property data into LLMs (via MCP) for analysis, Q\&A, and recommendations
- **Academic researchers** — housing market studies across Spain, Italy, and Portugal

### Technical notes

- Uses **Playwright** browser automation with headful mode (`headless: false`) on Apify's xvfb display — this causes DataDome to serve a softer device-check interstitial rather than an immediate hard block
- Requires **Spanish Residential Proxies** to bypass DataDome (default proxy configuration is pre-set; do not change)
- **CapSolver** `DatadomeSliderTask` integration for automatic CAPTCHA solving (~$0.004/solve)
- Crawlee fingerprint injection (CDP-level) for Windows/macOS/Spanish locale
- Native `page.addInitScript()` patches for `navigator.webdriver`, `window.chrome`, permissions, and other automation signals
- Automatically handles cookie consent popups
- Full pagination — navigates all result pages
- Session pooling and retry logic for reliability
- Writes `SCRAPE_STATS` summary to Key-Value Store at end of each run

### Legal disclaimer

*This actor is intended for lawful data collection from publicly available sources. Users are responsible for compliance with applicable laws, Idealista's terms of service, and data protection regulations (GDPR, CCPA, etc.). Do not use this actor to collect personal data without a lawful basis, or to systematically copy Idealista's database.*

# Actor input Schema

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

Use this field when the user provides a direct Idealista search URL (e.g. 'https://www.idealista.com/venta-viviendas/madrid/'). Paste one or more Idealista search result page URLs. Do NOT use this when searching by location name — use the Location field instead. Supports ES, IT, and PT domains.

## `operation` (type: `string`):

Choose 'sale' to scrape properties for sale, or 'rent' for rental listings. Ignored when Start URLs are provided.

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

Type of property to search. 'homes' covers flats, houses, villas, penthouses. Ignored when Start URLs are provided.

## `location` (type: `string`):

City or area to search. Use the location slug from Idealista URL (e.g. 'madrid', 'barcelona', 'roma', 'lisboa'). For Spain searches, this is what appears in the URL: idealista.com/venta-viviendas/{LOCATION}/. Ignored when Start URLs are provided.

## `country` (type: `string`):

Select the Idealista country domain to scrape. 'es' = idealista.com (Spain), 'it' = idealista.it (Italy), 'pt' = idealista.pt (Portugal). Ignored when Start URLs are provided.

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

Maximum number of property listings to return. Set to 0 for unlimited. Billing stops when this limit is reached. Default: 50.

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

IMPORTANT: Residential proxies are REQUIRED to bypass Idealista's DataDome bot protection. Datacenter proxies will be blocked immediately. Leave this as the default (Spanish residential) unless you have your own residential proxies.

## `capsolverApiKey` (type: `string`):

Idealista uses DataDome bot protection. A CapSolver API key is required for reliable access. Without it, many requests will be blocked by DataDome's visual CAPTCHA. Get your key at https://capsolver.com — DatadomeSliderTask costs ~$0.004 per solve. Leave empty to try without solving (success rate varies by IP).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.idealista.com/venta-viviendas/madrid/"
    }
  ],
  "operation": "sale",
  "propertyType": "homes",
  "location": "madrid",
  "country": "es",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped Idealista property listings with full field set including price, location, specs, and agent data

# 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": [
        {
            "url": "https://www.idealista.com/venta-viviendas/madrid/"
        }
    ],
    "location": "madrid",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "ES"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/idealista-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": [{ "url": "https://www.idealista.com/venta-viviendas/madrid/" }],
    "location": "madrid",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "ES",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/idealista-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": [
    {
      "url": "https://www.idealista.com/venta-viviendas/madrid/"
    }
  ],
  "location": "madrid",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}' |
apify call khadinakbar/idealista-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Idealista Scraper — Spain, Italy & Portugal Real Estate",
        "description": "Scrape property listings from Idealista.com, Idealista.it, and Idealista.pt. Get prices, GPS, agent contacts, amenities, energy ratings, and 28+ fields. Bypasses DataDome. Supports location search and direct URLs. MCP-ready.",
        "version": "1.0",
        "x-build-id": "a8cm7QgeeQWgfHc4P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~idealista-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-idealista-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/khadinakbar~idealista-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-idealista-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/khadinakbar~idealista-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-idealista-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": "Start URLs (Idealista search pages)",
                        "type": "array",
                        "description": "Use this field when the user provides a direct Idealista search URL (e.g. 'https://www.idealista.com/venta-viviendas/madrid/'). Paste one or more Idealista search result page URLs. Do NOT use this when searching by location name — use the Location field instead. Supports ES, IT, and PT domains.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Choose 'sale' to scrape properties for sale, or 'rent' for rental listings. Ignored when Start URLs are provided.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "homes",
                            "offices",
                            "premises",
                            "garages",
                            "lands",
                            "storageRooms",
                            "buildings"
                        ],
                        "type": "string",
                        "description": "Type of property to search. 'homes' covers flats, houses, villas, penthouses. Ignored when Start URLs are provided.",
                        "default": "homes"
                    },
                    "location": {
                        "title": "Location (city name or slug)",
                        "type": "string",
                        "description": "City or area to search. Use the location slug from Idealista URL (e.g. 'madrid', 'barcelona', 'roma', 'lisboa'). For Spain searches, this is what appears in the URL: idealista.com/venta-viviendas/{LOCATION}/. Ignored when Start URLs are provided.",
                        "default": "madrid"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "es",
                            "it",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Select the Idealista country domain to scrape. 'es' = idealista.com (Spain), 'it' = idealista.it (Italy), 'pt' = idealista.pt (Portugal). Ignored when Start URLs are provided.",
                        "default": "es"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to return. Set to 0 for unlimited. Billing stops when this limit is reached. Default: 50.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "IMPORTANT: Residential proxies are REQUIRED to bypass Idealista's DataDome bot protection. Datacenter proxies will be blocked immediately. Leave this as the default (Spanish residential) unless you have your own residential proxies."
                    },
                    "capsolverApiKey": {
                        "title": "CapSolver API Key (Required for reliable scraping)",
                        "type": "string",
                        "description": "Idealista uses DataDome bot protection. A CapSolver API key is required for reliable access. Without it, many requests will be blocked by DataDome's visual CAPTCHA. Get your key at https://capsolver.com — DatadomeSliderTask costs ~$0.004 per solve. Leave empty to try without solving (success rate varies by IP)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
