# Israel Real Estate Index | Official Prices, Rent & Yield (`alinz/israel-real-estate-index`) Actor

Official Israeli government housing price and rent indices for all 357 settlements and 1,336 neighbourhoods. Quarterly series 2021-2026 by room count, with rental yield, YoY change and a built-in national benchmark.

- **URL**: https://apify.com/alinz/israel-real-estate-index.md
- **Developed by:** [אלון זריהן](https://apify.com/alinz) (community)
- **Categories:** Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Israel Real Estate Price & Rent Index — Official Government Data

Housing prices, rent prices and **rental yield** for **every settlement and neighbourhood in Israel**, taken from the Israeli government's official real-estate portal (nadlan.gov.il) — the price indices built on Tax Authority transaction records.

This is not listing data. Listing sites show what sellers *ask*. This shows what the government's own index reports, for both **sale** and **rent**, in the same run — which is what makes the yield figure meaningful.

### What you get

| | Coverage |
|---|---|
| Settlements (cities/towns) | **357** |
| Neighbourhoods | **1,336** |
| Markets | Sale **and** rent |
| History | Quarterly, **2021 → 2026** (22 quarters) |
| Room breakdown | 3, 4, 5 rooms, and all-rooms |
| Full country run | ~30 seconds |

Every row carries a **national benchmark** for the same quarter and room count, so "is this place expensive?" is answerable without a second data pull.

### Why people use this

- **Investors** — screen the whole country for rental yield above a threshold in one run.
- **Appraisers (שמאים)** — official index figures with a citable source URL and data version per row.
- **Mortgage and credit analysts** — quarterly price trajectory per city for collateral and portfolio review.
- **Proptech / analytics teams** — a clean, normalized national dataset instead of parsing a government SPA.
- **Journalists and researchers** — defensible numbers with provenance attached.

### Output

Two shapes, chosen with `outputFormat`.

**`summary`** — one row per place. Best for screening and spreadsheets.

```json
{
  "placeName": "תל אביב -יפו",
  "placeType": "settlement",
  "placeId": 5000,
  "dealType": "buy",
  "yieldPct": 2.72,
  "priceIncreasesPct": -1.45,
  "avgPriceAll": 3531200,
  "avgPrice3r": 3825400,
  "avgPrice4r": 5070900,
  "avgPrice5r": 7019300,
  "yoyPctAll": -1.45,
  "latestPrice4r": 5229800,
  "latestPeriod4r": "2026-Q1",
  "itmX": 179706.06,
  "itmY": 666156.93,
  "dataVersion": "20-08-2026",
  "sourceUrl": "https://data.nadlan.gov.il/api/pages/settlement/buy/5000.json",
  "scrapedAt": "2026-08-30T11:06:22.036Z"
}
```

**`timeseries`** — one row per place × market × room count × quarter. Best for charting and modelling.

```json
{
  "placeName": "תל אביב -יפו",
  "dealType": "buy",
  "rooms": 4,
  "period": "2026-Q1",
  "year": 2026,
  "month": 3,
  "price": 5229800,
  "countryPrice": 2072000,
  "vsCountryPct": 152.4,
  "yoyChangePct": 4.2,
  "yieldPct": 2.72,
  "hasDeals": true
}
```

### Examples

**Every city in the country, sale and rent:**

```json
{ "placeTypes": ["settlement"], "dealTypes": ["buy", "rent"], "outputFormat": "summary" }
```

**Yield screen — where does rent actually pay?**

```json
{ "placeTypes": ["settlement"], "dealTypes": ["buy"], "minYieldPct": 4 }
```

**Neighbourhood detail inside specific cities:**

```json
{
  "placeTypes": ["neighborhood"],
  "dealTypes": ["buy", "rent"],
  "settlementNames": ["חיפה", "באר שבע"]
}
```

**Five-year price history for one city:**

```json
{
  "placeTypes": ["settlement"],
  "dealTypes": ["buy"],
  "outputFormat": "timeseries",
  "settlementNames": ["ירושלים"],
  "fromYear": 2021
}
```

City names accept partial Hebrew — `תל אביב` matches `תל אביב -יפו`. A filter that matches nothing **fails with a clear error** instead of quietly pulling the whole country and billing you for it.

### Field reference

| Field | Meaning |
|---|---|
| `placeType` | `settlement` or `neighborhood` |
| `placeId` / `placeName` | Official code and Hebrew name |
| `settlementId` / `settlementName` | Parent city (same as place for settlements) |
| `dealType` | `buy` or `rent` |
| `yieldPct` | Published gross rental yield, % |
| `priceIncreasesPct` | Published price-change index, % |
| `luxuryIndex` | Published luxury index, 0–10 |
| `avgPrice{3r,4r,5r,All}` | Trailing-year average price by room count |
| `yoyPct{…}` | Year-over-year change by room count, % |
| `latestPrice{…}` / `latestPeriod{…}` | Most recent quarter that has a real figure |
| `price` / `countryPrice` | *(timeseries)* Local and national price for that quarter |
| `vsCountryPct` | *(timeseries)* Local vs national, % |
| `rooms` | `3`, `4`, `5`, or `all` |
| `period` | e.g. `2026-Q1` |
| `hasDeals` | Whether the source flagged real transactions behind the series |
| `itmX` / `itmY` | Coordinates, Israeli Transverse Mercator (EPSG:2039) |
| `dataVersion` | Publication date stamped by the source |
| `sourceUrl` | Exact upstream file this row came from |

Prices are in ILS (₪). Sale prices are absolute; rent is monthly.

### Notes on the data

- **Nulls are real.** The most recent quarter often has no local figure yet — the index lags. Nulls are preserved rather than filled or interpolated, so you can see the lag instead of being misled by it. `latestPrice*` always points at the newest quarter that has an actual number.
- **Not every place has every field.** Small settlements and many neighbourhoods have no published `yield`. Setting `minYieldPct` excludes them.
- **Yield is the source's own figure**, not a recomputation. It is internally consistent — Haifa: ₪3,195/month × 12 ÷ ₪1,413,750 = 2.71%, matching the published 2.71%.
- **Update cadence.** The source stamps each file with a `dataVersion`; it moves roughly monthly. Re-run on a schedule and compare `dataVersion` to detect refreshes.

### Scope and conduct

This Actor reads **only the open, unauthenticated static JSON layer** that nadlan.gov.il serves publicly to any browser. It does not attempt to access the portal's protected per-transaction endpoints, which are gated behind reCAPTCHA and request signing, and it does not circumvent any access control. Requests are modest and rate-limited by default.

Individual deal-level records are therefore **not** included. If you need per-transaction data, use the portal directly.

### Integrations

Output goes to a standard Apify dataset: export as **JSON, CSV, Excel or XML**, or wire it into **Make, Zapier, n8n, Google Sheets, Slack**, or your own code via the Apify API. Schedule it to build your own history of how the official index moves over time.

# Actor input Schema

## `placeTypes` (type: `array`):

Which level to pull. 'settlement' = 357 cities and towns. 'neighborhood' = 1,336 neighbourhoods inside them.

## `dealTypes` (type: `array`):

Sale prices, rent prices, or both. Pull both to compare purchase price against rent in the same place.

## `outputFormat` (type: `string`):

'summary' = one row per place with current prices, YoY and yield — best for screening and spreadsheets. 'timeseries' = one row per quarter per room count — best for charting and modelling.

## `settlementNames` (type: `array`):

Optional. Hebrew city names, partial match is fine - 'תל אביב' matches 'תל אביב -יפו'. Three cities are pre-filled as a cheap sample run. CLEAR THIS FIELD to pull all 357 settlements in the country.

## `settlementIds` (type: `array`):

Optional. Official settlement codes (e.g. 5000 = Tel Aviv-Yafo, 3000 = Jerusalem). Takes precedence over names when both are given.

## `neighborhoodIds` (type: `array`):

Optional. Specific neighbourhood IDs. Only applies when 'neighborhood' is selected above.

## `minYieldPct` (type: `integer`):

Optional screen. Only return places whose published gross rental yield is at or above this value. Places with no yield figure are excluded when this is set.

## `fromYear` (type: `integer`):

Optional. Trim the time series to this year onward. Data starts in 2021. Applies to 'timeseries' output only.

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

Optional cap on rows returned. Useful for a cheap trial run before a full pull.

## `concurrency` (type: `integer`):

Parallel requests to the source. 10 is a good default and completes the whole country in well under a minute.

## Actor input object example

```json
{
  "placeTypes": [
    "settlement"
  ],
  "dealTypes": [
    "buy",
    "rent"
  ],
  "outputFormat": "summary",
  "settlementNames": [
    "תל אביב",
    "ירושלים",
    "חיפה"
  ],
  "settlementIds": [],
  "neighborhoodIds": [],
  "minYieldPct": 3,
  "fromYear": 2023,
  "maxResults": 100,
  "concurrency": 10
}
```

# Actor output Schema

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

All rows produced by the run — one per place in 'summary' mode, or one per place x market x room count x quarter in 'timeseries' mode.

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

Headline columns only: place, market, yield, average prices by room count and year-over-year change.

## `timeseries` (type: `string`):

Quarterly price series with the national benchmark alongside each local figure.

## `runStats` (type: `string`):

Counts of files fetched, missing, failed and filtered out, plus the input used and the timestamp of the run.

# 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 = {
    "placeTypes": [
        "settlement"
    ],
    "dealTypes": [
        "buy",
        "rent"
    ],
    "outputFormat": "summary",
    "settlementNames": [
        "תל אביב",
        "ירושלים",
        "חיפה"
    ],
    "settlementIds": [],
    "neighborhoodIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("alinz/israel-real-estate-index").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 = {
    "placeTypes": ["settlement"],
    "dealTypes": [
        "buy",
        "rent",
    ],
    "outputFormat": "summary",
    "settlementNames": [
        "תל אביב",
        "ירושלים",
        "חיפה",
    ],
    "settlementIds": [],
    "neighborhoodIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("alinz/israel-real-estate-index").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 '{
  "placeTypes": [
    "settlement"
  ],
  "dealTypes": [
    "buy",
    "rent"
  ],
  "outputFormat": "summary",
  "settlementNames": [
    "תל אביב",
    "ירושלים",
    "חיפה"
  ],
  "settlementIds": [],
  "neighborhoodIds": []
}' |
apify call alinz/israel-real-estate-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alinz/israel-real-estate-index"
        }
    }
}

```

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/il2ajMkkehVKzcotB/builds/B5zhTywzHWIJf4laB/openapi.json