# Yad2 Scraper - Israel Classifieds API (`dami_studio/yad2-scraper`) Actor

Scrape Yad2, Israel's biggest classifieds site: cars, apartments and second-hand goods in one actor. Hebrew title, price in shekels, city and area, private vs dealer, publish date, photos and the listing URL. $1.20 per 1,000 listings, flat on every plan.

- **URL**: https://apify.com/dami\_studio/yad2-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Real estate, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Yad2 Scraper — Israeli classifieds API (cars, real estate, second-hand goods)

Scrapes [Yad2](https://www.yad2.co.il), Israel's largest classifieds site. Three sections in one
actor:

| Section | What you get | Reach |
|---|---|---|
| **Vehicles** (רכב) | cars, motorcycles, scooters, trucks, watercraft | ~59,600 cars, fully pageable |
| **Real estate** (נדל"ן) | apartments and houses for sale, for rent, commercial | ~92,000 listings across 8 regions |
| **Second-hand goods** (יד שנייה) | Yad2's marketplace, by search term | 3,000–5,000 per common term |

Output is Hebrew, right-to-left, UTF-8. Prices are in shekels (ILS).

### What one row looks like

Real values from a run on 9 August 2026:

```json
{
  "listingId": "0ihrs5la",
  "section": "vehicles",
  "subSection": "cars",
  "title": "טסלה מודל 3 4X4 Long Range חשמלי אוט׳ (498 כ״ס) 2024",
  "yad2Title": "טסלה מודל 3 שנת 2024 יד ראשונה 33,000 ק\"מ",
  "description": "טסלה מודל 3, יד ראשונה! רכב מנהלים ספורטיבי עם הנעה אחורית, מצב מצוין ומינימליסטי...",
  "price": 175000,
  "currency": "ILS",
  "sellerType": "business",
  "sellerName": "לוין מוטורס",
  "contactName": "שאבי",
  "city": "מפעלי ברקן",
  "area": "אזור אריאל וישובי יהודה",
  "publishedAt": "2026-07-29T12:13:50+03:00",
  "updatedAt": "2026-08-09T04:27:59+03:00",
  "manufacturer": "טסלה",
  "model": "מודל 3",
  "year": 2024,
  "hand": "יד ראשונה",
  "engineType": "חשמלי",
  "imageCount": 8,
  "url": "https://www.yad2.co.il/vehicles/item/0ihrs5la"
}
```

A real-estate row instead carries `rooms`, `squareMeters`, `floor`, `propertyType`, `neighborhood`,
`street`, `latitude` and `longitude`. A second-hand row carries `condition` and `tags`.

### Every field

`listingId`, `section`, `subSection`, `title`, `yad2Title`, `description`, `price`, `currency`,
`previousPrice`, `sellerType`, `sellerName`, `sellerId`, `contactName`, `categoryId`,
`subCategoryId`, `city`, `area`, `areaId`, `region`, `neighborhood`, `street`, `latitude`,
`longitude`, `publishedAt`, `updatedAt`, `manufacturer`, `model`, `subModel`, `year`, `hand`,
`engineType`, `engineVolume`, `kilometers`, `rooms`, `squareMeters`, `floor`, `propertyType`,
`condition`, `tags`, `images`, `imageCount`, `adNumber`, `url`, `searchUrl`, `scrapedAt`.

Fields that do not apply to a section come back as `null` rather than going missing, so the dataset
stays a clean table when you mix sections.

### Input

Pick a **Section**, then narrow it:

- **Vehicles** — `vehicleType`, `manufacturers` (Hebrew or English: `Toyota`, `טויוטה`,
  `Mercedes-Benz`), `areas`, `minPrice`/`maxPrice`, `minYear`/`maxYear`, `maxKm`.
- **Real estate** — `dealType` (for sale / rent / commercial), `regions`, `cityId`,
  `minPrice`/`maxPrice`.
- **Second-hand goods** — `query` (required; `ספה`, `אופניים`, `iPhone`), `minPrice`/`maxPrice`,
  `businessOnly`.

Or skip all of it and paste Yad2 URLs into `searchUrls`:

```
https://www.yad2.co.il/vehicles/cars?manufacturer=48&year=2020-2026&price=40000-120000
https://www.yad2.co.il/realestate/forsale?city=5000
```

`sellerType` filters to private sellers or to dealers and agencies. `includeDetails` (on by default)
controls the second request per listing that fetches the publish date, the description and Yad2's
own headline; turn it off for roughly a 2× speed-up when you only need price, location and photos.

### Speed and cost

Runtimes measured on Apify, 1 GB, no proxy, publish-date lookups on. The cost column is what you
pay: $0.0012 per listing returned, plus $0.001 each time a run starts.

| Run | Rows | Runtime | You pay |
|---|---|---|---|
| Empty input (sample only) | 0 | 2.2 s | $0.001 |
| Tesla cars | 5 | 3.3 s | $0.007 |
| Cars | 300 | 21.7 s | $0.361 |
| Cars | 1,000 | 88.5 s | $1.201 |
| Apartments for sale, one region, no details | 1,200 | 54.7 s | $1.441 |

The 1,000-car run returned 1,000 unique ids, 1,000 titles and 1,000 publish dates, with no
duplicates and no failed requests. The 1,200-apartment run covered 53 cities in a single region.

### What this does NOT do

- **No free-text search on vehicles or real estate.** Yad2's own API has no `q` parameter on those
  feeds — it rejects one outright. Filter by manufacturer, area, region and price instead. Text
  search only exists for second-hand goods, and there it is required.
- **No browse-everything for second-hand goods.** Yad2's marketplace API refuses an empty search
  term, so you must supply one.
- **Real estate is not exhaustively pageable.** Yad2's map feed hands back at most 200 listings per
  query and its page parameter mostly repeats itself — pages 1 to 100 of one region yielded 255
  distinct listings between them. The actor works around this by splitting the price range and
  re-querying, which reached 1,547 distinct listings in the same region. Expect a few thousand per
  region, not all 28,000.
- **No phone numbers or e-mail addresses.** Yad2 hides seller contact details behind a logged-in
  request. You get the seller's display name and the agency name.
- **No `roommates` or `tractors`.** Those two sub-sections are not on the public gateway.
- **Second-hand rows have no publish date.** Their ad ids are UUIDs and Yad2's detail endpoint
  rejects anything over 12 characters, so there is nowhere to look it up. Vehicles and real estate
  both have one.
- Yad2's second-hand search is not deterministic — the same query twice returns a slightly
  different set. The actor de-duplicates by listing id, so a long run may need a few extra pages.

### Reliability notes

Yad2 sits behind Radware Bot Manager, which answers a blocked request with **HTTP 200 and a
JavaScript loader page** rather than an error. This actor detects that body and writes an uncharged
diagnostic row instead of treating it as "zero results". Every failure mode — a blocked request, an
unreadable payload, a search with no matches, a bad manufacturer name — produces a row with
`_diagnostic: true` and `charged: false`, and you are never billed for it. You are also not billed
for duplicates or for rows dropped by the `sellerType` filter.

An empty run returns one clearly labelled `_sample: true` row and charges nothing.

### FAQ

**Is there an official Yad2 API?**
No. Yad2 publishes no public API and no developer documentation. This actor talks to the same
internal gateway Yad2's own website uses.

**Can I scrape Yad2 without writing code?**
Yes. Fill in the form, press Start, and export to JSON, CSV, Excel or Google Sheets. There is also
a REST endpoint and clients for Python, JavaScript and n8n.

**How do I get Yad2 car listings for a specific make?**
Set Section to Vehicles and put the make in `manufacturers` — `Toyota`, `Kia`, `Mercedes-Benz` or
the Hebrew spelling. 69 manufacturers are recognised. Add `minYear`, `maxKm` and a price range to
narrow it further.

**How do I scrape Yad2 apartments in one city?**
Set Section to Real estate, leave `regions` empty, and put the Yad2 city code in `cityId` (5000 is
Tel Aviv-Yafo, 3000 Jerusalem, 4000 Haifa). Copy it out of the `city=` parameter of any Yad2 URL.
A city only matches inside its own region, so the actor sweeps all eight to find it.

**Does the output come back in Hebrew?**
Yes — titles, cities, neighbourhoods, seller names and descriptions are all the original Hebrew,
UTF-8 encoded and right-to-left. Nothing is transliterated. Manufacturer and area names can be
typed in either Hebrew or English on the input side.

**Can I monitor new listings?**
Yes. Vehicles and real-estate rows carry `publishedAt` and `updatedAt` as ISO 8601 timestamps in
Israel time (+03:00). Schedule the actor and compare `listingId` against your last run.

**Do I need a proxy?**
No. The actor runs straight out of Apify with no proxy and no residential bandwidth. If you would
rather use your own exit addresses, put them in `proxyConfiguration.proxyUrls`.

**What does it cost?**
$1.20 per 1,000 listings ($0.0012 each), plus $0.001 to start a run. Flat rate: the same price on
every plan, no volume tiers to reach. Failed runs, duplicates and filtered-out rows are not charged.

**Is scraping Yad2 legal?**
This actor reads only listings that Yad2 serves publicly, with no login and no personal contact
details. You are responsible for how you use the data, including under Israeli privacy law and the
GDPR where it applies.

# Actor input Schema

## `section` (type: `string`):

Which part of Yad2 to scrape. Vehicles = cars, motorcycles, scooters, trucks, watercraft. Real estate = apartments and houses for sale, for rent, and commercial property. Second-hand goods = Yad2's marketplace, which needs a search term.

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

Only used when Section is Vehicles.

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

Only used when Section is Real estate.

## `query` (type: `string`):

Required for the second-hand marketplace, which has no browse-everything endpoint. Hebrew works best: ספה (sofa), אופניים (bicycle), מקרר (fridge). Latin brand names such as iPhone or PlayStation also work. Yad2's vehicle and real-estate feeds have no free-text search at all, so this field is ignored for those sections - filter with manufacturer, area, region and price instead.

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

Optional. Paste Yad2 search URLs instead of filling in the fields, e.g. https://www.yad2.co.il/vehicles/cars?manufacturer=19\&year=2018-2024 or https://www.yad2.co.il/realestate/forsale?city=5000. The section, manufacturer, model, area, region, city, price, year, km and hand filters in the URL are all read.

## `manufacturers` (type: `array`):

Optional, vehicles only. Hebrew or English names both work: "Toyota", "טויוטה", "Mercedes-Benz", "Hyundai", "Tesla". 69 manufacturers are recognised. Each one is crawled as its own search.

## `areas` (type: `array`):

Optional, vehicles only. Yad2 area by Hebrew or English name ("Tel Aviv-Yafo area", "אזור חיפה והסביבה", "Beer Sheva area") or numeric id. 43 areas are recognised.

## `regions` (type: `array`):

Optional, real estate only. Yad2 splits the country into exactly 8 regions: Center and Sharon (1), South (2), Tel Aviv and surroundings (3), Judea and Samaria (4), Northern coastal plain (5), Jerusalem (6), North and the valleys (7), Jerusalem area (8). Hebrew names and ids both work. Leave empty to sweep all eight.

## `cityId` (type: `integer`):

Optional, real estate only. Yad2's numeric city code, e.g. 5000 = Tel Aviv-Yafo, 3000 = Jerusalem, 4000 = Haifa. Take it from the city= parameter of a Yad2 URL. A city only matches inside its own region, so leave Regions empty and the actor will find the right one.

## `minPrice` (type: `integer`):

Optional. Prices are in Israeli new shekels.

## `maxPrice` (type: `integer`):

Optional. Prices are in Israeli new shekels.

## `minYear` (type: `integer`):

Earliest model year to keep. Vehicle categories only — it is ignored on property and other listings.

## `maxYear` (type: `integer`):

Latest model year to keep. Vehicle categories only — it is ignored on property and other listings.

## `maxKm` (type: `integer`):

Optional, vehicles only. Upper bound on the odometer reading.

## `sellerType` (type: `string`):

Yad2's API has no seller filter, so this is applied by the actor after the results come back. Listings that do not match are dropped and are never charged.

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

On by default for vehicles and real estate. Yad2's list feeds carry no publish date, no description and no written title, so the actor makes one extra request per listing to get them. Turn this off to run roughly twice as fast when you only need price, location and photos. Second-hand goods already include their title in the list feed and are unaffected.

## `businessOnly` (type: `boolean`):

Optional, second-hand goods only. Return only listings from Yad2 business sellers.

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

How many listings to return in total. Each returned listing is one charged result; dropped, duplicate and failed rows are never charged. A single vehicle search reaches about 59,000 listings; a real-estate region reaches a few thousand through automatic price-band splitting.

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

Optional. The actor already routes through its own egress addresses, which Yad2 accepts. Supply proxyUrls here only if you want to use your own.

## Actor input object example

```json
{
  "section": "vehicles",
  "vehicleType": "cars",
  "dealType": "forsale",
  "query": "ספה",
  "searchUrls": [],
  "manufacturers": [],
  "areas": [],
  "regions": [],
  "sellerType": "any",
  "includeDetails": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per listing in the default dataset: id, Hebrew title, price in ILS, city and area, private vs dealer, publish date, photos and the listing URL. Empty or blocked runs return a single uncharged row instead.

# 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 = {
    "section": "vehicles",
    "vehicleType": "cars",
    "dealType": "forsale",
    "query": "ספה",
    "searchUrls": [],
    "manufacturers": [],
    "areas": [],
    "regions": [],
    "sellerType": "any",
    "includeDetails": true,
    "businessOnly": false,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = {
    "section": "vehicles",
    "vehicleType": "cars",
    "dealType": "forsale",
    "query": "ספה",
    "searchUrls": [],
    "manufacturers": [],
    "areas": [],
    "regions": [],
    "sellerType": "any",
    "includeDetails": True,
    "businessOnly": False,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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 '{
  "section": "vehicles",
  "vehicleType": "cars",
  "dealType": "forsale",
  "query": "ספה",
  "searchUrls": [],
  "manufacturers": [],
  "areas": [],
  "regions": [],
  "sellerType": "any",
  "includeDetails": true,
  "businessOnly": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dami_studio/yad2-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/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/ZJGBmmrlbLEa3jOwn/builds/rGuzyrBVZ63Z9ta8q/openapi.json