# Israel Land Use - What Any Plot May Be Built For (`swerve/israel-land-use`) Actor

Israel's official land-use designations from the national planning map: what each plot is zoned for (residential, commercial, open space and more), the plan that sets it, the planning status, the area and the coordinates. Search by address, plan number or map area.

- **URL**: https://apify.com/swerve/israel-land-use.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 land use areas

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 Land Use - What Any Plot May Be Built For

Give it an Israeli address and get the official land-use designation for that spot: residential, commercial, employment, open space, road, public buildings and the rest, straight from the national planning map. Every area comes with the plan that sets it, that plan's status, the area in square metres and map coordinates.

This is the first question in any Israeli property decision, and the answer is normally buried in a map viewer.

![What may be built here](https://api.apify.com/v2/key-value-stores/sNetpjj18h0cmb0pK/records/landuse-img-address.png)

### The field that matters

Every row carries **`coversSearchPoint`**: true when that designation actually applies at the address you asked about, false when it is merely nearby. Large designations such as national plans can stretch for kilometres, so "near your address" and "at your address" are very different answers, and this tells them apart.

![Queried three ways](https://api.apify.com/v2/key-value-stores/sNetpjj18h0cmb0pK/records/landuse-img-coverage.png)

### What you get

| Field | Example |
|---|---|
| `landUse`, `landUseCode` | "מגורים ג'" (residential), 680 |
| `coversSearchPoint` | true - this is the designation at your address |
| `planNumber`, `planName` | "416-0447284", the plan's Hebrew name |
| `planningStatus` | "אישור" (approved), "בבדיקה תכנונית" (under review) |
| `areaSqm`, `registeredAreaDunam`, `perimeterMeters` | 14831147.32, 0, 980.39 |
| `latitude`, `longitude` | 32.1893702, 34.8666297 |
| `geometryRings` | The full polygon outline, when you ask for it |
| `distanceMeters` | Distance from your address to the area's centre |
| `lastUpdated` | 2018-12-04 |

### Input

| Field | What it does |
|---|---|
| `addresses` | Hebrew addresses or place names, e.g. \["אחוזה 100 רעננה"]. Each is located on the map. |
| `radiusMeters` | How far around each address to collect areas. 300 covers a block, 1000 a neighbourhood. |
| `planNumbers` | Every area a given plan defines, e.g. \["302-0072793"]. Plan numbers come from our [Israel Zoning Plans Actor](https://apify.com/swerve/israel-zoning-plans). |
| `boundingBox` | Sweep a rectangle: {"minLat":32.17,"minLng":34.86,"maxLat":32.19,"maxLng":34.88}. |
| `landUseContains` | Keep only designations containing this Hebrew text, e.g. "מגורים" for residential. |
| `includeGeometry` | Adds the full polygon outline for mapping software. Centre coordinates are always returned. |
| `maxItems` | Optional cost cap. Blank returns everything that matches. |

#### Example: what applies at one address

```json
{ "addresses": ["אחוזה 100 רעננה"], "radiusMeters": 300 }
```

#### Example: every residential area in a neighbourhood

```json
{ "addresses": ["דיזנגוף 50 תל אביב"], "radiusMeters": 1000, "landUseContains": "מגורים" }
```

### How it works

Addresses are located through the government map service, then the national land-use layer is queried for everything intersecting the radius, 1,000 rows at a time until the area is exhausted. Results are de-duplicated across all your searches and pushed as they arrive, so a stopped run keeps what it already collected. The polygon is used to compute each area's centre point and to test whether it contains your address.

### Limits, stated honestly

- **A radius is a circle, not a municipal boundary.** Asking for a city name returns what surrounds that point, not everything inside the city limits.
- **Designations are returned in Hebrew** exactly as the planning authority publishes them, because that is the legally meaningful wording.
- **An address that cannot be located fails the run** rather than quietly returning nothing.
- `registeredAreaDunam` is the registered area in dunam as published, and is 0 when the plan states none. `areaSqm` is the computed polygon area and is always present.
- Land use tells you what a plan permits. It is not a building permit, and it does not tell you what is built there today.

### Related

- [Israel Zoning Plans](https://apify.com/swerve/israel-zoning-plans) - the plans behind these designations, with their official documents.
- [Israel Land Tenders](https://apify.com/swerve/israel-land-tenders) - state land auctions, including winning bids.
- [Israel Sold Property Prices](https://apify.com/swerve/nadlan-deals) - recorded sale prices for the same areas.
- [Israel Building Permits](https://apify.com/swerve/israel-building-permits) - what has actually been permitted and built there, as opposed to what the plan allows.

# Actor input Schema

## `addresses` (type: `array`):

Hebrew addresses or place names, e.g. \["אחוזה 100 רעננה", "דיזנגוף 50 תל אביב"]. Each one is located on the map and every land-use area within the radius below is returned.

## `radiusMeters` (type: `integer`):

How far around each address to collect land-use areas. 300 covers a block, 1000 covers a neighborhood. This is a radius around a point, not a municipal boundary.

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

Return every land-use area defined by these plans, e.g. \["302-0072793"]. Plan numbers come from our Israel Zoning Plans Actor.

## `boundingBox` (type: `object`):

Advanced: collect everything inside a rectangle, as {"minLat":32.17,"minLng":34.86,"maxLat":32.19,"maxLng":34.88}. Use this instead of addresses to sweep a whole area.

## `landUseContains` (type: `string`):

Keep only areas whose designation contains this Hebrew text, e.g. "מגורים" for residential or "מסחר" for commercial. Leave empty for every designation.

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

Optional cap on results. Leave blank to return ALL matching land-use areas (recommended); set a number only to limit cost.

## `includeGeometry` (type: `boolean`):

Adds the full polygon outline of each area, for mapping software. The centre point is always returned, so leave this off unless you need the exact shape.

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

The government map service answers without a proxy, so the default is no proxy.

## Actor input object example

```json
{
  "addresses": [
    "אחוזה 100 רעננה"
  ],
  "radiusMeters": 300,
  "includeGeometry": false,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `landUseAreas` (type: `string`):

All matching land-use areas (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 = {
    "addresses": [
        "אחוזה 100 רעננה"
    ],
    "proxyConfig": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/israel-land-use").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 = {
    "addresses": ["אחוזה 100 רעננה"],
    "proxyConfig": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("swerve/israel-land-use").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 '{
  "addresses": [
    "אחוזה 100 רעננה"
  ],
  "proxyConfig": {
    "useApifyProxy": false
  }
}' |
apify call swerve/israel-land-use --silent --output-dataset

```

## MCP server setup

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

```

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/u68eVtlKlce6DTUsx/builds/9ZdcfVsyWOAdQFw6e/openapi.json