# Italy Real Estate Market Data API - Prices, Sales, Forecasts (`nabeelbaghoor/italy-real-estate-market-data-api`) Actor

Italian real estate market data by region, province, municipality or micro-zone: listing prices and history, price forecasts, listings stock, transaction prices and volumes, and buyer and tenant demand, for sale and rent. Read only. Pay per result. Bring your own credentials.

- **URL**: https://apify.com/nabeelbaghoor/italy-real-estate-market-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 market record returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Italy Real Estate Market Data API - Prices, Sales, Forecasts

Turn a list of Italian regions, provinces, municipalities or micro-zones into a dataset of asking prices, sale prices, sales volumes, price forecasts and buyer demand, for sale or rent.

### What it collects

- **Listing prices**: average, minimum and maximum price per square metre, average, minimum and maximum asking price, negotiation margin, price elasticity and variability, each with its change over the window and its ranking among sibling zones, plus 10th to 90th percentile prices by typology, room count and maintenance condition.
- **Price history and forecast**: quarterly time series of listing prices by room count and condition, and a five year forecast of the average price per square metre with its 95 percent range, either as one average or split by high, medium and low energy class.
- **Listings stock**: number of listings, time on market, time to sell, absorption index and stock renewal, with their history.
- **Transactions**: sale prices per square metre and average sale price from processed land registry (Agenzia delle Entrate) data, percentiles by cadastral category, number of sales (NTN), turnover, average surface and surface classes, with their history.
- **Demand**: share of searches and views in the area, conversion rate, average leads per listing, searched surface and spending propensity, split by typology and condition, with their history.
- **Zones and vocabularies**: every region, province, municipality, macro-zone or micro-zone with its ID, the zones inside a given zone, the request codes, and the months for which data and transaction data are available.

### How to use it

1. Pick a service. If you do not know the zone ID you need, run **Zones - every zone of one type** with zone type Region, then **Zones - inside each given zone** on the region you want, and so on down to municipality or micro-zone.
2. Put one zone per line in **Zone IDs**: a bare ID read with the zone type input, or `type:id` such as `reg:3` or `com:100005` to mix types in one run.
3. Set the **contract** (sale or rent), the **time window**, the **year** and the **month**. A quarterly window only ends in March, June, September or December, a semiannual one in June or December, an annual one in December. The actor refuses any other month before spending a call, because the provider does too.
4. Optionally narrow by **property typology** (listing services), **cadastral category** (transaction services) or **forecast segmentation** (price forecast). A filter the selected service does not document is left off with a warning rather than sent.
5. Add your credentials and press Start.

### Example output

```json
{
  "service": "price",
  "serviceLabel": "Listing prices",
  "endpoint": "/api/price",
  "zoneType": "com",
  "zoneId": "100005",
  "window": "1M",
  "year": 2024,
  "month": 12,
  "contract": 1,
  "found": true,
  "recordType": "market",
  "requestId": "1eb7d444-17a7-4808-83e7-8b6ba3c51637",
  "retrievedAt": "2026-09-25T10:14:52.118Z",
  "record": {
    "price_sqm_avg": { "value": 2131, "delta": { "value": 0.76, "window": "1M" }, "ranking": { "of": 7, "position": 3 } },
    "discount": { "value": 8.4, "delta": { "value": 0.0, "window": "1M" }, "ranking": { "of": 7, "position": 1 } },
    "rooms": { "2": { "price_10pc": 1737, "price_50pc": 2574, "price_90pc": 3452 } },
    "...": "every other field the provider published, unchanged"
  },
  "note": null
}
```

### FAQ

#### What is an Italian real estate market data API used for?

Pricing and screening across Italy at a scale that portal browsing cannot reach. A lender or valuer reads price per square metre and its percentiles for every municipality in a portfolio. An investor compares transaction prices, sales volumes and absorption across provinces to find where the market is moving. A developer reads demand, searched surface and time on market before committing to a site. A proptech product puts price history and five year forecasts behind its own screens. The common shape is a list of zones in and a table of market facts out.

#### Where does the data come from?

The listing, stock and demand services are built from the listings and search activity of a large Italian property portal. The transaction services are built from processed Agenzia delle Entrate (Italian revenue agency) sales data, which is why they are filtered by cadastral category rather than by listing typology.

#### How do I find a zone ID?

Run the zones service. With zone type Region it lists the twenty Italian regions with their IDs (Lombardia is 3, Lazio is 12). The zones-inside service then lists the provinces of a region, the municipalities of a province, and so on. Those IDs go straight into the Zone IDs input of any market service.

#### What happens to a zone with no data?

It becomes its own row, marked `found: false`, with the provider's own reason in `note`. A run over fifty municipalities therefore returns fifty rows, and you can see at a glance which ones had nothing for that period. Rows without data are never charged.

#### Which period should I ask for?

Run the available periods service first. It lists, month by month, whether listing data, transaction data and energy class data exist. Transaction data lags listing data, so a month that answers the listing prices service may not yet answer the transaction services.

#### Can this actor change anything on my account?

No. Every route it can reach reads data. The provider's appraisal product on the same documentation portal also has routes that insert and update appraisal records, and none of them is wired into this actor. Signing in exchanges your credentials for a token and creates nothing.

#### Do I need an API key?

Yes. This actor is bring-your-own-key and never ships a credential of its own. The provider signs in with an OAuth password grant, so you have two options. Paste an access token you already have into the API key field (or set it as the DATA\_API\_KEY environment secret); tokens last four hours. Or give the client ID, client secret, username and password from your provider contract, and the actor signs in once at the start of the run and reuses the token, because the provider warns that signing in before every request can get an account temporarily blocked. All credential fields are stored as secrets. Without any credential the run ends cleanly with a message saying what to add.

#### Why is the provider's record kept whole instead of split into columns?

Because each service answers in its own nested shape, and the provider states that new fields can be added at any time. The columns that are lifted are the ones every row has: which service answered, the zone type and ID, the window, year, month and contract it was asked with, whether anything came back, and the provider's own request ID. The full answer sits beside them under `record`, unchanged.

#### What does it cost?

Pay per result. A market reading about one zone and period is the main event. A zone from a zone listing and a reference vocabulary are priced well below it, because they are what you read before spending anything on market data. Zones with no data are never charged.

### Keyword map

Italy real estate API, Italian property data API, Italy house prices API, prezzi immobili API, price per square metre Italy, Italian property market data, Agenzia delle Entrate transaction data, compravendite API, NTN sales volume Italy, Italy rent prices API, affitti prezzi API, property price forecast Italy, Italian real estate demand data, listings stock Italy, time on market Italy, cadastral category prices, microzone property prices, municipality house prices Italy, Milan property prices API, Rome property prices API, proptech data Italy, real estate market intelligence Italy.

# Actor input Schema

## `service` (type: `string`):

One service per run. Market services answer with one record per zone for the period you set. The zone services list zone IDs, which are what the market services are asked with: start there if you do not know the ID of a municipality or micro-zone. The reference services read the request vocabularies and the months for which data exists.

## `zoneIds` (type: `array`):

One zone per line. Give a bare ID, read with the zone type below, or type:id to name the type on the line, for example reg:3 for Lombardia or com:100005 for one municipality. Used by every market service and by the zones-inside service. Get IDs from the zone services.

## `zoneType` (type: `string`):

The zone type for bare IDs, and the type to list for the zones service. The provider documents region, province, municipality, macro-zone and micro-zone.

## `contract` (type: `string`):

Sale or rent. Required by every market service.

## `window` (type: `string`):

The length of the period each reading covers. The provider ends a quarterly period in March, June, September or December, a semiannual one in June or December, and an annual one in December, and refuses other months.

## `year` (type: `integer`):

The year of the period. Use the available periods service to see which months have data, and which have transaction data.

## `month` (type: `integer`):

The month the period ends in, 1 to 12, and allowed by the time window above.

## `typology` (type: `string`):

Restrict listing based readings to one property typology. Accepted by the listing prices, price history, price forecast, listings stock and demand services.

## `cadastralTypology` (type: `string`):

Restrict transaction based readings to one land registry category. Accepted by the transaction prices, transaction volumes and their history services.

## `segmentation` (type: `string`):

Split the price forecast by energy class (high, medium and low) instead of one average. Accepted by the price forecast service only.

## `nation` (type: `string`):

The provider documents Italy only.

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

Stop after this many rows. A zone listing of micro-zones can return thousands of records, so this is what bounds a run.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling. The provider does not publish a rate limit, so the default is modest. A rate limit refusal is retried with backoff.

## `apiKey` (type: `string`):

An access token from your own provider account, if you already have one. Tokens last four hours. Leave blank to use the DATA\_API\_KEY environment secret, or to have the actor sign in with the four fields below. This actor is bring-your-own-key and never ships a credential of its own.

## `clientId` (type: `string`):

The client ID from your provider contract, used with the client secret, username and password to sign in once per run. Not needed when you paste an access token. Falls back to the DATA\_API\_CLIENT\_ID environment secret.

## `clientSecret` (type: `string`):

The client secret that goes with the client ID. Falls back to the DATA\_API\_CLIENT\_SECRET environment secret.

## `username` (type: `string`):

Your provider account username. Falls back to the DATA\_API\_USERNAME environment secret.

## `password` (type: `string`):

Your provider account password. Falls back to the DATA\_API\_PASSWORD environment secret.

## `baseUrl` (type: `string`):

Override the host the actor calls, for example the provider's sandbox host. Only useful for testing.

## Actor input object example

```json
{
  "service": "price",
  "zoneIds": [
    "reg:3"
  ],
  "zoneType": "com",
  "contract": "1",
  "window": "1M",
  "year": 2024,
  "month": 12,
  "nation": "IT",
  "maxResults": 500,
  "requestsPerMinute": 30
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the zone and period that produced 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 = {
    "zoneIds": [
        "reg:3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/italy-real-estate-market-data-api").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 = { "zoneIds": ["reg:3"] }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/italy-real-estate-market-data-api").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 '{
  "zoneIds": [
    "reg:3"
  ]
}' |
apify call nabeelbaghoor/italy-real-estate-market-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/italy-real-estate-market-data-api"
        }
    }
}
```

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/zjRID3dhCAZlWiSti/builds/4VMbrNbpPXe7mN6Ew/openapi.json