# Leboncoin Scraper — Listings, Prices & Sellers (`tortuga/leboncoin-scraper`) Actor

Scrape Leboncoin.fr ads from any search URL or keyword + location + category: price, full description, all attributes, city & postcode, photos, seller type and name.

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

## Pricing

$0.80 / 1,000 listing scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Leboncoin Scraper — Listings, Prices & Sellers

Scrape Leboncoin.fr, France's largest classifieds site: title, price, **full description**, every attribute the ad shows (surface, rooms, energy class, make, model, year, mileage, fuel, gearbox, condition and the rest), city, postcode, department and region, publication date, all photos, shipping option, seller type (private or pro), seller name and SIREN for professionals. Start from any Leboncoin search URL, a category page or an ad URL, or simply type a keyword, a category and a few locations.

It reads the same JSON search service the Leboncoin website uses, so each request returns up to 100 complete ads: the description and all attributes come with every listing, with no extra page per ad and no extra fee. Export to JSON, CSV or Excel, or pull the results through the API into your app, a spreadsheet or an LLM pipeline.

### What data does Leboncoin Scraper extract?

| Field | Description |
|---|---|
| `id`, `url` | Leboncoin ad id and ad URL |
| `title`, `description` | Ad title and the full description text |
| `price`, `currency`, `oldPrice` | Price in EUR (monthly rent for rentals) and the previous price when the seller lowered it |
| `category`, `categoryId`, `adType` | e.g. `"Voitures"`, `"2"`; `offer` or `demand` (wanted ad) |
| `publishedAt`, `updatedAt`, `expiresAt` | First publication, last update / bump and expiry, ISO 8601 with Paris time offset |
| `city`, `postcode`, `department`, `departmentId`, `region`, `regionId`, `locationLabel` | e.g. `"Lyon"`, `"69003"`, `"Rhône"`, `"69"`, `"Rhône-Alpes"`, `"Lyon 69003 Part-Dieu"` |
| `latitude`, `longitude`, `locationPrecision` | Map point of the ad. `area` = centre of the town or district shown, `address` = the address a professional published, `approximate` = a private seller's address rounded to about 1 km |
| `attributes` | Every labelled attribute as `{key: value as shown}`: `{"mileage": "230000 km", "regdate": "2013", "fuel": "Diesel", ...}` or `{"square": "50 m²", "rooms": "2", "energy_rate": "C", "furnished": "Meublé", "monthly_charges": "150 €", ...}` |
| `brand`, `model`, `year`, `mileageKm`, `fuel`, `gearbox` | Vehicle fields as typed columns (also phones, bikes, etc. for brand / model) |
| `realEstateType`, `surfaceM2`, `rooms`, `bedrooms`, `energyClass`, `furnished` | Real-estate fields as typed columns |
| `condition` | Item condition, e.g. `"Très bon état"` |
| `images`, `imageCount`, `thumbnailUrl` | All photo URLs in large size |
| `shippingAvailable`, `shippingType` | Whether the seller ships, and how (`mondial_relay`, `colissimo`, `face_to_face`, ...) |
| `transactionStatus` | `"Achat en cours"` / `"Vendu"` when a purchase is under way |
| `sellerType`, `sellerName`, `sellerId`, `storeId`, `siren` | `pro` or `private`, the seller name as shown on the ad, Leboncoin user / store ids, SIREN for professionals |
| `sellerRating`, `sellerReviewCount` | Seller rating on a 0-5 scale and number of reviews, when the seller has reviews |
| `hasPhone`, `isUrgent`, `isBoosted` | Whether the ad offers a phone contact (the number itself is not collected), "Urgent" and paid-boost flags |
| `searchUrl`, `position`, `scrapedAt` | The search the ad came from, its rank in that search and when it was scraped |

### How to scrape Leboncoin listings

1. Open [leboncoin.fr](https://www.leboncoin.fr), search, and set the filters you want (category, location, radius, price, surface, mileage, private/pro, sort...).
2. Copy the URL from the address bar into **Start URLs**. Add as many searches as you like; category pages (`/c/voitures`) and ad URLs (`/ad/voitures/1234567890`) work too.
3. Or skip the browser: fill in **Search keyword**, **Category**, **Locations** (cities, postcodes or department numbers), **Min / Max price**, **Seller type** and **Sort**.
4. Set **Max items** and click **Start**. Download the results as JSON, CSV or Excel, or read them through the API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.leboncoin.fr/recherche?category=10&locations=Lyon&price=500-1200&square=30-max" },
    { "url": "https://www.leboncoin.fr/recherche?category=2&regdate=2015-max&mileage=min-100000&owner_type=private&sort=price&order=asc" }
  ],
  "searchQuery": "golf 7",
  "category": "2",
  "locations": ["Lyon", "38", "Bordeaux 33000"],
  "minPrice": 5000,
  "maxPrice": 20000,
  "sellerType": "private",
  "sort": "newest",
  "maxItems": 500,
  "maxItemsPerSearch": 200
}
```

### Output example

```json
{
  "id": "3283620928",
  "url": "https://www.leboncoin.fr/ad/locations/3283620928",
  "title": "GRAND T2 MEUBLÉ 50 m² – PARIS 15e – PARC GEORGES-BRASSENS À 2 MIN – DPE C",
  "description": "PARIS 15e – SAINT-LAMBERT – CALME – LUMINEUX – VUE DÉGAGÉE\n\nÀ louer, très beau T2 meublé de 50 m², situé au 3e étage avec ascenseur ...",
  "price": 1950,
  "currency": "EUR",
  "oldPrice": null,
  "category": "Locations",
  "categoryId": "10",
  "adType": "offer",
  "publishedAt": "2026-10-06T22:31:46+02:00",
  "updatedAt": "2026-10-06T22:31:46+02:00",
  "expiresAt": "2026-12-05T21:31:46+01:00",
  "city": "Paris",
  "postcode": "75015",
  "department": "Paris",
  "departmentId": "75",
  "region": "Ile-de-France",
  "regionId": "12",
  "locationLabel": "Paris 75015 Georges Brassens",
  "latitude": 48.83,
  "longitude": 2.3,
  "locationPrecision": "approximate",
  "condition": null,
  "realEstateType": "Appartement",
  "surfaceM2": 50,
  "rooms": 2,
  "bedrooms": 1,
  "energyClass": "C",
  "furnished": "Meublé",
  "attributes": {
    "real_estate_type": "Appartement", "furnished": "Meublé", "square": "50 m²", "rooms": "2", "bedrooms": "1 ch.",
    "energy_rate": "C", "ges": "C", "heating_type": "Collectif", "floor_number": "3", "elevator": "Oui",
    "building_year": "1971", "monthly_charges": "150 €", "security_deposit": "3600 €", "charges_included": "Oui"
  },
  "images": ["https://img.leboncoin.fr/api/v1/lbcpb1/images/.../....jpg?rule=ad-large"],
  "imageCount": 4,
  "shippingAvailable": null,
  "sellerType": "private",
  "sellerName": "Kamel",
  "siren": null,
  "sellerRating": null,
  "hasPhone": true,
  "isUrgent": false,
  "searchUrl": "https://www.leboncoin.fr/recherche?category=10&locations=Paris",
  "position": 2,
  "scrapedAt": "2026-10-06T23:39:40+00:00"
}
```

A car ad fills `brand`, `model`, `year`, `mileageKm`, `fuel`, `gearbox` (e.g. `"Volkswagen"`, `"Golf"`, `2013`, `230000`, `"Diesel"`, `"Automatique"`) and, for dealers, `sellerName` and `siren` (e.g. `"AB MOTORS"`, `"895063410"`).

### How many listings can I get per search?

Leboncoin serves at most 3,500 ads per search (the site shows 100 pages of 35). That is a limit of the site, not of the scraper; the run log and the `resultCapHit` note tell you when a search had more. To collect more, split the search: by department or city, by price band, or by subcategory, and add each as its own start URL. Ads that appear in several of your searches are saved and charged only once per run. For new-ads monitoring, sort by newest (the default for the search fields) and set **Max items per search** to the number you need.

### Does it get the full description and all attributes?

Yes, for every listing, without opening each ad. Leboncoin's search service returns the complete ad, so the description, all attributes (real estate: surface, rooms, bedrooms, floor, elevator, heating, DPE/GES, charges, deposit; vehicles: make, model, version, year, first registration, mileage, fuel, gearbox, horsepower, colour, doors, equipment; items: brand, model, condition, size...) and all photos are in each row.

### Does it collect phone numbers or require a login?

No login is needed and none is used. The scraper exports what any visitor sees on a Leboncoin ad: the seller's name as displayed, whether the seller is a private person or a professional, and the professional's SIREN and store id. Phone numbers sit behind a click (and often a login) and are never collected; `hasPhone` only tells you that a phone contact exists. A private seller's exact address is never exported: when a private ad carries an exact map point it is rounded to about 1 km (`locationPrecision: "approximate"`).

### Do I need a proxy? What does a run cost?

Leboncoin is protected by DataDome and refuses datacenter IPs. The default proxy, Apify **residential, France**, works reliably: in our tests 100% of requests went through (the scraper retries on a fresh IP when one is refused). A request returns up to 100 complete ads and moves about 0.1 MB, so 1,000 listings use roughly 1 MB of residential traffic, under $0.01 at Apify's residential rate, plus a little compute. Apify's **UNBLOCKER** proxy group also works; it bills about $0.0015 per request, i.e. about $0.015 per 1,000 listings. Datacenter proxies do not work.

### Monitor changes on a schedule

Turn on **Only new or changed items** to watch a search: each run remembers what earlier runs returned and outputs only ads that are new or whose price, crossed-out old price, transaction status (e.g. "Achat en cours") or ad status changed. Unchanged ads are dropped before they are saved, so they are not charged. **Max items** then sets how many ads are checked per run (keep the newest-first sort, e.g. the newest 50-100 ads of a search). Save the input as a task and add a Schedule in Apify (for example every hour or daily); give each watch its own **Monitoring key** if several schedules use the same search. Every output item has `changeType` (`new` or `changed`), and changed items have `previousValues` with the old values, e.g. `{"price": 450}`.

### Pricing

Pay per result: you are charged per listing saved to the dataset, with the full description and all attributes included. There is no start fee and no detail fee. See the Pricing tab for the current price. Platform usage (proxy traffic and compute) is billed by Apify and stays around one cent per 1,000 listings.

### Integrations and API

Run it from the Apify API, schedule it (e.g. every hour for new ads in your city), and send the results to Google Sheets, Slack, Make, Zapier, n8n or a webhook. Use `maxItems` to cap the cost of each run.

### Is it legal to scrape Leboncoin?

This Actor collects publicly visible ad data that anyone can see without an account. It does not log in, does not collect phone numbers or anything behind a click or login, and does not export private sellers' exact addresses. Seller names are personal data under the GDPR when they belong to private individuals: you are responsible for having a legitimate purpose and a legal basis for processing them, and for respecting Leboncoin's terms of use. If in doubt, ask a lawyer.

### Support

Found a bug or need a field that is not there? Open an issue on the Issues tab with the input you used and the run link.

# Actor input Schema

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

Leboncoin.fr search result pages with any filters and sort applied in the browser, e.g. https://www.leboncoin.fr/recherche?category=10\&locations=Lyon\&price=500-1200 or https://www.leboncoin.fr/recherche?category=2\&regdate=2015-max\&mileage=min-100000\&owner_type=private, category pages such as https://www.leboncoin.fr/c/voitures, or single ad URLs (https://www.leboncoin.fr/ad/voitures/1234567890). Leave empty if you use the search fields below.

## `searchQuery` (type: `string`):

Alternative to Start URLs: what you would type in the Leboncoin search box, e.g. "iphone 13", "golf 7 gtd", "canapé d'angle". Can be combined with the category, location and price fields.

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

Used with the search fields. Pick a category (top-level ones include all their sub-categories) or leave empty for all categories.

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

Used with the search fields. One location per line: a city (Paris, Lyon, Saint-Étienne - the whole city), a city with postcode (Lyon 69003), a postcode (75011), a department number (69, 06, 33) or a region code from a Leboncoin URL (r_12 = Ile-de-France). Leave empty for all of France. For a radius search, set it on leboncoin.fr and paste the URL into Start URLs.

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

Used with the search fields.

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

Used with the search fields.

## `sellerType` (type: `string`):

Used with the search fields: only private sellers (particuliers) or only professionals (pros).

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

Used with the search fields. Newest first is the best choice for monitoring new ads. Start URLs keep the sort set in the URL.

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

Stop after this many listings in total (across all searches). Keeps the cost predictable. Leboncoin serves at most 3,500 ads per search, so split bigger searches by location, price range or category.

## `maxItemsPerSearch` (type: `integer`):

Optional cap for each start URL / search, useful when you monitor several searches in one run (e.g. the 50 newest ads of each).

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this search returned and output only new ads or ads whose price or status changed. Use with a Schedule; unchanged ads are not charged. With this on, Max items (and Max items per search) is the number of ads checked per run (e.g. the newest 100).

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input

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

Leboncoin is protected by DataDome and refuses datacenter IPs. Residential proxies in France work (default): a request returns up to 100 complete ads and moves about 0.1 MB, so 1,000 listings use roughly 1 MB of residential traffic (under $0.01 at Apify's residential rate). Apify's UNBLOCKER group works too but bills about $0.0015 per request (about $0.015 per 1,000 listings).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.leboncoin.fr/recherche?category=10&locations=Lyon"
    }
  ],
  "category": "",
  "sellerType": "",
  "sort": "newest",
  "maxItems": 100,
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://www.leboncoin.fr/recherche?category=10&locations=Lyon"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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=10&locations=Lyon" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/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=10&locations=Lyon"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call tortuga/leboncoin-scraper --silent --output-dataset

```

## MCP server setup

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