# Subito Real Estate Scraper (`epicscrapers/subito-realestate-scraper`) Actor

Scrape subito.it real estate listings.

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

## Pricing

from $2.00 / 1,000 listings

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

## 🏠 Subito Real Estate Scraper

**Scrape thousands of real estate listings from Subito.it — Italy's largest classifieds marketplace — with structured output, automatic pagination, optional enrichment, and built-in proxy support.**

---

### What It Does

This Actor connects to Subito.it's internal API (the same one the Android app uses) to extract real estate listings across all 8 property subcategories — apartments, villas, rooms, land, garages, lofts, holiday homes, and commercial spaces. It handles pagination automatically, resolves search URLs, enriches listings with phone numbers and seller info, and outputs clean JSON ready for analysis.

### Who It's For

Real estate analysts, property investors, market researchers, lead generation teams, and anyone who needs Subito.it listing data at scale without writing custom scrapers or dealing with anti-bot protection.

---

### Key Benefits

| Instead of... | This Actor... |
|---|---|
| Manually clicking through pages on Subito.it | Scrapes thousands of listings in one run with automatic pagination |
| Writing a custom scraper that breaks every week | We maintain the scraper for you |
| Getting blocked and needing to rotate proxies | Built-in Apify proxy with Italian residential IPs |
| Copy-pasting phone numbers one by one | Optional phone number extraction built-in |
| Wondering if a seller is trustworthy | Optional seller badges, listing history, and shop details |
| Parsing messy HTML | Clean structured JSON with all real estate features extracted |

---

### Features

#### Input & Search

| Feature | Advantage | Benefit |
|---|---|---|
| **Start URLs** | Paste any Subito.it search URL, detail URL, or API URL | Start scraping in 10 seconds without configuring filters |
| **Keyword search** | Add keywords like "centro Milano trilocale" | Find exactly what you need, even without a URL |
| **Property filters** | 11+ filter options (region, price, surface, rooms, floor, energy class, seller type, more) | Narrow results precisely — no post-processing needed |
| **Multiple queries** | Run URLs and keywords in a single execution | Combine different searches in one run |
| **Max results control** | Limit results per query | Stay within API budgets and run predictable costs |

#### Data Extraction

| Feature | Advantage | Benefit |
|---|---|---|
| **Structured real estate fields** | Surface area, rooms, bathrooms, floor, energy class, heating, building condition, parking, balcony, garden, elevator, and more | Every real estate feature is extracted as a typed field — no regex or HTML parsing |
| **Category-specific fields** | CIN code for holiday rentals, room type / gender / smoking for shared rooms, office type for commercial spaces | Complete data for every property subcategory |
| **Price formatting** | Extracted as both raw number and Italian-formatted string | Ready for analysis and comparison |
| **Image URLs** | All listing images as CDN URLs | Build image galleries, train ML models, or archive listings |
| **Geo data** | City, province, region | Map listings or filter by location programmatically |

#### Enrichment

| Feature | Advantage | Benefit |
|---|---|---|
| **Phone numbers** | Fetches seller phone via Subito's contact endpoint | Build lead lists directly — no manual lookup |
| **Shop details** | Shop name, address, logo, website, listing count for professional sellers | Identify agencies, compare portfolio sizes |
| **Seller account info** | Badges (verified, premium), total listings, first listing date | Assess seller trustworthiness at a glance |

#### Reliability & Performance

| Feature | Advantage | Benefit |
|---|---|---|
| **Automatic retries** | 4 retries with exponential backoff + jitter | Survives rate limits and temporary failures |
| **Proactive rate limiting** | 150ms minimum gap between requests | Avoids triggering Subito's rate limits |
| **Concurrent enrichment** | Processes 5 ads in parallel per page | Faster enrichment without overwhelming the API |
| **Graceful exhaustion** | Stops charging when budget runs out, exits cleanly | No surprise failed runs or overcharges |
| **Proxy support** | Apify proxy with Italian residential IPs | Works reliably at scale with minimal blocking |

---

### Example Output

```json
{
  "request_url": "https://www.subito.it/annunci-lazio/vendita/immobili/appartamenti/roma",
  "category": "Immobili",
  "sub_category": "Appartamenti",
  "sub_category_slug": "appartamenti",
  "type": "In vendita",
  "type_key": "s",
  "publication_date": {
    "iso": "2026-07-07T14:30:00.000Z",
    "date": "2026-07-07",
    "time": "14:30:00",
    "timestamp": 1751812200000,
    "local": "7 luglio 2026 alle ore 14:30"
  },
  "advertiser_type": "privato",
  "advertiser_name": "Mario Rossi",
  "page_url": "https://www.subito.it/annunci-lazio/vendita/immobili/appartamenti/roma/monolocale-parioli-123456789.htm",
  "title": "Monolocale in zona Parioli",
  "description": "Bellissimo monolocale ristrutturato situato in zona Parioli...",
  "geo": {
    "city": "Roma",
    "province": "Roma",
    "province_code": "RM",
    "region": "Lazio"
  },
  "features": {
    "price": {
      "value": 185000,
      "formatted": "185.000 €",
      "label": "Prezzo"
    },
    "surface": {
      "value": 55,
      "unit": "mq",
      "formatted": "55 mq"
    },
    "rooms": 2,
    "bathrooms": 1,
    "floor": "3",
    "building_condition": "Ottimo - ristrutturato",
    "energy_class": "D",
    "heating": "Autonomo",
    "elevator": true,
    "balcony": true,
    "furnished": true
  },
  "images": [
    "https://img-subito.kwcdn.com/v1/...",
    "https://img-subito.kwcdn.com/v1/..."
  ],
  "advertiser_shop_data": {
    "name": "Agenzia Immobiliare XYZ",
    "shop_id": "abc123",
    "listing_count": null
  },
  "features_raw": [ ... ]
}
````

With enrichment enabled, additional fields appear:

```json
{
  "phone_number": "+39 345 1234567",
  "advertiser_shop_data": {
    "name": "Agenzia Immobiliare XYZ",
    "shop_categories": ["Vendita", "Affitto"],
    "address": "Via Roma 1, Roma, Lazio",
    "listing_count": 47,
    "impresapiu_shop_page": "https://www.subito.it/agenzie/xyz",
    "website": "https://www.agenziaxyz.it",
    "logo": "https://img-subito.kwcdn.com/..."
  },
  "advertiser_account": {
    "user_id": "user_abc",
    "first_ad_insertion_date": "2020-03-15",
    "total_num_approved_ads": 89,
    "badges": [
      {
        "name": "verified",
        "description": "Account verificato",
        "is_active": true
      },
      {
        "name": "premium",
        "description": "Utente premium",
        "is_active": false
      }
    ]
  }
}
```

***

### Input Options

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | `string[]` | `[]` | Subito.it search URLs, detail URLs, or direct API URLs. Paste URLs from the browser — filters are extracted automatically. |
| `searchKeywords` | `string[]` | `[]` | Free-text keywords to search (e.g. `"centro Milano trilocale"`, `"villa giardino piscina"`). Each keyword runs as a separate search. |
| `propertyType` | `string` | `"appartamenti"` | One of: `appartamenti`, `camere-posti-letto`, `ville-singole-e-a-schiera`, `terreni-e-rustici`, `garage-e-box`, `loft-e-mansarde`, `case-vacanza`, `uffici-locali-commerciali`. Leave empty for all types. |
| `adType` | `string` | `""` | `s` = sale, `u` = rent, `h` = holiday rental. Leave empty for all. |
| `advertiserType` | `string` | `""` | `private` = only private sellers, `professional` = only agencies. Leave empty for both. |
| `region` | `string` | `""` | Italian region slug (e.g. `lombardia`, `lazio`, `sicilia`). See schema for full list. Leave empty for all Italy. |
| `minPrice` | `integer` | — | Minimum price in € |
| `maxPrice` | `integer` | — | Maximum price in € |
| `minSurface` | `integer` | — | Minimum surface area in m² |
| `maxSurface` | `integer` | — | Maximum surface area in m² |
| `minRooms` | `integer` | — | Minimum number of rooms |
| `maxRooms` | `integer` | — | Maximum number of rooms |
| `floor` | `string` | — | Preferred floor (`1`–`7`). `1` = ground floor. |
| `energyClass` | `string` | — | Energy class filter (e.g. `A4`, `B`, `D`, `G`) |
| `maxItemsPerQuery` | `integer` | `100` | Maximum listings per URL or keyword. `0` = unlimited. |
| `enrichPhone` | `boolean` | `false` | Fetch seller phone numbers (extra API call per listing) |
| `enrichShop` | `boolean` | `false` | Fetch shop details for professional sellers |
| `enrichUserAccount` | `boolean` | `false` | Fetch seller badges, total listings, account age |
| `proxyConfiguration` | `proxy` | Apify IT residential | Proxy configuration. Defaults to Italian residential proxies. |

#### Quick Start Examples

| You want... | Input |
|---|---|
| Apartments for sale in Milan | `startUrls: ["https://www.subito.it/annunci-lombardia/vendita/immobili/appartamenti/"]` |
| Houses with pool under €500k in Tuscany | `startUrls: ["https://www.subito.it/annunci-toscana/vendita/immobili/ville-singole-e-a-schiera/?pr=,500000&q=piscina"]` |
| Rentals near a specific address | `searchKeywords: ["trilocale corso venezia milano affitto"]` |
| All garages in Rome on sale | `propertyType: "garage-e-box"`, `region: "lazio"`, `adType: "s"` |
| Holiday homes in Sicily with phone numbers | `propertyType: "case-vacanza"`, `region: "sicilia"`, `adType: "h"`, `enrichPhone: true` |
| A single listing detail page | `startUrls: ["https://www.subito.it/...qualche-annuncio-123456789.htm"]` |

***

### Common Use Cases

#### 🏘️ Market Research

Track property prices, listing volumes, and trends across Italian regions and property types. Run weekly to build a historical dataset.

#### 💰 Price Monitoring

Monitor specific segments (e.g. 2-room apartments in Rome under €200k). Set a max price and run daily to catch new listings.

#### 👥 Lead Generation

Extract contact information from listings with `enrichPhone: true`. Build prospect lists for agencies or investors.

#### 📊 Inventory Tracking

Track how many listings a specific agency has active, what properties they offer, and at what prices — useful for competitive analysis.

#### 🔍 Niche Searching

Find specific features (garage, garden, elevator) in combination with price and location — Subito's web search can't combine all these filters on mobile; this Actor can.

***

### Why This Actor?

**It talks to the Subito API directly.** Unlike HTML scrapers that parse rendered pages and break every time Subito updates its markup, this Actor uses the same API endpoints as the Android app. API responses are stable, structured JSON.

**It's built for real estate.** Instead of a generic scraper that treats every listing as title + price + description, this Actor extracts 25+ property-specific fields: surface area, rooms, bathrooms, floor, energy class, heating type, building condition, parking types, balcony, garden, elevator, furnished status, and more.

**It's reliable at scale.** Exponential backoff retries, proactive rate limiting, concurrent enrichment, and a shared throttle across all requests mean the Actor behaves well even on large runs and doesn't burn through your budget on retries.

**It's transparent.** Pay-per-event pricing means you only pay for what you use. The Actor exits gracefully when the budget is exhausted instead of failing mid-run.

***

### FAQ / Common Issues

#### Does it require proxies?

No — the Actor works without proxies. However, if you're scraping at scale, it's recommended to use Apify's Italian residential proxies (enabled by default). The Actor automatically routes all requests through the configured proxy.

#### Can it scrape ALL listings?

It scrapes everything Subito's search API returns. Subito limits search results to a maximum number of pages for any single query. To get more results, use multiple more specific queries (narrower region, different property types, multiple keywords).

#### Does it support Italian regions?

Yes — all 20 Italian regions are supported via the `region` parameter. City-level filtering is available through URLs (pasting a Subito URL that already has a city filter).

#### Does it require login?

No. All API endpoints used by this Actor are public. No cookies, no authentication, no session management needed.

#### How much does it cost?

The Actor uses Apify's pay-per-event model:

- **`listing-scraped`** — always charged (one unit per listing pushed to the dataset)
- **`phone-number-enriched`** — charged when a phone number is retrieved
- **`shop-details-enriched`** — charged when shop details are retrieved
- **`seller-account-enriched`** — charged when seller account info is retrieved

If you don't enable enrichment, you pay only for the listings. Set `maxItemsPerQuery` to control how many listings are scraped per run.

#### What happens if Subito changes their API?

The Actor uses the same API as the Android app, which is backwards-compatible by design. Major API changes are extremely rare. If something breaks, enrichment failures are handled silently so the rest of the run completes.

#### Can I scrape a single listing detail page?

Yes — paste the detail URL (ending in `-123456789.htm`) into `startUrls`. The Actor detects it automatically and fetches that single ad by its numeric ID.

#### What if a URL doesn't work?

The Actor has three fallback mechanisms for URLs: (1) direct API URL passthrough, (2) Subito's deeplink resolver, and (3) a built-in URL parser that extracts region, ad type, category, and query parameters from the URL path. Usually at least one succeeds.

***

### Try It

1. **Paste a URL** — Copy any Subito.it real estate search URL into `startUrls`
2. **Add filters** — Narrow by region, price, surface, rooms
3. **Enable enrichment** — Turn on phone numbers, shop details, or seller account info
4. **Run it** — Hit "Start" and get clean JSON in seconds

```bash
## Or run locally with Apify CLI
apify run --input my-search.json
```

Built for [Apify](https://apify.com). Works on the Apify platform and locally with the Apify CLI.

# Actor input Schema

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

Subito.it URLs or direct API endpoints. Supports search URLs (e.g. /annunci-lazio/vendita/immobili/appartamenti/), filtered URLs (?q=centro+milano), listing detail URLs etc. Leave empty if you use the keywords or filters below.

## `searchKeywords` (type: `array`):

One or more keywords to search for (e.g. 'centro Milano trilocale', 'villa giardino'). Each keyword becomes a separate search. The filters below (property type, region, price, surface, rooms) are shared across all keywords.

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

Type of real estate property.

## `adType` (type: `string`):

Filter by sale, rent, or holiday rental.

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

Show only listings from private sellers or professional/agencies. Applies to keyword searches and filter browsing; startUrls already carry their own filters.

## `region` (type: `string`):

Filter by Italian region.

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

Minimum price in Euro.

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

Maximum price in Euro.

## `minSurface` (type: `integer`):

Minimum property surface area in square meters.

## `maxSurface` (type: `integer`):

Maximum property surface area in square meters.

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

Minimum number of rooms (locali).

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

Maximum number of rooms (locali).

## `floor` (type: `string`):

Filter by floor number.

## `energyClass` (type: `string`):

Filter by energy class (A4, A3, A2, A1, B, C, D, E, F, G). Enter the class letter or range.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of listings to extract per URL or keyword. 0 = no limit.

## `enrichPhone` (type: `boolean`):

Retrieve the seller's phone number for each listing (requires an extra request per listing).

## `enrichShop` (type: `boolean`):

Retrieve shop details (address, logo, website, listing count) for professional seller listings.

## `enrichUserAccount` (type: `boolean`):

Retrieve the seller account's public information (badges, total listings count, date of first listing).

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

Apify proxy configuration.

## Actor input object example

```json
{
  "propertyType": "appartamenti",
  "maxItemsPerQuery": 100,
  "enrichPhone": false,
  "enrichShop": false,
  "enrichUserAccount": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/subito-realestate-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IT",
    } }

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/subito-realestate-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IT"
  }
}' |
apify call epicscrapers/subito-realestate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Subito Real Estate Scraper",
        "description": "Scrape subito.it real estate listings.",
        "version": "0.0",
        "x-build-id": "IkqKE5WsaPQjdp5pn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~subito-realestate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-subito-realestate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/epicscrapers~subito-realestate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-subito-realestate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/epicscrapers~subito-realestate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-subito-realestate-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Subito.it URLs or direct API endpoints. Supports search URLs (e.g. /annunci-lazio/vendita/immobili/appartamenti/), filtered URLs (?q=centro+milano), listing detail URLs etc. Leave empty if you use the keywords or filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more keywords to search for (e.g. 'centro Milano trilocale', 'villa giardino'). Each keyword becomes a separate search. The filters below (property type, region, price, surface, rooms) are shared across all keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "",
                            "appartamenti",
                            "camere-posti-letto",
                            "ville-singole-e-a-schiera",
                            "terreni-e-rustici",
                            "garage-e-box",
                            "loft-e-mansarde",
                            "case-vacanza",
                            "uffici-locali-commerciali"
                        ],
                        "type": "string",
                        "description": "Type of real estate property.",
                        "default": "appartamenti"
                    },
                    "adType": {
                        "title": "Transaction type",
                        "enum": [
                            "",
                            "s",
                            "u",
                            "h"
                        ],
                        "type": "string",
                        "description": "Filter by sale, rent, or holiday rental."
                    },
                    "advertiserType": {
                        "title": "Seller type",
                        "enum": [
                            "",
                            "private",
                            "professional"
                        ],
                        "type": "string",
                        "description": "Show only listings from private sellers or professional/agencies. Applies to keyword searches and filter browsing; startUrls already carry their own filters."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "",
                            "abruzzo",
                            "basilicata",
                            "calabria",
                            "campania",
                            "emilia-romagna",
                            "friuli-venezia-giulia",
                            "lazio",
                            "liguria",
                            "lombardia",
                            "marche",
                            "molise",
                            "piemonte",
                            "puglia",
                            "sardegna",
                            "sicilia",
                            "toscana",
                            "trentino-alto-adige",
                            "umbria",
                            "valle-d-aosta",
                            "veneto"
                        ],
                        "type": "string",
                        "description": "Filter by Italian region."
                    },
                    "minPrice": {
                        "title": "Minimum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in Euro."
                    },
                    "maxPrice": {
                        "title": "Maximum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in Euro."
                    },
                    "minSurface": {
                        "title": "Minimum surface (mq)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum property surface area in square meters."
                    },
                    "maxSurface": {
                        "title": "Maximum surface (mq)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum property surface area in square meters."
                    },
                    "minRooms": {
                        "title": "Minimum rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of rooms (locali)."
                    },
                    "maxRooms": {
                        "title": "Maximum rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rooms (locali)."
                    },
                    "floor": {
                        "title": "Floor",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7"
                        ],
                        "type": "string",
                        "description": "Filter by floor number."
                    },
                    "energyClass": {
                        "title": "Energy class",
                        "type": "string",
                        "description": "Filter by energy class (A4, A3, A2, A1, B, C, D, E, F, G). Enter the class letter or range."
                    },
                    "maxItemsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per URL or keyword. 0 = no limit.",
                        "default": 100
                    },
                    "enrichPhone": {
                        "title": "Phone numbers",
                        "type": "boolean",
                        "description": "Retrieve the seller's phone number for each listing (requires an extra request per listing).",
                        "default": false
                    },
                    "enrichShop": {
                        "title": "Shop details",
                        "type": "boolean",
                        "description": "Retrieve shop details (address, logo, website, listing count) for professional seller listings.",
                        "default": false
                    },
                    "enrichUserAccount": {
                        "title": "Seller account info",
                        "type": "boolean",
                        "description": "Retrieve the seller account's public information (badges, total listings count, date of first listing).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy configuration.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IT"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
