# Leboncoin Scraper \[$1/1K💰] | French Real Estate · Prices & DPE (`ahmed_jasarevic/leboncoin-scraper`) Actor

Scrape Leboncoin.fr — France's largest classifieds platform — for structured French real estate data. Extract prices in EUR, price per m², surface, rooms, DPE/GES energy ratings, GPS, photos, and seller info with SIRET. DataDome bypass via Chrome TLS impersonation plus French residential proxy.

- **URL**: https://apify.com/ahmed\_jasarevic/leboncoin-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:**
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Leboncoin Scraper — French Real Estate & Property Data

Scrape **Leboncoin.fr** — France's largest classifieds platform — and extract structured **French real
estate data** for property price tracking, market research, and DPE/GES energy analysis. Pull titles,
prices in EUR, price per m², property type, surface, rooms, DPE/GES ratings, GPS coordinates, photos,
and seller info (including SIRET) from immobilier listings across all of France — in clean, typed JSON.

### Main Use Cases

- **French property price tracking** — monitor asking prices by city, neighborhood and property type
- **Price per m² analysis** — compute and compare `pricePerSquareMeter` across French regions
- **French real estate market research** — analyze listings, seller types and location trends at scale
- **DPE/GES energy data** — extract France's mandatory energy-performance ratings for green/carbon research
- **Real estate investment & lead generation** — find undervalued listings and build agency/seller lists
- **Prop-tech database / API replacement** — power a French property site, comparateur or dashboard

### Get French Property Data Without An Official Leboncoin API

Leboncoin does **not** offer a public API for its listings. This actor talks to the same internal
`finder/search` API a real browser uses, returning clean typed JSON with **no HTML parsing**. Because
Leboncoin is protected by **DataDome** (rated 5/5 difficulty), the actor sends requests through
`curl-impersonate` with an exact **Chrome JA3/JA4 TLS fingerprint** and requires a **French
residential proxy** (geo-scoring blocks non-French and datacenter IPs). If the API is blocked it
falls back to parsing the `/recherche` page (`__NEXT_DATA__`, then cheerio).

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `category` | string | No | `9` | `9` = Ventes (sales, immobilier), `10` = Locations (rentals) |
| `realEstateType` | string | No | `all` | House, apartment, land, etc. (`all`/`1`–`7`) |
| `locations` | array | No | `[]` | Region code (`12`), `code|label`, dept/zip (`75__75000`), or city text (`Paris`) |
| `minPrice` / `maxPrice` | integer | No | — | Price range filter in EUR |
| `minSquare` / `maxSquare` | integer | No | — | Surface area filter in m² |
| `minRooms` | integer | No | — | Minimum number of rooms |
| `sort` / `order` | string | No | `time`/`desc` | `time`, `price`, `relevance`; `asc`/`desc` |
| `maxItems` | integer | No | `100` | Max listings to scrape (free ≤50, paid ≤10,000) |
| `includePhotos` | boolean | No | `true` | Extract photo URLs |
| `cookieBootstrap` | boolean | No | `false` | Mint a DataDome cookie in Chromium for one session if warm-up fails |
| `cacheResults` / `cacheTtlMinutes` | boolean/int | No | `false`/`60` | Cache results between runs |
| `proxyConfiguration` | object | No | Apify residential, country `FR` | French residential proxy (required for reliability) |

### Example Input

```json
{
  "category": "9",
  "locations": ["12|Ile de France", "75__75000"],
  "minPrice": 200000,
  "maxPrice": 500000,
  "minRooms": 3,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

### Output

Each listing is one typed JSON record: `id`, `url`, `title`, `price` (EUR),
`pricePerSquareMeter`, `propertyType`, `surface` (m²), `rooms`, `bedrooms`, `dpe`, `ges`,
`location` (city, zipcode, department, region, latitude, longitude), `photos`, `seller` (name,
type pro/private, SIRET), `publicationDate`, `description`, and `attributes`.

### Example Output

```json
{
  "id": "2900960027",
  "url": "https://www.leboncoin.fr/ad/ventes_immobilieres/2900960027",
  "title": "Appartement 3 pieces 65 m2",
  "price": 320000,
  "pricePerSquareMeter": 4923,
  "propertyType": "Appartement",
  "surface": 65,
  "rooms": 3,
  "bedrooms": 2,
  "dpe": "D",
  "ges": "B",
  "location": { "city": "Paris", "zipcode": "75011", "department": "75", "region": "Ile-de-France", "latitude": 48.8619, "longitude": 2.3784 },
  "photos": ["https://img.leboncoin.fr/api/v1/.../1.jpg"],
  "seller": { "name": "Century 21", "type": "pro", "isPro": true, "siret": "12345678901234" },
  "publicationDate": "2026-08-25T10:30:00+0200"
}
```

<sub>Illustrative example matching the actor's documented output schema.</sub>

### Scheduling, Monitoring & Automation

Run on a **daily or hourly schedule** to see new listings the moment they publish (set `sort: time`)
and to track price changes over time. Results stream via the Apify **API** and **webhooks** and
export to JSON/CSV/Excel — ideal for a comparateur, dashboard, or price-alert product.

### Related Actors

- **Bayut Scraper** (own) — UAE/MENA real estate data
- **Idealista Scraper** and other European real-estate scrapers for a broad property-price cluster
- Quality other French/european property list actors as relevant

<sub>Relevance over ownership; keep to ~5.</sub>

### FAQ

#### Why use this actor instead of the Leboncoin API?

Leboncoin has **no public API** for listings. This actor returns the same typed data by calling the
internal search endpoint a real browser uses, while solving the two things that break naive
scraping: **DataDome anti-bot** (handled with Chrome TLS impersonation) and **geo-blocking of
non-French IPs** (handled by requiring a French residential proxy).

#### What are the alternatives to this actor for French property data?

Other Leboncoin scrapers on Apify and French prop-tech APIs (e.g. SeLoger/Stream-like data services).
This actor distinguishes itself on clean typed JSON output, DPE/GES extraction, and a robust
DataDome bypass with a built-in French-residential-proxy path.

#### How do I track French property prices by city / neighborhood?

Filter `locations` by city/zip (e.g. `75__75011`) or region, scrape on a schedule, and aggregate
`price` and `pricePerSquareMeter` over time across your target areas.

#### How do I get DPE/GES energy data for French homes?

The `dpe` and `ges` fields are extracted directly from each listing — scrape a region/category and
aggregate energy ratings to analyze the French housing stock's energy performance.

#### Is scraping Leboncoin legal in France?

You are responsible for complying with Leboncoin's Terms of Service and French/EU law (GDPR).
Extract only publicly available data and respect privacy; avoid use that violates terms or privacy.
This is informational, not legal advice.

### For AI Agents & LLM Apps

**Purpose:** Extracts typed French real-estate listings from Leboncoin.fr — one record per ad with
price, price/m², location, DPE/GES, and seller info.

**Minimal working input** (all fields optional; empty `{}` valid — defaults to sales listings):

```json
{ "category": "9", "maxItems": 100 }
```

**Typical input** (targeted region):

```json
{ "category": "9", "locations": ["12|Ile de France"], "minPrice": 200000, "maxPrice": 500000, "maxItems": 500 }
```

**Output fields:** `id`, `url`, `title`, `price`, `pricePerSquareMeter`, `propertyType`, `surface`,
`rooms`, `bedrooms`, `dpe`, `ges`, `location` (city/zipcode/department/region/lat/lng), `photos`,
`seller` (name/type/SIRET), `publicationDate`, `description`, `attributes`.

**Behaviors an agent should know:**

- All inputs are optional; empty input scrapes sales (category `9`) by default.
- `category` `9` = sales, `10` = rentals.
- A **French residential proxy is effectively required** for reliable runs (defaults to Apify
  residential with `FR` country); non-French/datacenter IPs get blocked by DataDome.
- `maxItems` caps results (free tier ≤50, paid ≤10,000); each listing is billed.
- `sort: time` + `order: desc` (default) returns newest listings first — good for fresh-list detection.
- `cookieBootstrap: true` helps only if the HTTP warm-up fails to mint a DataDome cookie.

**Billing:** pay-per-result at roughly **$0.10 per 100 listings** (~$1 / 1,000), plus a start event fee.
Free tier: up to 50 items per run.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by
Leboncoin** (Adevinta / Leboncoin group). It accesses **only publicly available** Leboncoin pages and
endpoints — it does not bypass logins or solve CAPTCHAs. As with all web scraping, you are
responsible for your own compliance with Leboncoin's Terms of Service and applicable law, including
**GDPR** (especially if output contains seller contact or personal data) and French database
protection rules. This summary is informational, not legal advice.

### SEO Keywords

leboncoin scraper, scraper leboncoin, leboncoin immobilier scraper, french real estate data, prix immobilier france, prix au metre carre france, annonces immobilières données, dpe ges données logement, suivi prix immobilier, location appartement données, french property listings, leboncoin api alternative, french property prices, paris real estate data, ile de france property data, veille immobilière, energy performance ratings france

# Actor input Schema

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

Leboncoin category ID. 9 = Ventes immobilieres (sales), 10 = Locations immobilieres (rentals).

## `realEstateType` (type: `string`):

Type of property to search for.

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

Locations to target. Accepted forms: a region code (e.g. 12 for Ile-de-France, 84 for Auvergne-Rhone-Alpes), a code followed by a label (e.g. "12|Ile de France"), a department\_\_zip pair (e.g. "75\_\_75000"), or free text that is auto-resolved via leboncoin's parrot-location API (e.g. "Paris", "Bordeaux"). Leave empty for all France.

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

Minimum price filter in euros. Leave empty for no minimum.

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

Maximum price filter in euros. Leave empty for no maximum.

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

Minimum property surface in square meters. Leave empty for no minimum.

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

Maximum property surface in square meters. Leave empty for no maximum.

## `minRooms` (type: `integer`):

Minimum number of rooms. Leave empty for no minimum.

## `sort` (type: `string`):

Sort results by field.

## `order` (type: `string`):

Sort direction.

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

Maximum number of listings to scrape. Free users capped at 50.

## `includePhotos` (type: `boolean`):

Whether to extract photo URLs from listings.

## `cookieBootstrap` (type: `boolean`):

When enabled, if the HTTP warmup does not yield a DataDome cookie, a headless Chromium tab is opened once per session inside the actor to sign it and let the API fly. Set to true if you see 403/captcha errors on the finder API.

## `cacheResults` (type: `boolean`):

When enabled, results for the exact same search filters are stored in a key-value store and returned instantly on reruns within the TTL, without scraping Leboncoin again. Useful for repeated scheduled runs of the same query.

## `cacheTtlMinutes` (type: `integer`):

How long cached results stay valid before a rerun rescrapes. Only used when Cache Results is enabled.

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

ON = use Apify Proxy (billed to your Apify account; RESIDENTIAL + country FR recommended for the best DataDome bypass). OFF = use your own proxies (billed to your proxy provider) - paste them into the credentials box below.

## `proxyUrl` (type: `string`):

Bypass Apify proxy and route all traffic through a single custom proxy URL instead, e.g. http://user:pass@host:3128. Use a French residential/mobile proxy for best results. Takes precedence over the proxy configuration above, and is billed to your own proxy provider.

## Actor input object example

```json
{
  "category": "9",
  "realEstateType": "all",
  "locations": [],
  "sort": "time",
  "order": "desc",
  "maxItems": 100,
  "includePhotos": true,
  "cookieBootstrap": false,
  "cacheResults": false,
  "cacheTtlMinutes": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/leboncoin-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("ahmed_jasarevic/leboncoin-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ahmed_jasarevic/leboncoin-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/leboncoin-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xDdryiq4reLRYRW4u/builds/dZ5hhuR3EA0ntwfBF/openapi.json