# Leboncoin Listings Scraper (`fetch_cat/leboncoin-listings-scraper`) Actor

Scrape public Leboncoin listing search results and listing details for marketplace research, real estate, vehicles, resale monitoring, and lead generation.

- **URL**: https://apify.com/fetch\_cat/leboncoin-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 item processeds

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 Listings Scraper

Scrape public Leboncoin search results and listing detail pages into a structured dataset for price monitoring, real-estate snapshots, vehicle shortlists, resale research, and lead-generation workflows.

Use this Actor when you need repeatable Leboncoin exports in CSV, JSON, Excel, API, or automation tools without building and maintaining a custom scraper.

### At a glance

- **Primary job**: Collect public Leboncoin listing rows from keyword searches or pasted search URLs.
- **Input**: Keywords, public search URLs, optional category/location parameters, item limits, and optional detail enrichment.
- **Output**: One dataset row per listing with URL, ID, title, category, seller display fields, location, date, attributes, images, and price fields when public.
- **Best for**: Marketplace analysts, real-estate and vehicle monitors, resellers, researchers, and lead-gen teams.

### Common workflows

- **Keyword research**: Search terms such as `velo`, `iphone`, or a product brand and export fresh public listings.
- **Real-estate snapshots**: Paste a Leboncoin real-estate search URL and collect listings with nullable location/property attributes.
- **Vehicle shortlists**: Search a vehicle category and keep public listing details and category attributes when present.
- **Monitoring**: Schedule small recurring runs and compare listing IDs, prices, and locations across datasets.
- **Automation**: Send dataset rows to Google Sheets, CRMs, webhooks, MCP-compatible agents, or your own API pipeline.

### Ready-to-run examples

- **[Classifieds keyword search](https://apify.com/fetch_cat/leboncoin-listings-scraper/examples/classifieds-keyword-search)**: Scrape a bounded public Leboncoin keyword search.
- **[Real-estate market snapshot](https://apify.com/fetch_cat/leboncoin-listings-scraper/examples/real-estate-market-snapshot)**: Collect public Paris real-estate search results with detail enrichment.
- **[Vehicle listing shortlist](https://apify.com/fetch_cat/leboncoin-listings-scraper/examples/vehicle-listing-shortlist)**: Build a small vehicle listing shortlist for a common brand query.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Keyword search that produced the listing. |
| `sourceUrl` | Original search URL or generated keyword URL. |
| `pageUrl` | Result page where the listing was found. |
| `listingId` | Leboncoin listing identifier when available. |
| `listingUrl` | Public listing URL. |
| `title` | Listing title. |
| `priceText`, `priceValue`, `currency` | Raw and parsed price fields when publicly visible. |
| `category`, `subcategory` | Leboncoin category labels. |
| `sellerName`, `sellerType` | Public seller display fields when shown. |
| `locationText`, `city`, `department`, `region` | Public location labels. |
| `postedAtText`, `postedAt` | Raw and parsed publication date signals. |
| `imageUrls` | Public image URLs found in search/detail payloads. |
| `description` | Public description when available. |
| `attributes` | Category-specific fields such as condition, brand, property or vehicle attributes. |
| `detailStatus` | Detail enrichment status: `not_requested`, `success`, `blocked`, `missing`, or `failed`. |
| `missingFields` | Important optional fields that were not publicly available for the row. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Search keywords | `queries` | Generate Leboncoin search URLs from terms. | `["iphone"]` |
| Start URLs | `startUrls` | Process exact public Leboncoin search URLs. | `https://www.leboncoin.fr/recherche?text=velo` |
| Category code | `category` | Scope generated keyword searches to a Leboncoin category. | `"2"` |
| Location parameter | `location` | Reuse a raw Leboncoin `locations` parameter. | `Paris__48.856614_2.352221_10000` |
| Maximum listings | `maxItems` | Cap saved rows and control spend. | `50` |
| Maximum pages | `maxPagesPerQuery` | Bound pagination per query or start URL. | `2` |
| Include details | `includeDetails` | Visit listing pages for extra public fields. | `false` |
| Fail on no results | `failOnNoResults` | Fail blocked or unexpectedly empty runs instead of silent success. | `true` |
| Proxy | `proxyConfiguration` | Use Apify Proxy; residential is recommended for Leboncoin. | `RESIDENTIAL` |

### Example input

```json
{
  "queries": ["iphone"],
  "maxItems": 10,
  "maxPagesPerQuery": 1,
  "includeDetails": false,
  "failOnNoResults": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example output

```json
{
  "query": "iphone",
  "sourceUrl": "https://www.leboncoin.fr/recherche?text=iphone",
  "pageUrl": "https://www.leboncoin.fr/recherche?text=iphone",
  "listingId": "3102094611",
  "listingUrl": "https://www.leboncoin.fr/ad/telephones_objets_connectes/3102094611",
  "title": "IPhone 14 Pro Max Garantie 24 Mois",
  "priceText": null,
  "priceValue": null,
  "currency": null,
  "category": "Téléphones & Objets connectés",
  "sellerName": "DISTRIPHONE",
  "locationText": "Lyon 69002",
  "city": "Lyon 69002",
  "department": "Rhône",
  "region": "Rhône-Alpes",
  "postedAtText": "2026-07-03 12:05:44",
  "detailStatus": "not_requested",
  "missingFields": ["priceText"]
}
```

### Pricing

| Event | Charged when |
| --- | --- |
| Run start | Once when the Actor starts. |
| Item processed | Each listing row saved to the dataset. |

Store pricing uses Apify discount tiers. The Actor is priced per saved listing row, with lower per-row prices on higher Store tiers.

| Tier | Item processed price |
| --- | --- |
| Free | `$0.00115` |
| Bronze | `$0.001` |
| Silver | `$0.00078` |
| Gold | `$0.0006` |
| Platinum | `$0.0004` |
| Diamond | `$0.00028` |

Keep runs small while testing. Detail enrichment can increase runtime and proxy usage because it visits listing pages.

### Tips for best results

- **Start small**: Use `maxItems: 10` until output quality and spend are clear.
- **Prefer focused URLs**: Build the exact search on Leboncoin, then paste the result URL into `startUrls`.
- **Use residential proxy**: Leboncoin can show edge challenges to datacenter traffic.
- **Expect nullable fields**: Some listings do not expose price, seller, images, or category-specific attributes in every payload.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/leboncoin-listings-scraper").call({
  queries: ["iphone"],
  maxItems: 10,
  proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ["RESIDENTIAL"] }
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/leboncoin-listings-scraper").call(run_input={
    "queries": ["iphone"],
    "maxItems": 10,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~leboncoin-listings-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["iphone"],"maxItems":10,"proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/leboncoin-listings-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/leboncoin-listings-scraper"
    }
  }
}
```

Example prompt: "Run Leboncoin Listings Scraper for iphone with 10 listings and summarize categories and locations."

### Limits and caveats

- **Public data only**: The Actor does not log in, unlock phone numbers, send messages, or scrape private account pages.
- **Anti-bot risk**: Leboncoin may challenge some traffic. Residential proxy is recommended; blocked pages are classified instead of being saved as fake rows.
- **Completeness**: Pagination and detail enrichment are bounded by your input limits and by what the public pages expose.
- **Freshness**: Listings can change or disappear after a run finishes.

### Legality and responsible use

Process only data that you are allowed to access. Follow Leboncoin terms, Apify terms, robots and rate-limit expectations, and applicable privacy and data-protection laws. Do not use scraped data for spam, harassment, discriminatory decisions, or private contact bypasses.

### Related actors

- [Vinted Search Scraper](https://apify.com/fetch_cat/vinted-search-scraper)
- [Marktplaats Listings Scraper](https://apify.com/fetch_cat/marktplaats-listings-scraper)
- [Craigslist Classifieds Scraper](https://apify.com/fetch_cat/craigslist-classifieds-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

Some fields are not publicly visible for every listing or category. The Actor preserves the row and records important gaps in `missingFields` instead of guessing.

#### Should I enable detail pages?

Use `includeDetails` when you need extra public description, image, or attribute fields. Keep it disabled for cheaper, faster search-result monitoring.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL.

- 2026-07-24 - Feature: Launched Leboncoin Listings Scraper on Apify Store.

# Actor input Schema

## `queries` (type: `array`):

Leboncoin keywords to search, for example velo or iphone.

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

Leboncoin search result URLs to process.

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

Optional Leboncoin category code used with keyword searches, such as 2 for vehicles or 9 for real estate.

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

Optional raw Leboncoin locations parameter for keyword searches.

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

Maximum number of listing rows to save.

## `maxPagesPerQuery` (type: `integer`):

Maximum number of result pages to fetch per query or start URL.

## `includeDetails` (type: `boolean`):

Visit listing detail pages for extra public description, images, and attributes when available.

## `failOnNoResults` (type: `boolean`):

Fail the run if all sources return zero listings.

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

Use Apify Proxy. Residential proxy is recommended for Leboncoin.

## Actor input object example

```json
{
  "queries": [
    "velo"
  ],
  "startUrls": [
    {
      "url": "https://www.leboncoin.fr/recherche?text=velo"
    }
  ],
  "maxItems": 10,
  "maxPagesPerQuery": 1,
  "includeDetails": false,
  "failOnNoResults": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "queries": [
        "velo"
    ],
    "startUrls": [
        {
            "url": "https://www.leboncoin.fr/recherche?text=velo"
        }
    ],
    "failOnNoResults": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/leboncoin-listings-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 = {
    "queries": ["velo"],
    "startUrls": [{ "url": "https://www.leboncoin.fr/recherche?text=velo" }],
    "failOnNoResults": False,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/leboncoin-listings-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 '{
  "queries": [
    "velo"
  ],
  "startUrls": [
    {
      "url": "https://www.leboncoin.fr/recherche?text=velo"
    }
  ],
  "failOnNoResults": false
}' |
apify call fetch_cat/leboncoin-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/UOuSz2tE7AJ2Ibbwh/builds/MxA0a8utCymVoV9td/openapi.json