Leboncoin Scraper — France Classifieds, Real Estate & Vehicles | from $1.50/1K

Built for French market researchers, real-estate analysts, vehicle pricing teams, and lead-gen professionals who need structured data from France's largest classifieds site. 59 fields per ad — GPS, price-drop detection, DPE energy class, vehicle specs, seller SIREN. Apify Residential proxy built in — no external accounts needed.

Scrape listings from Leboncoin.fr, France's #1 classifieds marketplace. Search by keyword, location, category, price range and seller type, then export clean, structured data for every matching ad: title, full description, price (with price-drop detection), category, GPS location, publication dates, seller info, image URLs, and every category-specific attribute. Built for price monitoring, market and competitor research, real-estate and vehicle intelligence, and lead generation — at scale, with pay-per-result pricing.

This scraper reads Leboncoin's own Next.js data layer (__NEXT_DATA__ + the /_next/data JSON route), so the output is structured JSON, not brittle scraped HTML. A resilient fallback chain keeps it producing data even when Leboncoin redeploys (rotating buildId) or shifts its page structure, and every record carries a parse_confidence score so you can spot drift instantly.

What you can do with it

• Price monitoring — track how listing prices move over time across any keyword, category, or region; the old_price and price_dropped fields flag reductions automatically.
• Market & competitor research — pull every Renault Clio in a price band, every T3 apartment in a city, or every listing from professional sellers, with one filtered run.
• Real-estate intelligence — surface, rooms, bedrooms, DPE energy class and GES greenhouse rating are lifted into dedicated columns plus GPS coordinates.
• Vehicle intelligence — brand, model, mileage, fuel, gearbox and registration year are extracted into structured fields.
• Lead generation — filter to professional or private sellers, capture seller name, store ID, SIREN and whether a phone number is published.

Key features

• Search filters that actually filter — keyword, location slug, category ID, min/max price, seller type (private vs professional), and sort order are applied server-side, so you only pay for the listings you want (no mixed-category noise).
• Rich schema (59 fields) — far more than thin incumbents: full description, price-drop detection, subcategory, region/department IDs, expiration date, seller SIREN, image thumbnail, a flat attributes_map for one-step filtering, and structural real-estate / vehicle columns.
• Automatic pagination — walks every results page via Leboncoin's fast JSON route; maxItems caps the volume (and your spend).
• Resilient by design — guarded fallback chain (__NEXT_DATA__ → /_next/data JSON → HTML re-extraction → structural card parse) with a per-record parse_confidence and machine-readable warnings, so silent breakage is impossible.
• Resilient residential access — sticky residential session with cookie continuity and automatic fresh-IP rotation on a block, the right shape for Leboncoin's bot protection.
• No external accounts — uses Apify's built-in Residential proxy, billed to your run. Nothing else to sign up for.

Proxy requirement

Leboncoin blocks datacenter IPs with a 403 challenge, so Apify Residential proxy is required — set country to France (FR) for the best pass rate. The scraper carries the session cookie across pages and automatically rotates to a fresh residential IP if it ever hits a block. The buyer's proxy usage is billed at Apify's residential rate; the actor itself charges only per listing returned.

Input

Field	Type	Description
searchText	string	Keyword(s) to search (required), e.g. vélo, iphone 14, clio 4.
locations	string	City/region slug from a Leboncoin URL, e.g. Bordeaux_33000, paris_75. Blank = all France.
category	string	Numeric category ID to restrict results, e.g. 9 real estate, 2 cars, 17 phones.
priceMin / priceMax	integer	Price range in euros.
ownerType	enum	all, private, or pro.
sort	enum	Relevance, newest/oldest first, cheapest/most expensive.
maxItems	integer	Max listings (0 = all; default 100). You are charged per listing.
proxyConfiguration	object	Apify Residential proxy (FR) — required.

Output fields (selection)

Field	Description
ad_id	Leboncoin listing ID
title / description	Ad title and full body text (HTML stripped)
price / price_cents / price_currency	Price in EUR / cents / EUR
old_price / price_dropped	Previous price and a derived price-reduction flag
category / category_id / subcategory	Taxonomy
location_city / _region / _department / _zipcode	Location hierarchy (with IDs)
location_lat / location_lng	GPS coordinates
published_date / index_date / expiration_date	ISO 8601 dates
owner_type / owner_name / owner_store_id / owner_siren	Seller info
has_phone	Whether a phone number is published
images / image_count / thumbnail	Image URLs and preview
attributes / attributes_map	Full attribute list and a flat key→value map
surface_m2 / rooms / bedrooms / energy_rate / ges	Real-estate fields
vehicle_brand / vehicle_model / mileage / fuel / gearbox / registration_year	Vehicle fields
urgency_level / is_boosted / status	Listing flags
parse_confidence / warnings / source / scraped_at	Data-quality provenance

The dataset ships with three preset views — Listings Overview, Real Estate, and Vehicles — so the right columns surface for whatever you're scraping.

How it works (technical)

Leboncoin is a Next.js SSR site with no public API. Page 1 is fetched as HTML and the __NEXT_DATA__ blob is parsed for the first page of ads plus the deploy-specific buildId. Pages 2+ are pulled from the fast /_next/data/{buildId}/recherche.json endpoint. The buildId is re-extracted on every run (it rotates on each Leboncoin deploy — never hardcoded), and if it rotates mid-run the scraper transparently re-mints it from the HTML route. Search filters are plain query parameters on the same route, so filtering adds zero extra access exposure.

Pricing

Pay-per-result: from $1.50 per 1,000 listings. You are charged once per listing returned. You separately pay Apify's residential proxy bandwidth for your run. There is no charge for failed runs or for the actor starting.

Volume	Actor fee	Estimated proxy (FR residential)	Total est.
100 listings	~$0.15	~$0.05	~$0.20
1,000 listings	~$1.50	~$0.20	~$1.70
10,000 listings	~$15.00	~$1.50	~$16.50

---

FAQ

Do I need my own proxy account? No. The actor uses Apify's built-in Residential proxy billed to your Apify account — no external proxy subscription needed. Just set proxyConfiguration to use Apify Residential (France) as shown in the default input.

What output formats are available? JSON, CSV, and Excel — downloadable from the Apify dataset UI or via the REST API. The dataset ships with three preset views: Listings Overview, Real Estate, and Vehicles.

Can I schedule this to run automatically for price monitoring? Yes. Use Apify's scheduler to run daily or hourly and push new listings to your pipeline via webhook. The price_dropped and old_price fields are designed exactly for this use case.

What if Leboncoin blocks the scraper? The actor automatically rotates to a fresh residential IP on a block and retries. If a page consistently fails, the parse_confidence on affected records drops below 1.0 and warnings is populated — so breakage is never silent.

---

Use with AI agents (MCP)

This actor is available as an MCP tool for Claude, GPT-4, and other AI agents that support the Model Context Protocol:

https://mcp.apify.com/?tools=bovi/leboncoin-listings

Search French classifieds by keyword, location, and category — ideal for AI price-monitoring assistants, real-estate analytics pipelines, and vehicle arbitrage bots.

---

vs. competitors

	This actor	Typical Leboncoin scraper
Fields per listing	59	5–15
Price-drop detection	✓ (old_price, price_dropped)	No
Real-estate fields (DPE, surface)	✓	Rarely
Vehicle fields (brand, mileage, fuel)	✓	Rarely
GPS coordinates	✓	No
parse_confidence	✓	No
Access handling	Residential proxy + cookie continuity	Often breaks
Price	from $1.50/1K	$3–10/1K

Integrations

Built for French market researchers, real-estate analysts, and vehicle-pricing teams extracting classifieds data with price-drop detection — the JSON/dataset output drops into the tools you already run, no glue code:

• n8n / Make / Zapier — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: n8n, Make, Zapier.
• Webhooks — fire your own endpoint the moment a run finishes, to push results straight into your pipeline (docs).
• MCP server — expose this actor as a tool to Claude, Cursor, or any MCP client so an AI agent can pull this data mid-conversation (guide).
• API & SDKs — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all Apify integrations.

More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

• Marktplaats Listings Scraper
• Mercadolibre Scraper
• Olx Listings
• Poshmark Listings
• Shopify Products Scraper
• Tiktok Shop Scraper

Chain any of them together from the Integrations tab (the Run succeeded trigger) to build a multi-step workflow — one actor's output feeds the next.

Usage statistics

This Actor creates a small, content-free summary at the end of each run. It is used only to monitor reliability and improve this Actor. A copy is saved as USAGE_STATS in your own Apify key-value store, so you can see the exact record created for your run.

Set disableUsageStats to true in the input to opt out. Nothing is sent then; your USAGE_STATS record only says that statistics were disabled.

Only these fields are recorded:

• schema version, Actor name and build number;
• UTC start and finish hour (not a precise timestamp);
• run duration, number of results and time to the first result, each as a coarse range;
• whether the result was empty, the end status, and an error type from a fixed list;
• memory setting and counts of charged events;
• names of the input fields you set, never their values;
• the selected option for input fields that offer a fixed list of choices (for example a sort order).

We do not collect input text, search terms, URLs, domains, usernames, email addresses, names, proxy credentials, tokens, scraped records, output items, raw error messages, stack traces, or hashes of any of those values. Records are kept for no longer than 13 months, used only as aggregated operational statistics, and never sold or shared.

Additional fields (Phase 2)

This Actor also records your Apify user ID, whether Apify marks the account as paying, the size range of list inputs, the selected country when the input offers a fixed list of countries, and one category from a fixed Actor taxonomy. We use these fields only for aggregate reliability, repeat-use and cross-Actor analysis; reports suppress any cell with fewer than five distinct users.

The same disableUsageStats: true input flag turns these fields off too. The user ID is removed after 13 months; we do not export, sell, share, or attempt to re-identify this data.

Run-outcome signals (v2)

To learn whether a run did what it was asked to do, the record also holds a few more coarse ranges and yes/no flags. None of them contains content:

• the result limit you asked for (a range, when the input has one) and what share of it was delivered;
• results delivered per input item you listed (a range);
• output quality as ranges: how fully the result fields were filled, the share of rows that look like errors, the share of duplicate rows, and how many different fields appeared. These are counted in memory while results are saved; no result content is kept;
• how the run was started (console, API, schedule, webhook, another Actor);
• how it ended: stopped by you, timed out, reached the requested limit, stopped by the charge limit, and how many times the platform moved the run;
• if this Actor reports it: how many items to process worked or failed (ranges) and one failure reason from a fixed list;
• a short code made from the names of the input fields you set, never their values.

Repeat-run fingerprint (v2)

When your Apify user ID is recorded (see above), the record also holds an 8-character one-way code made from your input (proxy settings left out) and this Actor's name. It only lets us see that the same account ran the same input again soon after an unsatisfying run; we never see the input itself. It is stored only in the database, never published, and reports use it in aggregate with the same five-user minimum. It is the one exception to the statement above that no hashes are collected, and disableUsageStats: true turns it off.