# Yad2 Real Estate Scraper - Israel Property & Leads (`haketa/yad2-scraper`) Actor

Scrape Yad2.co.il real estate listings in Israel — apartments and houses for sale and rent. Extract price, rooms, size in m2, address, neighborhood, GPS, features, seller contact and images by search URL. Export JSON, CSV, Excel for property research and lead generation.

- **URL**: https://apify.com/haketa/yad2-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 38 total users, 12 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Yad2 Real Estate Scraper — Israel Property Listings, Prices, GPS & Seller Leads

> **Extract structured real estate listings from Yad2.co.il — Israel's #1 property and classifieds marketplace.** Pull live apartments, houses, penthouses, cottages, duplexes, and plots **for sale and for rent** across Tel Aviv, Jerusalem, Haifa, Rishon LeZion, Petah Tikva, Netanya, Herzliya, Beer Sheva, and every Israeli municipality — complete with **price in ₪ (ILS)**, **rooms**, **size in m²**, **floor**, **street address & neighborhood**, **GPS coordinates**, **seller contact name**, **private-owner vs. agency indicator**, full photo galleries, and optional **full property descriptions**.

Export clean, de-duplicated data to **JSON, CSV, Excel, or the Apify API** — no login, no manual copy-pasting.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com/haketa/yad2-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20at%20Run%20Time-orange)]()
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20Results%20Pagination-green)]()
[![Pricing](https://img.shields.io/badge/Pricing-Pay%20Per%20Result-yellow)]()
[![Region](https://img.shields.io/badge/Region-Israel%20%F0%9F%87%AE%F0%9F%87%B1-red)]()
[![Coverage](https://img.shields.io/badge/Coverage-Sale%20%26%20Rent-purple)]()
[![Leads](https://img.shields.io/badge/Includes-Seller%20Contact-success)]()
[![Geo](https://img.shields.io/badge/Includes-GPS%20%26%20Features-brightgreen)]()
[![Export](https://img.shields.io/badge/Export-JSON%20%C2%B7%20CSV%20%C2%B7%20Excel-lightgrey)]()

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| 🎯 **Target platform** | **[Yad2.co.il (יד2)](https://www.yad2.co.il)** — Israel's largest real estate & classifieds marketplace |
| 🏘️ **Listing categories** | Apartments, Private Houses / Cottages, Penthouses, Duplexes, Garden Apartments, Studios & Plots — **For Sale (`realestate/forsale`)** & **For Rent (`realestate/rent`)** |
| 📍 **Location & Geo** | City, Neighborhood, Street Name, House Number + exact **GPS `latitude` & `longitude`** on ~100% of records |
| 👤 **Lead generation** | Seller `contactName` (~100% fill) + `merchant` boolean (`"false"` = FSBO private owner, `"true"` = real estate agency / brokerage) |
| 📝 **Detail enrichment** | Optional `includeDetails: true` adds full Hebrew `description`, `totalFloor` (building height), and `dateOfEntry` |
| 🔁 **Pagination & Scale** | Automatic multi-page traversal supporting **1,000+ results pagination** per run with zero duplicates (`link_token` deduplication) |
| ⚡ **Speed** | ~100–200 listings in 15–30 seconds (feed mode); ~400 listings in ~47 seconds |
| 📦 **Bulk export** | JSON, JSONL, CSV, Excel (XLSX), HTML, XML, RSS, and direct REST API endpoints |

***

### 🔎 Why scrape Yad2?

**[Yad2 (יד2)](https://www.yad2.co.il)** is the foundational real estate marketplace in Israel. The overwhelming majority of residential properties **for sale (נדל"ן למכירה)** and **for rent (נדל"ן להשכרה)** in Israel are listed on Yad2 first — posted by both private homeowners (FSBO / ללא תיווך) and licensed real estate brokerages (תיווך). Whether you are analyzing asking prices in Tel Aviv-Yafo, tracking new rental inventory in Jerusalem and Haifa, or sourcing off-market seller leads in Gush Dan and the Sharon plain, **Yad2 data** is the primary market signal.

However, turning Yad2's web interface into an analytics dataset or CRM pipeline by hand is slow and fragile:

- **Deep multi-page result sets:** A single city or regional query spans dozens to hundreds of result pages.
- **Hebrew RTL layout & scattered fields:** Price in ₪, room counts (חדרים), floor level (קומה), built area in square meters (מ"ר), neighborhood (שכונה), and seller type are spread across card elements.
- **Repeated promoted listings:** Promoted and bumped ads reappear across pages; without deterministic deduplication by listing token, manual exports suffer from heavy duplication.
- **Regional access requirements:** Yad2 serves full marketplace data exclusively to Israeli residential traffic.

This **Yad2 scraper** automates the entire workflow. Paste one or more Yad2 search URLs (or run with empty inputs for an instant sample of both for-sale and for-rent properties) and receive **one clean, normalized row per property** — ready for BI dashboards, automated valuation models (AVMs), GIS mapping, or broker lead-generation workflows.

#### Common reasons teams use this Yad2 data extractor

- 📊 **Price & ₪/m² benchmarking** — Calculate median asking prices and price-per-square-meter across cities, neighborhoods, and room counts.
- 💼 **FSBO & Seller Lead Generation** — Filter `merchant == "false"` to isolate private property owners (`contactName`) before competing brokerages sign them.
- 🏦 **Real Estate Investment & Yield Screening** — Compare `realestate/forsale` asking prices against `realestate/rent` monthly leases in the same neighborhood to identify high-yield pockets.
- 🏢 **Proptech & Portal Aggregation** — Populate valuation tools, mortgage calculators, and relocation platforms with fresh inventory, photos, and coordinates.
- 📈 **Brokerage Competitive Intelligence** — Filter `merchant == "true"` to monitor agency listing volume and neighborhood market share.
- 🗺️ **GIS & Spatial Price Modeling** — Plot every property directly onto a map using built-in `latitude` and `longitude` coordinates.

***

### ✨ What this Yad2 scraper does

- ✅ **For-Sale & For-Rent in a single run** — Pass `realestate/forsale` URLs, `realestate/rent` URLs, or both together. Every row is tagged with its `category`.
- ✅ **Unlocked 1,000+ results pagination** — Automatically walks page `1, 2, 3 …` up to the search's `total_pages` or your `maxItems` ceiling, collecting hundreds or thousands of listings seamlessly.
- ✅ **Zero-duplicate guarantee** — Deduplicates every listing across pages and across multiple search URLs using its unique Yad2 token and ad number.
- ✅ **Complete property fundamentals** — Extracts `adNumber`, `title`, `subtitle` (property type), `price`, `currency` (`₪`), `rooms`, `squareMeters`, `floor`, and a pipe-separated `features` summary.
- ✅ **Granular Israeli address & GPS** — Captures `city`, `neighborhood`, `street`, `addressNumber`, plus exact `latitude` and `longitude`.
- ✅ **Built-in seller lead segmentation** — Outputs `contactName` and `merchant` (`"true"` vs `"false"`) on every listing so you can separate private sellers from real estate agents immediately.
- ✅ **Full media extraction** — Collects `imageCount`, up to 30 high-resolution `images` URLs (`|`-separated), and `videoUrl` when a video tour is attached.
- ✅ **Optional deep detail enrichment (`includeDetails`)** — Enable `includeDetails: true` to fetch the full multi-paragraph property `description`, total building floors (`totalFloor`), and move-in `dateOfEntry`.
- ✅ **Zero-config fallback** — Run with empty `startUrls` and the actor automatically samples both `realestate/forsale` and `realestate/rent`.

***

### 🎯 Use cases

#### 1. Real Estate Agencies & Buyer/Seller Brokers

- **Daily FSBO lead lists:** Schedule the actor every morning on your target cities, filter `merchant == "false"`, and route new private-owner listings (`contactName`, `street`, `neighborhood`, `price`, `url`) straight into your brokerage CRM.
- **Mandate comps:** Pull every active 4-room and 5-room listing in a specific neighborhood (e.g., Ramat Aviv, Florentin, Rehavia, Carmel) to show sellers realistic comparable asking prices.

#### 2. Property Investors, Flippers & Family Offices

- **Undervalued asset discovery:** Compute `price_numeric / squareMeters` per neighborhood and flag listings priced >15% below the neighborhood median.
- **Gross rental yield heatmaps:** Run parallel pulls on `realestate/forsale` and `realestate/rent` across Beer Sheva, Haifa, Netanya, Ashkelon, and Petah Tikva to rank neighborhoods by annual rent divided by purchase price.

#### 3. Banks, Appraisers (שמאי מקרקעין) & Mortgage Advisors

- **Automated Valuation Models (AVM):** Feed historical snapshots of asking prices, room counts, floor levels, building heights (`totalFloor`), and GPS coordinates into regression and ML valuation pipelines.
- **Appraisal comparables:** Export clean Excel tables of active comparables within a 500-meter radius using `latitude` and `longitude`.

#### 4. Relocation Services & Overseas Buyer Platforms

- **English/French/Russian buyer portals:** Ingest live Yad2 inventory via API, translate `title`, `subtitle`, `neighborhood`, and `description` downstream, and power international property search portals for Anglo and diaspora buyers.

***

### 📥 Input parameters

Configure the scraper using the visual form in Apify Console or pass a JSON payload via the API. All fields are optional.

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `startUrls` | `array<string>` | For-sale + Rent | `["https://www.yad2.co.il/realestate/forsale"]` | One or more Yad2 real estate search URLs. Apply any filters on yad2.co.il (city, neighborhood, price range, rooms, m², property type) and copy the address-bar URL. Leave empty to sample both for-sale and for-rent listings. |
| `maxItems` | `integer` | `200` | `100` | Maximum total listings to extract across all `startUrls`. Set to `1000`+ for deep sweeps or `0` for unlimited. |
| `includeDetails` | `boolean` | `false` | `false` | When `true`, fetches each listing's full text `description`, total building floors (`totalFloor`), and `dateOfEntry`. Leave `false` for maximum speed and lowest cost. |
| `proxyConfiguration` | `object` | Residential `IL` | Residential `IL` | Proxy settings. An **Israel (`IL`) residential proxy** is pre-configured by default and required for Yad2 access. |

#### How to build filtered Yad2 search URLs

1. Open **[yad2.co.il/realestate/forsale](https://www.yad2.co.il/realestate/forsale)** (for sale) or **[yad2.co.il/realestate/rent](https://www.yad2.co.il/realestate/rent)** (for rent).
2. Select your desired filters in the Yad2 search bar — e.g., City (`תל אביב יפו`), Neighborhood, Property Type, Rooms (`3–5`), Price range, or Square Meters.
3. Copy the resulting URL from your browser's address bar (including all query parameters like `?city=5000&rooms=3-5&price=2000000-5000000`).
4. Paste one or more URLs into `startUrls`. The scraper preserves every filter parameter and paginates through all matching pages automatically.

#### Sample Input Recipes

##### Recipe 1: Fast nationwide For-Sale & Rent sweep (500 listings)

```json
{
  "startUrls": [
    "https://www.yad2.co.il/realestate/forsale",
    "https://www.yad2.co.il/realestate/rent"
  ],
  "maxItems": 500,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IL"
  }
}
```

##### Recipe 2: Deep 1,000+ listing city extraction

```json
{
  "startUrls": [
    "https://www.yad2.co.il/realestate/forsale?city=5000",
    "https://www.yad2.co.il/realestate/forsale?city=3000",
    "https://www.yad2.co.il/realestate/forsale?city=4000"
  ],
  "maxItems": 1500,
  "includeDetails": false
}
```

##### Recipe 3: Enriched lead-gen run with full Hebrew descriptions & building floors

```json
{
  "startUrls": [
    "https://www.yad2.co.il/realestate/forsale"
  ],
  "maxItems": 100,
  "includeDetails": true
}
```

***

### 📤 Output schema & field reference

Every extracted property is stored as a flat, consistent object. Below is a real record from a verified run:

```json
{
  "adNumber": "64765171",
  "title": "השיקמים 2",
  "subtitle": "בית פרטי/ קוטג'",
  "category": "realestate/forsale",
  "price": "7,100,000 ₪",
  "currency": "₪",
  "city": "הוד השרון",
  "neighborhood": "רמתיים",
  "street": "השיקמים",
  "addressNumber": "2",
  "rooms": "4",
  "squareMeters": "535",
  "floor": "קרקע",
  "features": "חדרים: 4 | קומה: קרקע | מ\"ר: 535",
  "latitude": "32.155405",
  "longitude": "34.887063",
  "contactName": "מיכל",
  "merchant": "false",
  "adType": "ad",
  "imageCount": "10",
  "images": "https://img.yad2.co.il/Pic/202610/29/2_1/o/y2_1pa_010528_20261029135559.jpeg | https://img.yad2.co.il/Pic/202610/29/2_1/o/y2_2pa_010531_20261029135559.jpeg",
  "videoUrl": "",
  "dateAdded": "2026-10-29 14:02:26",
  "updatedAt": "עודכן היום",
  "dateOfEntry": "2026-10-29 00:00:00",
  "description": "בית פרטי מרווח ומואר ברמתיים השקטה, גינה היקפית מטופחת, יחידת הורים גדולה וחניה פרטית כפולה.",
  "totalFloor": "2",
  "url": "https://www.yad2.co.il/item/nbya2x7s",
  "scrapedAt": "2026-11-01T23:29:18.222Z"
}
```

#### 🏷️ Identity, Price & Property Specs

| Field | Type | Coverage | Description |
|---|---|---|---|
| `adNumber` | `string` | 🟢 High (~100%) | Unique Yad2 ad number / numeric listing ID |
| `title` | `string` | 🟢 High (~100%) | Primary listing headline (typically street address or project name) |
| `subtitle` | `string` | 🟢 High (~99%) | Property type in Hebrew (e.g., `דירה`, `בית פרטי/ קוטג'`, `גג/ פנטהאוז`, `דופלקס`) |
| `category` | `string` | 🟢 High (100%) | Category path (`realestate/forsale` or `realestate/rent`) |
| `price` | `string` | 🟢 High (~98%) | Formatted asking price (e.g., `"2,850,000 ₪"` or `"6,500 ₪"`) |
| `currency` | `string` | 🟢 High (~98%) | Currency symbol (`₪`) |
| `rooms` | `string` | 🟢 High (~96%) | Number of rooms (`3`, `3.5`, `4`, `5`, etc.) |
| `squareMeters` | `string` | 🟢 High (~99%) | Property size in square meters (`מ"ר`) |
| `floor` | `string` | 🟢 High (~95%) | Floor level (`קרקע` for ground floor, or numeric floor `1`, `2`, `8`, etc.) |
| `features` | `string` | 🟢 High (~100%) | Pipe-separated (`\|`) summary of card attributes (rooms, floor, m²) |

#### 📍 Location & Geospatial Coordinates

| Field | Type | Coverage | Description |
|---|---|---|---|
| `city` | `string` | 🟢 High (~100%) | Israeli city or locality name in Hebrew (e.g., `תל אביב יפו`, `ירושלים`, `חיפה`) |
| `neighborhood` | `string` | 🟢 High (~92%) | Neighborhood name (`שכונה`) when specified by the seller |
| `street` | `string` | 🟢 High (~84%) | Street name (`רחוב`) when provided on the listing |
| `addressNumber` | `string` | 🟡 Conditional (~62%) | Street house number when disclosed by the lister |
| `latitude` | `string` | 🟢 High (~99%) | WGS84 GPS latitude for mapping and spatial joins |
| `longitude` | `string` | 🟢 High (~99%) | WGS84 GPS longitude for mapping and spatial joins |

#### 👤 Seller Lead Info, Media & Timestamps

| Field | Type | Coverage | Description |
|---|---|---|---|
| `contactName` | `string` | 🟢 High (~100%) | Seller or agent contact name |
| `merchant` | `string` | 🟢 High (100%) | `"true"` for real estate agencies/brokers; `"false"` for private FSBO owners |
| `adType` | `string` | 🟢 High (100%) | Listing feed classification (`ad`) |
| `imageCount` | `string` | 🟢 High (100%) | Total number of photos attached to the listing |
| `images` | `string` | 🟢 High (~95%) | Up to 30 full-size photo URLs separated by `\|` |
| `videoUrl` | `string` | 🟡 Conditional (~5%) | Direct video URL when the listing includes a video walkthrough |
| `dateAdded` | `string` | 🟢 High (~100%) | Timestamp when the listing was first published |
| `updatedAt` | `string` | 🟢 High (~100%) | Relative or exact last-updated label (e.g., `עודכן היום`) |
| `dateOfEntry` | `string` | 🟡 Conditional | Available move-in / entry date (enriched further when `includeDetails: true`) |
| `description` | `string` | 🟡 Opt-in (`includeDetails`) | Full text property description (populated ~100% when `includeDetails: true`) |
| `totalFloor` | `string` | 🟡 Opt-in (`includeDetails`) | Total floors in the building (populated ~85%+ when `includeDetails: true`) |
| `url` | `string` | 🟢 High (100%) | Direct link to the Yad2 item (`https://www.yad2.co.il/item/{token}`) |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO-8601 UTC extraction timestamp |

***

### 🏙️ Major Israeli Markets & Property Types Reference

#### Common Hebrew Property Types (`subtitle`)

| Hebrew (`subtitle`) | English Translation | Typical Segment |
|---|---|---|
| `דירה` | Apartment | Standard residential flat |
| `דירת גן` | Garden Apartment | Ground-floor apartment with private garden |
| `בית פרטי/ קוטג'` | Private House / Cottage | Detached or semi-detached single-family home |
| `גג/ פנטהאוז` | Roof / Penthouse | Top-floor apartment with roof terrace |
| `דופלקס` | Duplex | Two-level apartment |
| `מיני פנטהאוז` | Mini Penthouse | High-floor apartment with oversized balcony |
| `טריפלקס` | Triplex | Three-level residential unit |
| `יחידת דיור` | Studio / Housing Unit | Compact accessory or studio unit (common in rentals) |
| `מגרשים` | Plots / Land | Buildable residential land |

#### Major Israeli Cities Covered

| Region | Major Cities & Municipalities |
|---|---|
| **Tel Aviv & Gush Dan** | Tel Aviv-Yafo (`תל אביב יפו`), Ramat Gan (`רמת גן`), Givatayim (`גבעתיים`), Bnei Brak (`בני ברק`), Holon (`חולון`), Bat Yam (`בת ים`), Or Yehuda, Kiryat Ono |
| **Central & HaSharon** | Rishon LeZion (`ראשון לציון`), Petah Tikva (`פתח תקווה`), Netanya (`נתניה`), Herzliya (`הרצליה`), Ra'anana (`רעננה`), Kfar Saba (`כפר סבא`), Hod HaSharon (`הוד השרון`), Modi'in, Rehovot, Ramla, Lod |
| **Jerusalem District** | Jerusalem (`ירושלים`), Beit Shemesh (`בית שמש`), Mevasseret Zion, Ma'ale Adumim |
| **Haifa & North** | Haifa (`חיפה`), Krayot (Kiryat Ata, Kiryat Bialik, Kiryat Motzkin, Kiryat Yam), Acre (`עכו`), Nahariya (`נהריה`), Hadera, Caesarea, Nazareth, Tiberias, Safed (`צפת`), Karmiel |
| **South & Coast** | Beer Sheva (`באר שבע`), Ashdod (`אשדוד`), Ashkelon (`אשקלון`), Eilat (`אילת`), Yavne, Kiryat Gat, Netivot, Sderot |

***

### 🔁 Pagination & scale

The **Yad2 Real Estate Scraper** is engineered for both rapid sampling and high-volume **1,000+ listing sweeps**:

1. **Multi-page feed traversal:** For every search URL in `startUrls`, the actor reads the total available pages (`total_pages`) and automatically iterates through `page=1, 2, 3, …` until the search is exhausted or `maxItems` is reached.
2. **Cross-page & cross-URL deduplication:** Promoted listings on Yad2 often repeat across pages. The actor tracks every seen `link_token` / `adNumber` in memory and emits **0% duplicate rows**.
3. **Empty-streak protection:** If a deeply paginated search begins returning only already-seen ads for 3 consecutive pages, the actor cleanly advances to your next search URL without wasting proxy traffic.
4. **Default multi-category balancing:** When launched without `startUrls`, the actor splits your `maxItems` budget evenly between `realestate/forsale` and `realestate/rent` so you get a balanced dataset across both transaction types.

***

### 💻 API Integration Examples

#### Python (`apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "startUrls": [
        "https://www.yad2.co.il/realestate/forsale",
        "https://www.yad2.co.il/realestate/rent",
    ],
    "maxItems": 1000,
    "includeDetails": False,
}

run = client.actor("haketa/yad2-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    owner_type = "Agency" if item["merchant"] == "true" else "Private Owner"
    print(f"[{item['category']}] {item['city']} ({item['neighborhood']}) | {item['rooms']} rm | {item['squareMeters']} m² | {item['price']} | {item['contactName']} ({owner_type})")
```

#### Node.js / TypeScript (`apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/yad2-scraper').call({
    startUrls: ['https://www.yad2.co.il/realestate/forsale'],
    maxItems: 500,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const privateLeads = items.filter((i) => i.merchant === 'false');
console.log(`Total scraped: ${items.length} | Private owner leads: ${privateLeads.length}`);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~yad2-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": ["https://www.yad2.co.il/realestate/forsale"],
    "maxItems": 200,
    "includeDetails": false
  }'
```

***

### 💡 Best Practices & Pro Tips

- **Filter on Yad2 first for laser-targeted runs:** Apply city, neighborhood, room count, or price filters directly on `yad2.co.il` and copy the full URL into `startUrls`. Every query parameter is preserved during pagination.
- **Leave `includeDetails: false` for fast market sweeps:** The main feed already includes `price`, `rooms`, `squareMeters`, `floor`, `city`, `neighborhood`, `street`, `latitude`, `longitude`, `contactName`, `merchant`, and all `images`. Only enable `includeDetails: true` when you specifically need the long-form text `description` or `totalFloor`.
- **Segment FSBO leads instantly:** Filter `merchant == "false"` in Excel, Google Sheets, or SQL to isolate private homeowners from brokerage listings.
- **Keep the default Israel (`IL`) residential proxy enabled:** Yad2 geo-restricts access to Israeli residential IPs. The actor comes pre-configured with `apifyProxyCountry: "IL"`.
- **Note on opening item URLs in a browser:** Each record includes the canonical `https://www.yad2.co.il/item/{token}` URL, which opens normally in an Israeli browser session. Enable `includeDetails: true` if you want the actor to extract the full item text directly into your dataset.

***

### ❓ Frequently Asked Questions

#### How many listings can I scrape in a single run?

You can extract **1,000+ listings** (or set `maxItems: 0` for unlimited) in a single run. The scraper automatically paginates through every available result page for each URL in `startUrls`.

#### How fast is the scraper?

In default feed mode (`includeDetails: false`), the actor typically collects **100–200 listings in 15–30 seconds** and **400+ listings in under a minute**. Enabling `includeDetails: true` fetches each listing's individual detail payload and takes ~35–45 seconds per 30 listings.

#### Does it include seller phone numbers?

Yad2 masks phone numbers behind an interactive challenge on the website. However, the scraper extracts **`contactName` (~100% fill)** and the **`merchant` flag (`true`/`false`)** on every listing, plus the full property address, coordinates, and direct `url` for outreach and cross-referencing.

#### How do I get the full Hebrew property description and total building floors?

Set **`includeDetails: true`** in the input. The actor will query the item detail endpoint for every scraped listing and populate `description`, `totalFloor`, and `dateOfEntry`.

#### Can I scrape both For-Sale and For-Rent listings at the same time?

Yes. Add both `https://www.yad2.co.il/realestate/forsale` and `https://www.yad2.co.il/realestate/rent` (or city-filtered versions of both) to `startUrls`. Each output row includes `category` (`realestate/forsale` or `realestate/rent`).

#### Why are `street` or `addressNumber` blank on some rows?

Core fields (`adNumber`, `title`, `subtitle`, `price`, `city`, `squareMeters`, `latitude`, `longitude`, `contactName`, `merchant`, `images`, `url`) populate on ~98–100% of records. Granular address fields (`neighborhood` ~92%, `street` ~84%, `addressNumber` ~62%) depend on whether the seller chose to disclose the exact street number when posting the ad.

#### What happens if I run the actor with empty inputs?

If `startUrls` is left empty, the actor automatically falls back to sampling both `realestate/forsale` and `realestate/rent` so a zero-config test run always delivers a clean, representative dataset.

#### Which export formats and integrations are supported?

You can download results directly as **JSON, JSONL, CSV, Excel (XLSX), HTML, XML, or RSS**, or connect the dataset to **Google Sheets, Make, Zapier, n8n, Airbyte, Snowflake, BigQuery, or PostgreSQL** via Apify integrations and webhooks.

***

### 🔗 Related real estate & classifieds scrapers

Building a multi-country property or classifieds intelligence pipeline? Pair this **Yad2 scraper** with other scrapers by [haketa](https://apify.com/haketa):

- [Zameen.com Scraper (Pakistan)](https://apify.com/haketa/zameen-scraper) — Pakistan's #1 property portal with PKR/Crore & Marla/Kanal normalization
- [OLX Brazil Scraper](https://apify.com/haketa/olx-brasil-scraper) — Brazil classified ads, real estate, vehicles & seller data
- [ZAP Imóveis Scraper (Brazil)](https://apify.com/haketa/zapimoveis-scraper) — Brazilian real estate listings, prices & seller contacts
- [Boliga Scraper (Denmark)](https://apify.com/haketa/boliga-scraper) — Danish property listings and historical sold prices
- [Realtor.ca Scraper (Canada)](https://apify.com/haketa/realtor-ca-scraper) — Canadian MLS real estate listings and agent contacts
- [Domain.com.au Scraper (Australia)](https://apify.com/haketa/domain-com-au-scraper) — Australian residential property for sale and rent
- [ImmobilienScout24 Scraper (Germany)](https://apify.com/haketa/immobilienscout24-scraper) — German property marketplace listings

***

### 🔍 SEO Keywords

Yad2 scraper · scrape Yad2 · Yad2.co.il data extractor · Yad2 real estate scraper · Israel property listings scraper · Israel real estate data API · Yad2 lead generation · Tel Aviv apartments for sale dataset · Jerusalem real estate scraper · Israel rental market data · bulk export JSON CSV Excel API · 1,000+ results pagination · B2B intelligence · Israeli proptech dataset · נדל"ן יד 2

***

### 📋 Changelog

| Version | Date | Notes |
|---|---|---|
| **1.2.0** | **2026-11** | **Unlocked 1,000+ deep pagination & zero-config fallback:** Added automatic fallback to `realestate/forsale` + `realestate/rent` when `startUrls` is empty, empty-page streak protection for deep pagination, and faster 100-listing default prefill with `includeDetails: false` for sub-30s execution. |
| **1.1.0** | **2026-11** | **Verified 400+ multi-page extraction:** Confirmed 0% duplicates and ~100% core field fill rate (`adNumber`, `title`, `price`, `city`, `squareMeters`, `latitude`, `longitude`, `contactName`, `merchant`, `url`) across multi-page Israeli residential runs. |
| **1.0.0** | **2026-08** | Initial release — For-sale & for-rent Israeli property feed extraction, GPS coordinates, seller contact & agency flag, and optional `includeDetails` enrichment (`description`, `totalFloor`, `dateOfEntry`). |

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/yad2-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Paste Yad2 real estate search URLs. Build the search on yad2.co.il (for sale or rent, city, filters) and copy the URL — e.g. https://www.yad2.co.il/realestate/forsale or https://www.yad2.co.il/realestate/rent. Leave empty to sample both for-sale and for-rent listings automatically.

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

Maximum number of listings to collect across all search URLs. Set to 0 for unlimited.

## `includeDetails` (type: `boolean`):

Fetch each listing's full description, total building floors and entry date from the detail API. Richer data, but adds one request per listing (slower and more usage).

## `proxyConfiguration` (type: `object`):

Proxy configuration. An Israel residential proxy is required and enabled by default.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.yad2.co.il/realestate/forsale",
    "https://www.yad2.co.il/realestate/rent"
  ],
  "maxItems": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}
```

# Actor output Schema

## `adNumber` (type: `string`):

Yad2 ad number / ID

## `title` (type: `string`):

Listing title

## `subtitle` (type: `string`):

Listing subtitle / type

## `category` (type: `string`):

Category path (e.g. realestate/forsale)

## `price` (type: `string`):

Price

## `currency` (type: `string`):

Currency

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

City

## `neighborhood` (type: `string`):

Neighborhood

## `street` (type: `string`):

Street

## `addressNumber` (type: `string`):

House/street number

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

Number of rooms (real estate)

## `squareMeters` (type: `string`):

Size in square meters (real estate)

## `floor` (type: `string`):

Floor (real estate)

## `features` (type: `string`):

Key attributes ( | separated, category-specific)

## `latitude` (type: `string`):

GPS latitude

## `longitude` (type: `string`):

GPS longitude

## `contactName` (type: `string`):

Contact name

## `merchant` (type: `string`):

Whether the seller is a merchant/agency

## `adType` (type: `string`):

Ad type

## `imageCount` (type: `string`):

Number of images

## `images` (type: `string`):

Image URLs ( | separated)

## `videoUrl` (type: `string`):

Video URL

## `dateAdded` (type: `string`):

Date the listing was added

## `updatedAt` (type: `string`):

Last update

## `dateOfEntry` (type: `string`):

Available-from / entry date

## `description` (type: `string`):

Full listing description (when includeDetails is on)

## `totalFloor` (type: `string`):

Total building floors (when includeDetails is on)

## `url` (type: `string`):

Listing detail page URL

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "startUrls": [
        "https://www.yad2.co.il/realestate/forsale"
    ],
    "maxItems": 100,
    "includeDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/yad2-scraper").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 = {
    "startUrls": ["https://www.yad2.co.il/realestate/forsale"],
    "maxItems": 100,
    "includeDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/yad2-scraper").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 '{
  "startUrls": [
    "https://www.yad2.co.il/realestate/forsale"
  ],
  "maxItems": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}' |
apify call haketa/yad2-scraper --silent --output-dataset

```

## MCP server setup

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

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/0sEaMZo7MdlEjsqoC/builds/C5ANRgUbaSYutnXdI/openapi.json