# Israel Zoning Plans - Land Use, Status & Documents (`swerve/israel-zoning-plans`) Actor

Search Israel's official zoning plan database by block (gush), parcel (helka), plan number or city. Returns plan number, city, description, approval status and date, plus links to the official regulations, site-plan and GIS documents.

- **URL**: https://apify.com/swerve/israel-zoning-plans.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 zoning plans

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 Zoning Plans Scraper - Tabaot by Block, Parcel or City

Search Israel's official national zoning-plan database (תכניות בניין עיר) and get clean structured data: plan number, city, what the plan permits, its approval status and date, and direct links to the binding regulations, the site plan and the GIS files.

This is the data that decides what may be built on a piece of land. Appraisers, developers, land investors, architects and lawyers check it before every deal.

### Why this instead of the government site

The government search returns **at most 150 plans per query** and picks which 150. This Actor detects that limit and splits the query automatically, so a dense block returns everything. On block 3946 the official site shows 150 plans; this Actor returns **226**.

![The government search stops at 150 plans; this Actor returns 226](https://api.apify.com/v2/key-value-stores/sNetpjj18h0cmb0pK/records/zoning-img-cap.png)

### What you get

![One row per zoning plan, with the fields returned](https://api.apify.com/v2/key-value-stores/sNetpjj18h0cmb0pK/records/zoning-img-fields.png)

| Field | Example |
|---|---|
| `planNumber`, `planId`, `planUrl` | "416-0447284", "4023472", link to the official page |
| `city`, `description` | "רעננה", "רע/מק/1010א - תכנית בסמכות ועדה מקומית מכוח סעיף 23 לתמ״א 38" |
| `status`, `statusDate`, `isApproved` | "פרסום לתוקף בעיתונים", "2019-11-22", true |
| `regulationsUrl` | Direct PDF of the binding regulations (takanon) |
| `sitePlanUrl` | Direct PDF of the site plan drawing (tasrit) |
| `gisFilesUrl` | ZIP of the plan's GIS layers, for mapping software |
| `documents[]` | Every published file: `{ kind, name, url }` |
| `queryBlock`, `queryParcel`, `queryCity` | Which of your search targets returned this plan |

Dates are normalized to `YYYY-MM-DD`. `isApproved` is true when the plan is in force, false while it is still in process, and null when the status is one we do not recognize, so an unknown status never silently looks rejected.

### Input

| Field | What it does |
|---|---|
| `blocks` | The reliable way to get complete results. `"6586"` for a whole block, `"6586/450"` for one parcel. These numbers appear on every Israeli title deed and sale record. |
| `planNumbers` | Exact plan numbers, e.g. `"רע/2000/ב"` or `"507-0829788"`. |
| `cities` | City names in Hebrew. Capped at 150 by the source, see below. |
| `statuses` | Deposited, objections, decision to approve, approved. |
| `fromStatusDate` / `toStatusDate` | Filter by when the current status was set. Applied by this Actor after fetching, because the source accepts date filters but ignores them. |
| `maxItems` | Optional cost cap. Blank returns everything that matches. |
| `includeDocuments` | On by default. Adds the document links at no extra requests. |

#### Example: everything on one parcel

```json
{ "blocks": ["6586/450"] }
```

#### Example: three blocks, approved plans only

```json
{ "blocks": ["6586", "6213", "7104"], "statuses": ["approved"] }
```

### How it works

One search request per target against the government plan-search API. Results are de-duplicated by plan id across all your targets, and pushed to the dataset as they arrive, so a stopped run keeps everything already collected. When a block comes back at the source's 150-row limit, the Actor re-queries that block once per plan type and merges the results, which is how it returns more than the website does.

### Limits, stated honestly

- **City searches are capped by the source at 150 plans**, no matter how many exist. The run logs how many the source says exist and how many are therefore missing, and it tells you to search by block instead. It never pretends a capped city search was complete.
- **The source ignores date filters**, so this Actor applies them itself after fetching. A plan whose date cannot be read is kept rather than dropped.
- Plans are published in Hebrew and returned in Hebrew, exactly as the government publishes them.
- Very dense blocks can still hit the limit inside a single plan type. The run warns and tells you to narrow to a parcel.

### Export formats

JSON, CSV, Excel, XML or HTML, from the Console or the API (`/v2/datasets/{datasetId}/items?format=csv`).

### Use cases

- **Due diligence before a purchase**: pull every plan touching the block and parcel, and read the binding regulations.
- **Development potential**: find blocks with recently approved plans that raise building rights.
- **Appraisal**: cite the plan number, status and date behind a valuation.
- **Monitoring**: run weekly on your blocks and diff to catch newly deposited or approved plans.

### Related

- [Israel Land Tenders](https://apify.com/swerve/israel-land-tenders) - state land auctions with reserve prices, deadlines and the winning bidders. Each lot carries its zoning plan number, which you can feed straight into this Actor.
- [Israel Sold Property Prices](https://apify.com/swerve/nadlan-deals) - recorded sale transactions, searchable by the same block and parcel numbers.

# Actor input Schema

## `blocks` (type: `array`):

The reliable way to get COMPLETE results. Write a block on its own ("6586") for every plan on that block, or block/parcel ("6586/450") for one parcel. Israeli land is identified by these numbers and they appear on every title deed and sale record.

## `planNumbers` (type: `array`):

Exact plan numbers as published, e.g. "תמל/1043" or "507-0829788". Returns that plan and its related plans.

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

City names in Hebrew, e.g. "תל אביב -יפו". WARNING: the government source returns at most 150 plans per city no matter how many exist, and it picks which 150. The run reports how many exist so you know what is missing. For complete coverage list the blocks instead.

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

Optional cap on results. Leave blank to return ALL plans matching your search (recommended); set a number only to limit cost.

## `statuses` (type: `array`):

Only plans currently at these stages. Leave empty for all stages.

## `fromStatusDate` (type: `string`):

Only plans whose current status was set on or after this date, e.g. 2020-01-01. Applied by this Actor after fetching, because the source ignores date filters.

## `toStatusDate` (type: `string`):

Only plans whose current status was set on or before this date, e.g. 2026-12-31.

## `includeDocuments` (type: `boolean`):

Adds direct links to the official PDF regulations, site plan, appendices and the GIS file bundle for each plan. No extra requests, so leave it on.

## `proxyConfig` (type: `object`):

The government source answers without a proxy, so the default is no proxy. Only switch it on if you see blocks.

## Actor input object example

```json
{
  "blocks": [
    "6586/450"
  ],
  "includeDocuments": true,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `plans` (type: `string`):

All matching zoning plans (JSON). Append ?format=csv for CSV.

# 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 = {
    "blocks": [
        "6586/450"
    ],
    "proxyConfig": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/israel-zoning-plans").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 = {
    "blocks": ["6586/450"],
    "proxyConfig": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("swerve/israel-zoning-plans").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 '{
  "blocks": [
    "6586/450"
  ],
  "proxyConfig": {
    "useApifyProxy": false
  }
}' |
apify call swerve/israel-zoning-plans --silent --output-dataset

```

## MCP server setup

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

```

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/2SFUbqBrZef6BOqgf/builds/XIEigPDSWSgBItIux/openapi.json