# Israel Official Sold Property Prices - GovMap (`swerve/nadlan-deals`) Actor

Fast scraper for Israel's official sold-property prices (GovMap), with map coordinates: date, price, price/sqm, address, rooms, floor, area. For year built, a unit's prior sales and appreciation trend, use the enriched version: apify.com/swerve/nadlan-gov-deals

- **URL**: https://apify.com/swerve/nadlan-deals.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** Real estate, E-commerce, Automation
- **Stats:** 35 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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?

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 Transactions - Official Sold Prices

Scrape **actual recorded apartment sale prices** in Israel, straight from the government's official GovMap real-estate database. These are real prices that apartments sold for, not asking prices, so they are the ground truth for valuation, comparables, and market analysis.

The data is free and public. The actor uses GovMap's open real-estate API directly, with no logins, no keys, and no signups.

### What you get per transaction

Sale price (NIS), price per square meter, sale date, street address, **map coordinates (WGS84 lat/lng)**, neighborhood, number of rooms, floor, registered area, the granular property type (for example standard apartment, garden apartment, penthouse), and the official block-parcel-subparcel (gush / helka / tat-helka).

```json
{
  "dealDate": "2026-05-17",
  "dealAmount": 4700000,
  "pricePerSqm": 46078,
  "address": "לוי אשכול 86",
  "cityName": "תל אביב-יפו",
  "neighborhoodName": "רמת אביב החדשה",
  "rooms": 4.5,
  "floor": "7",
  "area": 102,
  "propertyType": "דירה בבית קומות",
  "isFirstHand": null,
  "gush": "6886",
  "helka": "12",
  "tatHelka": "23",
  "assetId": "123456789",
  "lat": 32.113,
  "lng": 34.795,
  "scrapedAt": "2026-06-17T09:30:00.000Z"
}
```

### Inputs

| Input | What it does |
|---|---|
| `cities` | One or more cities, in Hebrew (for example `תל אביב -יפו`, `ירושלים`, `חיפה`). Each is geocoded and the deals around its center are collected. |
| `customCities` | Any city or town not in the dropdown, typed in Hebrew. Optional. |
| `neighborhoods` | Optional. Narrow to specific neighborhoods within the chosen city, in Hebrew. Only deals whose neighborhood matches are returned. |
| `dealDateRange` | `all`, or the last `3` / `6` / `12` months / `60` (5 years). |
| `rooms` | Filter by rooms, comma-separated, for example `3,4`. |
| `minPrice` / `maxPrice` | Sale-price range in NIS. |
| `maxItems` | Optional cap on how many transactions are returned and billed. |

### Output fields

| Field | Type | Meaning |
|---|---|---|
| `dealDate` | string | Sale date (YYYY-MM-DD). |
| `dealAmount` | integer | Actual sale price in NIS. |
| `pricePerSqm` | integer | Sale price divided by area, rounded (NIS per sqm). |
| `address` | string | Street and house number (Hebrew). Null when the registry row carries no address; the parcel identifiers below still identify the property. |
| `cityName` | string | City name (Hebrew), normalized to one canonical spelling. |
| `neighborhoodName` | string | Neighborhood name (Hebrew), as tagged by GovMap. Best-effort: well filled in large cities, often null elsewhere. |
| `rooms` | number | Number of rooms (for example 4.5). |
| `floor` | string | Floor as a numeric string (for example `"7"`, ground = `"0"`). GovMap publishes Hebrew ordinal words; the actor converts the known vocabulary and passes rare unrecognized values through in Hebrew. |
| `area` | number | Registered area in square meters. |
| `propertyType` | string | Granular property type (Hebrew), for example `דירה בבית קומות`, `דירת גן`, `דירת גג`. Null on a share of rows where GovMap omits it. |
| `isFirstHand` | boolean | **Currently always null.** A mid-2026 GovMap API change removed the new-vs-resale split (the parameter now errors), so the flag cannot be populated. Kept for schema stability. |
| `gush` / `helka` / `tatHelka` | string | Official block / parcel / sub-parcel. |
| `assetId` | string | GovMap deal id. |
| `lat` / `lng` | number | Building centroid in WGS84 — plot deals straight onto any map. |
| `scrapedAt` | string | ISO timestamp of the scrape. |

### Example

The 12-month resale transactions of one Tel Aviv neighborhood:

```json
{ "cities": ["תל אביב -יפו"], "neighborhoods": ["רמת אביב החדשה"], "dealDateRange": "12", "dealType": "resale" }
```

For a whole city, drop `neighborhoods`. For everything available, set `dealDateRange` to `all`.

### How it works

For each requested city (and each neighborhood, when given), the actor:

1. Resolves the city to its real municipal boundary (bundled outlines for 200+ cities, GovMap's public search as fallback).
2. Tiles that whole boundary into a grid of sub-queries and asks GovMap for the deal clusters in every tile, so outlying areas are covered, not just the center.
3. Pages through every recorded sale in each cluster.

It then keeps only residential apartment sales, maps each to the output row above, applies your date / rooms / price / neighborhood filters, removes duplicate deals, and writes results continuously, so even a large pull never loses progress. Requests are throttled to stay within GovMap's normal use, and when Israeli residential proxy credentials are available they are used; otherwise the public API is called directly.

### Notes and limits

- This is historical **sold** data. Transactions appear only after official registration, which typically lags the signing date by **four to six weeks** — a "last 3 months" pull is expected to be thin for the most recent weeks.
- Coverage per city is the **full municipal boundary**, tiled into a grid so outlying neighborhoods are included. Large cities produce hundreds of sub-queries (Tel Aviv ≈ 800+), which takes time: **run big cities with no timeout or one of 15+ minutes** — a short user-set timeout is the most common cause of a timed-out run.
- Year built and total building floors are **not provided** by this source; our enriched sibling actor covers them: apify.com/swerve/nadlan-gov-deals.
- The registry itself occasionally records the same physical transaction twice with a sub-parcel off by one and the amount/date marginally different. The actor deduplicates exact repeats, but these near-twin registry rows are kept, since they can also be two genuinely distinct units.
- There is no run timeout and no result cap, so a full pull runs to completion. Use `maxItems`, a date range, or a neighborhood to keep runs fast and cheap.

### Use cases

- Property valuation and automated comparables (real sold prices, not listings).
- Real-estate market and price-trend analysis by city or neighborhood.
- Appraisal, lending, and investment due diligence.
- Feeding a valuation model or a real-estate product with ground-truth prices.

### Also Available

- [Israel Zoning Plans](https://apify.com/swerve/israel-zoning-plans) - the zoning plans behind a block or parcel you have comps for.
- [Israel Land Tenders](https://apify.com/swerve/israel-land-tenders) - who bought state land nearby, and for how much.
- [Yad2 Real Estate Scraper](https://apify.com/swerve/yad2-scraper) - what is on the market right now, to compare asking prices against these recorded sales.

### When the government source is having a bad day

The deals come from GovMap, and GovMap's own service degrades in waves: measured on 2026-09-07, 70% of requests came back as gateway errors for a stretch. This Actor rides those windows out instead of giving up, retrying each request several times on a fresh Israeli IP with a jittered backoff.

That means **a run can take noticeably longer while the source is struggling, and that is the Actor working, not hanging**. On a live comparison during a bad window, the previous behaviour returned 71 deals for a city while the current one returned 145 for the identical query. For comps work an incomplete answer is worse than a slow one, so completeness wins.

# Actor input Schema

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

Pick one or more cities from the list (the most active real-estate cities are included). Each city is geocoded and sale transactions around its center are collected. For a town not listed, use "Other cities" below.

## `customCities` (type: `array`):

Any city/town NOT in the dropdown, typed in Hebrew (for example a small town or moshav). Optional.

## `neighborhoods` (type: `array`):

Narrow to specific neighborhoods within the chosen city, in Hebrew. When set, each neighborhood is geocoded inside the city and only deals whose neighborhood matches are returned. Leave empty for the whole city. To find exact names, run once with just the city and read the neighborhoodName field in the results.

## `dealDateRange` (type: `string`):

How far back to fetch sold transactions.

## `rooms` (type: `string`):

Filter by number of rooms. Comma-separated, e.g. "3,4" for 3 or 4-room apartments. Leave empty for all.

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

Only deals at or above this sale price.

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

Only deals at or below this sale price.

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

Caps how many transactions are returned and billed. Leave empty for everything in scope. Worth knowing about speed: the crawl tiles the city and stops as soon as this many deals are found, so a small cap returns in seconds. A cap LARGER than the number of deals that actually exist in the chosen time range can never stop early, so it sweeps the whole city and can take 15+ minutes on a dense one. Widen the time range as well as the cap if you want a big pull.

## Actor input object example

```json
{
  "cities": [
    "רעננה"
  ],
  "dealDateRange": "3",
  "maxItems": 20
}
```

# 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 = {
    "cities": [
        "רעננה"
    ],
    "dealDateRange": "3",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/nadlan-deals").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 = {
    "cities": ["רעננה"],
    "dealDateRange": "3",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("swerve/nadlan-deals").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 '{
  "cities": [
    "רעננה"
  ],
  "dealDateRange": "3",
  "maxItems": 20
}' |
apify call swerve/nadlan-deals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,swerve/nadlan-deals"
        }
    }
}

```

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/lvHHuhOAyskG27T1n/builds/mR650JZghHdFAlqRS/openapi.json