# Leboncoin FR $1💰 URL | Filters | Deep Search Scraper (`abotapi/leboncoin-fr-scraper`) Actor

Pull public leboncoin.fr listings across cars, property, jobs, electronics, furniture, and 35+ categories. Returns 60–78 fields, including price, GPS, seller info, attributes, and images. Search by filters or URL with pagination and listing ID dedupe.

- **URL**: https://apify.com/abotapi/leboncoin-fr-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Jobs, E-commerce
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.80 / 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/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.fr Scraper

Pull every public field from leboncoin.fr classified listings: cars, property, jobs, electronics, furniture, and 35 more categories. 60-78 flat fields per record including price, GPS coordinates, full seller info, exploded category attributes (mileage, fuel type, year, rooms, surface area), and the full image gallery. Search by filters or paste a Leboncoin search URL; both modes walk pagination forward and dedupe by listing ID.

### Why this scraper?

- 60-78 flat fields per listing (most rivals stop at 40)
- Two modes: build searches from filters, or paste raw Leboncoin search URLs
- Multi-location, multi-URL, multi-category in one run
- Optional detail-page enrichment for full body text and image gallery
- Optional seller-reviews enrichment (star rating + text reviews)
- Optional seller-other-listings enrichment (catalogue of pro sellers' active ads)
- Per-search budget cap so a 5-city run returns 5 cities, not just the first one
- Fast: 100 listings in ~13 seconds, 150 listings in ~16 seconds (verified on cloud, FR-residential)
- Session cache cuts repeat-run latency by half (subsequent runs within 22 minutes skip the cold-start)
- Works with FR-residential by default; any EU residential country also accepted (DE, BE, IT, ES, NL, PT, AT, ...)

### Data You Get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| `id` | `"0000000000"` |
| `list_id` | `0000000000` |
| `subject` | `"Sample Listing Title"` |
| `body` | `"Full seller description text appears here when fetchDetails=true."` |
| `url` | `"https://www.leboncoin.fr/ad/voitures/0000000000"` |
| `category_id` | `"2"` |
| `category_name` | `"Voitures"` |
| `ad_type` | `"offer"` |
| `status` | `"active"` |
| `brand` | `"leboncoin"` |
| `price` | `0` |
| `price_max` | `null` |
| `price_cents` | `0` |
| `publication_date` | `"2026-01-01 00:00:00"` |
| `index_date` | `"2026-01-01 00:00:00"` |
| `expiration_date` | `"2026-04-01 00:00:00"` |
| `has_phone` | `true` |
| `is_boosted` | `false` |
| `is_urgent` | `false` |
| `city` | `"Paris"` |
| `zipcode` | `"75001"` |
| `department_id` | `"75"` |
| `department` | `"Paris"` |
| `region_id` | `"12"` |
| `region` | `"Ile-de-France"` |
| `latitude` | `48.8566` |
| `longitude` | `2.3522` |
| `owner_type` | `"private"` |
| `owner_name` | `"Sample Seller"` |
| `owner_user_id` | `"00000000"` |
| `owner_store_id` | `"00000000"` |
| `owner_raw` | full upstream `owner` block (verbatim — captures `siren`, store address, response stats, and any field the platform adds) |
| `image_count` | `5` |
| `thumb_url` | `"https://img.leboncoin.fr/api/v1/lbcpb1/images/00/00/00/000000.jpg?rule=ad-thumb"` |
| `image_urls` | `["https://img.leboncoin.fr/...?rule=ad-image", "..."]` |
| `view_count` | `0` |
| `favorite_count` | `0` |
| `attr_year` | `"2020"` |
| `attr_mileage` | `"50000"` |
| `attr_fuel` | `"Diesel"` |
| `attr_gearbox` | `"Manuelle"` |
| `attr_rooms` | `"3 pièces"` |
| `attr_square` | `"60 m²"` |
| `attr_energy_rate` | `"D"` |
| `attr_ges` | `"C"` |
| `raw_attributes` | `[{"key": "year", "value": "2020", "value_label": "2020"}, ...]` |
| `seller_rating_avg` | `4.8` *(when `fetchSellerReviews=true`)* |
| `seller_review_count` | `42` *(when `fetchSellerReviews=true`)* |
| `seller_reviews` | `[{"rating": 5, "comment": "...", "author": "...", "created_at": "..."}, ...]` *(when `fetchSellerReviews=true`)* |
| `seller_other_listings_count` | `17` *(when `fetchSellerOtherListings=true`)* |
| `seller_other_listings` | `[{"id": "0000000000", "subject": "...", "price": 0, "url": "...", "thumb_url": "..."}, ...]` *(when `fetchSellerOtherListings=true`)* |

Category attributes (`attr_*`) vary by category. Cars carry mileage, fuel, gearbox, year. Property carries rooms, square, energy_rate, ges. The full set is preserved in `raw_attributes` for advanced consumers.

Seller enrichment fields are only populated when the corresponding input toggle is on. Private sellers without a public profile yield empty arrays. Sellers with no reviews yet yield `seller_review_count: 0` and an empty `seller_reviews` array.

### How to Use

#### Search by filters (cars in Paris under 15k EUR)

```json
{
  "mode": "search",
  "category": "voitures",
  "locations": ["Paris"],
  "minPrice": 5000,
  "maxPrice": 15000,
  "maxMileage": 50000,
  "fuel": "diesel",
  "sortBy": "price_asc",
  "maxPages": 5,
  "maxListings": 100
}
````

#### Search across multiple cities

```json
{
  "mode": "search",
  "category": "ventes_immobilieres",
  "locations": ["Paris", "Lyon", "Marseille", "Bordeaux"],
  "minSquare": 40,
  "maxSquare": 120,
  "rooms": ["2", "3", "4"],
  "ownerType": "pro",
  "maxPages": 3,
  "maxListings": 200
}
```

#### Paste Leboncoin search URLs (URL mode)

```json
{
  "mode": "url",
  "urls": [
    "https://www.leboncoin.fr/recherche?category=2&locations=Paris&fuel=2",
    "https://www.leboncoin.fr/recherche?category=9&locations=Lyon&price=200000-500000"
  ],
  "maxPages": 5,
  "maxListings": 200
}
```

#### Free-text query

```json
{
  "mode": "search",
  "text": "iphone 14 pro",
  "category": "telephonie",
  "locations": ["Paris", "Lyon"],
  "maxListings": 50,
  "fetchDetails": true
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `"search"` | `"search"` builds the URL from filters; `"url"` takes raw Leboncoin search URLs |
| `text` | string | none | Free-text keyword query (search mode) |
| `category` | string | `"all"` | Top-level category (cars, property, electronics, ...) |
| `locations` | array | `["Paris"]` | Cities, regions, or department codes (search mode, multi-select) |
| `ownerType` | string | `"all"` | Filter by seller: `"all"`, `"private"`, `"pro"` |
| `minPrice` / `maxPrice` | integer | none | Price range in EUR |
| `minSquare` / `maxSquare` | integer | none | Surface area in m² (property categories) |
| `rooms` | array | none | Number of rooms (property; multi-select e.g. `["2", "3"]`) |
| `minMileage` / `maxMileage` | integer | none | Mileage in km (vehicle categories) |
| `fuel` | string | `"all"` | `"all"`, `"petrol"`, `"diesel"`, `"hybrid"`, `"electric"`, `"gpl"`, `"other"` |
| `sortBy` | string | `"relevance"` | `"relevance"`, `"date_desc"`, `"date_asc"`, `"price_asc"`, `"price_desc"` |
| `urls` | array | none | Direct Leboncoin search URLs (URL mode, multi-URL) |
| `maxPages` | integer | `2000` | Max pages per search (100 listings per page). The actual page count is bounded by `maxListings`, so the high default just means "walk until budget hits." |
| `maxListings` | integer | `100` | Total listings cap across all searches; `0` = unlimited |
| `fetchDetails` | boolean | `false` | Visit each listing's detail page for full body + image gallery (adds 1 fetch per item) |
| `fetchSellerReviews` | boolean | `false` | Pull the seller's star rating + textual reviews. Adds 1 lightweight call per listing (no extra credits). Empty array for sellers with no reviews yet. |
| `fetchSellerOtherListings` | boolean | `false` | Pull the seller's other active ads (subject, price, URL, image). Adds 1 lightweight call per listing (no extra credits). Useful for mapping pro-seller catalogues. |
| `proxy` | object | residential FR | Proxy config; residential required. Default country is FR. Any EU country accepted (DE, BE, IT, ES, NL, PT, AT, CH, LU, IE, DK, SE, FI, PL, CZ, GR, HU, RO, BG). |

### Output Example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "id": "0000000000",
  "list_id": 0000000000,
  "subject": "Sample Listing Title",
  "body": "Full seller description text appears here when fetchDetails=true.",
  "url": "https://www.leboncoin.fr/ad/voitures/0000000000",
  "category_id": "2",
  "category_name": "Voitures",
  "ad_type": "offer",
  "status": "active",
  "brand": "leboncoin",
  "price": 0,
  "price_max": null,
  "price_cents": 0,
  "publication_date": "2026-01-01 00:00:00",
  "has_phone": true,
  "is_boosted": false,
  "city": "Paris",
  "zipcode": "75001",
  "department_id": "75",
  "department": "Paris",
  "latitude": 48.8566,
  "longitude": 2.3522,
  "owner_type": "private",
  "owner_name": "Sample Seller",
  "owner_user_id": "00000000",
  "image_count": 5,
  "thumb_url": "https://img.leboncoin.fr/api/v1/lbcpb1/images/00/00/00/000000.jpg?rule=ad-thumb",
  "image_urls": ["https://img.leboncoin.fr/api/v1/lbcpb1/images/00/00/00/000000.jpg?rule=ad-image"],
  "attr_year": "2020",
  "attr_mileage": "50000",
  "attr_fuel": "Diesel",
  "attr_gearbox": "Manuelle",
  "raw_attributes": [],

  "seller_rating_avg": 4.8,
  "seller_review_count": 42,
  "seller_reviews": [
    {
      "rating": 5,
      "comment": "Vendeur sérieux, transaction rapide.",
      "author": "Sample Buyer",
      "created_at": "2026-03-15T12:00:00Z"
    }
  ],

  "seller_other_listings_count": 17,
  "seller_other_listings": [
    {
      "id": "0000000001",
      "subject": "Another listing from same seller",
      "price": 9500,
      "url": "https://www.leboncoin.fr/ad/voitures/0000000001",
      "thumb_url": "https://img.leboncoin.fr/.../thumb.jpg"
    }
  ]
}
```

`seller_*` fields are populated only when the corresponding input toggle is on (`fetchSellerReviews`, `fetchSellerOtherListings`). Each toggle adds ~0.5s wall time per listing and zero extra Apify proxy/antibot cost.

### Plan Requirement

Leboncoin.fr's edge filter rejects datacenter traffic. **Residential proxy is required** — without it, the run will return 0 items. Recommended:

```json
{
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "FR" }
}
```

**Country selection**: FR is the default and works best (Leboncoin is a French marketplace). If FR returns 0 items on your account, try other EU countries — the actor accepts FR, BE, DE, ES, IT, NL, PT, AT, CH, LU, IE, DK, SE, FI, PL, CZ, GR, HU, RO, BG. Each Apify account has its own pool per country, so quality can vary; experiment with what works for you.

Apify's free plan does not include residential proxy credit. For best results upgrade to Starter or higher (https://apify.com/pricing). Datacenter proxies and non-EU exits will trigger a warning at startup.

# Actor input Schema

## `mode` (type: `string`):

Search mode builds the URL from your filters. URL mode takes one or more Leboncoin search URLs and walks them forward.

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

Optional keyword query (e.g. 'iphone 14', 'aston martin'). Search mode only.

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

Top-level category. Search mode only.

## `locations` (type: `array`):

Cities, regions, or department codes (e.g. \['Paris', 'Lyon', 'Marseille'], or \['75', '69\_d'] for departments). Leave empty for all of France. Multi-city is supported.

## `ownerType` (type: `string`):

Filter by seller type.

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

Minimum price in euros. Leave empty for no minimum.

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

Maximum price in euros. Leave empty for no maximum.

## `minSquare` (type: `integer`):

Minimum surface area in m² (property categories).

## `maxSquare` (type: `integer`):

Maximum surface area in m² (property categories).

## `rooms` (type: `array`):

Filter by number of rooms (property categories). Multi-select supported, e.g. \[2, 3, 4].

## `minMileage` (type: `integer`):

Minimum mileage in km (vehicle categories).

## `maxMileage` (type: `integer`):

Maximum mileage in km (vehicle categories).

## `fuel` (type: `string`):

Filter by fuel type (cars / motorcycles).

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

How to sort results.

## `urls` (type: `array`):

Leboncoin search page URLs to scrape (URL mode only). Multi-URL supported. Filter-mode fields are ignored. Pagination starts at the page in the URL and walks forward.

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

How many pages to walk per search URL (~100 listings per page). Default is high so the run keeps going until 'maxListings' is reached or the search runs out of results — actual page count is bounded by 'maxListings'.

## `maxListings` (type: `integer`):

Maximum total listings to return across all searches. Set 0 for unlimited.

## `fetchDetails` (type: `boolean`):

Visit each listing's detail page to pull the full description body, full image gallery, owner phone availability, similar listings, and any extra category attributes. Adds about 1 second per listing.

## `fetchSellerReviews` (type: `boolean`):

For each listing, fetch the seller's textual reviews (star rating + customer feedback). Zero extra antibot credits, ~0.5s wall time per item. Sellers with no reviews get an empty array.

## `fetchSellerOtherListings` (type: `boolean`):

For each listing, fetch the seller's other active ads (subject, price, url, image). Zero extra antibot credits, ~0.5s wall time per item. Useful for mapping pro-seller catalogues.

## `proxy` (type: `object`):

Proxy settings. Residential proxy is required (datacenter is rejected by the upstream edge filter). Default country is FR; if FR returns 0 items on your account, try other EU countries (DE, BE, IT, ES, NL, ...). Pool quality varies per Apify account and country, so experiment with what works for you.

## Actor input object example

```json
{
  "mode": "search",
  "category": "all",
  "locations": [
    "Paris"
  ],
  "ownerType": "all",
  "fuel": "all",
  "sortBy": "relevance",
  "urls": [
    "https://www.leboncoin.fr/recherche?category=2&locations=Paris"
  ],
  "maxPages": 200,
  "maxListings": 20,
  "fetchDetails": false,
  "fetchSellerReviews": false,
  "fetchSellerOtherListings": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "locations": [
        "Paris"
    ],
    "urls": [
        "https://www.leboncoin.fr/recherche?category=2&locations=Paris"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/leboncoin-fr-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 = {
    "locations": ["Paris"],
    "urls": ["https://www.leboncoin.fr/recherche?category=2&locations=Paris"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/leboncoin-fr-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 '{
  "locations": [
    "Paris"
  ],
  "urls": [
    "https://www.leboncoin.fr/recherche?category=2&locations=Paris"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call abotapi/leboncoin-fr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Leboncoin FR $1💰 URL | Filters | Deep Search Scraper",
        "description": "Pull public leboncoin.fr listings across cars, property, jobs, electronics, furniture, and 35+ categories. Returns 60–78 fields, including price, GPS, seller info, attributes, and images. Search by filters or URL with pagination and listing ID dedupe.",
        "version": "1.0",
        "x-build-id": "Hx5cp35nQyv7f3LSX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~leboncoin-fr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-leboncoin-fr-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/abotapi~leboncoin-fr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-leboncoin-fr-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/abotapi~leboncoin-fr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-leboncoin-fr-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "🎯 Start here, pick your mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Search mode builds the URL from your filters. URL mode takes one or more Leboncoin search URLs and walks them forward.",
                        "default": "search"
                    },
                    "text": {
                        "title": "Free text query",
                        "type": "string",
                        "description": "Optional keyword query (e.g. 'iphone 14', 'aston martin'). Search mode only."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "voitures",
                            "motos",
                            "utilitaires",
                            "caravaning",
                            "nautisme",
                            "equipement_auto",
                            "ventes_immobilieres",
                            "locations",
                            "colocations",
                            "bureaux_commerces",
                            "informatique",
                            "telephonie",
                            "image_son",
                            "consoles_jeux_video",
                            "ameublement",
                            "electromenager",
                            "arts_de_la_table",
                            "decoration",
                            "linge_de_maison",
                            "bricolage",
                            "jardinage",
                            "vetements",
                            "chaussures",
                            "accessoires_bagagerie",
                            "montres_bijoux",
                            "equipement_bebe",
                            "vetements_bebe",
                            "jeux_jouets",
                            "vins_gastronomie",
                            "loisirs_creatifs",
                            "instruments_de_musique",
                            "livres",
                            "cd_dvd",
                            "vetements_pro",
                            "offres_emploi",
                            "formation_professionnelle",
                            "services",
                            "evenements",
                            "animaux",
                            "materiel_agricole",
                            "equipement_pro"
                        ],
                        "type": "string",
                        "description": "Top-level category. Search mode only.",
                        "default": "all"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or department codes (e.g. ['Paris', 'Lyon', 'Marseille'], or ['75', '69_d'] for departments). Leave empty for all of France. Multi-city is supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ownerType": {
                        "title": "Seller type",
                        "enum": [
                            "all",
                            "private",
                            "pro"
                        ],
                        "type": "string",
                        "description": "Filter by seller type.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "Min price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in euros. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in euros. Leave empty for no maximum."
                    },
                    "minSquare": {
                        "title": "Min surface area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum surface area in m² (property categories)."
                    },
                    "maxSquare": {
                        "title": "Max surface area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum surface area in m² (property categories)."
                    },
                    "rooms": {
                        "title": "Number of rooms",
                        "type": "array",
                        "description": "Filter by number of rooms (property categories). Multi-select supported, e.g. [2, 3, 4].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minMileage": {
                        "title": "Min mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum mileage in km (vehicle categories)."
                    },
                    "maxMileage": {
                        "title": "Max mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum mileage in km (vehicle categories)."
                    },
                    "fuel": {
                        "title": "Fuel type",
                        "enum": [
                            "all",
                            "petrol",
                            "diesel",
                            "hybrid",
                            "electric",
                            "gpl",
                            "other"
                        ],
                        "type": "string",
                        "description": "Filter by fuel type (cars / motorcycles).",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date_desc",
                            "date_asc",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "relevance"
                    },
                    "urls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Leboncoin search page URLs to scrape (URL mode only). Multi-URL supported. Filter-mode fields are ignored. Pagination starts at the page in the URL and walks forward.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "How many pages to walk per search URL (~100 listings per page). Default is high so the run keeps going until 'maxListings' is reached or the search runs out of results — actual page count is bounded by 'maxListings'.",
                        "default": 200
                    },
                    "maxListings": {
                        "title": "Max total listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings to return across all searches. Set 0 for unlimited.",
                        "default": 20
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages (richer fields)",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to pull the full description body, full image gallery, owner phone availability, similar listings, and any extra category attributes. Adds about 1 second per listing.",
                        "default": false
                    },
                    "fetchSellerReviews": {
                        "title": "Enrich with seller reviews",
                        "type": "boolean",
                        "description": "For each listing, fetch the seller's textual reviews (star rating + customer feedback). Zero extra antibot credits, ~0.5s wall time per item. Sellers with no reviews get an empty array.",
                        "default": false
                    },
                    "fetchSellerOtherListings": {
                        "title": "Enrich with seller's other listings",
                        "type": "boolean",
                        "description": "For each listing, fetch the seller's other active ads (subject, price, url, image). Zero extra antibot credits, ~0.5s wall time per item. Useful for mapping pro-seller catalogues.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy is required (datacenter is rejected by the upstream edge filter). Default country is FR; if FR returns 0 items on your account, try other EU countries (DE, BE, IT, ES, NL, ...). Pool quality varies per Apify account and country, so experiment with what works for you."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
