# Israel Building Permits - Tel Aviv, TAMA 38 & Status (`swerve/israel-building-permits`) Actor

Building permits and permit requests from Israeli municipal planning systems: permit number and date, address, housing units, TAMA 38 urban-renewal flags, request type, construction start, occupancy and the official document link.

- **URL**: https://apify.com/swerve/israel-building-permits.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 permits

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 Building Permits (Tel Aviv-Yafo)

Building permits and permit requests straight from the municipal planning system: permit number and date, address, housing units, **TAMA 38 urban-renewal flags**, request type, construction start, occupancy date, and a link to the official document.

### Why this is hard to get anywhere else

Israel has **no national building-permit feed**. The Planning Administration's licensing system is not public, and the national open-data portal carries no permit dataset. Permits exist only inside each municipality's own GIS, in Hebrew, behind a slow and rate-limited server. This Actor does that work for you and returns clean, typed, English-keyed rows.

Coverage today is **Tel Aviv-Yafo**, which publishes the richest permit layer in the country: 10,500+ permits and requests, of which about 2,200 are TAMA 38.

### Use cases

- **Urban-renewal developers** finding every TAMA 38 project on a street, with unit counts and how far each has progressed
- **Real-estate agents** spotting buildings about to be renewed before they are marketed
- **Appraisers** checking what was approved on a parcel, the relief granted, and the occupancy date
- **Investors** tracking permit volume and added housing units by area over time
- **Proptech products** joining permits to listings and sold prices by address

### Input

| Field | Type | Description |
|-------|------|-------------|
| `addresses` | array | Hebrew addresses in Tel Aviv, each geocoded then searched within the radius. Leave empty to sweep the whole city |
| `radiusMeters` | integer | How far around each address to search. Default 300 |
| `onlyTama38` | boolean | Only TAMA 38 urban-renewal permits |
| `permitFrom` / `permitTo` | string | Permit granted between these dates (YYYY-MM-DD) |
| `minHousingUnits` | integer | Only permits adding at least this many units |
| `requestTypeContains` | string | Hebrew match on request type, e.g. `תוספת`, `שימוש חורג` |
| `addressContains` | string | Hebrew street name, searched city-wide with no geocoding |
| `bbox` | string | Search a rectangle: `minLng,minLat,maxLng,maxLat` |
| `includeBuildingStatus` | boolean | Adds preservation-list and dangerous-building status for each permit's parcel. Default false |
| `includeGeometry` | boolean | Add latitude/longitude for each permit. Default true |
| `maxItems` | integer | Optional cost cap. Blank returns every match |

#### Example input

```json
{ "addresses": ["רוטשילד 15 תל אביב"], "radiusMeters": 600, "onlyTama38": true }
```

### Output

Each row is one permit or permit request. `isPermitGranted` tells the two apart: a request still in the pipeline has no permit number or date, and must not be read as an approval.

```json
{
  "city": "Tel Aviv-Yafo",
  "isPermitGranted": true,
  "permitNumber": 20200460,
  "permitDate": "2020-09-07",
  "addresses": "שדרות נורדאו 43, יחזקאל 1",
  "housingUnits": 2,
  "isTama38": false,
  "requestType": "שינויים הארכת תוקף החלטה",
  "constructionStartDate": null,
  "documentUrl": "https://archive-binyan.tel-aviv.gov.il/pages/results.aspx?owstikid=01970430",
  "latitude": 32.09211,
  "longitude": 34.77843
}
```

#### Building status (`includeBuildingStatus`)

Two facts a developer needs before touching a building, joined from the city's own layers by parcel geometry:

- `isPreservationListed` - the parcel is on the municipal preservation list, which constrains what may be built (2,861 listed areas city-wide)
- `isDangerousBuilding` + `dangerousBuildingOrder` - a dangerous-building order is on the parcel, often a prime urban-renewal candidate (610 orders city-wide)

Both are **null when you leave the toggle off**, meaning "not checked" rather than "clear". A parcel is never reported as safe on the strength of a lookup that never ran.

Amenity-style flags are **tri-state**: `true`, `false`, or `null` when the municipality does not say. They are never silently reported as false.

### How it works

Queries the city's ArcGIS permit layer directly, paging to completion with no hidden caps. The server is slow and refuses datacenter IPs after a burst, so each retry alternates between a direct connection and an Israeli residential proxy, whichever is answering. Results are written to the dataset as each page arrives, so a long run never loses what it already collected.

If an address falls outside the covered city, the run **fails and says so** rather than returning an empty result that looks like "no permits here". The geocoder is fuzzy and will happily resolve nonsense to a village 100 km away, so every point is checked against the city's real coverage first.

### Limits

- Tel Aviv-Yafo only for now. Other cities are one config entry each and are being added.
- The city publishes both granted permits and open requests; use `isPermitGranted` to separate them.
- Hebrew free-text fields are returned as the municipality wrote them, untranslated.

### Also Available

- [Israel Zoning Plans](https://apify.com/swerve/israel-zoning-plans) - what may be built on a block: plan status, approval date, documents
- [Israel Land Use](https://apify.com/swerve/israel-land-use) - the official land-use designation for any address
- [Israel Land Tenders](https://apify.com/swerve/israel-land-tenders) - state land auctions with winning bidder and amount paid
- [Israel Sold Property Prices](https://apify.com/swerve/nadlan-deals) - recorded sale prices for comps
- [Yad2 Real Estate](https://apify.com/swerve/yad2-scraper) - live asking prices across Israel

### Keywords

Israel building permits, TAMA 38 scraper, Tel Aviv building permits, היתרי בנייה, תמ"א 38, Israeli urban renewal data, Israel construction permits API, Tel Aviv planning data, Israeli real estate data

# Actor input Schema

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

Hebrew addresses or place names in Tel Aviv-Yafo. Each one is geocoded and searched within the radius below. Example: "רוטשילד 15 תל אביב", "שינקין 20 תל אביב". Leave empty to sweep the whole city.

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

How far around each address to look. 300 m covers a block; 1000 m covers a neighbourhood.

## `onlyTama38` (type: `boolean`):

Return only permits flagged as TAMA 38 (earthquake-retrofit and urban-renewal projects). About 1 in 5 Tel Aviv permits qualify.

## `permitFrom` (type: `string`):

Only permits granted on or after this date. Format YYYY-MM-DD, e.g. 2023-01-01.

## `permitTo` (type: `string`):

Only permits granted on or before this date. Format YYYY-MM-DD, e.g. 2026-12-31.

## `minHousingUnits` (type: `integer`):

Only permits adding at least this many housing units. Use 1 to skip permits that add none (signage, use changes).

## `includeBuildingStatus` (type: `boolean`):

For each permit, check whether its parcel is on the preservation list (which restricts what may be built) and whether it has a dangerous-building order (a prime urban-renewal target). Adds a few requests per run.

## `requestTypeContains` (type: `string`):

Hebrew text matched against the request type. Examples: "תוספת" (addition), "שימוש חורג" (non-conforming use), "הריסה" (demolition).

## `addressContains` (type: `string`):

Hebrew street name matched against the permit address, e.g. "דיזנגוף". Searches the whole city, no geocoding needed.

## `bbox` (type: `string`):

Search a rectangle instead of an address, as minLng,minLat,maxLng,maxLat. Example: 34.770,32.062,34.782,32.070

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

Adds latitude and longitude for each permit, taken from the centre of its parcel. Turning this off makes runs slightly faster.

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

Optional cap on how many permits to return, to limit cost. Leave blank to get every permit that matches.

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

Israeli residential proxy is used by default. The municipal GIS is reachable without one, so this rarely needs changing.

## Actor input object example

```json
{
  "addresses": [
    "רוטשילד 15 תל אביב"
  ],
  "radiusMeters": 300,
  "onlyTama38": false,
  "includeBuildingStatus": false,
  "includeGeometry": true,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `permits` (type: `string`):

All matching permits and requests (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": [
        "רוטשילד 15 תל אביב"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/israel-building-permits").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": ["רוטשילד 15 תל אביב"] }

# Run the Actor and wait for it to finish
run = client.actor("swerve/israel-building-permits").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": [
    "רוטשילד 15 תל אביב"
  ]
}' |
apify call swerve/israel-building-permits --silent --output-dataset

```

## MCP server setup

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

```

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/9b9paTjmAnffSz9OA/builds/Q1AIQPTlg7RsNLcwp/openapi.json