# Madlan Scraper - Israel Sold Prices & Neighbourhood Data (`sian.agency/madlan-property-scraper`) Actor

Scrape Madlan.co.il: closed sale prices back to 2004, price per sqm, rent yields, demographics, schools and area analysis for any Israeli city or neighbourhood.

- **URL**: https://apify.com/sian.agency/madlan-property-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 sold transactions

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/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

## Madlan Scraper — Israel Sold Prices, Yields & Neighbourhood Data 🇮🇱

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Yad2 Real Estate Scraper](https://img.shields.io/badge/Store-Yad2%20Real%20Estate%20Scraper-1AE392)](https://apify.com/sian.agency/yad2-property-scraper?fpr=sian) [![Dubai Real Estate Data Scraper](https://img.shields.io/badge/Store-Dubai%20Real%20Estate%20Data-93D500)](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) [![Aqar Scraper](https://img.shields.io/badge/Store-Aqar%20Saudi%20Property-1AE392)](https://apify.com/sian.agency/aqar-property-scraper?fpr=sian)

#### 🎉 What Israeli property actually sold for — closed deals back to 2004, with price per square meter, block and parcel on every row

##### עסקאות נדל"ן, מחירי דירות ומדדי תשואה — plus median rent, gross yield, demographics, schools and analyst notes for any Israeli city or neighbourhood

### 🔎 What is the Madlan.co.il Israel Sold Prices & Area Data — and when should you use it?

The **Madlan.co.il Israel Sold Prices & Area Data** turns closed property sale prices and neighbourhood analytics from Madlan.co.il, for anywhere in Israel into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** what Israeli property actually SOLD for, rather than what it is listed at. Every transaction row carries the amount that changed hands, the date it closed, the size in square metres and the price per square metre. It also carries the room count, the floor, the year built, and the land-registry block and parcel (גוש/חלקה), plus the street, city and neighbourhood. A neighbourhood usually reaches back to 2004. The same actor returns median buy price, median rent and gross yield per apartment size, for the neighbourhood, its city and the country side by side, each with its quarterly history. A third mode returns a full area report: the demographics, the school roster with catchment polygons, the analyst notes on planning and construction nuisance, and the residents' own written opinions.

**Use something else when:** the question is about what is on the market now, or the property is not in Israel. Use [Yad2 Scraper](https://apify.com/sian.agency/yad2-property-scraper?fpr=sian) for Israel's live listings — asking prices, photos and agency contacts for apartments and commercial space currently for sale or rent. Use [Aqar Scraper](https://apify.com/sian.agency/aqar-property-scraper?fpr=sian) for Saudi Arabia's property market, with the same row shape for sale and rent. Use [Bayut Scraper](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) for the same job across the Gulf property markets. This actor reads the area and address pages Madlan.co.il publishes: closed sale transactions, price benchmarks, demographics, schools, analyst notes and resident opinions. It does not return property listings — asking prices, listing photos and agent contacts live on the listings portals, not here. Madlan publishes sale transactions only; there are no rental transactions to ask for.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/madlan-property-scraper

**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want closed sale prices, price benchmarks and neighbourhood analytics for Israel from Madlan.co.il using the Apify Actor `sian.agency/madlan-property-scraper`.

Use it when I need: what Israeli property actually SOLD for, rather than what it is listed at. Every transaction row carries the amount that changed hands, the date it closed, the size in square metres and the price per square metre. It also carries the room count, the floor, the year built, and the land-registry block and parcel (גוש/חלקה), plus the street, city and neighbourhood. A neighbourhood usually reaches back to 2004. The same actor returns median buy price, median rent and gross yield per apartment size, for the neighbourhood, its city and the country side by side, each with its quarterly history. A third mode returns a full area report: the demographics, the school roster with catchment polygons, the analyst notes on planning and construction nuisance, and the residents' own written opinions.

Don't use it when: the question is about what is on the market now, or the property is not in Israel — use yad2-property-scraper or aqar-property-scraper or bayut-property-scraper instead.

How to call it: pick one `operation` per run. `transactions` returns closed sale records, `priceBenchmarks` returns median buy price, rent and gross yield per apartment size, and `areaReport` returns one row per area with the demographics, schools, analyst notes and resident opinions. Name the places either way: put Hebrew names into `cities` (matched against the 1,206 settlements Madlan publishes) or `neighbourhoods` (1,755 of them). You can also paste Madlan page addresses into `areaUrls`: an `/area-info/` address for a city or neighbourhood, an `/address/` address for one building. Ask a neighbourhood when the history matters, because a whole city page stops at its most recent 1,000 deals. `maxResults` is what decides the size of a run. Narrow transactions with `fromYear`, `toYear`, `minPrice`, `maxPrice`, `minRooms`, `maxRooms`, `minSizeSqm` and `maxSizeSqm`. Each reads a field Madlan fills on virtually every deal, and anything a filter removes is never saved and never billed. Narrow benchmarks with `benchmarkSizes` and `buildCondition`, both of which are pick-lists of Madlan's own keys. Note that `rooms` is the Israeli room count including half rooms, not bedrooms, and that latitude and longitude arrive only on `/address/` runs.

Start with this input:
{
  "operation": "transactions",
  "neighbourhoods": [
    "רמת הטייסים"
  ],
  "fromYear": 2020,
  "minRooms": 4,
  "maxResults": 200
}

Ask me which Israeli places to cover, and whether to name them in Hebrew or paste Madlan page addresses. Also whether they want the closed deals, the price and yield benchmarks, or the full area report. And how far back the history needs to go: a neighbourhood carries about twenty years, a whole city only its most recent 1,000 deals, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *What did four-room flats sell for in Ramat HaTayasim over the last three years, and how does the price per square metre compare with the Tel Aviv average?*
- *Pull every closed sale above 5 million shekels in Tel Aviv since 2024, with the block and parcel for each one.*
- *Compare gross rental yield for three-room second-hand flats across five Jerusalem neighbourhoods.*
- *Give me the school roster and the planning notes for Ramat Aviv before I put in an offer.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/madlan-property-scraper.md](https://apify.com/sian.agency/madlan-property-scraper.md).

### 📋 Overview

Israel has no open feed of what property sold for. Appraisers, lenders and buyers argue over comparables, and the number most people reach for is an asking price, which is a hope rather than evidence. Madlan publishes the closed record: the deals registered with the tax authority. This Actor turns any Israeli city, neighbourhood or single building into rows of them.

Name a place and pick one of three shapes. **Sold Transactions** gives you the deals: amount, date, price per square meter, rooms, size, floor, year built, street, house number, and the גוש and חלקה a lawyer pulls the title record with. **Price Benchmarks** gives you the median buy price, median rent and gross yield per apartment size, for the neighbourhood, its city and the whole country side by side, each with a quarterly history. **Area Report** gives you one profile row: demographics, the price table by room count, schools with their catchment polygons, analyst notes on planning and nuisances, and what residents say.

**What you get:**

- ✅ **Closed sale prices, not asking prices** — every transaction row is a completed deal with the amount that changed hands and the date it closed
- 📅 **History back to about 2004** on a neighbourhood, from a single run — two decades of price per square meter on one sheet
- ⚡ **200 records in 4.9 seconds** on the default run, so a whole city is a coffee break
- 💰 **$0.46 per 1,000 transaction records**, against the cent-a-row that the same data usually costs
- 📈 **132 benchmark rows per place** — every apartment size, every build condition, three geography levels, with quarterly history
- 🗺️ **Demographics, schools and analyst notes** in the same Actor, keyed to the same areas
- 🆓 **25 records free on every run**, with every field filled in

### ✨ Features

- 💰 **Sold Transactions** — closed deals for a city, a neighbourhood or one building, with price, price per square meter, rooms, size, floor and year built
- 📜 **Block and parcel on every deal** — the גוש and חלקה that identify the plot in the land registry
- 📈 **Price Benchmarks** — median buy price, median rent and gross yield per apartment size, for 1 to 10 rooms plus duplex, penthouse, mini penthouse, single family and garden apartment
- 🏘️ **Second hand against new build** — Madlan publishes the two separately, and so does every benchmark row
- 📉 **Quarterly price history** on each benchmark row, ready to plot without a second run
- 🗺️ **Area Report** — demographics by age, origin and immigration, the price table by room count, and the count of homes currently listed
- 🏫 **School roster with catchment polygons** — level, class range, roster size, average class size and the registration zone as geometry
- 🧠 **Analyst notes and resident opinions** on planning, construction nuisance, transport and livability
- 🇮🇱 **Hebrew place lookup** against Madlan's own index — 1,206 settlements and 1,755 neighbourhoods, read fresh on every run
- 🔗 **Paste a Madlan page you already have open** and the run reads exactly that page
- 🎚️ **Filters that genuinely remove rows** — year, price, rooms and floor area each read a field Madlan fills on every deal
- 🆓 **25 records free per run**, then $0.46 per 1,000 transaction records

### 🎬 Quick Start

Pick what to scrape, name a place in Hebrew, press Start. Rows land in the dataset tab and export as JSON, CSV, Excel or XML.

```json
{
  "operation": "transactions",
  "cities": ["תל אביב יפו"],
  "maxResults": 200
}
```

That is the default run. It returned 200 closed Tel Aviv deals in 4.9 seconds, each with price, price per square meter, rooms, size, floor, year built, street, block and parcel.

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose what to scrape

Leave **What do you want to scrape** on **Sold Transactions** for closed deals. Switch it to **Price Benchmarks** for median price, rent and yield, or to **Area Report** for demographics, schools and analyst notes.

#### Step 2: Name the place

Type a city into **Cities and towns** or a neighbourhood into **Neighbourhoods**, in Hebrew. Both are matched against Madlan's own index. If you already have a Madlan page open in your browser, paste its address into **Madlan area or address pages** instead and the run reads that exact page.

#### Step 3: Set the size and run it

**Max records** decides what the run costs. Narrow further with the year, price, room and size boxes, then press **Start**.

**That's it. In under a minute you'll have:**

- Closed sale prices with the date, the size and the price per square meter
- The block and parcel for each deal, ready for a title search
- A dataset you can export or pull straight from the API

### 📥 Input Configuration

| Field | Type | Default | What it does |
|---|---|---|---|
| `operation` | select | `transactions` | `transactions`, `priceBenchmarks` or `areaReport` — one per run |
| `areaUrls` | array | — | Madlan page addresses, an `/area-info/` page or an `/address/` page. Used verbatim |
| `cities` | array | `תל אביב יפו` | City or town names in Hebrew, matched against 1,206 settlements |
| `neighbourhoods` | array | — | Neighbourhood names in Hebrew, matched against 1,755 neighbourhoods |
| `maxResults` | integer | `200` | Stop after this many records. 1 to 50,000 |
| `fromYear` | integer | `0` | Keep deals closed in this year or later. `0` means no floor |
| `toYear` | integer | `0` | Keep deals closed in this year or earlier. `0` means no ceiling |
| `minPrice` / `maxPrice` | integer | `0` | Shekel band on the closing amount. `0` means no bound |
| `minRooms` / `maxRooms` | integer | `0` | Room band, Israeli counting. `0` means no bound |
| `minSizeSqm` / `maxSizeSqm` | integer | `0` | Registered floor area band in square meters |
| `benchmarkSizes` | array | — | Which apartment sizes the benchmark run returns. Empty means all of them |
| `buildCondition` | select | `all` | `all`, `secondHand` or `new` — which build condition the benchmark rows cover |

**Apartment size keys for `benchmarkSizes`:** `1` through `10` for room counts, plus `duplex`, `penthouse`, `mini_penthouse`, `single_family`, `garden_apartment` and `all`.

**Narrowing a city run:**

```json
{
  "operation": "transactions",
  "cities": ["תל אביב יפו"],
  "fromYear": 2024,
  "minPrice": 5000000,
  "minRooms": 4,
  "maxResults": 1000
}
```

A Tel Aviv city page holds 1,000 deals. Those three filters kept 224 of them.

### 📤 Output

One flat row per record, 54 fields across the three shapes. The `recordType` field tells you which shape you are looking at.

**Sold Transactions rows:**

| Field | Type | Description |
|---|---|---|
| `recordType` | string | `transaction` |
| `dealId` | string | Madlan's own identifier for the deal |
| `dealDate` | string | **When the sale closed** |
| `price` | number | **The amount that changed hands, in shekels** |
| `currency` | string | `ILS` |
| `pricePerSqm` | number | **Shekels per square meter on this deal** |
| `rooms` | number | Israeli room count — the living room counts, so `3.5` is normal |
| `sizeSqm` | number | Registered floor area |
| `floor` | number | Floor the property sits on |
| `yearBuilt` | number | Year built, or the expected completion year on an off-plan deal |
| `unitNumber` | string | Unit within the building, where Madlan records one |
| `blockNumber` | string | **גוש — the land registry block** |
| `parcelNumber` | string | **חלקה — the land registry parcel** |
| `street` / `houseNumber` | string | Street name and number in Hebrew |
| `city` / `neighborhood` / `district` | string | Where the property sits |
| `latitude` / `longitude` | number | Coordinates, filled on address-page runs |
| `propertiesCount` | number | How many properties the registered deal covered |
| `isFinalDeal` | boolean | Whether Madlan marks the deal as final |
| `percentTransferred` | number | Share of the property that changed hands |
| `projectName` | string | Development name, on new-build deals |
| `addressDocId` | string | Madlan's identifier for the building |
| `dealScope` | string | Whether the deal was read for the address itself or its surroundings |
| `distanceMeters` | number | Distance from the address you asked about |

**Price Benchmarks rows:**

| Field | Type | Description |
|---|---|---|
| `recordType` | string | `priceBenchmark` |
| `propertySize` | string | Apartment size — a room count, or duplex, penthouse, garden apartment and the rest |
| `buildCondition` | string | `all`, `secondHand` or `new` |
| `geoLevel` / `geoName` | string | **Country, city or neighbourhood, and its name** |
| `buyPrice` | number | **Median buy price in shekels** |
| `rentPrice` | number | **Median monthly rent in shekels** |
| `rentalYieldPercent` | number | **Gross yield** |
| `pricePerSqm` | number | Median shekels per square meter |
| `dealsCount` | number | How many deals the median rests on |
| `priceHistory` | array | **Quarterly series behind the figure** |
| `priceForecast` | array | Madlan's forward view, where it publishes one |

**Area Report rows:**

| Field | Type | Description |
|---|---|---|
| `recordType` | string | `areaReport` |
| `areaName` / `areaType` / `areaDocId` | string | The area, its level and Madlan's identifier for it |
| `areaDescription` | string | Madlan's written summary of the area |
| `listingsForSaleCount` / `listingsForRentCount` | number | How many homes are currently advertised there |
| `ageDistribution` | array | **Residents by age band, as percentages** |
| `ethnicDistribution` | array | Residents by origin |
| `aliyaDistribution` | array | Residents by immigration wave |
| `popularParty` | string | Leading party at the last election |
| `pricesByRooms` | array | **Price table by room count** |
| `schools` | array | **School roster with level, class range, roster size and catchment polygons** |
| `schoolsInNeighbourhoodCount` / `schoolsInCityCount` | number | School counts |
| `analystNotes` | array | **Notes on planning, construction nuisance, transport and livability** |
| `residentOpinions` | array | What residents say, in their own words |

Every row also carries `sourceUrl` and `scrapedAt`.

**Example transaction row:**

```json
{
  "recordType": "transaction",
  "areaName": "רמת הטייסים",
  "areaType": "neighbourhood",
  "dealId": "a1b2c3d4",
  "dealDate": "2024-03-18",
  "price": 3150000,
  "currency": "ILS",
  "pricePerSqm": 32474,
  "rooms": 3.5,
  "sizeSqm": 97,
  "floor": 4,
  "yearBuilt": 1968,
  "blockNumber": "6134",
  "parcelNumber": "215",
  "street": "המלאכה",
  "houseNumber": "12",
  "city": "תל אביב יפו",
  "neighborhood": "רמת הטייסים",
  "latitude": null,
  "longitude": null,
  "sourceUrl": "https://www.madlan.co.il/area-info/...",
  "scrapedAt": "2026-09-09T08:41:02.517Z"
}
```

### 💼 Use Cases & Examples

#### 1. Valuation Comparables in a Market With No Open Feed

**Appraisers, mortgage lenders and buyers arguing an offer.** Israel publishes no open feed of what property sold for, so a comparable usually comes from an asking price. Name a neighbourhood and you get the closed deals instead, each with the amount, the size, the price per square meter, the floor, the year built and the block and parcel.

```json
{ "operation": "transactions", "neighbourhoods": ["רמת הטייסים, תל אביב יפו"], "maxResults": 500 }
```

#### 2. Price Per Square Meter by Neighbourhood, Over Twenty Years

**Market analysts and research desks.** A neighbourhood page carries its deals back to about 2004. One run gives every deal with its own date and price per square meter, so the series is built from the deals rather than someone's index. Run the next neighbourhood and the columns line up.

```json
{ "operation": "transactions", "neighbourhoods": ["הצפון הישן"], "fromYear": 2004, "maxResults": 2000 }
```

#### 3. Rental Yield Screening Across Areas

**Property investors and funds.** Benchmark rows carry median buy price, median rent and gross yield side by side for the neighbourhood, its city and the country, split by apartment size and by whether the stock is second hand or new. Every page tested returned exactly 132 of them.

```json
{ "operation": "priceBenchmarks", "cities": ["חיפה"], "buildCondition": "secondHand", "maxResults": 132 }
```

#### 4. Due Diligence on What Is Coming to a Street

**Buyers, relocation advisers and buying agents.** The area report carries analyst notes on planning, construction nuisance, transport and livability, plus resident opinions. It answers what a listing cannot: the tower going up next door, the metro works, the parking.

```json
{ "operation": "areaReport", "neighbourhoods": ["פלורנטין"], "maxResults": 1 }
```

#### 5. School Catchment Mapping

**Family relocation services and school-district products.** Each area report lists schools with their level, class range, roster size, average class size and registration-zone polygons. Feed the polygons to a map and the catchment question becomes a lookup.

```json
{ "operation": "areaReport", "cities": ["ירושלים"], "maxResults": 1 }
```

#### 6. One Building, Every Deal In It

**Estate agents pricing a specific flat.** Paste a Madlan address page and you get the deals recorded for that building and its immediate surroundings. One address page returned 69 deals, every one of them carrying latitude and longitude.

```json
{ "operation": "transactions", "areaUrls": ["https://www.madlan.co.il/address/..."], "maxResults": 100 }
```

#### 7. Feeding a Valuation Model or a Proptech Product

**Data engineers and proptech founders.** Rows come out flat and typed — numbers as numbers, dates as dates, one record per deal, with the area and its identifier on every row. They load into a warehouse, a model or a dashboard without anyone reading Hebrew to unpack them.

```json
{ "operation": "transactions", "cities": ["ראשון לציון", "פתח תקווה", "נתניה"], "maxResults": 3000 }
```

### 🔗 Integration Examples

#### JavaScript/Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('sian.agency/madlan-property-scraper').call({
    operation: 'transactions',
    neighbourhoods: ['רמת הטייסים, תל אביב יפו'],
    fromYear: 2020,
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const psm = items.filter((i) => i.pricePerSqm).map((i) => i.pricePerSqm).sort((a, b) => a - b);
console.log(`median shekels per m2: ${psm[Math.floor(psm.length / 2)]}`);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("sian.agency/madlan-property-scraper").call(run_input={
    "operation": "priceBenchmarks",
    "cities": ["חיפה"],
    "buildCondition": "secondHand",
    "maxResults": 132,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("rentalYieldPercent"):
        print(row["geoLevel"], row["propertySize"], row["rentalYieldPercent"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~madlan-property-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"operation":"transactions","cities":["תל אביב יפו"],"fromYear":2024,"maxResults":200}'
```

#### Automation Workflows (N8N / Zapier / Make)

Point an **HTTP Request** node at the `run-sync-get-dataset-items` endpoint above and you have an Israeli deals feed inside your workflow. A common shape: run it monthly for a list of neighbourhoods, compare the new median price per square meter against last month's, and push the movers into a Google Sheet or a Slack channel. Apify's own N8N, Zapier and Make integrations work too, if you would rather not build the HTTP call yourself.

### 📊 Performance & Pricing

One page fetch serves a whole operation, so a run is fast regardless of how many rows come out of it. The default Tel Aviv transactions run returned 200 records in 4.9 seconds. A city page holds 1,000 deals; a benchmark run returns 132 rows.

#### FREE Tier (Try It Now)

- **25 records per run**, with every field filled in
- All three operations available, no feature held back
- No API key, no login, nothing to buy on top

#### PAID Tier (Production Ready)

| Event | Price (Bronze) | What it covers |
|---|---|---|
| Sold Transactions | **$0.00046** per record | One closed sale — $0.46 per 1,000 |
| Price Benchmarks | **$0.00019** per record | One benchmark row — $0.19 per 1,000 |
| Area Report | **$0.01** per record | One complete area profile |
| Actor Start | $0.005 per run | Apify's per-run start event |

Higher Apify plan tiers pay less per row. You are charged for records that actually came back, so a place with no deals on file costs you nothing beyond the start event.

💰 The same Madlan transaction data is commonly billed at a cent a row, which puts a 1,000-deal Tel Aviv run near $10. Here it is $0.46.

🔗 [View current pricing](https://apify.com/sian.agency/madlan-property-scraper?fpr=sian)

### ❓ FAQ — Frequently Asked Questions

**Are these asking prices or what the property actually sold for?**
Sold. Every transaction row is a completed sale Madlan publishes from the Israel Tax Authority record, with the amount that changed hands and the date it closed. Asking prices live on a listings site, and the [Yad2 Real Estate Scraper](https://apify.com/sian.agency/yad2-property-scraper?fpr=sian) is where to get those.

**How far back does the history go?**
It depends on the area. A neighbourhood typically reaches back to about 2004 and returns everything it has. A whole city returns the most recent 1,000 deals, because that is where Madlan's payload stops. Ask a neighbourhood when history is the point.

**Can I get rental transactions?**
No. Madlan publishes sale transactions only, so there is no deal-type switch here to set. Rental figures do appear as medians in the benchmark rows, next to the buy price and the yield.

**Why is latitude empty on some rows?**
Madlan puts the coordinate on its address pages and leaves it off its area pages, so deals read from a city or neighbourhood page have no coordinate to carry. Every row still carries the street, house number, block and parcel. No filter in this Actor reads the coordinate.

**Is `rooms` the number of bedrooms?**
No. It is the Israeli room count, which includes the living room and comes in halves. Across the deals measured, a 3-room flat runs about 76 m² and a 4-room one about 97 m².

**What do the block and parcel numbers mean?**
They are the גוש and חלקה, the land registry identifiers for the plot. A lawyer or an appraiser uses them to pull the title record, and they sit on every transaction row.

**Do I need to write Hebrew to use it?**
To name a place, yes — city and neighbourhood names are matched against Madlan's own Hebrew index. There is a way round it: paste the address of a Madlan page you already have open and the run reads that page.

**Why is `yearBuilt` sometimes in the future?**
On an off-plan deal it holds the expected completion year rather than a past one. Both cases use the same field.

**What output formats can I export?**
JSON, CSV, Excel and XML, straight from the dataset tab, or through the Apify API.

### 🐛 Troubleshooting

**The run returned fewer records than Max records.**
The place ran out of matching deals. A neighbourhood holds what it holds, and a city page stops at 1,000. The log prints how many were read and how many survived your filters. Widen the year, price or room band, or add another place.

**The place name was not found.**
Madlan did not recognise what you typed. Check the Hebrew spelling, and where a neighbourhood name repeats around the country, write it with its city (רמת הטייסים, תל אביב יפו). Pasting a Madlan page address sidesteps the lookup entirely.

**A city run returned almost nothing for an early year.**
A city page carries only its most recent 1,000 deals, so a `fromYear` in the 2000s filters nearly all of them away. Ask the neighbourhood instead, where the history actually lives.

**Latitude and longitude came back empty.**
That run read area pages, which Madlan does not put coordinates on. Run against an address page and every deal carries them.

**The site declined a request.**
Madlan occasionally refuses a burst. The run retries by itself and carries on, so this usually only shows up in the log. If a run still ends early, wait a few minutes and start it again.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract private user data such as email addresses, phone numbers or home occupancy. This one reads what Madlan publishes on pages any visitor can open without logging in: registered sale transactions, area statistics and school information. Transaction records identify a property, not a person, and no buyer or seller name is collected.

You should still be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union, by Israel's own privacy law, and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

- 🐛 **Something broken?** [Open an issue](https://apify.com/sian.agency/madlan-property-scraper/issues) — we read every one
- ⭐ **Working well?** [Leave a 5-star review](https://apify.com/sian.agency/madlan-property-scraper/reviews) — it is what gets the next feature built
- 📧 **Email us:** <apify@sian-agency.online>
- 🔍 **Need another market?** [Browse the SIÁN Agency store](https://apify.com/sian.agency?fpr=sian) — property and rental scrapers for the Middle East, Europe, Asia and the Americas

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More tools](https://apify.com/sian.agency?fpr=sian)**

*Madlan is a trademark of Madlan Ltd. This actor is not affiliated with, endorsed by, or sponsored by Madlan.*

# Actor input Schema

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

Pick one per run. Sold Transactions returns the closed sale records Madlan publishes for an area — price, price per square meter, rooms, size, floor, year built and the block/parcel — going back as far as 2004 on a neighbourhood. Price Benchmarks returns the median buy price, rent and gross yield per apartment size, for the neighbourhood, its city and the country side by side, each with its quarterly history. Area Report returns one row per area holding the demographics, the price table, the…

## `areaUrls` (type: `array`):

Paste Madlan page addresses to read exactly the areas you already have in hand — an area page (/area-info/…) for a city or a neighbourhood, or an address page (/address/…) for one building. Anything pasted here is used verbatim, so a page you opened in your browser is the page the run reads. Leave it empty and the run uses the place names below instead.

## `cities` (type: `array`):

City or town names in Hebrew, matched against the 1,206 settlements Madlan publishes an area page for. A city returns the most recent 1,000 deals, which is where Madlan's payload stops; name a neighbourhood below when you want the full history instead.

## `neighbourhoods` (type: `array`):

Neighbourhood names in Hebrew, matched against the 1,755 neighbourhoods Madlan publishes. A neighbourhood usually carries its deals back to 2004. Write the neighbourhood on its own (רמת הטייסים) or with its city (רמת הטייסים, תל אביב יפו) when the name repeats around the country.

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

Stop after this many records. A single Tel Aviv page can hold 1,000 deals, so this is the control that decides what a run costs.

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

Keep only deals closed in this year or later. Leave at 0 for every year Madlan holds. Neighbourhood pages typically reach back to 2004; a city page only carries its most recent 1,000 deals, so an early year there returns little.

## `toYear` (type: `integer`):

Keep only deals closed in this year or earlier. Leave at 0 for no upper bound.

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

Keep only deals that closed at or above this amount, in shekels. Leave at 0 for no floor.

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

Keep only deals that closed at or below this amount, in shekels. Leave at 0 for no ceiling.

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

Keep only deals with at least this many rooms. Israeli room counts include half rooms, so 3 keeps a 3.5-room flat.

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

Keep only deals with at most this many rooms. Leave at 0 for no ceiling.

## `minSizeSqm` (type: `integer`):

Keep only deals at or above this registered floor area in square meters.

## `maxSizeSqm` (type: `integer`):

Keep only deals at or below this registered floor area in square meters.

## `benchmarkSizes` (type: `array`):

Which apartment sizes the Price Benchmarks run should return, using Madlan's own keys — 1 through 10 for room counts, or duplex, penthouse, mini\_penthouse, single\_family, garden\_apartment, all. Leave empty for every size Madlan publishes.

## `buildCondition` (type: `string`):

Which build condition the benchmark rows should cover. Madlan publishes buy price, rent and yield separately for second-hand and new-build stock, alongside a combined figure.

## Actor input object example

```json
{
  "operation": "transactions",
  "areaUrls": [],
  "cities": [
    "תל אביב יפו"
  ],
  "neighbourhoods": [],
  "maxResults": 200,
  "fromYear": 0,
  "toYear": 0,
  "minPrice": 0,
  "maxPrice": 0,
  "minRooms": 0,
  "maxRooms": 0,
  "minSizeSqm": 0,
  "maxSizeSqm": 0,
  "benchmarkSizes": [],
  "buildCondition": "all"
}
```

# Actor output Schema

## `madlanCoIlRecords` (type: `string`):

Every record this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "transactions",
    "areaUrls": [],
    "cities": [
        "תל אביב יפו"
    ],
    "neighbourhoods": [],
    "maxResults": 200,
    "fromYear": 0,
    "toYear": 0,
    "minPrice": 0,
    "maxPrice": 0,
    "minRooms": 0,
    "maxRooms": 0,
    "minSizeSqm": 0,
    "maxSizeSqm": 0,
    "benchmarkSizes": [],
    "buildCondition": "all"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/madlan-property-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 = {
    "operation": "transactions",
    "areaUrls": [],
    "cities": ["תל אביב יפו"],
    "neighbourhoods": [],
    "maxResults": 200,
    "fromYear": 0,
    "toYear": 0,
    "minPrice": 0,
    "maxPrice": 0,
    "minRooms": 0,
    "maxRooms": 0,
    "minSizeSqm": 0,
    "maxSizeSqm": 0,
    "benchmarkSizes": [],
    "buildCondition": "all",
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/madlan-property-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 '{
  "operation": "transactions",
  "areaUrls": [],
  "cities": [
    "תל אביב יפו"
  ],
  "neighbourhoods": [],
  "maxResults": 200,
  "fromYear": 0,
  "toYear": 0,
  "minPrice": 0,
  "maxPrice": 0,
  "minRooms": 0,
  "maxRooms": 0,
  "minSizeSqm": 0,
  "maxSizeSqm": 0,
  "benchmarkSizes": [],
  "buildCondition": "all"
}' |
apify call sian.agency/madlan-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/madlan-property-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/ou9MXraDfKUq0efh6/builds/2vkXaVRQ984pB7Jaf/openapi.json