# Leboncoin Scraper — France Classified Ads Real Estate & Cars (`crawloop/leboncoin-scraper`) Actor

Leboncoin scraper for French classifieds: real estate (m², rooms, DPE/GES), vehicles (mileage, fuel, year), prices, seller type, and locations. JSON export — Python, Node.js, and MCP ready. French residential proxy recommended.

- **URL**: https://apify.com/crawloop/leboncoin-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Real estate, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 listings

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 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 — France Classified Ads, Real Estate & Cars

> **Disclaimer:** Unofficial tool developed independently. Not affiliated with, sponsored by, or endorsed by Leboncoin or Adevinta. Leboncoin and related trademarks belong to their respective owners. Data is read from publicly accessible listing surfaces. Provided for informational and research use; you must comply with Leboncoin terms and applicable law.

**Leboncoin scraper** for France’s largest classifieds marketplace — extract structured ads into JSON/CSV via Apify. Pull search results by URL or keyword, real-estate specs (m², rooms, **DPE/GES**), vehicle details (brand, mileage, fuel, year), prices, seller type (pro/private), images, and geo coordinates. Fast HTTP path (no heavy browser) with French residential proxy for DataDome. Use as a **Leboncoin API alternative** from **Python**, **Node.js**, cURL, or **MCP** / AI assistants.

**Best for:** French real-estate comps, used-car inventory, seller monitoring, and marketplace research pipelines.

> **Crawloop European Marketplace Suite** — classifieds scrapers for FR / DE / NL.

| Leboncoin Scraper ◄── you are here | [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper) | [Marktplaats Scraper](https://apify.com/crawloop/marktplaats-scraper) | [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) |
| :--- | :--- | :--- | :--- |
| France classifieds + DPE / auto | Germany classifieds + monitor | Netherlands marketplace | German vehicles |

### When to use this Actor

- **Leboncoin search scraping** — Paste a filtered `recherche` URL or build queries with keywords, category, price, and location
- **Real estate intelligence** — Surface area, rooms, bedrooms, energy class (DPE) and greenhouse label (GES)
- **Vehicle inventory** — Brand, model, year, mileage (km), fuel type, gearbox for Voitures and related categories
- **Seller / agency monitoring** — Track active ads for a user UUID or profile URL (pro vs private)
- **Bulk export** — Dataset rows ready for Sheets, BI tools, or Apify integrations

### When not to use this Actor

- **Phone numbers or private messages** — Output includes `has_phone` only; no phone scraping, inbox, or login
- **Non-French marketplaces** — Use [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper) or [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) for Germany

### Key features

- **URL + filter modes** — Start URLs, keywords, category, price range, location, seller type
- **Detail & seller modes** — Direct listing URLs and seller IDs; optional detail-API enrichment
- **Deep attributes** — Real-estate and vehicle fields beyond title/price (DPE, m², mileage, fuel)
- **DataDome-ready HTTP** — Mobile TLS impersonation + session warmup; **FR residential proxy required**
- **MCP / AI ready** — Call from Claude, Cursor, and other tools via Apify MCP

### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `startUrls` | Array | — | Search, listing detail, or seller profile URLs |
| `searchKeywords` | Array | `[]` | Keywords (e.g. `appartement`, `Peugeot 208`) |
| `category` | String | `all` | `real_estate`, `vehicles`, `multimedia`, `home`, `fashion`, `jobs`, `services` |
| `minPrice` / `maxPrice` | Integer | — | Price range in EUR |
| `location` | String | — | City, zip code, or department label |
| `ownerType` | String | `any` | `any`, `private`, or `pro` |
| `sellerIds` | Array | — | Leboncoin user UUIDs |
| `detailUrls` | Array | — | Direct listing URLs to fetch as details |
| `enrichDetails` | Boolean | `false` | Re-fetch each search hit via the classified detail API |
| `maxItems` | Integer | `100` | Maximum dataset rows |
| `maxPages` | Integer | `20` | Max search pages (~35 ads per page) |
| `proxyConfiguration` | Object | FR residential | Apify Proxy — **French residential required** |

#### Input example

```json
{
  "startUrls": [
    { "url": "https://www.leboncoin.fr/recherche?category=9&locations=Paris" }
  ],
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

### Output Format

Each dataset row = one Leboncoin listing.

| Field | Type | Description |
| :--- | :--- | :--- |
| `id` | String | Leboncoin `list_id` |
| `url` | String | Canonical listing URL |
| `title` / `subject` | String | Ad headline |
| `description` | String | Full body text |
| `price` | Number | Price in EUR |
| `currency` | String | `EUR` |
| `category_id` / `category_name` | String | Category id and label |
| `location.city` / `zipcode` | String | City and postal code |
| `location.department_code` / `region_name` | String | Department / region when present |
| `location.lat` / `lng` | Number | Coordinates when available |
| `attributes.square_meters` / `rooms` / `bedrooms` | Number | Real-estate size fields |
| `attributes.dpe_energy_class` / `ges_greenhouse_class` | String | Energy labels |
| `attributes.vehicle_brand` / `vehicle_model` / `vehicle_year` | Mixed | Vehicle identity |
| `attributes.vehicle_mileage_km` / `fuel_type` / `gearbox` | Mixed | Vehicle specs |
| `owner.user_id` / `name` / `type` | String | Seller id, display name, `pro` or `private` |
| `owner.siren` | String | Business id when present |
| `images` | Array | Image URLs |
| `has_phone` | Boolean | Whether phone contact is offered (number not collected) |
| `publication_date` / `index_date` | String | Published + scrape timestamps |

#### Output example

```json
{
  "id": "3244017072",
  "url": "https://www.leboncoin.fr/ad/voitures/3244017072",
  "title": "206 1.4l hdi",
  "price": 3000,
  "currency": "EUR",
  "category_name": "Voitures",
  "location": {
    "city": "Nantes",
    "zipcode": "44000",
    "lat": 47.21,
    "lng": -1.55
  },
  "attributes": {
    "vehicle_brand": "Peugeot",
    "vehicle_model": "206",
    "vehicle_year": 2005,
    "vehicle_mileage_km": 225000,
    "fuel_type": "Diesel",
    "gearbox": "Manuelle"
  },
  "owner": {
    "type": "private",
    "name": "bruno",
    "user_id": "01362bde-5a92-4e4e-be6c-885e07db1b9a"
  },
  "has_phone": true
}
```

### Use cases

1. **Real estate comps** — Track €/m² and DPE bands in Paris, Lyon, Marseille, and other cities
2. **Auto deal sourcing** — Compare mileage-to-price for a brand/model across regions
3. **Agency / seller watchlists** — Monitor pro stores and private sellers by user id
4. **Cross-border arbitrage** — Pair with German classifieds scrapers for FR vs DE price gaps

### Integration examples

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('crawloop/leboncoin-scraper').call({
    startUrls: [{ url: 'https://www.leboncoin.fr/recherche?category=2&text=peugeot' }],
    maxItems: 50,
    proxyConfiguration: {
        useApifyProxy: true,
        apifyProxyGroups: ['RESIDENTIAL'],
        apifyProxyCountry: 'FR',
    },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => console.log(`${item.title} — ${item.price} €`));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("crawloop/leboncoin-scraper").call(
    run_input={
        "searchKeywords": ["appartement"],
        "category": "real_estate",
        "location": "Lyon",
        "maxPrice": 350000,
        "maxItems": 50,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "FR",
        },
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["location"]["city"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/crawloop~leboncoin-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchKeywords": ["iphone 15"],
    "category": "multimedia",
    "maxItems": 20,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "FR"
    }
  }'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/leboncoin-scraper`.

Example prompts:

- "Run Leboncoin Scraper for 3-room apartments in Lyon under €350,000 with maxItems 40 and return title, price, m², and DPE as JSON"
- "Scrape Peugeot 308 listings on Leboncoin with mileage under 80,000 km from private sellers; summarize price bands"
- "Chain Leboncoin Scraper then [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper) to compare FR vs DE used-phone prices for iPhone 15"

### Suite next step

After France classifieds, deepen auto pricing with [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper), or expand to Germany with [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper).

### FAQ

**Is this a Leboncoin API?**\
There is no official public API. This Actor is a Leboncoin API alternative that returns structured dataset items you can call from Python, Node.js, or MCP.

**Why do I need a French residential proxy?**\
Leboncoin uses DataDome with strong IP reputation checks. Datacenter and non-FR IPs usually get HTTP 403.

**Does this return phone numbers?**\
No. The Actor exposes `has_phone` only and does not collect personal phone numbers.

**Can I scrape a specific seller?**\
Yes — pass the profile URL in `startUrls` or the user UUID in `sellerIds`.

**Which categories are supported?**\
Real estate, vehicles, multimedia, home, fashion, jobs, services, plus any search URL you paste from the site.

### Related Actors

- [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper) — Germany classified ads
- [Marktplaats Scraper](https://apify.com/crawloop/marktplaats-scraper) — Netherlands marketplace
- [Mobile.de Scraper](https://apify.com/crawloop/mobile-de-scraper) — German vehicle listings

# Actor input Schema

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

Leboncoin search, listing detail, or seller profile URLs.

## `searchKeywords` (type: `array`):

Keywords to search (e.g. appartement, Peugeot 208, iPhone 15).

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

Leboncoin category filter when using keywords / filters.

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

Minimum price in euros.

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

Maximum price in euros.

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

City, zip code, or department label (e.g. Paris, 75015, Lyon).

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

Filter by private or professional sellers.

## `sellerIds` (type: `array`):

Leboncoin user UUIDs — scrape all active ads for these sellers.

## `detailUrls` (type: `array`):

Direct listing URLs or IDs to fetch as full ad details.

## `enrichDetails` (type: `boolean`):

For search results, fetch each listing via the classified detail API (slower, fuller description/attributes).

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

Maximum number of listings to save.

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

Maximum finder/search pages per query (35 ads per page).

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

French residential proxy is required to bypass DataDome reliably.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.leboncoin.fr/recherche?category=9&locations=Paris"
    }
  ],
  "searchKeywords": [],
  "category": "all",
  "ownerType": "any",
  "enrichDetails": false,
  "maxItems": 100,
  "maxPages": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset items — one Leboncoin listing per row.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.leboncoin.fr/recherche?category=9&locations=Paris"
        }
    ],
    "searchKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/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 = {
    "startUrls": [{ "url": "https://www.leboncoin.fr/recherche?category=9&locations=Paris" }],
    "searchKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/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 '{
  "startUrls": [
    {
      "url": "https://www.leboncoin.fr/recherche?category=9&locations=Paris"
    }
  ],
  "searchKeywords": []
}' |
apify call crawloop/leboncoin-scraper --silent --output-dataset

```

## MCP server setup

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