# Yad2 All-in-One Scraper - Real Estate, Cars & Products (`leadproof/yad2-all`) Actor

Scrape Yad2 apartments for rent and sale, cars and second-hand products. Search by category and filters, paginate results, and export prices, locations, images and optional listing details in one consistent dataset.

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

## Pricing

from $2.00 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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 All-in-One Scraper - Real Estate, Cars & Products

Collect public Yad2 and Madlan listings in one consistent dataset: apartments and houses for rent or sale, commercial property, cars, motorcycles, scooters, trucks, boats and Yad2 Market second-hand items. Export prices, full addresses with coordinates, images, dates and optional listing details as JSON, CSV or Excel, or connect the Actor through the Apify API, n8n, Make or Zapier.

### Why this Actor

- **Fast.** Searches are split into many small requests that run in parallel, each from its own Israeli residential IP. Thousands of listings arrive in about a minute.
- **Low platform cost.** It reads the same compact JSON the Yad2 app uses instead of rendering web pages, so proxy traffic and memory stay tiny.
- **Everything in one Actor.** Real estate, every vehicle type and the Yad2 Market share one input form and one output shape.
- **Yad2 and Madlan together.** Add Madlan to **Sources** to search both sites for the same apartments in one run. Madlan rows add the full price history and neighborhood scores (schools, parks, quiet streets, transport).
- **Monitoring built in.** Turn on **Only new or changed listings** and schedule the Actor: each run delivers just the listings that are new since the last run, plus price changes.
- **Complete searches.** Pages flagged by the source are retried from other IPs and requeued, and large market categories are split so nothing is cut off at the storefront page limit.

### Quick start

1. Choose **Category**: Real estate, Vehicles or Market.
2. For real estate choose **Transaction** (Rent, Sale or Commercial). For vehicles choose **Vehicle type**.
3. Fill the **Filters** you need and set **Maximum results**. No search URL is required.
4. Optional: enable **Read listing details** for descriptions, dates, amenities and full car specs.
5. Run, then download the dataset or read it through the API.

#### Apartments for rent in Tel Aviv

```json
{
  "category": "real_estate",
  "transactionType": "rent",
  "filters": {"city": "Tel Aviv", "minRooms": 3, "maxPrice": 8000},
  "maxResults": 500
}
```

#### Houses for sale in several moshavim, new listings only

```json
{
  "category": "real_estate",
  "transactionType": "sale",
  "filters": {"city": "צפרירים, אביעזר, נס הרים, גפן"},
  "maxResults": 500,
  "onlyNewListings": true,
  "monitorName": "ella-valley"
}
```

#### Yad2 and Madlan together, price drops only

```json
{
  "category": "real_estate",
  "transactionType": "sale",
  "sources": ["yad2", "madlan"],
  "filters": {"city": "חיפה", "minRooms": 4, "priceDropped": true},
  "maxResults": 1000
}
```

#### Toyota Corolla from 2019, up to 100,000 km

```json
{
  "category": "vehicles",
  "vehicleType": "cars",
  "filters": {"manufacturer": "Toyota", "model": "Corolla", "yearFrom": 2019, "maxMileage": 100000},
  "maxResults": 1000
}
```

#### Used phones on Yad2 Market

```json
{
  "category": "products",
  "filters": {"category": "מכשירים סלולריים", "query": "iphone", "maxPrice": 3000},
  "maxResults": 200
}
```

### What you can search

| Category | Types | Filters applied by Yad2 | Other filters |
| --- | --- | --- | --- |
| Real estate | Rent, sale, commercial | City or locality, area, price, rooms, size, apartment type | Other property types, floor; parking, elevator and furnished with details |
| Vehicles | Cars, motorcycles, scooters, trucks, watercraft | Manufacturer, model, year, price, mileage, hand, area; gearbox for cars | Fuel type; car city with details |
| Market | Every Yad2 Market category and subcategory | Category, subcategory | Condition, city, price, free-text query |
| Madlan (source) | Rent, sale, commercial | City or locality, price, rooms, size, floor, property type, parking, elevator, price dropped | Other filters on each card |

City names are resolved with Yad2's own place search, so small localities such as moshavim and kibbutzim work, and several can be given at once separated by commas. Manufacturers accept Hebrew or English names (Toyota, BMW, Yamaha). You can also paste Yad2 search URLs from your browser into **Search URLs**; their filters are kept.

Every filter is checked again on every returned row, so a row that does not match is never delivered. Mileage and car gearbox are applied by Yad2 itself, so they work without details. Fields shown only on the listing page (real-estate parking, elevator and furnished; vehicle city) need **Read listing details**; without it the run stops at once with a clear input error instead of scanning pages that cannot match.

### Output

| Field | Description |
| --- | --- |
| `id`, `url` | Listing ID and canonical listing URL on its site |
| `source` | `yad2`, `madlan` or `yad2_market` |
| `category`, `transactionType` | `real_estate`, `vehicles` or `products`; rent, sale or commercial |
| `title`, `description` | Source title; description with details (always included for Market items) |
| `price`, `currency` | Price in ILS. Null when Yad2 shows "price on request" |
| `previousPrice` | Earlier price when Yad2 shows a price drop, or the last delivered price in monitoring mode |
| `location` | Street and number, neighborhood and city, or the vehicle area |
| `images` | Public image URLs (not downloaded) |
| `seller` | `private`, `agency` or `business`; agency name and broker licence numbers when public |
| `attributes` | Category fields, see below |
| `publishedAt`, `updatedAt` | Listing dates (with details, and always for Market items) |
| `changeType` | Monitoring mode: `new` or `price_changed` |
| `scrapedAt`, `extraction` | UTC timestamp; data source and detail status |

- **Real estate attributes:** city, area, region, neighborhood, street, house number, latitude and longitude, floor, total floors, property type, rooms, size in sqm, condition, tags, paid placement type, and with details: entry date, parking, elevator, furnished and the full amenity list (air conditioning, balcony, safe room, storage, accessibility and more).
- **Vehicle attributes:** manufacturer, model and sub-model with source IDs, year, hand, fuel type, engine volume, area, dealer commitments, tags, and with details: mileage, gearbox, colour, horsepower, body type, seats, doors, ownership type, test date, city and the equipment specification.
- **Madlan real estate** uses the same attributes and adds `priceHistory` (every listed price with its date), `neighborhoodScores`, `buildingYear` and, for commercial property, the amenity list and description. Listings from neighboring places that Madlan mixes into an answer are left out.
- **Market attributes:** condition, category and subcategory, collection, city, business seller flag, giveaway flag, listing end date and the item fields the seller entered (brand, series, size and similar).

Values Yad2 does not show stay null. Private sellers' names and phone numbers are not collected.

### Monitoring new listings

With **Only new or changed listings** on, the Actor remembers each delivered listing and its price in a named key-value store in your account (`yad2-all-monitor`). The next run with the same search delivers only listings it has not delivered before, plus listings whose price changed, each marked in `changeType`. Use **Monitor name** to keep several watches apart or to change the search while keeping the memory. Schedule the Actor (for example every morning) and connect the dataset to email, Slack or a spreadsheet. Only delivered rows are remembered, so a listing that did not fit into **Maximum results** is still new on the next run.

### Pricing

**$2 per 1,000 delivered listings ($0.002 each), plus Apify platform usage. No start fee.** Duplicates within a run are removed before delivery and never charged. The same price applies with or without details.

Platform usage is small because the Actor transfers compact JSON and runs in 512 MB: typical searches use a fraction of a cent of proxy traffic per thousand listings, detail reads a little more. Usage is billed by Apify separately and can occur even when nothing matches. The run's event spending limit caps result fees; your Apify account usage limit caps the rest.

### Limits and run status

`maxResults` is a ceiling, not a promise. Page, request and time budgets are sized automatically from `maxResults`; set them yourself to cap a run harder.

Read **SUMMARY** in the run's key-value store. It reports delivered, scanned, filtered, duplicate and unchanged counts, the source totals per search, network use, any pages that could not be loaded and the stop reason. A run is `partial` when a limit stopped it, or when a page or a detail could not be loaded on several IPs; the rows already delivered are kept and charged normally. A run fails only for invalid input or when no page could be loaded at all.

Madlan pages stop after a fixed depth, so a large Madlan search is split into price ranges automatically; listings without a price are then only found in searches small enough to need no split. Yad2 Market reads at most 25,000 items per collection listing; larger categories are split into subcategories automatically, and a very large single subcategory is read from its newest and oldest ends.

Checkpoints let an interrupted run resume with the same input and storage. Use fresh storage when changing the input.

### Advanced options

- **Search URLs** replace the generated searches with Yad2 URLs from your browser (real estate, any vehicle type, or a market.yad2.co.il collection).
- **Parallel requests** sets how many requests are in flight at once (default 20).
- **Transport** keeps the older Chrome browser mode as a fallback for sale and rent real estate, cars and market pages. It is slower and needs about 2 GB of memory.

### Support

Open an Issue with the run ID and the result you expected. Please do not post credentials or private input data.

### Related LeadProof actors

- [Israel Real Estate Scraper](https://apify.com/leadproof/israel-real-estate) searches Yad2 and Madlan together, one row per apartment.
- [Google Maps Scraper](https://apify.com/leadproof/google-maps-scraper) for Israeli businesses such as real-estate agencies and car dealers.
- [Google Maps Verified Leads](https://apify.com/leadproof/google-maps-verified-leads) for business leads with verified emails.
- All actors: [apify.com/leadproof](https://apify.com/leadproof).

Unofficial tool, not affiliated with Yad2 or Madlan. Use public information responsibly and comply with applicable source terms.

Built by [LeadProof](https://leadproof.co).

# Actor input Schema

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

Choose a category. One category per run.

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

For real\_estate only. Rent is the default. Commercial covers offices, shops and other business property.

## `vehicleType` (type: `string`):

For vehicles only. Cars is the default.

## `sources` (type: `array`):

Sites to search. Madlan covers real estate (rent, sale, commercial) and adds price history and neighborhood scores. Results from all sources share one output format; each row names its source.

## `maxResults` (type: `integer`):

Maximum delivered listings across all searches. Large runs (thousands of listings) finish in about a minute.

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

Filters require matching source evidence. City and product category select source feeds automatically. Remaining filters are enforced locally.

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

Optional. Public Yad2 search URLs copied from the browser, for example https://www.yad2.co.il/realestate/rent/tel-aviv-area?city=5000\&minRooms=3, a cars/motorcycles URL, or a market.yad2.co.il collection. They replace the generated searches.

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

Reads each listing page for description, dates, amenities, broker licence, car mileage, gearbox, colour and full spec. One extra small request per delivered listing. Required for filters on those fields.

## `onlyNewListings` (type: `boolean`):

Remembers every delivered listing and its price in a named key-value store. Later runs with the same search deliver only new listings and price changes, marked in changeType. Ideal for scheduled monitoring.

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

Optional name for the memory of Only new or changed listings, for example haifa-rentals. Without it the memory is keyed to the search itself. Setting it turns the mode on.

## `maxPages` (type: `integer`):

Total search-page limit across all searches. Leave empty to size it to Maximum results.

## `maxRequests` (type: `integer`):

Hard request budget including details and retries. Leave empty to size it to Maximum results.

## `maxRunSeconds` (type: `integer`):

Crawler time limit across checkpoint resumes. Leave empty for at least 240 seconds, more for very large runs.

## `maxConcurrency` (type: `integer`):

Requests in flight at once, each from its own IP. 20 is fast and gentle on the source.

## `requestDelaySeconds` (type: `number`):

Browser transport only: minimum interval between page loads.

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

Israeli residential proxy by default. Every request uses a new session (IP); requests flagged by the source are retried from other IPs.

## `transport` (type: `string`):

Gateway (default) reads the Yad2 mobile JSON gateway and the Yad2 Market storefront: fast, low memory, low proxy use. Chrome is kept as a fallback for sale and rent real estate, cars and market pages.

## `debugSource` (type: `boolean`):

Development only: save bounded public feed structure and search links for parser diagnosis.

## Actor input object example

```json
{
  "category": "real_estate",
  "sources": [
    "yad2"
  ],
  "maxResults": 5,
  "includeDetails": false,
  "onlyNewListings": false,
  "maxConcurrency": 20,
  "requestDelaySeconds": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IL"
  },
  "transport": "gateway",
  "debugSource": false
}
```

# Actor output Schema

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

Unified dataset records.

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

Export listings in CSV format.

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

Results, coverage limits, detail failures and stop reason.

## `checkpoint` (type: `string`):

Internal resume state tied to this input and dataset.

# 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 = {
    "sources": [
        "yad2"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadproof/yad2-all").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 = {
    "sources": ["yad2"],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("leadproof/yad2-all").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 '{
  "sources": [
    "yad2"
  ],
  "maxResults": 5
}' |
apify call leadproof/yad2-all --silent --output-dataset

```

## MCP server setup

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

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/pcMLfQNyphnt4kcbm/builds/aFabB8LRwCKNE0Pbz/openapi.json