# Madlan Deal Finder - Underpriced Israel Real Estate (`swerve/madlan-deal-analyzer`) Actor

AI-powered deal finder - compares active listings against recent real estate transactions to find properties priced below market value. Covers 140+ Israeli cities on Madlan.co.il.

- **URL**: https://apify.com/swerve/madlan-deal-analyzer.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** Real estate, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Deal Analyzer — Find Underpriced Israeli Real Estate

AI-powered deal finder that identifies **underpriced apartments and houses** on [Madlan.co.il](https://www.madlan.co.il) by comparing active listings against recent transaction data from the Israeli land registry. Every listing gets a deal score (0-100) so you can instantly spot below-market opportunities.

### Features

- **Deal scoring** — every listing rated 0-100 based on how far below estimated market value it's priced
- **Real transaction comparisons** — compares active listings against recent land-registry sales, not other listings
- **Neighbourhood-level analysis** — benchmarks each property against deals in the same neighbourhood, not the whole city
- **Estimated market value** — AI-derived fair price for each listing, based on rooms, sqm, and neighbourhood comparables
- **Plain-English insights** — Hebrew/English text explaining why each listing is a deal (e.g. "18% below comparable 3-room apartments in Florentin")
- **140+ Israeli cities** — scan Tel Aviv, Jerusalem, Haifa, Ramat Gan, or all cities at once
- **Neighbourhood ratings** — each deal includes safety, school, and community scores from Madlan
- **Configurable thresholds** — tune `minScore` from 55 (more deals, lower quality) to 80+ (only screaming deals)

### Use Cases

- **Real estate investors** scanning Tel Aviv and Ramat Gan daily for 15%+ below-market buy opportunities before competing investors spot them
- **Buy-side agents** building a pipeline of underpriced listings to pitch to investor clients with quantified discount evidence
- **Property flippers** identifying undervalued apartments in renovating neighbourhoods (Florentin, Kiryat Yovel) with room for value-add
- **Real estate funds** sourcing deal flow at scale across multiple cities, filtered by minimum score and neighbourhood
- **Mortgage originators and brokers** validating that borrower-stated purchase prices are reasonable (or flagging overpayment risk)
- **PropTech startups** powering deal-alert products, investor dashboards, and AVM comparables without building the transaction-matching engine themselves

### How It Works

1. Fetches active listings from the target city/neighbourhood on Madlan
2. Pulls recent land-registry transaction history for the same area
3. For each listing, finds comparable deals (same rooms, similar sqm, same neighbourhood)
4. Computes a fair market estimate from the comparables
5. Scores the listing: bigger discount = higher score
6. Returns only listings with score ≥ `minScore`, sorted best-first

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `city` | string | `"Tel Aviv"` | City name (Hebrew/English), comma-separated, or `"all"` |
| `dealType` | string | `"buy"` | Only `"buy"` is supported (rental transactions aren't in the Israeli land registry) |
| `neighbourhood` | string | — | Filter to specific neighbourhoods (Hebrew names, comma-separated) |
| `minScore` | integer | `65` | Minimum deal score to include (0-100). 65 = below market, 75+ = great deal |
| `maxListings` | integer | `500` | Max active listings to analyze per city |
| `monthsBack` | integer | `120` | Months of transaction history to use. Israeli land registry lags 5-7 years, so keep this high |

#### Example Input

```json
{
  "city": "Tel Aviv",
  "neighbourhood": "פלורנטין, שפירא",
  "minScore": 70,
  "maxListings": 500,
  "monthsBack": 120
}
````

### Output

Each returned deal includes:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Madlan listing ID |
| `url` | string | Direct link to the listing on Madlan |
| `address` | string | Full address |
| `neighbourhood` | string | Neighbourhood name in Hebrew |
| `city` | string | City name in English |
| `cityHebrew` | string | City name in Hebrew |
| `askingPrice` | number | Asking price in ILS |
| `askingPricePerSqm` | number | Asking price per sqm |
| `rooms` | number | Number of rooms |
| `areaSqm` | number | Area in sqm |
| `floor` | number | Floor number |
| `condition` | string | Property condition (renovated, new, etc.) |
| `propertyType` | string | Apartment, penthouse, house, etc. |
| `images` | array | Listing image URLs |
| `dealScore` | number | 0-100 deal score (higher = better deal) |
| `discountPercent` | number | % below estimated market value |
| `comparableDeals` | number | How many recent transactions were used as comparables |
| `avgComparablePricePerSqm` | number | Average price/sqm of comparables |
| `medianComparablePricePerSqm` | number | Median price/sqm of comparables |
| `estimatedMarketValue` | number | Fair price based on comparables |
| `insight` | string | Plain-language explanation of why this is a deal |
| `neighbourhoodStats` | object | Neighbourhood avg/median prices, deal count, and ratings (safety, schools, community) |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Example Output

```json
{
  "listingId": "m7k2pq91",
  "url": "https://www.madlan.co.il/listings/m7k2pq91",
  "address": "ז'בוטינסקי 142, תל אביב יפו",
  "neighbourhood": "פלורנטין",
  "city": "Tel Aviv",
  "cityHebrew": "תל אביב יפו",
  "askingPrice": 2450000,
  "askingPricePerSqm": 38281,
  "rooms": 3,
  "areaSqm": 64,
  "floor": 2,
  "condition": "משופצת",
  "propertyType": "apartment",
  "dealScore": 78,
  "discountPercent": 17.4,
  "comparableDeals": 12,
  "avgComparablePricePerSqm": 46300,
  "medianComparablePricePerSqm": 45800,
  "estimatedMarketValue": 2965000,
  "insight": "Priced 17% below comparable 3-room apartments recently sold in Florentin. 12 comparable deals averaged ₪46,300/sqm vs. this listing's ₪38,281/sqm.",
  "neighbourhoodStats": {
    "name": "פלורנטין",
    "avgPricePerSqm": 46300,
    "medianPricePerSqm": 45800,
    "dealCount": 142,
    "avgPrice": 2950000,
    "ratings": { "safety": 7.2, "schools": 6.8, "community": 8.1 }
  },
  "scrapedAt": "2026-04-20T10:30:00.000Z"
}
```

### Tips

- **Start with `minScore: 65`** to see inventory, then raise to 75+ once you learn your market
- **Use `monthsBack: 120`** or higher — Israeli land-registry data lags real-time by years
- **Filter by neighbourhood** for the sharpest signal — city-wide averages hide intra-city variation
- **Run daily or hourly** via Apify schedules to catch new listings before other investors

### Also Available

- [Yad2 Real Estate Scraper](https://apify.com/swerve/yad2-scraper) — Israel's #1 classifieds, 800+ listings per city
- [Madlan Real Estate Scraper](https://apify.com/swerve/madlan-scraper) — Israel's most data-rich property platform
- [Madlan Market Analytics](https://apify.com/swerve/madlan-analytics) — neighbourhood-level market data, demographics, insights
- [Homeless.co.il Scraper](https://apify.com/swerve/homeless-scraper) — one of Israel's oldest real estate classifieds
- [Spitogatos Scraper](https://apify.com/swerve/spitogatos-scraper) — Greece & Cyprus real estate listings

### Keywords

Madlan deal analyzer, Israeli real estate deals, underpriced apartments Tel Aviv, Israel property investment tool, real estate deal scoring, below market listings Israel, Israeli land registry comparables, AVM Israel, Tel Aviv investment properties, Jerusalem real estate deals, Israeli property analytics, Madlan transaction data, real estate arbitrage Israel

# Actor input Schema

## `city` (type: `string`):

City name in Hebrew or English. Comma-separated for multiple cities. Use 'all' for all 140+ cities.

## `dealType` (type: `string`):

Analyze buy listings against real transaction data. Rental analysis is not available (land registry only records purchases).

## `neighbourhood` (type: `string`):

Only analyze specific neighborhoods (comma-separated Hebrew names). Leave empty for all neighborhoods in the city.

## `minScore` (type: `integer`):

Only return listings with a deal score above this threshold (0-100). Higher = better deal. 65 = below market, 70 = good deal, 80+ = great deal. Lower this to 55 for more results, raise to 75+ for only the best deals.

## `maxListings` (type: `integer`):

Maximum number of active listings to analyze per city.

## `monthsBack` (type: `integer`):

How many months of transaction history to use for comparison. Note: Israeli land registry data typically lags 5-7 years behind real time, so use a large window (120+ months) for best results.

## Actor input object example

```json
{
  "city": "Tel Aviv",
  "dealType": "buy",
  "minScore": 65,
  "maxListings": 500,
  "monthsBack": 120
}
```

# 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 = {
    "city": "Tel Aviv"
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/madlan-deal-analyzer").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 = { "city": "Tel Aviv" }

# Run the Actor and wait for it to finish
run = client.actor("swerve/madlan-deal-analyzer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "city": "Tel Aviv"
}' |
apify call swerve/madlan-deal-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=swerve/madlan-deal-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Madlan Deal Finder - Underpriced Israel Real Estate",
        "description": "AI-powered deal finder - compares active listings against recent real estate transactions to find properties priced below market value. Covers 140+ Israeli cities on Madlan.co.il.",
        "version": "1.0",
        "x-build-id": "W25RzFU987ulls2Ms"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swerve~madlan-deal-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swerve-madlan-deal-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/swerve~madlan-deal-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-swerve-madlan-deal-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/swerve~madlan-deal-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-swerve-madlan-deal-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "city"
                ],
                "properties": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name in Hebrew or English. Comma-separated for multiple cities. Use 'all' for all 140+ cities."
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "buy"
                        ],
                        "type": "string",
                        "description": "Analyze buy listings against real transaction data. Rental analysis is not available (land registry only records purchases).",
                        "default": "buy"
                    },
                    "neighbourhood": {
                        "title": "Neighbourhood Filter (שכונה)",
                        "type": "string",
                        "description": "Only analyze specific neighborhoods (comma-separated Hebrew names). Leave empty for all neighborhoods in the city."
                    },
                    "minScore": {
                        "title": "Minimum Deal Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return listings with a deal score above this threshold (0-100). Higher = better deal. 65 = below market, 70 = good deal, 80+ = great deal. Lower this to 55 for more results, raise to 75+ for only the best deals.",
                        "default": 65
                    },
                    "maxListings": {
                        "title": "Max Listings to Analyze",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Maximum number of active listings to analyze per city.",
                        "default": 500
                    },
                    "monthsBack": {
                        "title": "Transaction History (months)",
                        "minimum": 6,
                        "maximum": 240,
                        "type": "integer",
                        "description": "How many months of transaction history to use for comparison. Note: Israeli land registry data typically lags 5-7 years behind real time, so use a large window (120+ months) for best results.",
                        "default": 120
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
