# Idealista All-in-one Scraper - Properties, Prices & Agencies (`pro100chok/idealista-scraper`) Actor

Scrape Idealista real estate listings across Spain, Italy and Portugal — for sale or rent. Extract prices, size (m²), rooms, photos, energy rating, coordinates, agency details and phone numbers, by URL or filters. Export to JSON, CSV or Excel. No login or API key required.

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

## Pricing

from $0.70 / 1,000 property scrapeds

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

## Idealista Scraper — Properties, Prices, Photos & Agency Contacts (Spain, Italy, Portugal)

Extract real-estate listings from **Idealista** — the biggest property portal in Spain, Italy and Portugal — as clean, structured data. Scrape **for sale and for rent**, homes, new developments, offices, garages, land and more. Get **prices, €/m², sizes, rooms, full descriptions, whole photo galleries, energy certificates, GPS coordinates and advertiser/agency details**, ready to export to JSON, CSV or Excel.

**Pay-per-result — from $0.70 per 1,000 properties.** No login, no Idealista API key, no code, and no proxies to configure. Point the scraper at a search, a single property, a property code, or an agency — and get rows back.

---

### What does this Idealista Scraper do?

Idealista has no open public API — its official data feed is partner-only and gated. This actor is the practical **Idealista API alternative**: it reads the same pages you see in your browser and returns them as structured records. It works across all three markets — **idealista.com (Spain), idealista.it (Italy) and idealista.pt (Portugal)** — from one actor.

| Mode | What you give it | What you get back |
|---|---|---|
| 🔎 **Search results** | Any Idealista search URL, or filters (location, operation, type, price, size…) | One row per listing, with pagination handled automatically |
| 🏠 **Property detail** | A property URL (`/inmueble/`, `/immobile/`, `/imovel/`) or a property code | The full listing: description, every feature, energy certificate, price drops, the complete photo gallery, coordinates |
| 🏢 **Agencies / advertisers** | An agency `/pro/` URL or slug — or a whole search | One de-duplicated row per agency: profile, active-listing count, years on Idealista |
| 📞 **Phone reveal** | `fetchPhones: true` | The advertiser's phone number, when published |
| 🔄 **Monitoring** | `monitoringMode: true` | Only listings you haven't seen in previous runs — a daily new-listing feed |

---

### Why use this Idealista Scraper?

- ✅ **All three countries in one actor** — Spain, Italy and Portugal, same input, same output schema.
- ✅ **40+ fields per property** — price, €/m², explicit price-drop amount and percentage, size, rooms, bathrooms, floor, condition, year built, energy certificate, reference, full description, feature list, coordinates, the complete tagged photo gallery, and advertiser/agency details.
- ✅ **Go past Idealista's ~1,800-result cap** — a single search stops at ~1,800 rows; turn on `splitByPrice` and the actor splits the query into price bands and collects far more, de-duplicated.
- ✅ **Agency & advertiser data** — advertiser name, professional/private flag, agency logo, microsite, profile URL and internal id; or one clean row per agency with its listing count and client-since year.
- ✅ **Phone numbers** — reveal the advertiser's phone for each property (opt-in).
- ✅ **Monitoring mode** — return only new listings since the last run, perfect for daily alerts and incremental archives.
- ✅ **Search by URL or by filters** — paste a search URL you built on the website, or fill in `location` + `operation` + `propertyType` + filters and let the actor build the search.
- ✅ **Anti-bot handling built in** — Idealista is protected by DataDome; residential proxy rotation, geo-matching (Spain for .com, Italy for .it, Portugal for .pt) and automatic retries are all included, so you never touch proxies.
- ✅ **Pay only for results** — no monthly subscription; proxy and compute are included in the per-result price.

#### How it compares

| | Official Idealista API | Typical Idealista scrapers | **This actor** |
|---|---|---|---|
| Access | Partner-only, approval required | Public | **Public, no key** |
| Countries | Usually Spain-focused | Often one country | **Spain + Italy + Portugal** |
| Past the ~1,800 cap | n/a | Usually silently truncated | **Price-band split (opt-in)** |
| Agency profiles + phones | Restricted | Rarely | **Included (opt-in)** |
| New-listings monitoring | n/a | Rarely | **Built in** |
| Pricing | Quota/contract | Often a monthly fee | **Pay-per-result, from $0.70/1k** |

*Competitor-column claims are generalisations; individual actors vary.*

---

### What data can you extract from Idealista?

#### Property fields

| Group | Fields |
|---|---|
| **Identity** | `propertyCode`, `url`, `title`, `subtitle`, `operation` (sale/rent), `propertyType`, `reference`, `country`, `scrapedAt` |
| **Price** | `price`, `priceByArea` (€/m²), `priceDrop` (`previousPrice`, `percentage`) |
| **Property** | `size` (m²), `rooms`, `bathrooms`, `floor`, `condition`, `yearBuilt`, `energyCertificate` (A–G), `newDevelopment`, `features[]`, `description` |
| **Location** | `address`, `latitude`, `longitude`, `locationId` |
| **Media** | `thumbnail`, `numPhotos`, `images[]` (`url`, `urlWebp`, `tag`, `isPlan`, `width`, `height`, `multimediaId`), `hasVideo`, `hasPlan`, `has3DTour` |
| **Advertiser** (`contactInfo`) | `commercialName`, `contactName`, `userType` (professional/private), `phone` / `phones[]`, `profileUrl`, `micrositeShortName`, `agencyLogo`, `commercialDataId` |

#### Agency fields (agency mode)

`agencyName`, `agencySlug`, `commercialDataId`, `totalListings`, `clientSince`, `publicationQuality`, `agencyLogo`, `videoUrl`, `videoThumbnail`, `address`, `agencyWebUrl`, `country`, `scrapedAt`.

---

### How to scrape Idealista step by step

1. Open the actor in the Apify Console and click **Try for free** (new accounts get **$5 in free usage credits every month** — enough for thousands of listings).
2. Choose how to target listings:
   - **Easiest:** on idealista.com (or .it / .pt) set your filters, copy the URL from the address bar, and paste it into **Idealista URLs** (`startUrls`).
   - **Or** fill in **Location**, **Country**, **Operation** and **Property type** and let the actor build the search.
3. (Optional) Turn on **Scrape full detail for each result** (`fetchDetails`) for the complete description, features, energy certificate, full gallery and coordinates.
4. (Optional) Turn on **Reveal phone numbers** (`fetchPhones`) or **Output agencies instead of properties** (`scrapeAgencies`).
5. Set **Max results** and click **Start**.
6. When the run finishes, download the dataset as **JSON, CSV, Excel, XML or HTML**, or pull it via the Apify API.

---

### How to get more than 1,800 results from one search

Idealista caps any single search query at roughly **1,800 results** (about 60 pages). Ask for a whole city and you'll silently miss most of the market. Turn on **Bypass the ~1,800 result limit** (`splitByPrice`) and the actor automatically re-runs your search across a ladder of price bands (0–100k, 100k–200k, … 3M+), then de-duplicates by property code — so you collect far more of the market from a single input.

```json
{ "startUrls": [{ "url": "https://www.idealista.com/venta-viviendas/madrid-madrid/" }], "splitByPrice": true, "maxItems": 0 }
````

### How to get only new listings (daily monitoring)

Turn on **Monitoring mode** (`monitoringMode`) and the actor remembers every property code it has already emitted (in the actor's key-value store). On the next run of the same actor it returns **only listings it hasn't seen before** — a ready-made new-listing feed you can schedule daily and pipe into Slack, a sheet, or a CRM.

### How to scrape real-estate agencies and phone numbers

- Set **Output agencies instead of properties** (`scrapeAgencies: true`) on a search URL and the actor walks the results, collects every unique advertiser microsite, and returns **one clean row per agency** — name, listing count, client-since year, logo and profile URL. A ready-made B2B lead list.
- Or scrape specific agencies directly with **Agency slugs** (the part after `/pro/`).
- Set **Reveal phone numbers** (`fetchPhones: true`) to add the advertiser's phone number to each property record when one is published.

***

### Input parameters

| Field | Key | Description |
|---|---|---|
| Idealista URLs | `startUrls` | Search, property or agency URLs — type auto-detected. The most reliable input. |
| Location | `location` | Location slug as it appears in an Idealista URL, e.g. `madrid-madrid`, `barcelona-barcelona`. |
| Country | `country` | `es` (idealista.com), `it` (idealista.it) or `pt` (idealista.pt). |
| Operation | `operation` | `sale` or `rent`. |
| Property type | `propertyType` | `homes`, `newDevelopments`, `offices`, `premises`, `garages`, `lands`, `storageRooms`, `buildings`, `rooms`. |
| Sort by | `sortBy` | `relevance`, `mostRecent`, `lowestPrice`, `highestPrice`, `biggest`, `smallest`, `highestPriceReduction`… |
| Price / size | `minPrice`, `maxPrice`, `minSize`, `maxSize` | Numeric filters. |
| Bedrooms | `bedrooms` | `studio`, `1`, `2`, `3`, `4` (multiple). |
| Home type | `homeType` | `flat`, `penthouse`, `duplex`, `detachedHouse`, `countryHouse`, `studio` (multiple). |
| Condition | `condition` | `newDevelopment`, `good`, `renew` (multiple). |
| Floor | `floor` | `topFloor`, `intermediateFloor`, `groundFloor` (multiple). |
| Amenities | `amenities` | `airConditioning`, `lift`, `terrace`, `garage`, `garden`, `swimmingPool`, `storageRoom`, `fittedWardrobes`, `exterior`, `luxury`, `accessible`, `seaViews`. |
| Published within | `publicationDate` | `24h`, `48h`, `week`, `month`. |
| Property codes | `propertyCodes` | Scrape specific properties by code. |
| Agency slugs | `agencySlugs` | Scrape agency profiles by slug. |
| Full detail | `fetchDetails` | Expand every search result with its full property page. |
| Advertiser details | `fetchContacts` | Fetch the advertiser block (on by default). |
| Reveal phones | `fetchPhones` | Reveal the advertiser's phone number. |
| Agencies mode | `scrapeAgencies` | One row per unique agency found in a search. |
| Monitoring | `monitoringMode` | Only listings not seen in previous runs. |
| Bypass cap | `splitByPrice` | Split the search into price bands to go past ~1,800. |
| Max results | `maxItems` | Cap the number of records (0 = no limit). |
| Max pages | `endPage` | Stop each search after N pages (~30 per page). |
| Concurrency | `maxConcurrency` | Parallel workers, 1–20. |
| Max retries | `maxRetries` | Proxy-rotation retries per blocked request. |
| Proxy | `proxyConfiguration` | Residential recommended; country auto-matched to the site. |

***

### Ready-to-paste input recipes

**All flats for sale in Madrid, cheapest first, with full detail**

```json
{ "location": "madrid-madrid", "operation": "sale", "propertyType": "homes", "homeType": ["flat"], "sortBy": "lowestPrice", "fetchDetails": true, "maxItems": 200 }
```

**A filtered search you built on the website, with phone reveal**

```json
{ "startUrls": [{ "url": "https://www.idealista.com/alquiler-viviendas/barcelona-barcelona/con-precio-hasta_1500/" }], "fetchDetails": true, "fetchPhones": true }
```

**New listings only (schedule this daily)**

```json
{ "startUrls": [{ "url": "https://www.idealista.com/venta-viviendas/valencia-valencia/" }], "monitoringMode": true, "maxItems": 0 }
```

**Go past the ~1,800-result cap for a whole city**

```json
{ "startUrls": [{ "url": "https://www.idealista.com/venta-viviendas/madrid-madrid/" }], "splitByPrice": true, "maxItems": 0 }
```

**Agencies operating in an area (lead list)**

```json
{ "startUrls": [{ "url": "https://www.idealista.com/venta-viviendas/madrid-madrid/" }], "scrapeAgencies": true }
```

**Italy rentals built from filters**

```json
{ "country": "it", "location": "milano-milano", "operation": "rent", "propertyType": "homes", "minSize": 60, "bedrooms": ["2", "3"], "amenities": ["lift", "terrace"], "maxItems": 150 }
```

**Specific properties by code, in Portugal, with phones**

```json
{ "country": "pt", "propertyCodes": ["33528290", "33500123"], "fetchDetails": true, "fetchPhones": true }
```

***

### Output examples

**Property record**

```json
{
  "propertyCode": "111901446",
  "url": "https://www.idealista.com/inmueble/111901446/",
  "title": "Piso en venta en Calle del Príncipe de Vergara",
  "subtitle": "Ciudad Jardín, Madrid",
  "operation": "sale",
  "propertyType": "homes",
  "price": 1250000,
  "priceByArea": 8117,
  "priceDrop": { "previousPrice": 1350000, "percentage": 7 },
  "size": 154,
  "rooms": 4,
  "bathrooms": 2,
  "floor": "4ª planta exterior con ascensor",
  "condition": "good",
  "yearBuilt": 1971,
  "energyCertificate": "D",
  "reference": "DG 220077",
  "description": "Gilmar le presenta en exclusiva este magnífico piso de 154 m²...",
  "features": ["154 m² construidos", "4 habitaciones", "2 baños", "Terraza", "Trastero", "Aire acondicionado"],
  "numPhotos": 28,
  "images": [
    { "url": "https://img4.idealista.com/.../1453959145.jpg", "tag": "Salón", "isPlan": false, "width": 1500, "height": 1000 }
  ],
  "latitude": 40.4419,
  "longitude": -3.6772,
  "contactInfo": {
    "commercialName": "Gilmar Avenida de América",
    "userType": "professional",
    "phone": "+34919382490",
    "profileUrl": "https://www.idealista.com/pro/gilmaravdadeamerica/",
    "micrositeShortName": "gilmaravdadeamerica",
    "commercialDataId": "130154577"
  },
  "country": "es",
  "scrapedAt": "2026-07-09T18:20:00+00:00"
}
```

**Agency record** (`scrapeAgencies: true`)

```json
{
  "type": "agency",
  "url": "https://www.idealista.com/pro/gilmaravdadeamerica/",
  "agencySlug": "gilmaravdadeamerica",
  "agencyName": "Gilmar Avenida de América",
  "commercialDataId": "130154577",
  "totalListings": 214,
  "clientSince": 2001,
  "publicationQuality": 98,
  "agencyLogo": "https://st3.idealista.com/.../logo.jpg",
  "country": "es",
  "scrapedAt": "2026-07-09T18:20:00+00:00"
}
```

***

### How much does it cost to scrape Idealista?

This actor is **pay-per-result**: you pay a small fixed amount for each record saved to your dataset, plus a negligible actor-start fee. There is **no monthly subscription**, and residential proxy and compute are **included** in the price — no separate proxy bill.

| Event | Free plan | Paid plans (from) |
|---|---|---|
| Property scraped | $0.85 / 1,000 | $0.70 / 1,000 |
| Agency scraped | $2.50 / 1,000 | $1.50 / 1,000 |
| Phone number revealed | $2.50 / 1,000 | $1.50 / 1,000 |
| Actor start | $0.00005 per GB | $0.00005 per GB |

Paid-plan prices fall as your Apify subscription tier rises (Bronze → Diamond). Worked examples on the **free-plan** rate:

| What you scrape | Cost |
|---|---|
| 100 properties | ~$0.09 |
| 1,000 properties | ~$0.85 |
| 1,000 properties + phone reveal | up to ~$3.35 |
| 1,000 agencies | ~$2.50 |
| 10,000 properties | ~$8.50 |

**Free-plan translation:** the Apify Free plan includes about **$5 in usage credits every month**, which is roughly **5,800 properties per month at no cost**. Phone reveal and agency profiles are only charged when data is actually returned — you are **never charged for a phone that isn't published, or for a search that returns nothing**.

***

### Integrations

Run this scraper on a **schedule** and connect the output to the rest of your stack — no glue code needed:

- **Make, Zapier and n8n** — trigger a run or react to new dataset items.
- **Google Sheets, Airtable, Slack, Discord** — push fresh listings automatically.
- **Webhooks** — fire your own endpoint when a run finishes.
- **API clients** — official JavaScript/TypeScript and Python clients, plus a plain REST API and CLI.
- **Schedules** — keep a market refreshed daily/weekly, ideal with monitoring mode.

### Use with AI agents (MCP)

This actor works with the **Apify MCP Server**, so AI assistants and agents (Claude, ChatGPT, Cursor and others) can call it directly as a tool. Example natural-language prompt:

> "Scrape the 50 cheapest flats for sale in Valencia from Idealista and give me the price, size in m² and the agency's phone number for each."

***

### Popular use cases

- 🏠 **Real-estate investors & flippers** — track new listings and price drops across a city daily.
- 📊 **Market & price analysts** — build €/m² benchmarks by neighbourhood, city or region.
- 🏢 **Proptech & CRM vendors** — feed live Iberian inventory into your product.
- 📇 **Estate agents & lead-gen teams** — export agency profiles and advertiser phone numbers.
- 🎓 **Researchers, journalists & NGOs** — study housing supply and pricing with real data.
- 🤖 **AI & data teams** — clean JSON to power dashboards, models and agents.

***

### Is it legal to scrape Idealista?

Scraping **publicly available** data — like the listings anyone can browse on Idealista — is generally lawful, and this actor only collects public information. But your results can contain **personal data** (for example an advertiser's name or phone number), which is protected by the GDPR in the EU (and LOPDGDD/RGPD locally) and by similar laws elsewhere. Only collect and store personal data when you have a lawful basis, keep only what you need, and always respect Idealista's Terms of Service. This actor is **not affiliated with Idealista**.

For a deeper overview, see Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

***

### FAQ

#### Do I need an Idealista account or API key?

No. There's no login and no Idealista API key. Just paste a URL or set a few filters.

#### Does Idealista have a public API?

Idealista's official data API is partner-only and approval-gated, so it isn't practical for most users. This actor is the accessible **Idealista API alternative** — it returns the same public listing data as structured JSON/CSV.

#### Which countries and sites are supported?

Spain (idealista.com), Italy (idealista.it) and Portugal (idealista.pt) — all from one actor. The proxy egress country is matched to the site automatically.

#### Can I scrape both properties for sale and rentals?

Yes. Set `operation` to `sale` or `rent`, or just paste a for-sale or rental search URL — the actor follows whatever the URL asks for.

#### How do I get more than 1,800 results from one search?

Turn on **Bypass the ~1,800 result limit** (`splitByPrice`). The actor re-runs your search across price bands and de-duplicates, collecting far more of the market.

#### Can I get real-estate agencies with phone numbers?

Yes. Use `scrapeAgencies: true` to get one row per agency (with listing count and client-since year), and `fetchPhones: true` to add advertiser phone numbers to property records.

#### Do I need proxies or a proxy subscription?

No. Residential proxy rotation, country geo-matching and retries are built in and included in the per-result price.

#### Will I be charged for a search that returns nothing?

No. You're charged per property or agency actually saved to your dataset (plus a tiny actor-start fee). Zero-result runs cost essentially nothing, and a phone is only charged when one is genuinely returned.

#### Why are some fields (coordinates or phone) empty?

Some advertisers hide the exact address, so coordinates come back empty and only the neighbourhood/city is available. Phone numbers appear only when the advertiser publishes one and `fetchPhones` is on. Detail-only fields (full description, features, energy certificate, gallery) require `fetchDetails: true`.

#### How much does it cost to scrape Idealista?

From **$0.70 per 1,000 properties** on paid plans ($0.85 on the free plan). Proxy and compute are included. See the pricing section above for worked examples.

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

Yes. Every run stores results in a dataset you can download as **JSON, CSV, Excel, XML or HTML**, or read via the Apify API.

#### Can I scrape a single property by URL or code?

Yes. Paste a property URL into `startUrls`, or list codes in `propertyCodes` with the matching `country`.

#### Can I get only new listings for a daily alert?

Yes. Turn on `monitoringMode` and schedule the actor — it returns only listings it hasn't seen in previous runs.

#### How do I filter by price, rooms or property type?

Either build the search with the `minPrice`/`maxPrice`, `bedrooms`, `homeType`, `condition`, `amenities` and `propertyType` fields, or apply the filters on idealista.com and paste the resulting URL — both work.

#### Can I use this with Make, Zapier or n8n?

Yes — via Apify's native integrations, webhooks, or the REST API. Combine it with Schedules for hands-off daily exports.

***

### Feedback & support

Found a bug or need a new field or filter? Open an issue on the actor's **Issues** tab in the Apify Console — include your input and run link and we'll take a look.

***

### More scrapers by this developer

- [Zillow Scraper](https://apify.com/pro100chok/zillow-scraper-all-in-one) — US listings, property details, Zestimate & agents.
- [Apartments.com Scraper](https://apify.com/pro100chok/apartments-scraper-usage) — US rentals, prices & reviews.
- [Booking.com Scraper](https://apify.com/pro100chok/booking-all-in-one-scraper) — hotels, prices, reviews & host data.
- [Google Maps Scraper](https://apify.com/pro100chok/google-maps-scraper) — places, emails, reviews & photos for lead gen.
- [Website Contact Scraper](https://apify.com/pro100chok/extract-emails) — bulk emails, phones & socials from any site.
- [TripAdvisor Scraper](https://apify.com/pro100chok/tripadvisor-all-in-one) — hotels, restaurants & reviews.

***

**Tags:** idealista scraper, idealista api, idealista.com scraper, idealista.it scraper, idealista.pt scraper, scrape idealista, idealista spain scraper, idealista italy scraper, idealista portugal scraper, spain real estate scraper, italy real estate scraper, portugal real estate scraper, iberia property data, madrid property scraper, barcelona property scraper, valencia property scraper, milan property scraper, lisbon property scraper, alquiler idealista, venta viviendas, immobili idealista, comprar casas, real estate api, property listing scraper, real estate lead generation, real estate agency contacts, agent phone scraper, property price tracker, real estate monitoring, 1800 cap bypass, property market intelligence, real estate json csv export

# Actor input Schema

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

Paste any Idealista URLs — search result pages, single property pages (/inmueble/, /immobile/, /imovel/), or agency pages (/pro/...). The type of each URL is detected automatically. This is the most reliable way to control exactly what is scraped: set your filters on idealista.com and paste the resulting URL. Works for idealista.com (Spain), idealista.it (Italy) and idealista.pt (Portugal).

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

Build a search without a URL: the location slug exactly as it appears in an Idealista URL, e.g. 'madrid-madrid', 'barcelona-barcelona', or a neighbourhood path like 'madrid/chamartin'. Combined with the fields below. Leave empty if you use 'Idealista URLs' above.

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

Idealista country/site to use when building a search from filters.

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

Buy or rent.

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

Type of property to search for.

## `sortBy` (type: `string`):

Ordering of the search results.

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

Minimum price in euros.

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

Maximum price in euros.

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

Minimum built size in m².

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

Maximum built size in m².

## `bedrooms` (type: `array`):

Number of bedrooms (multiple allowed).

## `homeType` (type: `array`):

Filter by home sub-type (multiple allowed).

## `condition` (type: `array`):

Filter by property condition (multiple allowed).

## `floor` (type: `array`):

Filter by floor level (multiple allowed).

## `amenities` (type: `array`):

Filter by amenities (multiple allowed).

## `publicationDate` (type: `string`):

Only include listings published within this period.

## `propertyCodes` (type: `array`):

Scrape specific properties by their Idealista code (the number in /inmueble/<code>/). Uses the Country selected above.

## `agencySlugs` (type: `array`):

Scrape agency / professional profiles by slug (the part after /pro/ in the URL, e.g. 'gilmar-centro'). Uses the Country selected above.

## `fetchDetails` (type: `boolean`):

For every search result, also open its property page to get the full description, all features, energy certificate, full photo gallery and coordinates. Slower and costs more requests.

## `fetchContacts` (type: `boolean`):

On detail pages, fetch the advertiser block (name, logo, microsite, agency id, reference). Reliable and recommended.

## `fetchPhones` (type: `boolean`):

Reveal the advertiser's phone number for each property (returned as contactInfo.phone). Adds a few extra requests per property. Not every listing publishes a phone.

## `scrapeAgencies` (type: `boolean`):

For search URLs, return one row per unique agency/advertiser found (with profile details) instead of the properties.

## `monitoringMode` (type: `boolean`):

Only output listings not seen in previous runs of this Actor (tracked by property code). Great for daily alerts.

## `splitByPrice` (type: `boolean`):

Idealista limits a single search to ~1,800 results. Enable this to automatically split the search into price bands and collect far more results (deduplicated).

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

Maximum number of records to output (0 = no limit).

## `endPage` (type: `integer`):

Stop each search after this many result pages (0 = until the last page). ~30 results per page.

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

How many properties/pages to process in parallel. Each parallel worker uses its own proxy IP. Higher = faster but more proxy traffic.

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

How many times to rotate the proxy IP and retry when a request is blocked.

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

Proxy used for scraping. Residential proxies are strongly recommended and the egress country is matched to the site automatically (Spain for .com, Italy for .it, Portugal for .pt).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.idealista.com/venta-viviendas/madrid-madrid/"
    }
  ],
  "country": "es",
  "operation": "sale",
  "propertyType": "homes",
  "sortBy": "relevance",
  "publicationDate": "",
  "fetchDetails": true,
  "fetchContacts": true,
  "fetchPhones": true,
  "scrapeAgencies": false,
  "monitoringMode": false,
  "splitByPrice": true,
  "maxItems": 100,
  "endPage": 0,
  "maxConcurrency": 5,
  "maxRetries": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `contacts` (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.com/venta-viviendas/madrid-madrid/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pro100chok/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/" }] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Idealista All-in-one Scraper - Properties, Prices & Agencies",
        "description": "Scrape Idealista real estate listings across Spain, Italy and Portugal — for sale or rent. Extract prices, size (m²), rooms, photos, energy rating, coordinates, agency details and phone numbers, by URL or filters. Export to JSON, CSV or Excel. No login or API key required.",
        "version": "1.0",
        "x-build-id": "cg5QFzvYYaZ4X0E7z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pro100chok~idealista-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pro100chok-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/pro100chok~idealista-scraper/runs": {
            "post": {
                "operationId": "runs-sync-pro100chok-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/pro100chok~idealista-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-pro100chok-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 any Idealista URLs — search result pages, single property pages (/inmueble/, /immobile/, /imovel/), or agency pages (/pro/...). The type of each URL is detected automatically. This is the most reliable way to control exactly what is scraped: set your filters on idealista.com and paste the resulting URL. Works for idealista.com (Spain), idealista.it (Italy) and idealista.pt (Portugal).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Build a search without a URL: the location slug exactly as it appears in an Idealista URL, e.g. 'madrid-madrid', 'barcelona-barcelona', or a neighbourhood path like 'madrid/chamartin'. Combined with the fields below. Leave empty if you use 'Idealista URLs' above."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "es",
                            "it",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Idealista country/site to use when building a search from filters.",
                        "default": "es"
                    },
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Buy or rent.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "homes",
                            "newDevelopments",
                            "offices",
                            "premises",
                            "garages",
                            "lands",
                            "storageRooms",
                            "buildings",
                            "rooms"
                        ],
                        "type": "string",
                        "description": "Type of property to search for.",
                        "default": "homes"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "mostRecent",
                            "leastRecent",
                            "lowestPrice",
                            "highestPrice",
                            "biggest",
                            "smallest",
                            "highestPriceReduction"
                        ],
                        "type": "string",
                        "description": "Ordering of the search results.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in euros."
                    },
                    "maxPrice": {
                        "title": "Max price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in euros."
                    },
                    "minSize": {
                        "title": "Min size (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum built size in m²."
                    },
                    "maxSize": {
                        "title": "Max size (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum built size in m²."
                    },
                    "bedrooms": {
                        "title": "Bedrooms",
                        "type": "array",
                        "description": "Number of bedrooms (multiple allowed).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "studio",
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "Studio",
                                "1",
                                "2",
                                "3",
                                "4+"
                            ]
                        }
                    },
                    "homeType": {
                        "title": "Home type",
                        "type": "array",
                        "description": "Filter by home sub-type (multiple allowed).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "flat",
                                "penthouse",
                                "duplex",
                                "detachedHouse",
                                "countryHouse",
                                "studio"
                            ],
                            "enumTitles": [
                                "Flat",
                                "Penthouse",
                                "Duplex",
                                "Detached house / chalet",
                                "Country house",
                                "Studio"
                            ]
                        }
                    },
                    "condition": {
                        "title": "Condition",
                        "type": "array",
                        "description": "Filter by property condition (multiple allowed).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "newDevelopment",
                                "good",
                                "renew"
                            ],
                            "enumTitles": [
                                "New development",
                                "Good condition / second hand",
                                "To renovate"
                            ]
                        }
                    },
                    "floor": {
                        "title": "Floor",
                        "type": "array",
                        "description": "Filter by floor level (multiple allowed).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "topFloor",
                                "intermediateFloor",
                                "groundFloor"
                            ],
                            "enumTitles": [
                                "Top floor",
                                "Intermediate floor",
                                "Ground floor"
                            ]
                        }
                    },
                    "amenities": {
                        "title": "Amenities",
                        "type": "array",
                        "description": "Filter by amenities (multiple allowed).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "airConditioning",
                                "lift",
                                "terrace",
                                "garage",
                                "garden",
                                "swimmingPool",
                                "storageRoom",
                                "fittedWardrobes",
                                "exterior",
                                "luxury",
                                "accessible",
                                "seaViews"
                            ],
                            "enumTitles": [
                                "Air conditioning",
                                "Lift",
                                "Terrace",
                                "Garage",
                                "Garden",
                                "Swimming pool",
                                "Storage room",
                                "Fitted wardrobes",
                                "Exterior",
                                "Luxury",
                                "Accessible",
                                "Sea views"
                            ]
                        }
                    },
                    "publicationDate": {
                        "title": "Published within",
                        "enum": [
                            "",
                            "24h",
                            "48h",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Only include listings published within this period.",
                        "default": ""
                    },
                    "propertyCodes": {
                        "title": "Property codes",
                        "type": "array",
                        "description": "Scrape specific properties by their Idealista code (the number in /inmueble/<code>/). Uses the Country selected above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencySlugs": {
                        "title": "Agency slugs",
                        "type": "array",
                        "description": "Scrape agency / professional profiles by slug (the part after /pro/ in the URL, e.g. 'gilmar-centro'). Uses the Country selected above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Scrape full detail for each result",
                        "type": "boolean",
                        "description": "For every search result, also open its property page to get the full description, all features, energy certificate, full photo gallery and coordinates. Slower and costs more requests.",
                        "default": true
                    },
                    "fetchContacts": {
                        "title": "Fetch advertiser / agency details",
                        "type": "boolean",
                        "description": "On detail pages, fetch the advertiser block (name, logo, microsite, agency id, reference). Reliable and recommended.",
                        "default": true
                    },
                    "fetchPhones": {
                        "title": "Reveal phone numbers",
                        "type": "boolean",
                        "description": "Reveal the advertiser's phone number for each property (returned as contactInfo.phone). Adds a few extra requests per property. Not every listing publishes a phone.",
                        "default": true
                    },
                    "scrapeAgencies": {
                        "title": "Output agencies instead of properties",
                        "type": "boolean",
                        "description": "For search URLs, return one row per unique agency/advertiser found (with profile details) instead of the properties.",
                        "default": false
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only new listings)",
                        "type": "boolean",
                        "description": "Only output listings not seen in previous runs of this Actor (tracked by property code). Great for daily alerts.",
                        "default": false
                    },
                    "splitByPrice": {
                        "title": "Bypass the ~1,800 result limit",
                        "type": "boolean",
                        "description": "Idealista limits a single search to ~1,800 results. Enable this to automatically split the search into price bands and collect far more results (deduplicated).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of records to output (0 = no limit).",
                        "default": 100
                    },
                    "endPage": {
                        "title": "Max pages per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop each search after this many result pages (0 = until the last page). ~30 results per page.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many properties/pages to process in parallel. Each parallel worker uses its own proxy IP. Higher = faster but more proxy traffic.",
                        "default": 5
                    },
                    "maxRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many times to rotate the proxy IP and retry when a request is blocked.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for scraping. Residential proxies are strongly recommended and the egress country is matched to the site automatically (Spain for .com, Italy for .it, Portugal for .pt).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
