# Leboncoin Immobilier Phone Leads Scraper (`mostafa-ennadi/leboncoin-immobilier-phone-leads-scraper`) Actor

Extract Leboncoin  real estate ads with phone numbers using filters like city, price range, property type, furnished status, rooms, bedrooms, surface, energy rating, outdoor features, floor, orientation, condition, keywords, and seller type. Export structured results in JSON or CSV.

- **URL**: https://apify.com/mostafa-ennadi/leboncoin-immobilier-phone-leads-scraper.md
- **Developed by:** [mostafa ennadi](https://apify.com/mostafa-ennadi) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$1.00 / 1,000 annonces

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

## Leboncoin Real Estate Phone Leads Scraper

[English](#english) | [Français](#français)

---

### English

#### Overview

Extract **Leboncoin real estate ads with phone numbers** using practical filters such as:

- city or all France
- price range
- property type
- furnished status
- rooms
- bedrooms
- surface
- energy rating
- elevator
- floor
- outdoor features
- orientation
- condition
- seller type
- keywords

This actor is built for **real estate lead generation** and returns structured results in the default dataset.

#### What this actor does

- Scrapes **Leboncoin real estate ads**
- Retrieves **phone-number leads**
- Supports **city-specific search** or **France-wide search**
- Lets you filter listings by key real-estate fields
- Writes clean structured results to the **dataset**
- Shows simple run logs with:
  - progress
  - current page
  - processed ads
  - found ads
  - phone leads
  - final results

#### Best for

- real estate lead generation
- rental lead collection
- apartment and house prospecting
- private seller research
- property ad monitoring
- market research

#### Input fields

| Field | Type | Description |
|---|---|---|
| `city` | string | Optional city name. Leave empty to search across France |
| `price_min` | integer | Minimum property price |
| `price_max` | integer | Maximum property price |
| `real_estate_type` | array | Property type filter |
| `furnished` | array | Furnished status filter |
| `rooms_min` | integer | Minimum number of rooms |
| `rooms_max` | integer | Maximum number of rooms |
| `bedrooms_min` | integer | Minimum number of bedrooms |
| `bedrooms_max` | integer | Maximum number of bedrooms |
| `surface_min` | integer | Minimum surface in m² |
| `surface_max` | integer | Maximum surface in m² |
| `energy_rate` | array | Energy rating filter |
| `elevator` | boolean | Filter properties with elevator |
| `floor_property` | array | Floor filter |
| `outside_access` | array | Outdoor features filter |
| `orientation` | array | Property orientation filter |
| `global_condition` | array | Property condition filter |
| `text` | string | Optional real estate keywords |
| `owner_type` | string | `all`, `private`, or `pro` |
| `only_with_phone` | boolean | Keep only ads with a phone number |
| `max_pages` | integer | Optional page limit |
| `max_items` | integer | Number of results to collect. Default `1000`, max `20000` |
| `request_id` | string | Optional custom request identifier |

#### Example input

```json
{
  "city": "Paris",
  "price_min": 500,
  "price_max": 1500,
  "real_estate_type": ["2"],
  "furnished": ["1"],
  "rooms_min": 2,
  "rooms_max": 4,
  "bedrooms_min": 1,
  "surface_min": 25,
  "surface_max": 120,
  "owner_type": "private",
  "only_with_phone": true,
  "max_items": 1000
}
````

#### How `only_with_phone` works

If:

```json
{
  "only_with_phone": true
}
```

the actor keeps **only results that contain a phone number** in the final dataset.

This means:

- ads without a phone number are skipped from final output
- cached phone numbers are reused when available
- live phone lookup is used when needed

#### Result limit note

- default `max_items` is `1000`
- maximum `max_items` is `20000`

#### Typical property values

Common examples used in filters:

- `real_estate_type`: `["1"]`, `["2"]`
- `furnished`: `["1"]`, `["2"]`
- `energy_rate`: `["a"]`, `["b"]`, `["c"]`, `["d"]`, `["e"]`, `["f"]`, `["g"]`
- `owner_type`: `all`, `private`, `pro`

#### Output fields

Typical output fields include:

- `list_id`
- `url`
- `subject`
- `price`
- `price_cents`
- `has_phone`
- `phonenumber`
- `owner.type`
- `owner.name`
- `location.city`
- `location.city_label`
- `location.zipcode`
- `location.department_id`
- `location.region_name`
- `real_estate_type`
- `square`
- `rooms`
- `bedrooms`
- `furnished`
- `energy_rate`
- `ges`
- `outside_access`
- `floor_property`
- `elevator`
- `orientation`
- `global_condition`
- `land_plot_surface`
- `first_publication_date`
- `index_date`
- `status`
- `images.nb_images`
- `body`

#### Example output item

```json
{
  "list_id": "3178003486",
  "url": "https://www.leboncoin.fr/ad/locations/3178003486",
  "subject": "Appartement meublé 2 pièces",
  "price": 950,
  "price_cents": 95000,
  "has_phone": true,
  "phonenumber": "0612345678",
  "owner.type": "private",
  "owner.name": "Jean",
  "location.city": "Paris",
  "location.city_label": "Paris 15e Arrondissement",
  "location.zipcode": "75015",
  "location.department_id": "75",
  "location.region_name": "Île-de-France",
  "real_estate_type": "Appartement",
  "square": 42,
  "rooms": 2,
  "bedrooms": 1,
  "furnished": "Meublé",
  "energy_rate": "D",
  "elevator": "Oui",
  "status": "active"
}
```

#### Pricing

This actor can be monetized on a simple result basis:

**$1.00 / 1,000 results**

#### Notes

- `city` is optional
- if `city` is empty, the actor searches across **France**
- output is handled in **JSON** and written to the default dataset
- `max_workers` is fixed internally

***

### Français

#### Présentation

Extrayez des **annonces immobilières Leboncoin avec numéros de téléphone** grâce à des filtres pratiques comme :

- ville ou toute la France
- plage de prix
- type de bien
- statut meublé / non meublé
- nombre de pièces
- nombre de chambres
- surface
- étiquette énergétique
- ascenseur
- étage
- extérieurs
- orientation
- état du bien
- type de vendeur
- mots-clés

Cet actor est conçu pour la **génération de leads immobiliers** et retourne des résultats structurés dans le dataset par défaut.

#### Ce que fait cet actor

- Scrape les **annonces immobilières Leboncoin**
- Récupère des **leads avec numéros de téléphone**
- Permet une recherche **par ville** ou sur **toute la France**
- Utilise des filtres immobiliers utiles
- Écrit les résultats structurés dans le **dataset**
- Affiche des logs simples avec :
  - progression
  - page actuelle
  - annonces traitées
  - annonces trouvées
  - leads avec téléphone
  - résultats finaux

#### Cas d’usage

- génération de leads immobiliers
- prospection location
- recherche d’appartements et maisons
- recherche de vendeurs particuliers
- veille d’annonces
- étude de marché immobilier

#### Champs d’entrée

| Champ | Type | Description |
|---|---|---|
| `city` | string | Ville optionnelle. Laissez vide pour chercher sur toute la France |
| `price_min` | integer | Prix minimum |
| `price_max` | integer | Prix maximum |
| `real_estate_type` | array | Filtre type de bien |
| `furnished` | array | Filtre meublé / non meublé |
| `rooms_min` | integer | Nombre minimum de pièces |
| `rooms_max` | integer | Nombre maximum de pièces |
| `bedrooms_min` | integer | Nombre minimum de chambres |
| `bedrooms_max` | integer | Nombre maximum de chambres |
| `surface_min` | integer | Surface minimum en m² |
| `surface_max` | integer | Surface maximum en m² |
| `energy_rate` | array | Filtre étiquette énergétique |
| `elevator` | boolean | Filtrer les biens avec ascenseur |
| `floor_property` | array | Filtre étage |
| `outside_access` | array | Filtre extérieurs |
| `orientation` | array | Filtre orientation |
| `global_condition` | array | Filtre état du bien |
| `text` | string | Mots-clés immobiliers optionnels |
| `owner_type` | string | `all`, `private` ou `pro` |
| `only_with_phone` | boolean | Garder uniquement les annonces avec téléphone |
| `max_pages` | integer | Limite optionnelle du nombre de pages |
| `max_items` | integer | Nombre de résultats à collecter. Par défaut `1000`, maximum `20000` |
| `request_id` | string | Identifiant facultatif |

#### Exemple d’entrée

```json
{
  "city": "Paris",
  "price_min": 500,
  "price_max": 1500,
  "real_estate_type": ["2"],
  "furnished": ["1"],
  "rooms_min": 2,
  "rooms_max": 4,
  "bedrooms_min": 1,
  "surface_min": 25,
  "surface_max": 120,
  "owner_type": "private",
  "only_with_phone": true,
  "max_items": 1000
}
```

#### Fonctionnement de `only_with_phone`

Si vous utilisez :

```json
{
  "only_with_phone": true
}
```

l’actor gardera **uniquement les résultats contenant un numéro de téléphone** dans le dataset final.

Cela signifie :

- les annonces sans numéro sont exclues de la sortie finale
- les numéros déjà présents en cache sont réutilisés
- une recherche du numéro est lancée si nécessaire

#### Limite sur les résultats

- `max_items` par défaut est `1000`
- `max_items` maximum est `20000`

#### Valeurs de filtres courantes

Exemples fréquents :

- `real_estate_type`: `["1"]`, `["2"]`
- `furnished`: `["1"]`, `["2"]`
- `energy_rate`: `["a"]`, `["b"]`, `["c"]`, `["d"]`, `["e"]`, `["f"]`, `["g"]`
- `owner_type`: `all`, `private`, `pro`

#### Champs de sortie

Les champs de sortie typiques incluent :

- `list_id`
- `url`
- `subject`
- `price`
- `price_cents`
- `has_phone`
- `phonenumber`
- `owner.type`
- `owner.name`
- `location.city`
- `location.city_label`
- `location.zipcode`
- `location.department_id`
- `location.region_name`
- `real_estate_type`
- `square`
- `rooms`
- `bedrooms`
- `furnished`
- `energy_rate`
- `ges`
- `outside_access`
- `floor_property`
- `elevator`
- `orientation`
- `global_condition`
- `land_plot_surface`
- `first_publication_date`
- `index_date`
- `status`
- `images.nb_images`
- `body`

#### Exemple de résultat

```json
{
  "list_id": "3178003486",
  "url": "https://www.leboncoin.fr/ad/locations/3178003486",
  "subject": "Appartement meublé 2 pièces",
  "price": 950,
  "price_cents": 95000,
  "has_phone": true,
  "phonenumber": "0612345678",
  "owner.type": "private",
  "owner.name": "Jean",
  "location.city": "Paris",
  "location.city_label": "Paris 15e Arrondissement",
  "location.zipcode": "75015",
  "location.department_id": "75",
  "location.region_name": "Île-de-France",
  "real_estate_type": "Appartement",
  "square": 42,
  "rooms": 2,
  "bedrooms": 1,
  "furnished": "Meublé",
  "energy_rate": "D",
  "elevator": "Oui",
  "status": "active"
}
```

#### Tarification

Cet actor peut être monétisé simplement au résultat :

**$1.00 / 1 000 résultats**

#### Remarques

- `city` est optionnel
- si `city` est vide, la recherche se fait sur **toute la France**
- la sortie est gérée en **JSON** puis écrite dans le dataset par défaut
- `max_workers` est fixé en interne

# Actor input Schema

## `city` (type: `string`):

City name. Example: Paris.

## `price_min` (type: `integer`):

Minimum property price.

## `price_max` (type: `integer`):

Maximum property price.

## `real_estate_type` (type: `array`):

Filter by real estate type.

## `furnished` (type: `array`):

Filter by furnished status.

## `rooms_min` (type: `integer`):

Minimum number of rooms.

## `rooms_max` (type: `integer`):

Maximum number of rooms.

## `bedrooms_min` (type: `integer`):

Minimum number of bedrooms.

## `bedrooms_max` (type: `integer`):

Maximum number of bedrooms.

## `surface_min` (type: `integer`):

Minimum surface in m².

## `surface_max` (type: `integer`):

Maximum surface in m².

## `energy_rate` (type: `array`):

Filter by energy rating.

## `floor_property` (type: `array`):

Filter by floor level.

## `outside_access` (type: `array`):

Filter by outdoor access.

## `orientation` (type: `array`):

Filter by property orientation.

## `global_condition` (type: `array`):

Filter by property condition.

## `text` (type: `string`):

Optional real estate keywords.

## `owner_type` (type: `string`):

Filter by seller type.

## `only_with_phone` (type: `boolean`):

Keep only ads that contain a phone number.

## `max_pages` (type: `integer`):

Maximum number of pages to process.

## `max_items` (type: `integer`):

Maximum number of items to return.

## `request_id` (type: `string`):

Optional custom request identifier.

## Actor input object example

```json
{
  "owner_type": "all",
  "only_with_phone": false,
  "max_items": 1000
}
```

# Actor output Schema

## `job_uuid` (type: `string`):

Unique remote job identifier.

## `status` (type: `string`):

Final actor status.

## `download_type` (type: `string`):

Final download format.

## `item_count` (type: `string`):

Number of exported items.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mostafa-ennadi/leboncoin-immobilier-phone-leads-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mostafa-ennadi/leboncoin-immobilier-phone-leads-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 '{}' |
apify call mostafa-ennadi/leboncoin-immobilier-phone-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mostafa-ennadi/leboncoin-immobilier-phone-leads-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Leboncoin Immobilier Phone Leads Scraper",
        "description": "Extract Leboncoin  real estate ads with phone numbers using filters like city, price range, property type, furnished status, rooms, bedrooms, surface, energy rating, outdoor features, floor, orientation, condition, keywords, and seller type. Export structured results in JSON or CSV.",
        "version": "0.0",
        "x-build-id": "PUvmgBjcXFG7gPlJK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mostafa-ennadi~leboncoin-immobilier-phone-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mostafa-ennadi-leboncoin-immobilier-phone-leads-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/mostafa-ennadi~leboncoin-immobilier-phone-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mostafa-ennadi-leboncoin-immobilier-phone-leads-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/mostafa-ennadi~leboncoin-immobilier-phone-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mostafa-ennadi-leboncoin-immobilier-phone-leads-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": {
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name. Example: Paris."
                    },
                    "price_min": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum property price."
                    },
                    "price_max": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum property price."
                    },
                    "real_estate_type": {
                        "title": "Property type",
                        "type": "array",
                        "description": "Filter by real estate type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2"
                            ],
                            "enumTitles": [
                                "House",
                                "Apartment"
                            ]
                        }
                    },
                    "furnished": {
                        "title": "Furnished",
                        "type": "array",
                        "description": "Filter by furnished status.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2"
                            ],
                            "enumTitles": [
                                "Furnished",
                                "Unfurnished"
                            ]
                        }
                    },
                    "rooms_min": {
                        "title": "Min rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of rooms."
                    },
                    "rooms_max": {
                        "title": "Max rooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rooms."
                    },
                    "bedrooms_min": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "bedrooms_max": {
                        "title": "Max bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of bedrooms."
                    },
                    "surface_min": {
                        "title": "Min surface",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum surface in m²."
                    },
                    "surface_max": {
                        "title": "Max surface",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum surface in m²."
                    },
                    "energy_rate": {
                        "title": "Energy rating",
                        "type": "array",
                        "description": "Filter by energy rating.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "a",
                                "b",
                                "c",
                                "d",
                                "e",
                                "f",
                                "g"
                            ],
                            "enumTitles": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "F",
                                "G"
                            ]
                        }
                    },
                    "floor_property": {
                        "title": "Floor",
                        "type": "array",
                        "description": "Filter by floor level.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ground_floor",
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6",
                                "7",
                                "8",
                                "9",
                                "10+"
                            ],
                            "enumTitles": [
                                "Ground floor",
                                "1st floor",
                                "2nd floor",
                                "3rd floor",
                                "4th floor",
                                "5th floor",
                                "6th floor",
                                "7th floor",
                                "8th floor",
                                "9th floor",
                                "10+ floors"
                            ]
                        }
                    },
                    "outside_access": {
                        "title": "Outdoor features",
                        "type": "array",
                        "description": "Filter by outdoor access.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "balcony",
                                "terrace",
                                "garden"
                            ],
                            "enumTitles": [
                                "Balcony",
                                "Terrace",
                                "Garden"
                            ]
                        }
                    },
                    "orientation": {
                        "title": "Orientation",
                        "type": "array",
                        "description": "Filter by property orientation.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "north",
                                "south",
                                "east",
                                "west"
                            ],
                            "enumTitles": [
                                "North",
                                "South",
                                "East",
                                "West"
                            ]
                        }
                    },
                    "global_condition": {
                        "title": "Condition",
                        "type": "array",
                        "description": "Filter by property condition.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3"
                            ],
                            "enumTitles": [
                                "New",
                                "Good condition",
                                "Needs renovation"
                            ]
                        }
                    },
                    "text": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Optional real estate keywords."
                    },
                    "owner_type": {
                        "title": "Seller type",
                        "enum": [
                            "all",
                            "private",
                            "pro"
                        ],
                        "type": "string",
                        "description": "Filter by seller type.",
                        "default": "all"
                    },
                    "only_with_phone": {
                        "title": "Only ads with phone",
                        "type": "boolean",
                        "description": "Keep only ads that contain a phone number.",
                        "default": false
                    },
                    "max_pages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pages to process."
                    },
                    "max_items": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of items to return.",
                        "default": 1000
                    },
                    "request_id": {
                        "title": "Request ID",
                        "type": "string",
                        "description": "Optional custom request identifier."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
