# Habitaclia.com Spain Scraper (`logiover/habitaclia-com-spain-scraper`) Actor

Scrape real estate listings from Habitaclia.com — leading Spanish property portal owned by Adevinta, with deep coverage in Catalonia and major cities. Extract apartments, houses, attics, duplexes, offices, land and parking by region or city, with price (EUR), area (m²), rooms, location and images.

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

## Pricing

from $2.00 / 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

## Habitaclia.com Property Scraper

**Scrape real estate listings from Habitaclia.com — one of Spain's leading property portals**, owned by Adevinta (the same group behind Fotocasa). This Apify actor extracts apartments, houses, attics, duplexes, offices, commercial premises, land and parking spaces from any Spanish region or city, returning clean, structured JSON ready for analysis, dashboards or downstream pipelines.

Built for **real estate analysts, property investors, market researchers, data journalists and proptech teams** who need reliable, schema-stable Spanish property data without dealing with browsers, captchas or proxy rotation manually.

### Why Habitaclia

Habitaclia.com is part of the Adevinta network and has particularly **deep coverage in Catalonia** (Barcelona, Girona, Tarragona, Lleida) along with strong nationwide inventory in Madrid, Valencia, Sevilla, Málaga, Zaragoza, Bilbao and the Balearic & Canary Islands. Its long-running tenure as a regional Catalan portal means it often surfaces listings that don't appear on smaller national-only sites, making it a valuable complement to Idealista, Fotocasa and Pisos.com data.

### What gets scraped

For every listing card on a Habitaclia search page, the actor returns a complete record:

**Identity & links**
- `adId`, `detailUrl`, `title`, `shortDescription`

**Transaction & classification**
- `transactionType` — `sale` (comprar) or `rent` (alquiler)
- `propertyType` — `apartment` | `housing` | `house` | `attic` | `duplex` | `office` | `commercial` | `industrial` | `land` | `parking`

**Pricing**
- `price` (EUR), `priceCurrency`, `pricePerSqm`
- `priceDropValue`, `hasPriceDrop`

**Specifications**
- `areaSqm`, `usableAreaSqm`, `terrainAreaSqm`
- `rooms`, `roomsLabel`, `bathrooms`
- `floor`, `buildingCondition`, `yearBuilt`
- `energyClass`, `energyConsumption`, `energyEmissions`, `orientation`

**Location** (parsed and deduplicated)
- `country` (`ES`), `province`, `city`, `district`, `neighborhood`, `street`
- `fullAddress`, `latitude`, `longitude`

**Media & advertiser**
- `mainImageUrl`, `imageUrls`, `imageCount`
- `advertiserId`, `advertiserName`, `advertiserUrl`, `advertiserType` (agency / private)

**Boolean flags**
- `hasElevator`, `hasParking`, `hasGarage`, `hasTerrace`, `hasBalcony`, `hasAirConditioning`, `hasHeating`, `hasGarden`, `hasPool`, `hasStorage`, `hasFittedWardrobes`, `hasSeaView`, `isFurnished`, `isLuxury`, `isExterior`, `isFeatured`

**Provenance**
- `searchUrl`, `searchTransaction`, `searchPropertyType`, `searchLocation`, `searchKeyword`, `scrapedAt`, `labels`

### Common use cases

- **Market research & price benchmarking** — track median €/m² across neighborhoods over time, compare Barcelona Eixample vs Sant Gervasi, study Madrid Centro vs Salamanca premiums
- **Investment due diligence** — surface new listings matching specific yield, area, room or location criteria before they hit competitor portals
- **Lead generation for real-estate agencies** — feed CRM systems with curated, region-specific inventory
- **Academic & journalistic research** — quantify Spanish housing-market dynamics, gentrification, supply shocks
- **Real estate ML training data** — collect labeled property records for valuation models, recommendation engines or fraud detection
- **Portfolio monitoring** — track price drops on watched listings, alert on new inventory in target zones
- **Supply mapping for property tech** — populate map-based proptech apps with current Spanish listings

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `transactionType` | enum | `sale` | `sale` (comprar) or `rent` (alquiler) |
| `propertyType` | enum | `apartment` | One of: `apartment`, `housing`, `house`, `attic`, `duplex`, `office`, `commercial`, `industrial`, `land`, `parking` |
| `location` | string | `barcelona` | Habitaclia location slug. Lowercase ASCII, underscore for spaces. See examples below. |
| `minPrice`, `maxPrice` | int | — | Price range filter in EUR |
| `minArea`, `maxArea` | int | — | Surface area filter in m² |
| `minRooms`, `maxRooms` | int | — | Room-count filter |
| `advertiserType` | enum | `all` | `all`, `agency`, or `private` |
| `keyword` | string | — | Substring filter on title + description |
| `maxListings` | int | `200` | Hard cap on saved records |
| `maxPages` | int | `20` | Maximum search pages to crawl |
| `proxyConfiguration` | object | RESIDENTIAL ES | Apify proxy — RESIDENTIAL with `apifyProxyCountry: "ES"` strongly recommended |

#### Location slug reference

Common slugs that work directly with Habitaclia:

````

barcelona       madrid           valencia         sevilla
malaga          alicante         zaragoza         bilbao
palma\_de\_mallorca   girona       tarragona        lleida
murcia          granada          cordoba          valladolid
las\_palmas      santa\_cruz\_de\_tenerife            san\_sebastian

````

For specific municipalities use their slug too: `sant_cugat_del_valles`, `terrassa`, `sabadell`, `mataro`, `badalona`, `getafe`, `alcala_de_henares`, etc.

### URL convention

Habitaclia uses an offset-based pagination scheme:

| Page | URL pattern |
|---|---|
| 1 | `https://www.habitaclia.com/{prefix?}{ptype}-{location}.htm` |
| N (N>1) | `https://www.habitaclia.com/{prefix?}{ptype}-{location}-{N-1}.htm` |

Where `{prefix}` is empty for sale or `alquiler-` for rent. Worked examples:

- `/pisos-barcelona.htm` — apartments for sale in Barcelona, page 1
- `/pisos-barcelona-1.htm` — same, page 2
- `/alquiler-pisos-madrid.htm` — apartments for rent in Madrid
- `/casas-girona-3.htm` — houses for sale in Girona, page 4
- `/aticos-palma_de_mallorca.htm` — penthouses in Palma de Mallorca

### Output

One JSON record per listing, written to the default Apify dataset. Sample:

```json
{
  "adId": "10899004377662",
  "detailUrl": "https://www.habitaclia.com/comprar-piso-...-i10899004377662.htm",
  "title": "Piso en Calle aragó 79. Vea el tour virtual 3d en 4k",
  "transactionType": "sale",
  "propertyType": "apartment",
  "price": 599000,
  "priceCurrency": "EUR",
  "pricePerSqm": 4792,
  "areaSqm": 125,
  "rooms": 4,
  "bathrooms": 2,
  "country": "ES",
  "province": "Barcelona",
  "city": "Barcelona",
  "neighborhood": "La Nova Esquerra de l'Eixample",
  "street": "Calle aragó 79",
  "fullAddress": "Calle aragó 79, La Nova Esquerra de l'Eixample, Barcelona",
  "mainImageUrl": "https://images.habimg.com/imgh/10899-4377662/...jpg",
  "scrapedAt": "2026-05-06T11:46:40.892Z"
}
````

Export the dataset as JSON, CSV, Excel, XML, RSS or HTML directly from the Apify console, or stream it via the Apify API into BigQuery, Snowflake, Postgres or any data warehouse.

### Example runs

**Barcelona apartments, sale only, capped at 500 records**

```json
{
  "transactionType": "sale",
  "propertyType": "apartment",
  "location": "barcelona",
  "maxListings": 500,
  "maxPages": 35
}
```

**Madrid rentals between 1,000 € and 1,800 €**

```json
{
  "transactionType": "rent",
  "propertyType": "apartment",
  "location": "madrid",
  "minPrice": 1000,
  "maxPrice": 1800,
  "maxListings": 200
}
```

**Houses for sale on the Costa Brava, agency-listed only, 3+ bedrooms**

```json
{
  "transactionType": "sale",
  "propertyType": "house",
  "location": "girona",
  "minRooms": 3,
  "advertiserType": "agency",
  "maxListings": 1000
}
```

**Office space for rent in Valencia**

```json
{
  "transactionType": "rent",
  "propertyType": "office",
  "location": "valencia"
}
```

### Performance & reliability

- **HTTP-only fetching** with `got-scraping` — no headless browser, no Playwright overhead
- **Apify RESIDENTIAL proxy** with country pinned to `ES` for clean access
- **Per-attempt fresh proxy session ID** — automatic rotation on 403 / 429 / 503 / short-body responses
- **6-attempt exponential backoff** on transient proxy or upstream failures
- **Pagination loop detection** — auto-stops when the same first card repeats across pages
- **Thin-page guard** — auto-stops when later pages return fewer than 5 cards (end of inventory)
- **Polite 1.2 s delay** between page fetches to stay under rate limits

Typical throughput: **200 listings in roughly 90 seconds** on a 1 GB Apify actor instance.

### Diagnostic key-value entries

On the first page of every run, the actor writes diagnostic keys to the default key-value store, useful for selector calibration if Habitaclia ever changes its DOM layout:

- `debug_page1_html` — raw HTML response of page 1
- `debug_card1_html` — outer HTML of the first detected listing card
- `debug_card1_classes` — sorted list of every unique CSS class found inside that card
- `debug_card1_parsed` — parsed JSON for the first card

### FAQ

**Does this scraper work without Apify proxy?**
Habitaclia is hosted in the EU and tolerates clean datacenter traffic for small runs, but RESIDENTIAL ES proxy is strongly recommended for runs above 100 listings. The default input is pre-configured this way.

**How fresh is the data?**
Real-time. Each run fetches live listing pages directly — no caching, no third-party feed.

**Can I scrape the full listing detail pages?**
This actor is optimized for card-level extraction (which already returns 30+ fields per record). Detail-page enrichment (full description, all photos, energy certificate, agency contact, exact GPS) is a planned extension — open an issue if you need it.

**What about duplicate listings?**
The actor deduplicates by `adId` within a run. Cross-portal deduplication (same property listed on Idealista + Fotocasa + Habitaclia) is your responsibility — match on coordinates, area, price and street.

**Does it support custom search URLs?**
Currently the actor builds URLs from the structured input. Drop a feature request if you need to paste raw Habitaclia search URLs directly.

**What does `housing` mean?**
Habitaclia's `viviendas` (housing) bucket combines apartments + houses + attics + duplexes — useful when you want all residential inventory regardless of subtype.

### Legal & compliance

- Use this actor only for **publicly accessible data** that you have a lawful basis to collect under GDPR and Spanish data-protection law
- Respect Habitaclia's Terms of Service and `robots.txt`; throttle aggressive crawls
- Personal data (advertiser names, phone numbers) must be handled in accordance with applicable privacy regulations
- This actor is an independent project and is not affiliated with, endorsed by, or sponsored by Habitaclia.com or Adevinta

### Local development

```bash
git clone <this-repo>
cd habitaclia-com-scraper
npm install
apify run --purge
```

Modify `src/main.js` to adjust selectors or extend extraction. The diagnostic key-value entries make selector recalibration straightforward — inspect `debug_card1_html` and `debug_card1_classes` after any failed run.

### Changelog

- **0.1.0** — initial release: card-level extraction, sale/rent, all 10 property types, RESIDENTIAL ES proxy with 6-attempt retry, location parsing with street detection, deduplicated full-address output

### License

ISC.

# Actor input Schema

## `transactionType` (type: `string`):

Sale (comprar) or rent (alquiler).

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

Category of property to search.

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

Habitaclia location slug. Examples: 'barcelona', 'madrid', 'valencia', 'sevilla', 'malaga', 'alicante', 'zaragoza', 'bilbao', 'palma\_de\_mallorca', 'girona', 'tarragona', 'lleida'. Use lowercase ASCII; replace spaces with underscore. Province slugs work for province-wide searches; specific town slugs (e.g. 'sant\_cugat\_del\_valles') target one municipality.

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

Minimum price in EUR (client-side filter).

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

Maximum price in EUR (client-side filter).

## `minArea` (type: `integer`):

Minimum surface area in m² (client-side filter).

## `maxArea` (type: `integer`):

Maximum surface area in m² (client-side filter).

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

Minimum number of rooms (client-side filter).

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

Maximum number of rooms (client-side filter).

## `advertiserType` (type: `string`):

Filter by advertiser type (client-side).

## `keyword` (type: `string`):

Optional substring filter on title and description.

## `maxListings` (type: `integer`):

Hard cap on number of listings saved.

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

Maximum search pages to crawl. Habitaclia typically shows ~25 listings per page.

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

Apify proxy settings. RESIDENTIAL group with country=ES recommended.

## Actor input object example

```json
{
  "transactionType": "sale",
  "propertyType": "apartment",
  "location": "barcelona",
  "advertiserType": "all",
  "maxListings": 200,
  "maxPages": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Real estate listings scraped from Habitaclia.com.

# 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 = {
    "transactionType": "sale",
    "propertyType": "apartment",
    "location": "barcelona",
    "advertiserType": "all",
    "maxListings": 200,
    "maxPages": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "ES"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/habitaclia-com-spain-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 = {
    "transactionType": "sale",
    "propertyType": "apartment",
    "location": "barcelona",
    "advertiserType": "all",
    "maxListings": 200,
    "maxPages": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "ES",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/habitaclia-com-spain-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 '{
  "transactionType": "sale",
  "propertyType": "apartment",
  "location": "barcelona",
  "advertiserType": "all",
  "maxListings": 200,
  "maxPages": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}' |
apify call logiover/habitaclia-com-spain-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Habitaclia.com Spain Scraper",
        "description": "Scrape real estate listings from Habitaclia.com — leading Spanish property portal owned by Adevinta, with deep coverage in Catalonia and major cities. Extract apartments, houses, attics, duplexes, offices, land and parking by region or city, with price (EUR), area (m²), rooms, location and images.",
        "version": "0.0",
        "x-build-id": "yv7KtxEaomKjTtw31"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~habitaclia-com-spain-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-habitaclia-com-spain-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~habitaclia-com-spain-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-habitaclia-com-spain-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~habitaclia-com-spain-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-habitaclia-com-spain-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",
                "required": [
                    "transactionType",
                    "propertyType",
                    "location",
                    "maxListings",
                    "maxPages",
                    "proxyConfiguration"
                ],
                "properties": {
                    "transactionType": {
                        "title": "Transaction type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Sale (comprar) or rent (alquiler).",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "apartment",
                            "housing",
                            "house",
                            "attic",
                            "duplex",
                            "office",
                            "commercial",
                            "industrial",
                            "land",
                            "parking"
                        ],
                        "type": "string",
                        "description": "Category of property to search.",
                        "default": "apartment"
                    },
                    "location": {
                        "title": "Location slug",
                        "type": "string",
                        "description": "Habitaclia location slug. Examples: 'barcelona', 'madrid', 'valencia', 'sevilla', 'malaga', 'alicante', 'zaragoza', 'bilbao', 'palma_de_mallorca', 'girona', 'tarragona', 'lleida'. Use lowercase ASCII; replace spaces with underscore. Province slugs work for province-wide searches; specific town slugs (e.g. 'sant_cugat_del_valles') target one municipality.",
                        "default": "barcelona"
                    },
                    "minPrice": {
                        "title": "Min price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR (client-side filter)."
                    },
                    "maxPrice": {
                        "title": "Max price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR (client-side filter)."
                    },
                    "minArea": {
                        "title": "Min area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum surface area in m² (client-side filter)."
                    },
                    "maxArea": {
                        "title": "Max area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum surface area in m² (client-side filter)."
                    },
                    "minRooms": {
                        "title": "Min rooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum number of rooms (client-side filter)."
                    },
                    "maxRooms": {
                        "title": "Max rooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of rooms (client-side filter)."
                    },
                    "advertiserType": {
                        "title": "Advertiser type",
                        "enum": [
                            "all",
                            "agency",
                            "private"
                        ],
                        "type": "string",
                        "description": "Filter by advertiser type (client-side).",
                        "default": "all"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional substring filter on title and description."
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on number of listings saved.",
                        "default": 200
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum search pages to crawl. Habitaclia typically shows ~25 listings per page.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. RESIDENTIAL group with country=ES recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "ES"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
