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

\[💰 $4.0 / 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
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

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.
- **4 sort orders** — Newest first, Price low-to-high, Price high-to-low, Most relevant. "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, kilometrage, agency name, image URLs, and listing URL. No nested galleries to bill for.
- **Pay only for results — no compute time charges.** $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 kilometrage + year + 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, Most relevant. |

#### 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",
    "subcategory": "קופה",
    "title": "BMW סדרה 3",
    "price": 165000,
    "currency": "ILS",
    "city": "חיפה",
    "manufacturer": "BMW",
    "model": "סדרה 3",
    "year": 2021,
    "kilometrage": 38500,
    "engineSize": 2000,
    "transmission": "אוטומטית",
    "fuelType": "בנזין",
    "color": "שחור",
    "ownerCount": 1,
    "previousOwnership": "פרטי",
    "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, vehicle body style, market product type, or pet breed |
| `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 | Free-text price label when no numeric price is available |
| `url` | string | Direct link to the Yad2 listing detail page |
| `publishedAt` | string | ISO timestamp of original posting |
| `updatedAt` | string | ISO timestamp of last update |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City (Hebrew) |
| `neighborhood` | string | Neighborhood (Hebrew) |
| `street` | string | Street name (Hebrew) |
| `address` | string | Composed full address |
| `latitude` | number | Geo latitude |
| `longitude` | number | Geo longitude |

#### 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 |
| `year` | number | Year of production |
| `kilometrage` | number | Odometer reading in km |
| `engineSize` | number | Engine displacement in cc |
| `transmission` | string | Manual / automatic |
| `fuelType` | string | Petrol / diesel / hybrid / electric |
| `color` | string | Vehicle color |
| `ownerCount` | number | Number of previous owners |
| `previousOwnership` | string | Previous ownership type (private / leasing / rental etc.) |
| `condition` | string | General condition label |

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

**Pay-per-result pricing — no compute charges.** $4.00 per 1,000 listings, half the going rate for Yad2 data on Apify.

| Results | Cost |
|---------|------|
| 100 | $0.40 |
| 1,000 | $4.00 |
| 10,000 | $40.00 |
| 100,000 | $400.00 |

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.

## `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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/yad2-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yad2 Scraper",
        "description": "[💰 $4.0 / 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.",
        "version": "1.0",
        "x-build-id": "pTEKNpvjlX3TaqpOf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~yad2-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-yad2-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~yad2-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-yad2-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~yad2-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-yad2-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "realestate-rent",
                            "realestate-forsale",
                            "realestate-commercial",
                            "vehicles-cars",
                            "vehicles-motorcycles",
                            "vehicles-trucks",
                            "market",
                            "pets"
                        ],
                        "type": "string",
                        "description": "Which Yad2 section to search. Ignored when you paste Start URLs below — the URL already specifies the section.",
                        "default": "realestate-rent"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "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": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum Price (ILS)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price (in Israeli Shekels). Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (ILS)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price (in Israeli Shekels). Leave empty for no maximum."
                    },
                    "roomsMin": {
                        "title": "Minimum Rooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "number",
                        "description": "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": {
                        "title": "Maximum Rooms",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "number",
                        "description": "Only include real estate listings with at most this many rooms. Ignored for non-real-estate categories."
                    },
                    "yearMin": {
                        "title": "Minimum Vehicle Year",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include vehicle listings from this year onward (e.g. 2018). Ignored for non-vehicle categories."
                    },
                    "yearMax": {
                        "title": "Maximum Vehicle Year",
                        "minimum": 1950,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include vehicle listings up to this year. Ignored for non-vehicle categories."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "newest",
                            "price_low",
                            "price_high",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How Yad2 should order the listings before we collect them. \"Newest\" surfaces fresh inventory first — best for alerting and lead generation.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "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.",
                        "default": 200
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
