# Yad2 New Listings Monitor - New Apartments Every 15 Minutes (`leadproof/yad2-new-listings-monitor`) Actor

Watch a Yad2 real-estate search and get only the new listings and price changes on every scheduled run. Built for frequent checks: cheap reads, no old listings sent as new, one check at a time per monitor.

- **URL**: https://apify.com/leadproof/yad2-new-listings-monitor.md
- **Developed by:** [Lead Proof](https://apify.com/leadproof) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 new listing or price changes

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?

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 New Listings Monitor

Watch a Yad2 real-estate search and get only the listings that are new since your last check, plus price changes. Schedule it every 15 minutes, every hour or once a day: each run is one check.

### Why this Actor

- **Only new listings, never old ones sent as new.** The first run remembers the current listings and delivers nothing. After that, a listing is delivered only when it was published after the monitor started. An older listing that shows up late is remembered quietly and never charged.
- **Built for frequent checks.** A check does not page through the whole search. It reads the Yad2 map in price bands and the top of each result segment, where new listings appear. A check of all rentals in Tel Aviv takes under a minute.
- **One check at a time.** Two runs of the same monitor never overlap: a run that starts while another is still checking steps back without charging.
- **Alerts.** Give a webhook URL and get a POST whenever a check is partial or fails.
- **Full listing data.** Each new listing is opened once for its publish date, description, amenities and broker licence.

### Quick start

1. Set **Transaction** and a **City** (or paste a Yad2 search URL).
2. Give the watch a **Monitor name**, for example `tlv-rent`.
3. Run it once. That first run remembers what is listed now.
4. Schedule the Actor, for example every 15 minutes, and connect the dataset to email, Slack, a sheet or your own system.

```json
{
  "transactionType": "rent",
  "filters": {"city": "תל אביב", "minRooms": 3, "maxPrice": 9000},
  "monitorName": "tlv-rent-3-rooms",
  "webhookUrl": "https://example.com/yad2-alerts"
}
```

### How a check works

Yad2 orders search results by last update inside segments (paid levels), separately for private and agency listings, and a new listing appears at the top of its segment. Every check reads the first pages and the start of each segment, which catches most new listings in the check they appear. It also reads the whole search through the Yad2 map, split into price bands that each fit one request. Any single map read lacks a few percent of listings, mostly ones updated in the last minutes, so a listing that both reads miss is delivered on a later check.

A listing counts as new when its Yad2 ad number is higher than any ad number the first check saw. Ad numbers follow publish order, so a listing that was already online when the monitor started is never delivered as new.

### Output

One row per new listing or price change, in the same shape as [Yad2 All](https://apify.com/leadproof/yad2-all):

| Field | Meaning |
|---|---|
| `changeType` | `new` or `price_changed` |
| `id`, `url` | Yad2 listing token and link |
| `title`, `description` | Title, and the description when the listing was opened |
| `price`, `previousPrice` | Price in ILS; for a price change, the price before |
| `location`, `attributes` | Street, neighborhood, city, coordinates, rooms, size, floor, property type, amenities |
| `publishedAt`, `updatedAt` | Listing dates (when the listing was opened) |
| `seller` | `private` or `agency`, agency name and broker licences when public |
| `monitor` | `foundVia` (`feed` or `map`), `monitorName`, `checkedAt` |
| `extraction.detailStatus` | `included`, or `unavailable` when opening the listing failed |

Each run also writes a `SUMMARY` record: status (`baseline`, `succeeded`, `partial`, `skipped`, `failed`), listings checked, new listings, price changes, older listings remembered quietly, map and page reads.

Values Yad2 does not show stay null: street and house number are missing on some listings. Private sellers' names and phone numbers are not collected.

### Pricing

Pay per event, platform usage included:

- **Check:** a small fee per search checked.
- **Listings checked:** a fee per 100 listings looked at in a check, so a small, filtered search costs less than a whole city.
- **New listing or price change:** per delivered row.

The first run of a monitor is charged as a check and delivers nothing. The exact prices are on the Pricing tab. Narrower searches (rooms, price, neighborhood URL) and less frequent checks cost less.

### Good to know

- Filters on parking, elevator and furnished are not available: search results do not show them. New listings include them, so filter on your side.
- Use one **Monitor name** per search. Changing the search under the same name keeps the old memory and watermark.
- Memory lives in the named key-value store `yad2-new-listings-monitor` in your Apify account. Listings unseen for 60 days are dropped from it.
- A partial check (some requests refused by Yad2) still delivers what it found; the next check reads the rest.
- The Actor reads public Yad2 data through Israeli residential proxies, retrying refused requests from other IPs. It has no official agreement with Yad2.

### Related LeadProof actors

- [Yad2 All](https://apify.com/leadproof/yad2-all): one-off collection of Yad2 real estate, vehicles and Market items.
- [Israel Real Estate Scraper](https://apify.com/leadproof/israel-real-estate): Yad2 and Madlan listings in one run.

Questions or a custom watch: support@leadproof.co. Built by [LeadProof](https://leadproof.co).

# Actor input Schema

## `transactionType` (type: `string`):

Which Yad2 real-estate board to watch.

## `filters` (type: `object`):

Real-estate filters for the search to watch. City is the usual starting point.

## `searchUrls` (type: `array`):

Optional. Public Yad2 real-estate search URLs copied from the browser, for example https://www.yad2.co.il/realestate/rent/tel-aviv-area?city=5000\&minRooms=3. Use these or Filters.

## `monitorName` (type: `string`):

Name of this watch, for example tlv-rent. Each name keeps its own memory, so use one name per search. Without a name the memory is keyed to the search itself.

## `includePriceChanges` (type: `boolean`):

Also deliver remembered listings whose price changed, marked changeType price_changed. Charged like a new listing.

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

Read each new listing once for its publish date, description, amenities and broker licence. Only new listings are opened.

## `webhookUrl` (type: `string`):

Optional. Receives a JSON POST when a check is partial or fails, with the reason.

## `feedDepth` (type: `integer`):

Yad2 orders results in segments and a new listing lands at the top of its segment. This many pages are read at the start of each segment on every check.

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

Israeli residential proxy by default. Every request uses a new IP.

## Actor input object example

```json
{
  "transactionType": "rent",
  "filters": {
    "city": "תל אביב"
  },
  "includePriceChanges": true,
  "includeDetails": true,
  "feedDepth": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

New listings and price changes found by this check.

## `csv` (type: `string`):

The same rows as CSV.

## `summary` (type: `string`):

Status, listings checked, new listings, price changes, map and page reads.

# 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 = {
    "filters": {
        "city": "תל אביב"
    },
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadproof/yad2-new-listings-monitor").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 = {
    "filters": { "city": "תל אביב" },
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("leadproof/yad2-new-listings-monitor").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 '{
  "filters": {
    "city": "תל אביב"
  },
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  }
}' |
apify call leadproof/yad2-new-listings-monitor --silent --output-dataset

```

## MCP server setup

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

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/JU4cneGZd2QN4jRvG/builds/CyWmajrdGIZqIz6e9/openapi.json