# Idealista Scraper - Spain Italy Portugal Property (`lentic_clockss/idealista-scraper`) Actor

Scrape Idealista.com / .it / .pt across homes, new builds, rooms, garages, commercial, land, and business transfers by location or URL. Extract prices, rooms, living space, agencies, and photos as an Idealista API alternative.

- **URL**: https://apify.com/lentic\_clockss/idealista-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does Idealista Scraper do?

**Scrape Idealista property listings in Spain, Italy, and Portugal for sale and to rent**, then export structured real-estate data to an Apify Dataset. This Actor is a practical **Idealista API alternative** for agencies, investors, researchers, and automations that need clean housing data from:

- [Idealista Spain](https://www.idealista.com/) (`idealista.com`)
- [Idealista Italy](https://www.idealista.it/) (`idealista.it`)
- [Idealista Portugal](https://www.idealista.pt/) (`idealista.pt`)

Set `country`, a location path, or paste Idealista search / detail URLs. Optionally open each listing detail page to enrich prices, rooms, living space, agency contacts, descriptions, and photos. Supports **all top-nav Idealista property categories** (homes, new builds, rooms, garages, storage, offices, commercial, land, buildings, holiday, business transfer).

### What can this Idealista Scraper do?

- Scrape **Spain** (`country=ES`) on `idealista.com`
- Scrape **Italy** (`country=IT`) on `idealista.it`
- Scrape **Portugal** (`country=PT`) on `idealista.pt`
- Scrape **for-sale** (`channel=BUY`) and **to-rent** (`channel=RENT`)
- Scrape **all Idealista top-nav property types** via `propertyType` or category `startUrls`
- Build searches from location paths or `startUrls`
- Paginate Idealista search result pages (`/pagina-N.htm`)
- Enrich listings from Idealista detail pages (`scrapeDetails`), including new-build detail URLs when present
- Extract prices, rooms, living space, floor, agency, images, tags, `propertyType`, and map metadata
- Cap runs with `maxItems` and `maxPages`
- Run on Apify with scheduling, Dataset export, webhooks, and API access
- Use Apify **RESIDENTIAL** proxy with country **ES**, **IT**, or **PT**

### What data can you extract from Idealista?

| Property field | Example |
| --- | --- |
| Country | `ES`, `IT`, `PT` |
| Property type | Local Idealista path (`viviendas`, `negozi`, `lojas_ou_armazens`, …) |
| Listing ID / URL | Idealista id + detail URL (`/inmueble/`, `/immobile/`, `/imovel/`, `/obra-nueva/`) |
| Title / address | Card or detail title |
| Price | `350.000 €`, `1.500 €/mes` |
| Rooms / living space | `3` / `85` m² (often null for garages, storage, land) |
| Floor / features | Floor, elevator, orientation when shown |
| Description | SRP summary or detail description |
| Agency / advertiser | Detail `config` or DOM |
| Images / plans / videos | Gallery URLs and counts |
| Channel | `BUY` or `RENT` |
| Source layer | `srp`, `srp+ldp` |

### Why scrape Idealista?

Idealista is one of Southern Europe’s largest property portals across Spain, Italy, and Portugal. Scraping Idealista listings helps with:

- Cross-border market research and price benchmarking (Madrid, Barcelona, Roma, Lisboa…)
- Lead generation for agencies, mortgage brokers, and service providers
- Investment screening across sale and rental inventory
- Monitoring new Idealista listings, price drops, and agency coverage
- Feeding dashboards, CRMs, spreadsheets, or AI agent workflows

### How to scrape Idealista property data

1. Open this Actor and click **Try for free** (or **Start**).
2. Set `country` to `ES`, `IT`, or `PT` (or paste Idealista `startUrls` — the host infers the market).
3. Set `location` (for example `madrid-madrid`, `roma-roma`, `lisboa`) **or** provide search URLs.
4. Choose `channel`: `BUY` for sale or `RENT` for to-rent.
5. Set `maxItems` and `maxPages` for a small test first.
6. Enable `scrapeDetails` when you need agency names, full descriptions, and media from detail pages.
7. Prefer Apify **RESIDENTIAL** proxy with country matching the market (`ES` / `IT` / `PT`).
8. Click **Start**, then download the Dataset as JSON, CSV, Excel, or JSONL.

#### Example input (Spain — Madrid for sale)

```json
{
  "country": "ES",
  "location": "madrid-madrid",
  "channel": "BUY",
  "propertyType": "homes",
  "maxItems": 10,
  "maxPages": 1,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "ES"
  }
}
````

#### Example input (Italy — Roma for sale)

```json
{
  "country": "IT",
  "location": "roma-roma",
  "channel": "BUY",
  "propertyType": "homes",
  "maxItems": 5,
  "maxPages": 1,
  "scrapeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IT"
  }
}
```

#### Example input (Portugal — Lisboa to rent)

```json
{
  "country": "PT",
  "location": "lisboa",
  "channel": "RENT",
  "propertyType": "homes",
  "maxItems": 5,
  "maxPages": 1,
  "scrapeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "PT"
  }
}
```

### Idealista markets and URL patterns

| Country | Host | BUY path | RENT path | Detail path | Default location |
| --- | --- | --- | --- | --- | --- |
| ES | `idealista.com` | `/venta-*` | `/alquiler-*` | `/inmueble/{id}/`, `/obra-nueva/{id}/` | `madrid-madrid` |
| IT | `idealista.it` | `/vendita-*` | `/affitto-*` | `/immobile/{id}/` | `roma-roma` |
| PT | `idealista.pt` | `/comprar-*` | `/arrendar-*` | `/imovel/{id}/` | `lisboa` |

Business-transfer searches omit the buy/rent prefix: `/traspasos/`, `/cessione-attivita/`, `/trespasse/`.

Run **one Idealista country per Actor run**. Mixing `.com` / `.it` / `.pt` URLs in the same input is rejected.

#### Property types (`propertyType`)

Logical aliases work in every market: `homes`, `new_homes`, `rooms`, `garages`, `storage`, `offices`, `commercial`, `land`, `buildings`, `holiday`, `business_transfer`.

| Market | Local path segments |
| --- | --- |
| **ES** | `obranueva`, `viviendas`, `habitacion`, `garajes`, `trasteros`, `oficinas`, `locales`, `terrenos`, `edificios`, `vacacional`, `traspasos` |
| **IT** | `nuove_costruzioni`, `case`, `stanze`, `garage`, `cantine`, `uffici`, `negozi`, `terreni`, `edifici`, `case_vacanze`, `cessione-attivita` |
| **PT** | `empreendimentos`, `casas`, `quarto`, `garagens`, `arrecadacoes`, `escritorios`, `lojas_ou_armazens`, `terrenos`, `predios`, `trespasse` |

Notes:

- Room types (`habitacion` / `stanze` / `quarto`) are **rent-only**; `channel=BUY` is coerced to `RENT`.
- Portugal “Para férias” on the homepage redirects to Rentalia (external); use ES `vacacional` / IT `case_vacanze` for on-site holiday inventory.
- You can always paste a category search URL in `startUrls` instead of setting `propertyType`.

#### Example input (Spain — storage / trasteros)

```json
{
  "country": "ES",
  "location": "madrid-madrid",
  "channel": "BUY",
  "propertyType": "storage",
  "maxItems": 5,
  "maxPages": 1,
  "scrapeDetails": false
}
```

#### Example input (Italy — commercial / negozi)

```json
{
  "country": "IT",
  "location": "roma-roma",
  "channel": "RENT",
  "propertyType": "commercial",
  "maxItems": 5,
  "maxPages": 1,
  "scrapeDetails": false
}
```

### Input

| Field | Description |
| --- | --- |
| `country` | `ES`, `IT`, or `PT`. Inferred from `startUrls` host when present. |
| `startUrls` | Idealista search or detail URLs. Overrides built search URLs when set. |
| `location` | Idealista location path such as `madrid-madrid`, `roma-roma`, `lisboa`. |
| `channel` | `BUY` or `RENT` (mapped to local Idealista path prefixes). |
| `propertyType` | Local path segment or logical alias (see table above). |
| `maxItems` | Maximum Idealista listings to save. |
| `maxPages` | Maximum search pages to crawl. |
| `scrapeDetails` | Open each Idealista detail page for enrichment. |
| `requestDelayMillis` | Delay between browser navigations (helps with DataDome). |
| `proxyConfiguration` | Prefer Apify RESIDENTIAL with matching country. |

### Output example

```json
{
  "id": "111396097",
  "url": "https://www.idealista.com/inmueble/111396097/",
  "source": "idealista",
  "country": "ES",
  "sourceLayer": "srp+ldp",
  "channel": "BUY",
  "propertyType": "viviendas",
  "title": "Piso en venta en Calle de Castelló",
  "priceAmount": 1490000,
  "rooms": 2,
  "livingSpace": 106,
  "agencyName": "Única Consultoría Inmobiliaria",
  "images": ["https://img4.idealista.com/..."],
  "scrapedAt": "2026-07-18T05:44:53+00:00"
}
```

### Pricing

This Actor uses **Pay per event** pricing:

| Event | Price |
| --- | --- |
| Actor start (`apify-actor-start`) | **$0.005** per start |
| Result (`apify-default-dataset-item`) | **$2.50 / 1,000** results (`$0.0025` each) |

**Platform usage costs are paid by the user** (compute, residential proxy transfer, storage). Idealista is protected by DataDome, so residential proxy usage is expected on cloud runs.

### Idealista scraping tips for better results

- Start with `maxItems=3–10` and `maxPages=1` to validate location and proxy.
- Match proxy country to the Idealista market (`ES` / `IT` / `PT`).
- Keep a non-zero `requestDelayMillis` (for example `3000–4000`) for DataDome stability.
- Prefer search URLs from the live Idealista site when a location path is unclear.
- Use `scrapeDetails=true` only when you need agency / media enrichment (higher runtime and proxy use).
- Do not mix Spain, Italy, and Portugal URLs in one run.

### Live View / standby endpoints

When the Actor runs in standby / Live View mode, these operational endpoints are available:

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/` | Service info |
| `GET` | `/health` | Health check |
| `GET` | `/input-example` | Low-cost input example |
| `GET` | `/openapi.json` | Deployed OpenAPI document |

Scraping still runs through a normal Actor run (not these standby endpoints).

### Is it legal to scrape Idealista?

Scraping publicly available Idealista listing data for research, market analysis, or internal business intelligence is commonly done, but you must follow Idealista’s terms, local law, and privacy rules. Do not scrape personal data you are not allowed to process, and respect robots / rate limits. This Actor is provided as a technical tool; you are responsible for lawful use.

### FAQ

#### Can I scrape Idealista Spain, Italy, and Portugal with one Actor?

Yes. Set `country` to `ES`, `IT`, or `PT`, or paste URLs from `idealista.com`, `idealista.it`, or `idealista.pt`. Run one country per job.

#### Is this an Idealista API?

No. Idealista does not offer a public listing API for this use case. This Actor is an **Idealista API alternative** that extracts data from Idealista search and detail pages.

#### Why do I need a residential proxy?

Idealista uses DataDome. Direct / datacenter HTTP often returns `403`. Apify RESIDENTIAL proxy in the target country is required for reliable cloud runs.

#### What is the difference between `scrapeDetails=false` and `true`?

`false` is faster and cheaper: Idealista search cards only. `true` opens each detail page for agency names, fuller descriptions, and media metadata.

#### Can I export Idealista data to Excel or CSV?

Yes. After the run finishes, download the Dataset as Excel, CSV, JSON, or JSONL from the Apify Console, or pull it via the Apify API.

#### How do I scrape Idealista rentals only?

Set `channel` to `RENT` (maps to `/alquiler-*`, `/affitto-*`, or `/arrendar-*` depending on country).

### Support

If a run fails or returns empty results, check the run log for DataDome / proxy messages and open an Apify issue on this Actor with the run ID, country, location or `startUrls`, and whether `scrapeDetails` was enabled.

# Actor input Schema

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

Idealista market: ES (idealista.com), IT (idealista.it), PT (idealista.pt). When startUrls are set, country is inferred from the URL host.

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

Idealista search (SRP) or detail (LDP) URLs for .com / .it / .pt. When provided, these override location/channel URL building and infer the country.

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

Idealista location path segment. Examples: madrid-madrid (ES), roma-roma (IT), lisboa (PT). Empty uses the market default. Ignored when startUrls contain search URLs.

## `channel` (type: `string`):

BUY/RENT mapped per market: ES venta/alquiler, IT vendita/affitto, PT comprar/arrendar.

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

Idealista top-nav category path or logical alias. Aliases: homes, new\_homes, rooms, garages, storage, offices, commercial, land, buildings, holiday, business\_transfer. ES paths: obranueva, viviendas, habitacion, garajes, trasteros, oficinas, locales, terrenos, edificios, vacacional, traspasos. IT: nuove\_costruzioni, case, stanze, garage, cantine, uffici, negozi, terreni, edifici, case\_vacanze, cessione-attivita. PT: empreendimentos, casas, quarto, garagens, arrecadacoes, escritorios, lojas\_ou\_armazens, terrenos, predios, trespasse. Room types are rent-only; transfer types use /traspasos|/cessione-attivita|/trespasse/ without buy/rent prefix. startUrls override this when set.

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

Maximum property records to save.

## `maxPages` (type: `integer`):

Maximum SRP pages to fetch. Idealista typically renders about 30 cards per page.

## `scrapeDetails` (type: `boolean`):

When true, open each listing detail page and extract config, adDetail, adMultimediasInfo, details, advertiser, and media fields. Default false for lighter/faster SRP-only runs; set true for enrichment. Prefer 4096 MB memory for detail-heavy runs.

## `includeRawPayloads` (type: `boolean`):

When true, keep bulky fields such as rawCardText, map, mapConfig, and detailSections on each dataset item. Default false to reduce memory and dataset size.

## `requestDelayMillis` (type: `integer`):

Politeness delay before browser navigations. Keep non-zero for DataDome-protected pages.

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

Apify Proxy is required for cloud runs. Prefer RESIDENTIAL with country matching the Idealista market (ES/IT/PT).

## Actor input object example

```json
{
  "country": "ES",
  "startUrls": [
    {
      "url": "https://www.idealista.com/venta-viviendas/madrid-madrid/"
    }
  ],
  "location": "madrid-madrid",
  "channel": "BUY",
  "propertyType": "homes",
  "maxItems": 10,
  "maxPages": 1,
  "scrapeDetails": false,
  "includeRawPayloads": false,
  "requestDelayMillis": 3000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Normalized Idealista listing records from SRP and optional LDP enrichment.

## `runSummary` (type: `string`):

Counts, engine, warnings, and timestamps for the run.

# 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-madrid/"
        }
    ],
    "location": "madrid-madrid",
    "propertyType": "homes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/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-madrid/" }],
    "location": "madrid-madrid",
    "propertyType": "homes",
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/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-madrid/"
    }
  ],
  "location": "madrid-madrid",
  "propertyType": "homes"
}' |
apify call lentic_clockss/idealista-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Idealista Scraper - Spain Italy Portugal Property",
        "description": "Scrape Idealista.com / .it / .pt across homes, new builds, rooms, garages, commercial, land, and business transfers by location or URL. Extract prices, rooms, living space, agencies, and photos as an Idealista API alternative.",
        "version": "0.2",
        "x-build-id": "y7DuZNvIVWy6czoNC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~idealista-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-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/lentic_clockss~idealista-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-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/lentic_clockss~idealista-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-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": {
                    "country": {
                        "title": "Country / market",
                        "enum": [
                            "ES",
                            "IT",
                            "PT"
                        ],
                        "type": "string",
                        "description": "Idealista market: ES (idealista.com), IT (idealista.it), PT (idealista.pt). When startUrls are set, country is inferred from the URL host.",
                        "default": "ES"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Idealista search (SRP) or detail (LDP) URLs for .com / .it / .pt. When provided, these override location/channel URL building and infer the country.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "location": {
                        "title": "Location path",
                        "type": "string",
                        "description": "Idealista location path segment. Examples: madrid-madrid (ES), roma-roma (IT), lisboa (PT). Empty uses the market default. Ignored when startUrls contain search URLs.",
                        "default": ""
                    },
                    "channel": {
                        "title": "Channel",
                        "enum": [
                            "BUY",
                            "RENT"
                        ],
                        "type": "string",
                        "description": "BUY/RENT mapped per market: ES venta/alquiler, IT vendita/affitto, PT comprar/arrendar.",
                        "default": "BUY"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "type": "string",
                        "description": "Idealista top-nav category path or logical alias. Aliases: homes, new_homes, rooms, garages, storage, offices, commercial, land, buildings, holiday, business_transfer. ES paths: obranueva, viviendas, habitacion, garajes, trasteros, oficinas, locales, terrenos, edificios, vacacional, traspasos. IT: nuove_costruzioni, case, stanze, garage, cantine, uffici, negozi, terreni, edifici, case_vacanze, cessione-attivita. PT: empreendimentos, casas, quarto, garagens, arrecadacoes, escritorios, lojas_ou_armazens, terrenos, predios, trespasse. Room types are rent-only; transfer types use /traspasos|/cessione-attivita|/trespasse/ without buy/rent prefix. startUrls override this when set.",
                        "default": "homes"
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum property records to save.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum SRP pages to fetch. Idealista typically renders about 30 cards per page.",
                        "default": 1
                    },
                    "scrapeDetails": {
                        "title": "Scrape detail pages",
                        "type": "boolean",
                        "description": "When true, open each listing detail page and extract config, adDetail, adMultimediasInfo, details, advertiser, and media fields. Default false for lighter/faster SRP-only runs; set true for enrichment. Prefer 4096 MB memory for detail-heavy runs.",
                        "default": false
                    },
                    "includeRawPayloads": {
                        "title": "Include raw/bulky payloads",
                        "type": "boolean",
                        "description": "When true, keep bulky fields such as rawCardText, map, mapConfig, and detailSections on each dataset item. Default false to reduce memory and dataset size.",
                        "default": false
                    },
                    "requestDelayMillis": {
                        "title": "Delay between navigations (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Politeness delay before browser navigations. Keep non-zero for DataDome-protected pages.",
                        "default": 3000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is required for cloud runs. Prefer RESIDENTIAL with country matching the Idealista market (ES/IT/PT).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "ES"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
