# Idealista Scraper | 💛 $0.5/1k | No Limit (`epicscrapers/idealista-scraper`) Actor

⚡ From $0.5/1k 💛 Scrape Idealista property listings from Spain, Italy, Portugal, and France. Extract prices, locations, descriptions, images, property details, and listing URLs from search pages or individual property pages. Export to CSV/JSON

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

## Pricing

from $0.50 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Scrape Idealista Property Listings with Filters, Details, Images, and Pagination

Extract real estate listings from Idealista in Spain, Italy, Portugal, and France. This Actor is built for property researchers, investors, agencies, analysts, and data teams that need structured Idealista data without manually copying listings page by page.

Use it to collect prices, locations, property details, images, descriptions, and listing URLs from Idealista search pages or individual property pages.

### Why use this Actor?

Tired of manually checking Idealista listings, copying prices into spreadsheets, or losing track of market changes across cities and neighborhoods?

This Actor turns Idealista pages into clean, structured JSON that you can export, analyze, or connect to your existing workflows.

### Key benefits

- **Scrape many listings in one run** instead of manually opening every result page.
- **Start from an Idealista URL** and keep the same country, location, property type, and filters you already selected on the website.
- **Collect property details and media** such as price, size, rooms, bathrooms, address, location, description, images, and listing URL.
- **Search by city or area** when you do not already have an Idealista URL.
- **Filter results by price, size, rooms, bathrooms, photos, floor plan, elevator, garage, heating, air conditioning, and more.**
- **Export data easily** from Apify datasets to JSON, CSV, Excel, Google Sheets, databases, or APIs.
- **Schedule recurring runs** to monitor new listings, price changes, and market inventory automatically.

### What data can you extract?

Depending on the listing and selected options, the Actor can extract:

- Property ID and property code
- Idealista listing URL
- Country
- Sale or rent operation
- Property type
- Price and currency
- Size
- Number of rooms
- Number of bathrooms
- Address
- Municipality / city
- Province / region
- Latitude and longitude when available
- Description
- Thumbnail image
- Additional images and media when enabled
- Contact-related metadata when available
- Property features
- Similar recommended properties when enabled
- Source URL
- Scrape timestamp
- Error message for failed records

### Features, advantages, and benefits

| Feature | Advantage | Benefit |
|---|---|---|
| Search URL support | Paste an Idealista search page directly | Reuse filters you already selected on Idealista without rebuilding the search manually |
| Individual property URL support | Scrape a single listing page | Quickly enrich one property with structured data |
| Automatic pagination | Collects multiple result pages up to your limit | Scrape large result sets without manually handling pages |
| Location search | Search by country, operation, property type, and city/area | Build searches even when you do not have an Idealista URL |
| Price and size filters | Narrow results by budget and property dimensions | Focus only on listings that match your criteria |
| Room and bathroom filters | Target specific residential property requirements | Save time when monitoring homes or apartments |
| Optional detail extraction | Opens listings for richer information | Get more complete records when search results are not enough |
| Optional multimedia extraction | Collects extra images and media when available | Build richer property databases and visual dashboards |
| Recommended properties option | Includes similar properties when available | Discover comparable listings for market analysis |
| Configurable result limit | Control how many listings are saved per query | Manage cost, speed, and dataset size |

### Example output

```json
{
  "id": "35585970",
  "propertyCode": "35585970",
  "url": "https://www.idealista.it/immobile/35585970/",
  "country": "it",
  "operation": "sale",
  "propertyType": "chalet",
  "price": 37000,
  "currency": "EUR",
  "size": 172,
  "rooms": 6,
  "bathrooms": 2,
  "address": "Detached house in Località Scabbiabella, 24, Torriglia",
  "municipality": "Torriglia",
  "province": "Genova",
  "latitude": 44.5184183,
  "longitude": 9.1172171,
  "description": "Scabbiabella – Semi-detached two-level house...",
  "thumbnail": "https://img4.idealista.it/...",
  "multimedia": {
    "images": [
      {
        "url": "https://img4.idealista.it/...",
        "tag": "views"
      },
      {
        "url": "https://img4.idealista.it/...",
        "tag": "corridor"
      }
    ]
  },
  "features": {
    "hasSwimmingPool": false,
    "hasTerrace": true,
    "hasAirConditioning": false,
    "hasBoxRoom": false,
    "hasGarden": false
  },
  "sourceUrl": "https://www.idealista.it/en/vendita-case/genova-provincia/",
  "scrapedAt": "2026-07-11T14:14:42.211Z",
  "status": "success"
}
````

### How to use

#### Option 1: Scrape from Idealista URLs

Use this when you already have a search page or property page open in your browser.

1. Open Idealista.
2. Apply the filters you need.
3. Copy the search results URL or listing URL.
4. Paste it into **Idealista URLs**.
5. Set **Maximum results per query**.
6. Run the Actor.

Example input:

```json
{
  "startUrls": [
    {
      "url": "https://www.idealista.it/vendita-case/genova-provincia/"
    }
  ],
  "maxResults": 100,
  "includeDetails": true,
  "includeMultimedia": true
}
```

#### Option 2: Search by location

Use this when you do not have an Idealista URL and want to search by country and area.

Example input:

```json
{
  "country": "it",
  "operation": "sale",
  "propertyType": "homes",
  "locationQuery": "Genova",
  "maxResults": 100,
  "minPrice": 100000,
  "maxPrice": 400000,
  "minRooms": 2,
  "includeDetails": true
}
```

### Input options

#### Search source

| Input | Description | Example |
|---|---|---|
| `startUrls` | Idealista search result URLs or individual property URLs. Best option when you already selected filters on Idealista. | `https://www.idealista.it/vendita-case/genova-provincia/` |
| `country` | Country for location searches. Used when `startUrls` is empty. | `it` |
| `operation` | Choose sale or rent for location searches. | `sale` |
| `propertyType` | Property type to search for. | `homes` |
| `locationQuery` | City, town, neighborhood, or area name. | `Genova` |
| `locationIds` | Advanced option for users who already know Idealista location IDs. | `["0-EU-IT-08-000-000001"]` |
| `locationSelectionMode` | How to choose location matches: best match, all matches, or exact match only. | `best` |

Supported country values:

- `es` — Spain
- `it` — Italy
- `pt` — Portugal
- `fr` — France

Supported property type values:

- `homes`
- `offices`
- `premises`
- `garages`
- `lands`
- `buildings`
- `rooms`
- `newDevelopments`

#### Result settings

| Input | Description | Default |
|---|---|---|
| `maxResults` | Maximum number of properties to save for each URL or location search. | `100` |
| `includeDetails` | Collect richer information from each property page. Slower, but more complete. | `false` |
| `includeMultimedia` | Collect extra photos and media when available. | `false` |
| `includeRecommendations` | Collect similar recommended properties when available. | `false` |

#### Price and size filters

These are mainly used for location searches. If you use an Idealista URL, filters are usually taken from the URL itself.

| Input | Description |
|---|---|
| `minPrice` | Minimum property price |
| `maxPrice` | Maximum property price |
| `minSize` | Minimum property size in square meters |
| `maxSize` | Maximum property size in square meters |
| `minRooms` | Minimum number of rooms |
| `maxRooms` | Maximum number of rooms |
| `minBathrooms` | Minimum number of bathrooms |

#### Property filters

| Input | Description |
|---|---|
| `hasPhotos` | Prefer listings with photos when supported |
| `hasPlan` | Include only listings with a floor plan when supported |
| `exterior` | Include only exterior-facing properties when supported |
| `elevator` | Include only properties with an elevator when supported |
| `airConditioning` | Include only properties with air conditioning when supported |
| `garage` | Include only properties with garage or parking when supported |
| `heating` | Include only properties with heating when supported |
| `accessible` | Include only accessible properties when supported |
| `security` | Include only properties with security features when supported |

#### Advanced settings

Most users can keep these defaults.

| Input | Description | Default |
|---|---|---|
| `quality` | Image/detail quality preference. | `low` |
| `gallery` | Include gallery images in search results when available. | `true` |
| `order` | Result ordering mode. | `weigh` |
| `sort` | Sort direction. | `desc` |
| `itemsPerPage` | Results requested per search page. | `50` |
| `searchConcurrency` | Number of search pages requested in parallel. | `4` |
| `maxRetries` | Number of retries for temporary failures. | `3` |
| `requestTimeoutSeconds` | Maximum time to wait for a request before retrying. | `45` |
| `delaySeconds` | Delay between search batches. | `0` |
| `debug` | Enable more detailed run logs. | `false` |

### Common use cases

- **Market research** — compare property prices across cities, neighborhoods, and property types.
- **Price monitoring** — track listings that match a budget or investment profile.
- **Lead generation** — collect structured property data for real estate workflows.
- **Investment analysis** — analyze price, size, location, and features at scale.
- **Competitive intelligence** — monitor available inventory in target regions.
- **Inventory tracking** — build datasets of active listings for internal dashboards.
- **Location analysis** — map listings using latitude and longitude when available.

### Why this Actor

- **Flexible search options**: use either Idealista URLs or structured location searches.
- **Clean output**: records include normalized fields such as price, currency, size, rooms, bathrooms, address, coordinates, description, images, and source URL.
- **Useful filters**: narrow searches by price, size, rooms, property features, and more.
- **Detail enrichment**: optionally collect more complete property data and media.
- **Multi-country support**: works with Idealista pages in Spain, Italy, Portugal, and France.
- **Ready for automation**: export results to Apify datasets, APIs, spreadsheets, or downstream systems.
- **Built for recurring monitoring**: schedule the same search to run daily, weekly, or hourly and keep your property dataset fresh.

### Automate Idealista monitoring with scheduled runs

One of the best ways to use this Actor is to run it on a schedule. Instead of checking Idealista manually, you can let Apify collect fresh data every day, every week, or as often as your workflow requires.

#### Scheduled workflow ideas

- **Daily new-listing monitor** — run the same Idealista search every morning and export the latest matching properties.
- **Price monitoring** — collect the same market repeatedly and compare prices over time.
- **Investor watchlists** — track properties in specific cities, neighborhoods, or price ranges.
- **Agency inventory tracking** — monitor available listings in your operating areas.
- **Market reports** — schedule weekly exports for dashboards, spreadsheets, or BI tools.
- **Lead generation pipeline** — send fresh listings into your CRM or database using Apify integrations.

#### How to schedule this Actor on Apify

1. Open the Actor on Apify.
2. Click **Run** and configure your input, such as an Idealista search URL, `maxResults`, and optional detail extraction.
3. Save the task after confirming the input works for your use case.
4. Open **Schedules** in Apify.
5. Create a new schedule and select the saved task.
6. Choose how often it should run, for example daily, weekly, or hourly.
7. Connect the dataset output to your preferred destination, such as Google Sheets, an API, Make, Zapier, or your own database.

#### Example scheduled setup

```json
{
  "startUrls": [
    {
      "url": "https://www.idealista.it/vendita-case/genova-provincia/"
    }
  ],
  "maxResults": 200,
  "includeDetails": true,
  "includeMultimedia": false
}
```

Run this task every morning to build a recurring dataset of properties for sale in Genova. You can then compare datasets over time to detect new listings, removed listings, and price changes.

### FAQ

#### Does this Actor require proxies?

For reliable scraping, proxies are recommended. The Actor includes proxy configuration in the input, and the default setup is suitable for most runs on Apify.

#### Can it scrape all pages from a search?

The Actor can paginate through search results up to the `maxResults` value you set. Very large searches may be limited by availability, website behavior, or the filters used.

#### Can I scrape a single property page?

Yes. Paste an individual Idealista property URL into `startUrls` and run the Actor.

#### Can I use filters from Idealista itself?

Yes. The easiest workflow is to apply filters on Idealista, copy the resulting URL, and paste it into `startUrls`.

#### Does it support multiple countries?

Yes. It supports Idealista pages for Spain (`es`), Italy (`it`), Portugal (`pt`), and France (`fr`).

#### Does it support rentals and sales?

Yes. For structured location searches, set `operation` to `sale` or `rent`. For URL searches, use the corresponding Idealista sale or rent URL.

#### Why are some fields empty?

Some listings do not provide every field. For example, coordinates, bathrooms, features, images, or contact-related data may be missing depending on the listing and selected options.

#### Should I enable `includeDetails`?

Enable `includeDetails` when you need richer property records. Keep it disabled when you want faster runs and basic listing data is enough.

#### How much does it cost?

The cost depends on your Apify plan, run settings, number of results, detail extraction, media extraction, and proxy usage. Start with a small `maxResults` value to estimate cost for your workflow.

### Start scraping Idealista data

Run the Actor with an Idealista search URL or a city-based search, choose your result limit, and export clean property data in minutes.

# Actor input Schema

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

Paste Idealista search result pages or individual property pages here. When you use URLs, the Actor automatically detects the country, language, property type, location, and filters from each URL.

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

Choose the country only when searching by location name below. For URL searches, the country is detected from the Idealista URL automatically.

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

Choose whether you want properties for sale or for rent. This is used only for location searches.

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

Choose what kind of properties you want to search for. This is used only for location searches.

## `locationQuery` (type: `string`):

Enter a city, town, neighborhood, or area name, for example Genova, Madrid, Lisboa, or Paris. The Actor will choose the best matching Idealista location.

## `locationIds` (type: `array`):

Advanced option. If you already know Idealista location IDs, enter them here instead of using a city or area name.

## `locationSelectionMode` (type: `string`):

When a city or area name has multiple matches, choose whether to use the best match, all matches, or only an exact name match.

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

The maximum number of properties to save for each Idealista URL or location search.

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

Turn this on to request the full property details for every search result. This gives richer data but makes the run slower.

## `includeMultimedia` (type: `boolean`):

Turn this on to request the separate media endpoint for each property. Search results already include basic images when available.

## `includeRecommendations` (type: `boolean`):

Turn this on to also collect a small list of similar properties recommended by Idealista for each result.

## `minPrice` (type: `integer`):

Only include properties with a price at or above this amount. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Only include properties with a price at or below this amount. Leave empty for no maximum.

## `minSize` (type: `integer`):

Only include properties with at least this many square meters. Leave empty for no minimum size.

## `maxSize` (type: `integer`):

Only include properties with no more than this many square meters. Leave empty for no maximum size.

## `minRooms` (type: `integer`):

Only include homes with at least this many rooms, when Idealista supports this filter for the selected property type.

## `maxRooms` (type: `integer`):

Only include homes with no more than this many rooms, when Idealista supports this filter for the selected property type.

## `minBathrooms` (type: `integer`):

Only include properties with at least this many bathrooms, when available.

## `hasPhotos` (type: `boolean`):

Turn this on to prefer results that include photos, when supported by Idealista for the selected search.

## `hasPlan` (type: `boolean`):

Turn this on to include only properties that have a floor plan, when supported by Idealista.

## `exterior` (type: `boolean`):

Turn this on to include only exterior-facing properties, when supported by Idealista.

## `elevator` (type: `boolean`):

Turn this on to include only properties with an elevator, when supported by Idealista.

## `airConditioning` (type: `boolean`):

Turn this on to include only properties with air conditioning, when supported by Idealista.

## `garage` (type: `boolean`):

Turn this on to include only properties with a garage or parking option, when supported by Idealista.

## `heating` (type: `boolean`):

Turn this on to include only properties with heating, when supported by Idealista.

## `accessible` (type: `boolean`):

Turn this on to include only properties marked as accessible, when supported by Idealista.

## `security` (type: `boolean`):

Turn this on to include only properties with security features, when supported by Idealista.

## `quality` (type: `string`):

Advanced option. Choose the image/detail quality requested from Idealista.

## `gallery` (type: `boolean`):

Advanced option. Keep this on to request gallery images in search results when Idealista provides them.

## `order` (type: `string`):

Advanced option. Idealista ordering mode. The default usually matches Idealista's recommended order.

## `sort` (type: `string`):

Advanced option. Choose ascending or descending result order.

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

The Actor uses Apify Residential Proxy by default and automatically selects the proxy country from the URL or selected country.

## `itemsPerPage` (type: `integer`):

Advanced option. How many listings to request per Idealista search page. Idealista currently caps this at 50.

## `searchConcurrency` (type: `integer`):

Advanced option. Number of search result pages to fetch in parallel. Higher values can be faster but may increase proxy errors or rate limits.

## `maxRetries` (type: `integer`):

Advanced option. How many times to retry temporary API errors before giving up.

## `requestTimeoutSeconds` (type: `integer`):

Advanced option. Maximum time to wait for each Idealista API request before retrying it. Increase this if residential proxies are slow.

## `delaySeconds` (type: `number`):

Advanced option. Wait this many seconds between batches of parallel search page requests. Increase if Idealista starts rate limiting.

## `debug` (type: `boolean`):

Advanced option. Turn this on to print more technical information while the Actor runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.idealista.it/vendita-uffici/genova-genova/con-prezzo-min_120000/"
    }
  ],
  "country": "it",
  "operation": "sale",
  "propertyType": "homes",
  "locationSelectionMode": "best",
  "maxResults": 100,
  "includeDetails": false,
  "includeMultimedia": false,
  "includeRecommendations": false,
  "hasPhotos": false,
  "hasPlan": false,
  "exterior": false,
  "elevator": false,
  "airConditioning": false,
  "garage": false,
  "heating": false,
  "accessible": false,
  "security": false,
  "quality": "low",
  "gallery": true,
  "order": "weigh",
  "sort": "desc",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "itemsPerPage": 50,
  "searchConcurrency": 4,
  "maxRetries": 3,
  "requestTimeoutSeconds": 45,
  "delaySeconds": 0,
  "debug": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.idealista.it/vendita-uffici/genova-genova/con-prezzo-min_120000/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/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.it/vendita-uffici/genova-genova/con-prezzo-min_120000/" }] }

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/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.it/vendita-uffici/genova-genova/con-prezzo-min_120000/"
    }
  ]
}' |
apify call epicscrapers/idealista-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Idealista Scraper | 💛 $0.5/1k | No Limit",
        "description": "⚡ From $0.5/1k 💛 Scrape Idealista property listings from Spain, Italy, Portugal, and France. Extract prices, locations, descriptions, images, property details, and listing URLs from search pages or individual property pages. Export to CSV/JSON",
        "version": "0.1",
        "x-build-id": "FUfXT3030qVLLs2w9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~idealista-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-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/epicscrapers~idealista-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-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/epicscrapers~idealista-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-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": "Idealista URLs",
                        "type": "array",
                        "description": "Paste Idealista search result pages or individual property pages here. When you use URLs, the Actor automatically detects the country, language, property type, location, and filters from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Country for location search",
                        "enum": [
                            "es",
                            "it",
                            "pt",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Choose the country only when searching by location name below. For URL searches, the country is detected from the Idealista URL automatically.",
                        "default": "it"
                    },
                    "operation": {
                        "title": "I want to find",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Choose whether you want properties for sale or for rent. This is used only for location searches.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "homes",
                            "offices",
                            "premises",
                            "garages",
                            "lands",
                            "buildings",
                            "rooms",
                            "newDevelopments"
                        ],
                        "type": "string",
                        "description": "Choose what kind of properties you want to search for. This is used only for location searches.",
                        "default": "homes"
                    },
                    "locationQuery": {
                        "title": "City or area",
                        "type": "string",
                        "description": "Enter a city, town, neighborhood, or area name, for example Genova, Madrid, Lisboa, or Paris. The Actor will choose the best matching Idealista location."
                    },
                    "locationIds": {
                        "title": "Idealista location IDs",
                        "type": "array",
                        "description": "Advanced option. If you already know Idealista location IDs, enter them here instead of using a city or area name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationSelectionMode": {
                        "title": "How to choose matching locations",
                        "enum": [
                            "best",
                            "all",
                            "exact"
                        ],
                        "type": "string",
                        "description": "When a city or area name has multiple matches, choose whether to use the best match, all matches, or only an exact name match.",
                        "default": "best"
                    },
                    "maxResults": {
                        "title": "Maximum results per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of properties to save for each Idealista URL or location search.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Open each property page for more details",
                        "type": "boolean",
                        "description": "Turn this on to request the full property details for every search result. This gives richer data but makes the run slower.",
                        "default": false
                    },
                    "includeMultimedia": {
                        "title": "Get extra photos and media",
                        "type": "boolean",
                        "description": "Turn this on to request the separate media endpoint for each property. Search results already include basic images when available.",
                        "default": false
                    },
                    "includeRecommendations": {
                        "title": "Get similar recommended properties",
                        "type": "boolean",
                        "description": "Turn this on to also collect a small list of similar properties recommended by Idealista for each result.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with a price at or above this amount. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with a price at or below this amount. Leave empty for no maximum."
                    },
                    "minSize": {
                        "title": "Minimum size",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many square meters. Leave empty for no minimum size."
                    },
                    "maxSize": {
                        "title": "Maximum size",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with no more than this many square meters. Leave empty for no maximum size."
                    },
                    "minRooms": {
                        "title": "Minimum rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include homes with at least this many rooms, when Idealista supports this filter for the selected property type."
                    },
                    "maxRooms": {
                        "title": "Maximum rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include homes with no more than this many rooms, when Idealista supports this filter for the selected property type."
                    },
                    "minBathrooms": {
                        "title": "Minimum bathrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with at least this many bathrooms, when available."
                    },
                    "hasPhotos": {
                        "title": "Only properties with photos",
                        "type": "boolean",
                        "description": "Turn this on to prefer results that include photos, when supported by Idealista for the selected search.",
                        "default": false
                    },
                    "hasPlan": {
                        "title": "Only properties with a floor plan",
                        "type": "boolean",
                        "description": "Turn this on to include only properties that have a floor plan, when supported by Idealista.",
                        "default": false
                    },
                    "exterior": {
                        "title": "Exterior properties only",
                        "type": "boolean",
                        "description": "Turn this on to include only exterior-facing properties, when supported by Idealista.",
                        "default": false
                    },
                    "elevator": {
                        "title": "Elevator",
                        "type": "boolean",
                        "description": "Turn this on to include only properties with an elevator, when supported by Idealista.",
                        "default": false
                    },
                    "airConditioning": {
                        "title": "Air conditioning",
                        "type": "boolean",
                        "description": "Turn this on to include only properties with air conditioning, when supported by Idealista.",
                        "default": false
                    },
                    "garage": {
                        "title": "Garage or parking",
                        "type": "boolean",
                        "description": "Turn this on to include only properties with a garage or parking option, when supported by Idealista.",
                        "default": false
                    },
                    "heating": {
                        "title": "Heating",
                        "type": "boolean",
                        "description": "Turn this on to include only properties with heating, when supported by Idealista.",
                        "default": false
                    },
                    "accessible": {
                        "title": "Accessible property",
                        "type": "boolean",
                        "description": "Turn this on to include only properties marked as accessible, when supported by Idealista.",
                        "default": false
                    },
                    "security": {
                        "title": "Security features",
                        "type": "boolean",
                        "description": "Turn this on to include only properties with security features, when supported by Idealista.",
                        "default": false
                    },
                    "quality": {
                        "title": "Image quality",
                        "enum": [
                            "low",
                            "high"
                        ],
                        "type": "string",
                        "description": "Advanced option. Choose the image/detail quality requested from Idealista.",
                        "default": "low"
                    },
                    "gallery": {
                        "title": "Include gallery in search results",
                        "type": "boolean",
                        "description": "Advanced option. Keep this on to request gallery images in search results when Idealista provides them.",
                        "default": true
                    },
                    "order": {
                        "title": "Result ordering",
                        "type": "string",
                        "description": "Advanced option. Idealista ordering mode. The default usually matches Idealista's recommended order.",
                        "default": "weigh"
                    },
                    "sort": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Advanced option. Choose ascending or descending result order.",
                        "default": "desc"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The Actor uses Apify Residential Proxy by default and automatically selects the proxy country from the URL or selected country.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "itemsPerPage": {
                        "title": "Results per search page",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Advanced option. How many listings to request per Idealista search page. Idealista currently caps this at 50.",
                        "default": 50
                    },
                    "searchConcurrency": {
                        "title": "Parallel search page requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Advanced option. Number of search result pages to fetch in parallel. Higher values can be faster but may increase proxy errors or rate limits.",
                        "default": 4
                    },
                    "maxRetries": {
                        "title": "Retry failed requests",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Advanced option. How many times to retry temporary API errors before giving up.",
                        "default": 3
                    },
                    "requestTimeoutSeconds": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Advanced option. Maximum time to wait for each Idealista API request before retrying it. Increase this if residential proxies are slow.",
                        "default": 45
                    },
                    "delaySeconds": {
                        "title": "Delay between search batches",
                        "minimum": 0,
                        "type": "number",
                        "description": "Advanced option. Wait this many seconds between batches of parallel search page requests. Increase if Idealista starts rate limiting.",
                        "default": 0
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Advanced option. Turn this on to print more technical information while the Actor runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
