# LeBonCoin Scraper — French Classifieds & Marketplace Data (`studio-amba/leboncoin-scraper`) Actor

Scrape classified listings from LeBonCoin.fr — France's #1 marketplace. Search by keyword, category, location, and price. Extract titles, prices, images, seller info, and more. No login or cookies required.

- **URL**: https://apify.com/studio-amba/leboncoin-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Extract classified listing data from **LeBonCoin.fr** — France's largest online marketplace with over 28 million monthly visitors. Search by keyword, category, location, and price range. Get structured data including titles, prices, seller info, images, location coordinates, and category-specific attributes. **No login or cookies required.**

### What does LeBonCoin Scraper do?

This scraper extracts structured data from LeBonCoin.fr search results. It handles all major categories: cars, real estate, electronics, furniture, clothing, jobs, and more. Results are delivered as clean JSON objects ready for analysis, monitoring, or integration with your data pipeline.

Run it on the [Apify platform](https://apify.com) to get API access, scheduled runs, webhook integrations, and automatic proxy rotation.

### Why use LeBonCoin Scraper?

- **Market research** — Track pricing trends across French classified categories
- **Competitive analysis** — Monitor competitor listings, pricing strategies, and inventory
- **Real estate intelligence** — Aggregate property listings with location data and attributes
- **Lead generation** — Find sellers and businesses in specific regions or categories
- **Price monitoring** — Set up scheduled runs to track price changes over time
- **Academic research** — Collect marketplace data for economic or social studies

### How to use LeBonCoin Scraper

1. Click **Try for free** to open the Actor in Apify Console
2. Enter your search query (e.g., "laptop", "appartement Paris")
3. Optionally filter by category, location, or price range
4. Set the maximum number of results you want
5. Click **Start** and wait for results
6. Download your data as JSON, CSV, Excel, or use the API

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `query` | String | No | Search term (e.g., "laptop", "vélo", "iPhone 15") |
| `category` | String | No | Filter by category (e.g., "informatique", "voitures", "locations") |
| `location` | String | No | City or region (e.g., "Paris", "Lyon", "Ile-de-France") |
| `minPrice` | Number | No | Minimum price in euros |
| `maxPrice` | Number | No | Maximum price in euros |
| `sortBy` | String | No | Sort order: relevance, newest, cheapest, most-expensive |
| `maxResults` | Integer | No | Maximum listings to scrape (default: 50, max: 1000) |
| `proxyConfiguration` | Object | No | Proxy settings (residential proxies recommended) |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `listingId` | String | `"2847561234"` |
| `title` | String | `"MacBook Pro 14 M3 Pro 512Go"` |
| `description` | String | Full listing description text |
| `price` | Number | `1450` |
| `currency` | String | `"EUR"` |
| `category` | String | `"Informatique"` |
| `city` | String | `"Paris"` |
| `zipcode` | String | `"75011"` |
| `department` | String | `"Paris"` |
| `region` | String | `"Île-de-France"` |
| `latitude` | Number | `48.8566` |
| `longitude` | Number | `2.3522` |
| `sellerName` | String | `"Jean-Pierre"` |
| `sellerType` | String | `"private"` or `"pro"` |
| `imageUrls` | Array | List of full-size image URLs |
| `attributes` | Object | `{"brand": "Apple", "model": "MacBook Pro"}` |
| `publicationDate` | String | `"2026-04-01T10:30:00.000Z"` |
| `url` | String | Full listing URL |
| `hasPhone` | Boolean | Whether seller shows phone number |
| `shippingAvailable` | Boolean | Whether delivery is available |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
    "listingId": "2847561234",
    "title": "MacBook Pro 14 M3 Pro 512Go",
    "description": "MacBook Pro 14 pouces, puce M3 Pro, 18 Go RAM, 512 Go SSD. Excellent état, vendu avec chargeur original.",
    "price": 1450,
    "currency": "EUR",
    "category": "Informatique",
    "city": "Paris",
    "zipcode": "75011",
    "department": "Paris",
    "region": "Île-de-France",
    "latitude": 48.8566,
    "longitude": 2.3522,
    "sellerName": "Jean-Pierre",
    "sellerType": "private",
    "imageUrls": [
        "https://img.leboncoin.fr/api/v1/lbcimage/ad-large/abc123.jpg"
    ],
    "thumbnailUrl": "https://img.leboncoin.fr/api/v1/lbcimage/ad-small/abc123.jpg",
    "attributes": {
        "brand": "Apple",
        "model": "MacBook Pro",
        "condition": "Très bon état"
    },
    "publicationDate": "2026-04-01T10:30:00.000Z",
    "url": "https://www.leboncoin.fr/ad/informatique/2847561234",
    "hasPhone": false,
    "isUrgent": false,
    "shippingAvailable": true,
    "scrapedAt": "2026-04-06T14:00:00.000Z"
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### How much does it cost to scrape LeBonCoin?

LeBonCoin uses strong anti-bot protection (DataDome), so this actor requires residential proxies for reliable operation. Estimated costs:

- **~50 listings**: ~0.05 USD (1 page)
- **~500 listings**: ~0.30 USD (15 pages)
- **~1,000 listings**: ~0.50 USD (30 pages)

Costs depend on proxy usage and Apify platform pricing. The free tier includes enough credits to test with small runs.

### Tips for best results

- **Use residential proxies** — LeBonCoin has DataDome protection. Residential proxies (especially France-based) give the best success rate.
- **Start small** — Test with 5-10 results first to verify the data matches your needs.
- **Be specific** — Narrow your search with category and location filters to get more relevant results.
- **Schedule runs** — Set up daily or weekly runs to track price changes over time.
- **Combine with other actors** — Use Apify integrations to push data to Google Sheets, Slack, or your database.

### Limitations

- Requires residential proxies for reliable operation due to DataDome anti-bot protection
- Maximum ~1,000 results per run (LeBonCoin pagination limit)
- Some listing details (phone number, full description) may only be available on individual listing pages
- Data is scraped from the public website and may change without notice

### FAQ and support

**Is it legal to scrape LeBonCoin?** This actor accesses only publicly available data. Users are responsible for complying with applicable laws and LeBonCoin's terms of service.

**Why am I getting blocked?** Make sure you're using residential proxies. Datacenter proxies will be blocked by DataDome protection.

**Can I scrape specific listing URLs?** Currently, the actor supports search-based scraping. Direct URL scraping may be added in a future version.

Found a bug or need a custom solution? Open an issue in the [Issues tab](https://console.apify.com/actors/H40UFY258ygbAeQeu/issues) or contact support.

# Actor input Schema

## `query` (type: `string`):

Search term (e.g. 'laptop', 'iPhone 15', 'vélo'). Leave empty to browse all listings or a specific category.

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

Filter results by category.

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

City name or department to search in (e.g. 'Paris', 'Lyon', 'Ile-de-France'). Used in the search URL.

## `minPrice` (type: `number`):

Minimum price filter in euros.

## `maxPrice` (type: `number`):

Maximum price filter in euros.

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

How to sort results.

## `maxResults` (type: `integer`):

Maximum number of listings to scrape.

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

Proxy settings. Residential proxies are strongly recommended for LeBonCoin (DataDome protection). Use Apify Residential proxy group for best results.

## Actor input object example

```json
{
  "query": "laptop",
  "sortBy": "relevance",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "laptop",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "query": "laptop",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LeBonCoin Scraper — French Classifieds & Marketplace Data",
        "description": "Scrape classified listings from LeBonCoin.fr — France's #1 marketplace. Search by keyword, category, location, and price. Extract titles, prices, images, seller info, and more. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "JFH6OO9jgzFRK2D7l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~leboncoin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-leboncoin-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/studio-amba~leboncoin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-leboncoin-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/studio-amba~leboncoin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-leboncoin-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",
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term (e.g. 'laptop', 'iPhone 15', 'vélo'). Leave empty to browse all listings or a specific category."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "voitures",
                            "motos",
                            "caravaning",
                            "utilitaires",
                            "equipement_auto",
                            "equipement_moto",
                            "equipement_caravaning",
                            "nautisme",
                            "ventes_immobilieres",
                            "locations",
                            "colocations",
                            "bureaux_commerces",
                            "informatique",
                            "consoles_jeux_video",
                            "image_son",
                            "telephones",
                            "ameublement",
                            "electromenager",
                            "arts_de_la_table",
                            "decoration",
                            "linge_de_maison",
                            "bricolage",
                            "jardinage",
                            "vetements",
                            "chaussures",
                            "accessoires_bagagerie",
                            "montres_bijoux",
                            "equipement_bebe",
                            "vetements_bebe",
                            "jouets",
                            "dvd_films",
                            "cd_musique",
                            "livres",
                            "sports_hobbies",
                            "instruments_de_musique",
                            "collection",
                            "jeux_jouets",
                            "vins_gastronomie",
                            "animaux",
                            "offres_d_emploi",
                            "services",
                            "billetterie",
                            "materiel_professionnel",
                            "autres"
                        ],
                        "type": "string",
                        "description": "Filter results by category."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City name or department to search in (e.g. 'Paris', 'Lyon', 'Ile-de-France'). Used in the search URL."
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum price filter in euros."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum price filter in euros."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "newest",
                            "cheapest",
                            "most-expensive"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are strongly recommended for LeBonCoin (DataDome protection). Use Apify Residential proxy group for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
