# Yad2 Scraper (`solidcode/yad2-scraper`) Actor

\[💰 $4.00 / 1K] Extract listings from Yad2, Israel's largest classifieds site. Real estate (rent, sale, commercial), vehicles, and second-hand goods. Search by category and location or paste Yad2 URLs directly. Returns price, location, photos, agent details, and category-specific attributes.

- **URL**: https://apify.com/solidcode/yad2-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 141 total users, 15 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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 Scraper

Pull classifieds listings from Yad2 — Israel's largest marketplace — at scale. Real estate (rentals, for-sale, commercial), vehicles (cars, motorcycles, trucks), the second-hand market, and pets, all from one actor with one flat output schema. Built for Israeli real-estate investors, vehicle resellers, lead-gen agencies, and market researchers who need comprehensive Yad2 coverage without decoding Hebrew search URLs or maintaining a brittle in-house scraper.

### Why This Scraper?

- **8 Yad2 sections in one actor** — real-estate rentals, real-estate for-sale, real-estate commercial, cars, motorcycles, trucks & commercial vehicles, the second-hand market (יד שנייה), and pets. Switch with a single dropdown.
- **Up to ~56,000 vehicle listings and ~9,700 real-estate sales per region** — enough to cover Tel Aviv, Jerusalem, or Israel-wide in a single run, with an internal hard cap of 100,000 rows when `maxResults=0`.
- **English-to-Hebrew location resolver for the top ~50 Israeli cities** — type "Tel Aviv", "Jerusalem", "Be'er Sheva", "Herzliya", "Ramat Gan" and the actor maps it to Yad2's internal city/area codes. Hebrew input (`תל אביב`) works natively too.
- **Power-user `startUrls`** — paste any Yad2 search URL straight from your browser bar (e.g. `/realestate/forsale?topArea=2&city=5000&minPrice=2000000`) and every filter in the URL is honored as-is. Mix multiple URLs in one run.
- **3 sort orders across 7 of the 8 sections** — Newest first, Price low-to-high, Price high-to-low, applied by Yad2 itself before collection so a capped run returns the right end of the range. "Newest first" is ideal for lead-gen alerting.
- **Range filters per category** — price range (ILS) for everything, room range (1–20, half-rooms allowed) for real estate, year range (1950–2030) for vehicles.
- **One flat row per listing — 41 fields** — listing ID, title, price (with `priceLabel` for "price on request"), city, neighborhood, full address, latitude/longitude, rooms, square meters, floor, year, engine size, fuel type, owner count, agency name, image URLs, and listing URL. No nested galleries to bill for.
- **Pay only for results — no compute time charges.** From $4.00 per 1,000 listings, half the $8/1K going rate for Yad2 data on Apify. You pay for the rows you receive, nothing else.
- **Hebrew text emitted verbatim in UTF-8** — titles, descriptions, neighborhoods, and street names preserved exactly as Yad2 displays them, ready for direct ingestion into RTL-aware tooling.

### Use Cases

**Real Estate Investment & Analysis**

- Track new for-sale inventory in Tel Aviv, Jerusalem, Haifa neighborhoods on a daily schedule
- Compare rent vs sale prices per square meter across cities to spot yield opportunities
- Monitor commercial property listings for office and retail expansion targets
- Build comp tables for buy-side underwriting using room count, m², and floor data

**Vehicle Pricing & Dealer Intelligence**

- Benchmark used-car prices by manufacturer, model, and year against your inventory
- Track fleet truck and motorcycle listings for B2B sales intelligence
- Alert on private-seller cars below market price for resale flips
- Build local depreciation curves from model year, owner count and price triples

**Lead Generation**

- Pull active real-estate agency listings with `agencyName` for outreach campaigns
- Capture pet-listing seller names and phone numbers (when posted publicly) for breeder directories
- Identify high-volume private sellers across vehicles and second-hand market for B2B onboarding

**Market Research & Trend Analysis**

- Map listing density by city and neighborhood for relocation services
- Track second-hand market price evolution for electronics, furniture, and appliances
- Monitor Israel-wide inventory levels by category for macroeconomic dashboards

**Marketplace Arbitrage**

- Surface mispriced second-hand goods (price vs. condition vs. location)
- Find listings posted Israel-wide but absent from competing local marketplaces
- Track price drops on long-listed inventory by re-running daily and diffing

### Getting Started

#### Real Estate Rentals in Tel Aviv

The simplest possible run — just pick a category and a city:

```json
{
    "category": "realestate-rent",
    "location": "Tel Aviv",
    "maxResults": 100
}
```

#### For-Sale Apartments with Filters

Narrow by price and room count:

```json
{
    "category": "realestate-forsale",
    "location": "Jerusalem",
    "priceMin": 2000000,
    "priceMax": 4500000,
    "roomsMin": 3,
    "roomsMax": 5,
    "sortBy": "newest",
    "maxResults": 500
}
```

#### Used Cars by Year

```json
{
    "category": "vehicles-cars",
    "location": "Haifa",
    "yearMin": 2018,
    "yearMax": 2024,
    "priceMax": 80000,
    "sortBy": "price_low",
    "maxResults": 1000
}
```

#### Power-User Start URLs

Paste any Yad2 search URL — the actor honors every filter in the URL:

```json
{
    "startUrls": [
        { "url": "https://www.yad2.co.il/realestate/forsale?topArea=2&city=5000&minPrice=3000000&maxPrice=6000000" },
        { "url": "https://www.yad2.co.il/vehicles/cars?manufacturer=19&year=2020-2024" }
    ],
    "maxResults": 2000
}
```

#### Second-Hand Market — Israel-wide

```json
{
    "category": "market",
    "priceMin": 100,
    "priceMax": 5000,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | select | `Real Estate — Rentals` | Yad2 section to search. Options: Real Estate — Rentals, Real Estate — For Sale, Real Estate — Commercial, Vehicles — Cars, Vehicles — Motorcycles, Vehicles — Trucks & Commercial, Second-Hand Market (Furniture, Electronics, etc.), Pets. Ignored when `startUrls` is provided. |
| `location` | string | `Tel Aviv` | City, neighborhood, or area name in Hebrew or English (e.g. "Tel Aviv", "תל אביב", "Haifa", "Jerusalem"). Leave empty to search Israel-wide. Ignored when `startUrls` is provided. |
| `startUrls` | URL\[] | `[]` | One or more Yad2 search URLs. When provided, these override `category` and `location` — the URL's own filters are honored. The most flexible way to scrape. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | — | Minimum price in Israeli Shekels. Leave empty for no minimum. |
| `priceMax` | integer | — | Maximum price in Israeli Shekels. Leave empty for no maximum. |
| `roomsMin` | number | — | Minimum room count for real estate. Half-rooms allowed (e.g. 2.5). Ignored for non-real-estate categories. |
| `roomsMax` | number | — | Maximum room count for real estate. Ignored for non-real-estate categories. |
| `yearMin` | integer | — | Minimum vehicle year (e.g. 2018). Ignored for non-vehicle categories. |
| `yearMax` | integer | — | Maximum vehicle year. Ignored for non-vehicle categories. |
| `sortBy` | select | `Newest first` | Order results before collection. Options: Newest first, Price: low to high, Price: high to low. Second-hand Market listings always arrive in Yad2's own order, so this setting does not apply to that category. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `200` | Hard cap on total listings collected. Set to `0` for no cap (an internal upper limit of 100,000 still applies). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. |

### Output

Each row is one Yad2 listing in a single flat shape across all 8 categories. Fields irrelevant to a given category are returned as `null`, so downstream tooling sees the same schema whether it's processing apartments, cars, or pets.

#### Real Estate Example

```json
{
    "listingId": "Lz3kPqRm",
    "category": "realestate-forsale",
    "subcategory": "דירה",
    "title": "דירה, 3 חדרים, 78 מ\"ר, בלב תל אביב",
    "description": "דירה משופצת ברחוב שקט במרכז תל אביב, 3 חדרים, מרפסת...",
    "price": 3450000,
    "currency": "ILS",
    "priceLabel": null,
    "city": "תל אביב יפו",
    "neighborhood": "לב תל אביב",
    "street": "אלנבי",
    "address": "אלנבי 42, לב תל אביב, תל אביב יפו",
    "latitude": 32.0723,
    "longitude": 34.7745,
    "rooms": 3,
    "squareMeters": 78,
    "floor": 2,
    "totalFloors": 4,
    "propertyCondition": "משופץ",
    "entranceDate": "2025-09-01",
    "hasParking": true,
    "sellerType": "agency",
    "agencyName": "Anglo-Saxon",
    "images": ["https://img.yad2.co.il/Pic/.../1.jpg"],
    "imageCount": 12,
    "publishedAt": "2025-04-30T08:14:22.000Z",
    "updatedAt": "2025-05-02T10:01:05.000Z",
    "url": "https://www.yad2.co.il/realestate/item/tel-aviv-area/Lz3kPqRm"
}
```

#### Vehicle Example

```json
{
    "listingId": "Vh8mNxQs",
    "category": "vehicles-cars",
    "title": "BMW סדרה 3",
    "price": 165000,
    "currency": "ILS",
    "city": "אזור חיפה והסביבה",
    "manufacturer": "BMW",
    "model": "סדרה 3",
    "trim": "330i M Sport אוט׳ בנזין 2.0 (258 כ״ס)",
    "year": 2021,
    "engineSize": 2000,
    "fuelType": "בנזין",
    "ownerCount": 1,
    "sellerType": "private",
    "images": ["https://img.yad2.co.il/Pic/.../car1.jpg"],
    "imageCount": 8,
    "publishedAt": "2025-05-01T14:22:00.000Z",
    "url": "https://www.yad2.co.il/vehicles/item/Vh8mNxQs"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Yad2 listing token |
| `category` | string | One of `realestate-rent`, `realestate-forsale`, `realestate-commercial`, `vehicles-cars`, `vehicles-motorcycles`, `vehicles-trucks`, `market`, `pets` |
| `subcategory` | string | Property type, motorcycle body style, market product type, or pet breed. Car and truck listings carry no body style on Yad2, so the field is empty there and the trim line below carries the spec instead |
| `title` | string | Listing headline |
| `description` | string | Free-text description (real estate / pets) |
| `price` | number | Numeric price in ILS, or `null` for "price on request" |
| `currency` | string | Always `ILS` (Israeli Shekels) |
| `priceLabel` | string | Reads `Price on request` when the seller published no price, so an unpriced listing is never mistaken for a free one. `null` whenever `price` carries a number |
| `url` | string | Direct link to the Yad2 listing detail page |
| `condition` | string | Item condition label on second-hand market listings (e.g. חדש באריזה) |
| `publishedAt` | string | ISO timestamp of original posting (property, car and pet listings) |
| `updatedAt` | string | ISO timestamp of last update (property and pet listings) |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City for property, market and pet listings; Yad2's regional area label for vehicles (Hebrew) |
| `neighborhood` | string | Neighborhood (Hebrew, property and pet listings) |
| `street` | string | Street name (Hebrew, property listings) |
| `address` | string | Composed full address for property listings; regional area for vehicles |
| `latitude` | number | Geo latitude (property listings) |
| `longitude` | number | Geo longitude (property listings) |

#### Real Estate Specific

| Field | Type | Description |
|-------|------|-------------|
| `rooms` | number | Room count (half-rooms allowed) |
| `squareMeters` | number | Floor area in m² |
| `floor` | number | Floor of the apartment |
| `totalFloors` | number | Total floors in the building |
| `propertyCondition` | string | Condition label (e.g. משופץ / חדש מקבלן) |
| `entranceDate` | string | Move-in date |
| `hasParking` | boolean | Parking included (derived from `parkingSpacesCount`) |

#### Vehicle Specific

| Field | Type | Description |
|-------|------|-------------|
| `manufacturer` | string | Vehicle manufacturer (e.g. BMW, Toyota) |
| `model` | string | Vehicle model |
| `trim` | string | Full trim line as the seller published it, typically drivetrain, fuel, engine size and horsepower (car listings) |
| `year` | number | Year of production |
| `engineSize` | number | Engine displacement in cc |
| `fuelType` | string | Petrol / diesel / hybrid / electric (cars) |
| `ownerCount` | number | Number of previous owners |

#### Seller & Media

| Field | Type | Description |
|-------|------|-------------|
| `sellerType` | string | `private`, `agency`, `dealer`, or `business` |
| `sellerName` | string | Seller name when posted publicly (mostly pets / market) |
| `phone` | string | Seller phone when posted publicly without click-to-reveal |
| `agencyName` | string | Real-estate agency name |
| `images` | string\[] | Listing image URLs |
| `imageCount` | number | Number of images attached to the listing |

### Tips for Best Results

- **Hebrew location text is fastest.** Pasting `תל אביב` or `ירושלים` skips the English-to-Hebrew dictionary lookup entirely and matches Yad2's autocomplete on the first try. Less common cities and neighborhoods that aren't in the top-50 dictionary need Hebrew text.
- **Use `startUrls` for advanced filters not in the schema.** Yad2's URL bar exposes manufacturer codes, body-style filters, sub-area picks, and dozens of other niche filters. Configure your search on yad2.co.il, copy the URL, paste it into `startUrls`, and the actor honors every parameter.
- **Mix multiple `startUrls` in one run.** You can combine a Tel Aviv rentals URL, a Jerusalem for-sale URL, and a Haifa cars URL in one input — each becomes its own scan, all rows land in the same dataset, deduplicated by `listingId`.
- **Sort by "Newest first" for daily alerting.** Schedule the actor to run every morning with `sortBy: "newest"` and `maxResults: 200` to capture only freshly posted listings since yesterday.
- **Vehicle year and price filters require both bounds.** Yad2's vehicle search treats open-ended ranges as zero results. The actor auto-fills the missing end (price defaults to 0–9,999,999, year to 1950–2030) so partial input still works, but tight ranges return faster results.
- **Start with `maxResults: 100–200` to validate.** Verify the data shape, the filters, and the location resolution match what you expect, then scale up.
- **Commercial listings quote two different things, so read `price` next to `squareMeters`.** Israeli agents advertise offices, stores and warehouses either as a whole-property figure or as a monthly asking rate per square metre, and Yad2 publishes both in the same field. A 55 against a 170 m² floorplate is a rate, not a total. Landlords who want enquiries instead of a public number come through as `Price on request`, so filter on `priceLabel` when you need only priced inventory.
- **For market arbitrage, the second-hand category covers electronics by default.** Use `startUrls` with category-specific paths like `/products/אלקטרוניקה`, `/products/ריהוט`, or `/products/לבית-ולגן` to target other product slugs.

### Pricing

**From $4.00 per 1,000 results — pay-per-result, no compute charges.** Half the going rate for Yad2 data on Apify. Your price per result depends on your Apify discount tier, and Gold members pay the headline $4.00 per 1,000.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.47 | $0.45 | $0.42 | $0.40 |
| 1,000 | $4.75 | $4.50 | $4.25 | $4.00 |
| 10,000 | $47.50 | $45.00 | $42.50 | $40.00 |
| 100,000 | $475.00 | $450.00 | $425.00 | $400.00 |

Tiered pricing takes effect on 2 October 2026; until then every plan pays the flat $4.00 per 1,000. You only pay for the listings the actor returns. Compute time is on us. A "result" is one row in the output dataset (one Yad2 listing).

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, real-estate analysis, vehicle pricing intelligence, and lead generation. Users are responsible for complying with applicable laws (including Israeli Privacy Protection Law and GDPR where relevant) and Yad2's Terms of Service. Do not use extracted data for spam, harassment, fraud, or any illegal purpose. Respect personal data fields (seller names, phone numbers) by limiting use to legitimate B2B and consumer-research contexts.

# Actor input Schema

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

Which Yad2 section to search. Ignored when you paste Start URLs below — the URL already specifies the section.

## `location` (type: `string`):

City, neighborhood, or area name in Hebrew or English (e.g. "Tel Aviv", "תל אביב", "Haifa", "Jerusalem"). Leave empty to search Israel-wide. Ignored when Start URLs are provided.

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

Paste one or more Yad2 search URLs directly (e.g. https://www.yad2.co.il/realestate/rent?topArea=2\&city=5000). When provided, these override Category and Location. Filters in the URL are honored as-is — the most flexible way to scrape.

## `priceMin` (type: `integer`):

Only include listings at or above this price (in Israeli Shekels). Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only include listings at or below this price (in Israeli Shekels). Leave empty for no maximum.

## `roomsMin` (type: `number`):

Only include real estate listings with at least this many rooms. Half-rooms are allowed (e.g. 2.5). Ignored for non-real-estate categories.

## `roomsMax` (type: `number`):

Only include real estate listings with at most this many rooms. Ignored for non-real-estate categories.

## `yearMin` (type: `integer`):

Only include vehicle listings from this year onward (e.g. 2018). Ignored for non-vehicle categories.

## `yearMax` (type: `integer`):

Only include vehicle listings up to this year. Ignored for non-vehicle categories.

## `sortBy` (type: `string`):

How Yad2 should order the listings before we collect them. "Newest" surfaces fresh inventory first — best for alerting and lead generation. Second-hand Market listings always arrive in Yad2's own order, so this setting does not apply to that category.

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

Hard cap on the total number of listings to collect across all sources. Default 200 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 100,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "category": "realestate-rent",
  "location": "Tel Aviv",
  "startUrls": [],
  "sortBy": "newest",
  "maxResults": 200
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact view of scraped listings with the most important fields.

## `details` (type: `string`):

Full details of each listing — price, location, attributes, seller info, photos, geo.

# 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 = {
    "category": "realestate-rent",
    "location": "Tel Aviv",
    "startUrls": [],
    "sortBy": "newest",
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "category": "realestate-rent",
    "location": "Tel Aviv",
    "startUrls": [],
    "sortBy": "newest",
    "maxResults": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "category": "realestate-rent",
  "location": "Tel Aviv",
  "startUrls": [],
  "sortBy": "newest",
  "maxResults": 200
}' |
apify call solidcode/yad2-scraper --silent --output-dataset

```

## MCP server setup

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