# Immobiliare.it All-in-One Scraper — Italy Buy & Rent Listings (`khadinakbar/immobiliare-it-all-in-one-scraper`) Actor

Scrape immobiliare.it Italy real estate by city or search URL. Sale & rent. Price, m², locali, GPS, agency phone, images. Unblocker HTTP, MCP-ready, no login.

- **URL**: https://apify.com/khadinakbar/immobiliare-it-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 property scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Immobiliare.it All-in-One Scraper — Italy Buy & Rent Listings

Immobiliare.it All-in-One Scraper is an Apify Actor for collecting public Italy real-estate listings from Immobiliare.it. It accepts a city or area slug such as `milano` or `roma`, or a pasted Immobiliare search or detail URL, and returns one structured record per listing. Each record can include asking price, surface in m², locali (mapped to `rooms`), city, province, macrozone, GPS coordinates, agency name, agency phone, images, and the canonical listing URL. It runs over HTTP with Apify Unblocker Italy and is usable through Apify MCP.

### Best fit and connected workflows

This Actor fits workflows centered on Italian residential inventory from Immobiliare.it:

- Buy-side research from `vendita` searches, with price, m², locali, and agency contact fields
- Rental research from `affitto` searches, with monthly rent and size fields
- URL-driven collection when you already filtered on Immobiliare.it and want the Actor to follow that search
- Location-driven collection when you want the Actor to slugify a city such as Milano or Roma and run sale or rent filters
- CRM and spreadsheet import where one flat row per listing is the next step

If your workflow centers on another property market, these verified related Actors provide natural routing options:

- Then use [Fotocasa All-in-One Scraper](https://apify.com/khadinakbar/fotocasa-all-in-one-scraper) to extend Immobiliare.it All-in-One Scraper with a neighboring Spain buy/rent source when the brief calls for Fotocasa data
- Then use [Idealista Scraper](https://apify.com/khadinakbar/idealista-scraper) to extend Immobiliare.it All-in-One Scraper with a neighboring ES/IT/PT Idealista source when the brief calls for Idealista data
- Then use [Rightmove All-in-One Scraper](https://apify.com/khadinakbar/rightmove-all-in-one-scraper) to extend Immobiliare.it All-in-One Scraper with a neighboring UK BUY/RENT/SOLD source when the brief calls for Rightmove data

Immobiliare.it All-in-One Scraper — Italy Buy & Rent Listings is designed as a focused standalone workflow for Immobiliare.it Italy.

### Practical scenario

Marco is screening Milano apartments for sale under €400k for a relocation client. He sets `location` to `milano`, `operation` to `sale`, `maxPrice` to `400000`, and `maxItems` to `10`. The dataset returns fields such as `price`, `surfaceSqm`, `rooms`, `city`, `agencyPhone`, and `url`. Marco sorts by €/m², shortlists three macrozones, and opens each `url` to review photos before sharing a shortlist with the client. Auction listings stay out of the sample because `excludeAuctions` defaults to true.

### Input

Use either an Immobiliare.it URL in `startUrls` or a location-based search with `location` and `operation`.

| Field | Type | Purpose |
|---|---|---|
| `startUrls` | array | Immobiliare search (`/vendita-case/…`, `/affitto-case/…`) or detail (`/annunci/{id}/`) URLs. Search URLs are paginated until `maxItems`. |
| `location` | string | Italian city or area when `startUrls` is empty (for example milano, roma, torino). |
| `operation` | string | `sale` or `rent` for location mode. |
| `propertyType` | string | Category such as `home`, `commercial`, `land`, or `rooms`. |
| `minPrice` / `maxPrice` | integer | EUR filters (monthly rent for rent mode). |
| `minSurface` / `maxSurface` | integer | Floor-area filters in m². |
| `minRooms` / `maxRooms` | integer | Locali filters (Italian room count, not US bedrooms). |
| `excludeAuctions` | boolean | Default true — keep judicial auction inventory out of comps. |
| `fetchDetails` | boolean | Optional detail-page enrich for energy and bathroom attempts when present. |
| `maxItems` | integer | Cap on returned rows and property event charges. |
| `proxyConfiguration` | object | Prefer Apify Unblocker Italy for stable yield past DataDome. |

Focused input example:

```json
{
  "location": "milano",
  "operation": "sale",
  "maxItems": 10,
  "excludeAuctions": true,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["UNBLOCKER"],
    "apifyProxyCountry": "IT"
  }
}
```

URL-mode input example:

```json
{
  "startUrls": [
    { "url": "https://www.immobiliare.it/vendita-case/milano/" }
  ],
  "maxItems": 10
}
```

### Output

Each dataset item is one flat JSON record per listing. Download JSON, HTML, CSV, or Excel from the Dataset tab.

| Field | Type | Meaning |
|---|---|---|
| `listingId` | string | Immobiliare numeric listing identifier. |
| `url` | string | Canonical `/annunci/{id}/` listing URL. |
| `contract` | string | `sale` or `rent`. |
| `title` | string or null | Public listing title. |
| `price` | number or null | Asking price in EUR (monthly for rent). |
| `surfaceSqm` | number or null | Floor area in square metres. |
| `rooms` | integer or null | Locali count when published. |
| `city` / `province` / `macrozone` | string or null | Location labels. |
| `latitude` / `longitude` | number or null | GPS coordinates when published. |
| `agencyName` | string or null | Agency or advertiser name. |
| `agencyPhone` | string or null | Public agency phone when shown. |
| `images` | array | Photo URLs when published. |
| `scrapedAt` | string | Collection timestamp for the row. |

Illustrative JSON record:

```json
{
  "listingId": "131616220",
  "url": "https://www.immobiliare.it/annunci/131616220/",
  "contract": "sale",
  "title": "Appartamento via Example",
  "price": 285000,
  "surfaceSqm": 78,
  "rooms": 3,
  "city": "Milano",
  "province": "Milano",
  "macrozone": "Città Studi",
  "latitude": 45.46,
  "longitude": 9.18,
  "agencyName": "Agenzia Example",
  "agencyPhone": "02 1234567",
  "scrapedAt": "2026-09-22T09:00:00.000Z"
}
```

`OUTPUT` and `RUN_SUMMARY` in the default key-value store hold `outcome`, `itemsPushed`, and charge counts. Outcomes include `COMPLETE`, `VALID_EMPTY`, `INVALID_INPUT`, and `UPSTREAM_FAILED`.

### How it works

The Actor builds a vendita or affitto search path from `location`, or follows pasted Immobiliare.it URLs. It pages the public listings API (`/api-next/search-list/listings/`) until `maxItems` is reached, maps locali to `rooms`, and optionally enriches detail pages from `__NEXT_DATA__` when `fetchDetails` is on. Default Unblocker Italy keeps DataDome from emptying the run. Every terminal path writes `OUTPUT` and `RUN_SUMMARY` with an explicit outcome.

### Pricing

This Actor uses Apify Pay per event plus standard Apify platform usage (passed through to the caller, including Unblocker). Charged events:

- Actor start — $0.00005
- Property scraped — $0.005 per returned search listing
- Property detailed — $0.008 per detail-enriched listing when `fetchDetails` is on

Open the live Pricing tab in the Apify Console for the current source of truth. A run that returns ten search listings charges the start event once and the property-scraped event ten times, plus platform usage for compute and Unblocker.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as `apify--immobiliare-it-all-in-one-scraper`. Exact Actor identity: `khadinakbar/immobiliare-it-all-in-one-scraper`.

Tool shape: resolve an Italy city or Immobiliare.it URL, return flat listing rows with price, size, locali, agency phone, GPS, and URL for CRM or agent reasoning.

> Search Immobiliare.it for homes for sale in Milano, return price, surfaceSqm, rooms, city, agencyPhone, and url for each listing. Cap at 10 rows and keep auctions excluded.

Agent readback guidance:

- Dataset rows are the primary result store
- `OUTPUT` / `RUN_SUMMARY` carry the run outcome and counts
- `url` plus `scrapedAt` keep provenance inspectable
- `maxItems` bounds both yield and PPE charges
- Cost maps one returned search row to one `property-scraped` event; check the Pricing tab for live amounts alongside platform usage
- Invalid-only URLs finish `INVALID_INPUT`; empty niche inventory can finish `VALID_EMPTY` with zero property charges

### Apify API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("khadinakbar/immobiliare-it-all-in-one-scraper").call({
  location: "roma",
  operation: "rent",
  maxItems: 10,
  excludeAuctions: true,
  fetchDetails: false,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ["UNBLOCKER"],
    apifyProxyCountry: "IT",
  },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Best results and outcome guidance

Prefer Unblocker Italy (the default). Segment large cities by macrozone or price band instead of one oversized cap. Paste a ready-made Immobiliare.it search URL when filters are already set on the site. Leave `fetchDetails` off unless you specifically need detail-page energy or bathroom attempts. Treat `rooms` as Italian locali. Empty niche inventory can finish as `VALID_EMPTY` with zero property charges; paste-only non-Immobiliare URLs finish as `INVALID_INPUT`.

### Design note

I found that bare Residential and datacenter HTTP against Immobiliare.it serves DataDome challenge pages before any listing JSON appears, so Unblocker Italy is the durable default for complete listing runs. Geography autocomplete also needs browser cookies, so location mode slugifies the city into `/vendita-case/{slug}/` or `/affitto-case/{slug}/` and pages the listings API — that is what keeps Milano sale and Roma rent canaries complete on the private release build.

### Troubleshooting and recovery

| Symptom | Likely cause | Recovery |
|---|---|---|
| Empty dataset with DataDome challenge pages in logs | Proxy group still set to Residential or datacenter | Set `proxyConfiguration` to Unblocker Italy and rerun |
| `INVALID_INPUT` with zero charges | startUrls contain only non-Immobiliare hosts | Paste a `/vendita-case/`, `/affitto-case/`, or `/annunci/{id}/` URL, or set `location` |
| `VALID_EMPTY` on a niche filter | No public inventory for that city/filter band | Widen price/surface/locali, try a larger city, or paste a known search URL |
| Detail energy/baths missing with `fetchDetails` | Field omitted on that public listing page | Keep search-card fields; treat detail enrich as best-effort |
| Deep pagination returns fewer pages than expected | Portal page-depth ceiling for that search | Segment by macrozone or price band instead of one large `maxItems` |

### FAQ

**How do I scrape rentals instead of sales?**\
Set `operation` to `rent`, or paste an `affitto-case` search URL into `startUrls`.

**How do I scrape a single listing?**\
Paste a detail URL ending in `/annunci/{id}/` into `startUrls`.

**How do I keep agency outreach fields?**\
Use the default search path; `agencyName` and `agencyPhone` are returned when Immobiliare.it publishes them on the card.

**How do I bound cost?**\
Set `maxItems` to the number of listings you need; each accepted search row maps to one property-scraped event.

### Responsible use

Use this Actor on public Immobiliare.it listing data you are authorized to process, follow applicable law and Immobiliare.it terms, and keep the output in your own compliance workflow. Keep returned phones inside lawful, consented outreach workflows. Immobiliare.it is a trademark of its respective owners. This independent Actor is not affiliated with, associated with, or endorsed by Immobiliare.it or Idealista Group.

Issues and feature requests: use the Actor Issues tab on Apify.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/immobiliare-it-all-in-one-scraper/changelog.md

# Actor input Schema

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

Immobiliare.it search or listing URLs. Search examples: https://www.immobiliare.it/vendita-case/milano/ or https://www.immobiliare.it/affitto-case/roma/. Detail URLs look like https://www.immobiliare.it/annunci/123456789/. When set, location/operation filters below are ignored for those URLs.

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

Italian city or area when Start URLs is empty (e.g. milano, roma, torino, firenze). Slugified into /vendita-case/{slug}/ or /affitto-case/{slug}/. Ignored when Start URLs is set.

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

Sale (vendita) or rent (affitto) when using Location mode. Ignored when Start URLs already encode vendita/affitto. Defaults to sale.

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

Category for Location mode. home = case (default). commercial/land/rooms map to Immobiliare path families.

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

Minimum asking price in EUR. For rent this is monthly rent. Leave empty for no minimum.

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

Maximum asking price in EUR. For rent this is monthly rent. Leave empty for no maximum.

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

Minimum floor area in square metres.

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

Maximum floor area in square metres.

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

Minimum number of locali (Italian room count — not the same as bedrooms).

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

Maximum number of locali.

## `excludeAuctions` (type: `boolean`):

Skip auction listings that skew prices. Default true (noAste=1).

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

Open each listing detail page for energy class, baths, floor, and longer description when present. Slower and charges property-detailed instead of property-scraped. Default false — search cards already include price, m², locali, agency phone, and images.

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

Hard cap on dataset rows and named PPE charges. Each search page returns about 25 listings. Defaults to 50. Maximum 5000.

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

Apify proxy settings. Default is Unblocker Italy — Immobiliare uses DataDome and blocks bare Residential/datacenter HTTP. Keep Unblocker IT unless you have a working alternate.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.immobiliare.it/vendita-case/milano/"
    }
  ],
  "location": "milano",
  "operation": "sale",
  "propertyType": "home",
  "excludeAuctions": true,
  "fetchDetails": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ],
    "apifyProxyCountry": "IT"
  }
}
```

# Actor output Schema

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

Default dataset with one Immobiliare.it property per row.

## `OUTPUT` (type: `string`):

Terminal outcome record (COMPLETE, VALID\_EMPTY, INVALID\_INPUT, UPSTREAM\_FAILED).

## `RUN_SUMMARY` (type: `string`):

Same terminal outcome as OUTPUT for agent-friendly readback.

# 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.immobiliare.it/vendita-case/milano/"
        }
    ],
    "location": "milano",
    "operation": "sale",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ],
        "apifyProxyCountry": "IT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/immobiliare-it-all-in-one-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.immobiliare.it/vendita-case/milano/" }],
    "location": "milano",
    "operation": "sale",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
        "apifyProxyCountry": "IT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/immobiliare-it-all-in-one-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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.immobiliare.it/vendita-case/milano/"
    }
  ],
  "location": "milano",
  "operation": "sale",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ],
    "apifyProxyCountry": "IT"
  }
}' |
apify call khadinakbar/immobiliare-it-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/immobiliare-it-all-in-one-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nFtDuqa7WOlXVwauo/builds/feQVXXkzVGUjhxP6a/openapi.json