# La Centrale Scraper: Used Cars, Vans & Motorbikes (`nice_dev/lacentrale-listings-scraper`) Actor

Scrape lacentrale.fr used cars, vans and motorbikes by make, model, place or dealer: price, year, mileage, seller phone, photos. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/nice_dev/lacentrale-listings-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Features:** Limited permissions
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.69 / 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/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

### 🚗 What is La Centrale Scraper?

**La Centrale Scraper** extracts **vehicle listings from [La Centrale](https://www.lacentrale.fr)**, one of France's main used-car sites (France with Corsica and the overseas departments, Belgium, Luxembourg): **price, make, model, version, year, mileage, fuel, gearbox, location, photos, and the seller's name and phone number**. Cars, vans, motorbikes, scooters and quads, used and new. As an option it opens each **listing page** for the description, the equipment, the price history and La Centrale's own price estimate. It works as a **La Centrale API alternative**: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Type a **make** and a **model** (`RENAULT`, `CLIO`) or paste a La Centrale search URL (a `www.lacentrale.fr/listing` page: cars, vans, motorbikes, scooters or quads), click **Start**, and download the listings in JSON, CSV or Excel. No login, nothing to set up, and it is **fast**: in our test run, 150 listings were read in about 3 seconds. Run several searches at once, take a dealer's whole stock, follow listings by their reference, or read more than the 8,000 results the site shows for one search.

### 📋 What data can you extract from La Centrale?

One item per listing, 96 fields:

| Category | What you get |
| --- | --- |
| 🚗 **Vehicle** | make, model, version, trim, body type, fuel, gearbox, doors, colour, year, mileage — `RENAULT`, `CLIO`, `ESSENCE`, `79200 km` |
| 💰 **Price** | price in euros, La Centrale's rating of the price against the market, monthly payment, manufacturer warranty left — `7990 EUR`, `GOOD_DEAL`, `121 EUR / month` |
| 🏢 **Seller** | dealer or private seller, kind of dealer, name, id, **phone number(s)**, dealer page — `PRO`, `C012345`, `0612345678` |
| 📍 **Place** | country (France, Belgium, Luxembourg), département, region — `FR`, `32`, `FR-OCC` |
| 📷 **Photos** | main photo, number of photos, 360° and panoramic photo flags, every photo in large size (full listing page) |
| 🚚 **Delivery and options** | delivery offered, its prices and range, the advertising options the seller bought, history report offered |
| 🕒 **Dates** | the day it was put online (what the date filters read), last update, announced price drop — `2026-11-07` |
| 📝 **Listing page (option)** | the seller's description, every equipment item, first registration, power, CO₂, consumption, Crit'Air, dimensions, seats, first hand, and for an electric or plug-in hybrid vehicle the range, battery capacity and state of health — `90 hp`, `114 g/km`, `458 km` |
| 📈 **Value and price history (option)** | La Centrale's price estimate, catalogue price when new, first price and every price change, mileage rating, warranties, next service and its cost |
| 🏪 **Dealer card (option)** | address, GPS position, rating and number of reviews, WhatsApp number, verified-seller mark |
| 🔎 **Search context** | the La Centrale search that found the listing, `removed` for a reference that is gone, time of extraction |

Every field, with an example, is listed in the **Output** section below.

The last three rows marked "option" are filled only when **Full listing page** is on (off by default: it opens one more page per listing, about 20 seconds per page, with several pages read in parallel; it is billed per listing on top of the listing, see Pricing). Without it these fields are `null` or empty, and the list of photos holds only the main photo and the small previews.

### ✅ Why use La Centrale Scraper?

- 🚀 **Fast**: 100 listings per request; in our test run, 150 listings in about 3 seconds (without the listing page).
- 📞 **Seller phone number in every row**: dealers and private sellers, as published in the listing, even without the listing page.
- 🏪 **A dealer's whole stock**: give the dealer id or the dealer page address and get every vehicle they have on sale (cars, vans, motorbikes, scooters and quads, unless you pick sections in **Vehicle types**).
- 🔁 **Follow listings by their reference**: re-read the listings you saved; one that La Centrale no longer shows comes back as a `removed` row, so you can see which ones are gone (sold or withdrawn).
- 🧩 **Several searches in one run**: makes and models × places, with a cap per search so that one big search cannot eat the whole budget.
- 📍 **Any place**: a département, Corsica, the overseas departments, a region, Belgium, Luxembourg, or a radius around a postcode.
- 📈 **Beyond 8,000 results per search**: the site stops at 8,000 listings per search; the Actor reads on, each listing delivered once.
- 🎛️ **Many filters**: price, year, mileage, fuel, gearbox, body type, doors, colour, price rating, dealer or private seller, Crit'Air, power, CO₂, consumption, electric range, battery, equipment, sort order, publication dates, excluded words.
- 🔔 **Monitoring built in**: tick **Only new listings**, schedule the Actor, and each run returns (and charges) only what it has never delivered before.
- 🔌 API, scheduling, monitoring, integrations (Make, Zapier, n8n, Google Sheets…), proxy rotation and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to scrape La Centrale

1. Create a free Apify account.
2. Open **La Centrale Scraper** and type a **Make** (e.g. `RENAULT`) and a **Model** (e.g. `CLIO`), or leave both empty for every vehicle.
3. Or paste your own La Centrale URLs into **Start URLs**: a search results page of `www.lacentrale.fr/listing` (pagination is automatic; the site's filters the Actor reads are listed under **Known limitations**, and a page with any other filter is refused at the start, with the filter's name), single listing pages or dealer pages.
4. Narrow the search with **Location** and the vehicle filters if you like. Set **Max listings** (100 by default, 0 = no limit) — and **Max listings per search** when you run several searches — then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to scrape La Centrale?

This Actor uses **pay per event** pricing. You pay for each **listing saved**, plus a small fee per run start. The exact prices, for every Apify plan, are on the **Pricing** tab of the Actor. Platform usage (compute, proxy) is included in the price.

The **Full listing page** option is billed on top, only when you tick it: a price for each listing delivered with its page read. A listing whose page could not be read is delivered from the results page, without the page fields, and is not charged for the page.

A `removed` row (a listing asked by reference that La Centrale no longer shows) is saved, and charged, like any other row.

Filters that La Centrale does not offer itself (publication dates, excluded words) are applied by the Actor on each listing it reads: a listing you keep costs its normal price, a listing a filter drops costs only the filter fee shown on the Pricing tab. The vehicle filters of the form (price, year, mileage, fuel…) are sent to La Centrale with the search: only the matching listings are read and charged. These three filters (`postedAfter`, `postedBefore`, `excludeKeywords`) are not applied to listings you ask for by reference or page: `listingIds`, or a listing page in `startUrls` (following listings by reference returns each one, as it is).

### ⚙️ Input

A search by make, model and place:

```json
{
    "make": "RENAULT",
    "model": "CLIO",
    "location": "75",
    "priceMax": 12000,
    "maxItems": 200
}
```

Several searches, a cap per search, only recent listings, only the ones not delivered before:

```json
{
    "makesModels": ["PEUGEOT:208", "RENAULT:CLIO"],
    "locations": ["75", "69", "13"],
    "maxItemsPerQuery": 100,
    "postedAfter": "7 days",
    "onlyNew": true,
    "stateKey": "city-cars-fr"
}
```

The whole stock of a dealer, with the full listing page:

```json
{
    "sellerIds": ["C059526"],
    "extractDetails": true,
    "maxItems": 0
}
```

Follow listings by their reference (a listing that is gone comes back as a `removed` row):

```json
{
    "listingIds": ["E120320215", "W103541170"]
}
```

Or with your own URLs:

```json
{
    "startUrls": [
        { "url": "https://www.lacentrale.fr/listing?makesModelsCommercialNames=RENAULT%3ACLIO&sortBy=firstOnlineDateDesc" },
        { "url": "https://www.lacentrale.fr/auto-occasion-annonce-69120320215.html" }
    ],
    "maxItems": 500
}
```

| Field | Notes |
| --- | --- |
| `startUrls` | La Centrale search pages (`https://www.lacentrale.fr/listing?makesModelsCommercialNames=RENAULT%3ACLIO&sortBy=firstOnlineDateDesc`, all pages are read: the site's filters kept are listed under Known limitations, and a page with any other filter is refused before the first request, with the filter's name), listing pages (`https://www.lacentrale.fr/auto-occasion-annonce-69120320215.html`) or dealer pages (`https://pros.lacentrale.fr/C059526`). When this list is not empty, the make, model and place fields do not start any search, but they are still checked (a value that is not valid is refused, even though it is not used: clear the field); the vehicle filters, caps and monitoring still apply. Max 1,000 URLs. |
| `make` | Make as La Centrale writes it: `RENAULT`, `PEUGEOT`, `MERCEDES`, `BMW`, `VOLKSWAGEN` (case is ignored). Empty = every make. |
| `model` | Model of that make: `CLIO`, `308`, `CLASSE A`. A generation works too: `CLIO:CLIO 5`. Needs a make. |
| `makesModels` | Several searches in one run, one per line: `PEUGEOT`, `PEUGEOT:208`, `RENAULT:CLIO:CLIO 5`. Added to the make and model above. Each line is crossed with each place (max 500 searches per run). |
| `location`, `locations` | A French département (`29`, `75`; Corsica = `20`, overseas = `97`), several of them (`29,22,56`), a region (`FR-BRE`, `FR-IDF`), Belgium (`BE`), Luxembourg (`LU`) or a postcode (`29200`) searched within the radius. Empty = all of France, Belgium and Luxembourg. `locations` adds more places, one search each. |
| `radiusKm` | Distance around a postcode, from `1` to `500` km (`30` by default). Not used for a département or a region. |
| `vehicleTypes` | Which sections to search: `AUTO` (cars), `UTILITY` (vans), `MOTO`, `SCOOTER`, `QUAD`. Empty = the sections of the body types chosen in `categories` (motorbike types search motorbikes), else cars and vans; for a dealer in `sellerIds`, every section. |
| `sellerIds` | Every vehicle on sale by these dealers, in every section (cars, vans, motorbikes, scooters, quads) unless `vehicleTypes` is filled: the dealer id the Actor returns (`sellerId`, e.g. `C059526`) or the dealer page address (`https://pros.lacentrale.fr/C059526`). Each dealer is one search; the vehicle filters still apply. When this list (or `listingIds`) is not empty, the make, model and place fields do not start any search — as with `startUrls`, so a form that still shows RENAULT / CLIO runs the dealers alone; the run log names the fields it ignored. |
| `listingIds` | Fetch these listings directly, by reference (`E120320215`, `W103541170`) or listing page address (`https://www.lacentrale.fr/auto-occasion-annonce-69120320215.html`), 100 per request. A listing La Centrale no longer shows comes back with `status` = `removed` (only from an answer read in full; one the Actor cannot read is an error, listed in `FAILED_REQUESTS`). The vehicle filters are not applied to them. When this list is not empty, the make, model and place fields do not start any search (the search URLs of `startUrls` and the dealers of `sellerIds` still run beside them). |
| `maxItems` | Stop after this many listings for the whole run (`0` = unlimited). |
| `maxItemsPerQuery` | Cap for EACH search (make and model × place, dealer, or search URL). `0` = no per-search cap. |
| `splitLargeSearches`, `extractDetails`, `includeRaw` | Go past the 8,000 listings the site shows for one search (on by default); add the full listing page: description, equipment, price history, dealer card and the other fields marked "option" above (one more page per listing, billed on top); add La Centrale's untouched data of each listing in an extra column (much bigger rows). |
| `priceMin`, `priceMax`, `yearMin`, `yearMax`, `mileageMin`, `mileageMax` | Lowest and highest price in euros, model year and mileage in km. |
| `energies` | Fuel, any of them: `DIESEL`, `ESSENCE`, `ELECTRIC`, `HYBRID`, `PLUGIN_HYBRID`, `HYDROGEN`… (the form lists them all). Empty = all. |
| `gearbox` | `AUTO` or `MANUAL` (`ANY` = both). |
| `categories` | Body type, any of them: `BERLINE`, `BREAK`, `CABRIOLET`, `CITADINE`, `SUV_4X4_CROSSOVER`… and the motorbike types (the form lists them all). Empty = all. With no `vehicleTypes`, the sections searched are those of the types you choose (a motorbike type searches motorbikes). |
| `doors` | Number of doors, any of them: `2`, `3`, `4`, `5`. |
| `externalColors` | Exterior colour, any of them: `noir`, `blanc`, `gris`, `bleu`, `rouge`… |
| `priceRatings` | La Centrale's rating of the price against the market: `VERY_GOOD_DEAL`, `GOOD_DEAL`, `EQUITABLE_DEAL`, `BAD_DEAL`, `NOT_COMPUTED`. |
| `sellerType` | `PRO` (dealers only), `PART` (private sellers only) or `ANY`. |
| `sellerFamilyCodes` | Kind of dealer, any of them: `CONCESSIONNAIRE`, `GARAGISTE`, `COURTIER_AUTOMOBILE`, `LOUEUR`… (the form lists them all). |
| `postedWithinDays` | Only listings put online on the last N calendar days, today included (1 to 365), filtered by La Centrale itself. Its days are UTC days: `1` = today only, since midnight UTC; `7` = today and the 6 days before, one day fewer than `postedAfter` set to 7 days. For exact dates use the date filters below. |
| `onlyWithPhotos`, `deliveryOnly`, `firstHandOnly`, `newVehiclesOnly`, `leaseOnly` | Tick boxes: only listings with photos, with home delivery, vehicles marked « first hand » by their seller (La Centrale's own mark), new (zero-kilometre) vehicles, listings with a lease-to-own offer. |
| `critAirMax` | Highest Crit'Air sticker: `1` keeps Crit'Air 0 and 1. |
| `powerMinHp`, `co2Max`, `consumptionMax`, `electricRangeMin`, `batteryCapacityMin` | Lowest power in horsepower, highest CO₂ in g/km, highest consumption in l/100 km, lowest electric range in km, lowest battery capacity in kWh. |
| `equipment` | Only vehicles with ALL these equipment items, written as La Centrale names them, in capitals with `_` between words: `GPS`, `CAMERA_DE_RECUL`, `TOIT_OUVRANT`, `ATTELAGE`. |
| `sort` | Order of the listings: `NEWEST` (default), `PRICE_ASC`, `PRICE_DESC`, `MILEAGE_ASC`, `YEAR_DESC`… With a cap, the order decides WHICH listings you get: the first 8,000 of a search follow the order you chose (with a price order, all of them); past 8,000, the next ones come cheapest first. |
| `postedAfter`, `postedBefore` | Publication date range: `2026-09-01`, or a period before now (`7 days`, `2 weeks`, `1 month`, `24 hours`). |
| `excludeKeywords` | Drop the listings whose title (make, model and version) contains one of these WHOLE words (case and accents ignored): `amg` drops "CLASSE A 45 AMG". Several words in one entry (`pack sport`) must appear together, in that order. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the listings never delivered under this memory key; `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (leave the default Apify Proxy: the proxy is included in the price; on the Apify free plan add your own proxy URLs), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

A real listing, shortened (some columns left out, the long texts cut, the seller's details replaced by an example):

```json
{
    "id": "87103591394",
    "reference": "W103591394",
    "url": "https://www.lacentrale.fr/auto-occasion-annonce-87103591394.html",
    "status": "online",
    "title": "RENAULT CLIO IV 0.9 TCE 90 ENERGY LIMITED ECO2",
    "vehicleType": "AUTO",
    "make": "RENAULT",
    "model": "CLIO",
    "version": "IV 0.9 TCE 90 ENERGY LIMITED ECO2",
    "energy": "ESSENCE",
    "gearbox": "MANUAL",
    "doors": 5,
    "year": 2014,
    "mileageKm": 79200,
    "price": 7990,
    "currency": "EUR",
    "priceRating": "GOOD_DEAL",
    "monthlyPrice": 121,
    "sellerType": "PRO",
    "sellerId": "C012345",
    "sellerName": "Garage Martin",
    "sellerPhone": "0612345678",
    "sellerPhones": [
        "0612345678"
    ],
    "country": "FR",
    "department": "32",
    "region": "FR-OCC",
    "deliveryPrices": [],
    "publicationOptions": [
        "DELIVERY",
        "STRENGTHS"
    ],
    "picturesCount": 10,
    "images": [
        "https://pictures.lacentrale.fr/classifieds/W103591394_STANDARD_1.jpg?fit=inside&format=webp&size=1096x829&signature=…"
    ],
    "publishedAt": "2026-11-07",
    "detailScraped": true,
    "description": "RENAULT Clio 4 0.9 TCe 90ch – 10/07/2014 – Moteur à chaîne – Première main – Garantie 6 mois",
    "equipment": [
        "Indicateur de sous-gonflage des pneus",
        "Système audio inclut DVD",
        "Limiteur de vitesse"
    ],
    "firstRegistrationDate": "2014-07-10",
    "powerHp": 90,
    "co2GPerKm": 114,
    "marketValue": 8685,
    "priceHistory": [
        7990,
        7990
    ],
    "searchUrl": "https://www.lacentrale.fr/listing?makesModelsCommercialNames=RENAULT%3ACLIO&sortBy=firstOnlineDateDesc",
    "scrapedAt": "2026-11-07T20:40:03.753Z"
}
```

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

#### All 96 fields

| Fields | What you get |
| --- | --- |
| `id`, `reference`, `url`, `status` | **Listing**: `87103591394`, `W103591394`, the address of the listing page; `online`, or `removed` for a reference La Centrale no longer shows |
| `title`, `vehicleType`, `make`, `model`, `commercialName`, `detailedModel`, `version`, `trimLevel`, `motorization` | **Vehicle**: `RENAULT CLIO IV 0.9 TCE 90 ENERGY LIMITED ECO2`, `AUTO`, `RENAULT`, `CLIO`, `CLIO 4`, `RENAULT CLIO IV`, `IV 0.9 TCE 90 ENERGY LIMITED ECO2`, `LIMITED`, `0.9 TCE 90` |
| `category`, `energy`, `gearbox`, `doors`, `externalColor`, `year`, `mileageKm` | `CITADINE`, `ESSENCE`, `MANUAL`, `5`, `gris anthracite metal`, `2014`, `79200` |
| `price`, `currency`, `priceRating`, `monthlyPrice` | **Price**: `7990`, `EUR`, `GOOD_DEAL` (La Centrale's rating of the price against the market), `121` (monthly payment of the financing offer) |
| `manufacturerWarrantyMonths`, `extendedWarranty`, `isNewVehicle`, `isNewListing` | `6`, `null`, `false`, `true`: warranty left in months, extended warranty offered, new (zero-kilometre) vehicle, La Centrale's "new" badge |
| `sellerType`, `sellerFamily`, `sellerId`, `sellerName`, `sellerPhone`, `sellerPhones`, `sellerUrl` | **Seller**: `PRO` or `PART`, `CENTRE_MULTIMARQUES`, `C012345`, the name, the first phone number, every phone number, the dealer page (`null` for a private seller) |
| `country`, `department`, `region` | **Place**: `FR`, `32`, `FR-OCC` (Belgium and Luxembourg: `BE` or `LU` in `department`, `region` empty) |
| `deliveryAvailable`, `deliveryPrices`, `deliveryMaxDistanceKm`, `publicationOptions`, `historyReportAvailable` | **Delivery and options**: delivery offered, its prices by distance and farthest distance, the advertising options the seller bought (`PHOTO_360`…), vehicle history report offered |
| `picturesCount`, `has360Photos`, `hasPanoramaPhoto`, `imageUrl`, `images` | **Photos**: `10`, 360° photos, panoramic photo, main photo, photo addresses (every photo in large size with the full listing page, otherwise the main photo and the small previews) |
| `publishedAt`, `updatedAt`, `photosUpdatedAt`, `priceDropLimitDate` | **Dates**: `2026-11-07` (the day it was put online, what the date filters read), `2026-11-07T13:27:01.000Z`, `2026-11-07T13:14:47.000Z`, date of the price drop the seller announced |
| `detailScraped`, `description`, `equipment`, `firstRegistrationDate`, `firstHand` | **Full listing page**: `true` when the page was read, the seller's text, every equipment item, `2014-07-10`, `true` |
| `powerHp`, `fiscalHorsePower`, `engineSizeCc`, `co2GPerKm`, `consumptionL100km`, `critAir`, `euroStandard`, `seats` | **Engine and emissions** (full listing page): `90`, `5`, `898`, `114`, `4.2`, `1`, `EURO5`, `5` |
| `lengthMm`, `widthMm`, `heightMm`, `weightKg`, `trunkVolumeL` | **Size** (full listing page): `4060`, `1730`, `1450`, `1009`, `300` |
| `electricRangeKm`, `batteryCapacityKWh`, `batteryHealthPercent` | **Battery** of an electric or plug-in hybrid vehicle (full listing page, `null` for a petrol or diesel one or when the page gives none): `458` (range in km), `93.4` (capacity in kWh), `97` (state of health in %, La Centrale's estimate; the middle of the range when the page shows one, such as 92 – 96 %) |
| `newPrice`, `marketValue`, `mileageRating`, `initialPrice`, `priceChangePct`, `priceHistory` | **Value and price history** (full listing page): `16600`, `8685` (La Centrale's price estimate), `UNDER_MILEAGE`, `7990`, `0`, `[7990, 7990]` |
| `warrantyMonths`, `dealerWarrantyMonths`, `vatRecoverable`, `nextServiceDate`, `nextServiceCost` | **Warranty and servicing** (full listing page): `24`, `6`, `false`, `2027-03` (month of the next service), cost of that service in euros |
| `sellerAddress`, `sellerZipCode`, `sellerCity`, `latitude`, `longitude`, `sellerRating`, `sellerReviewCount`, `sellerWhatsapp`, `sellerVerified` | **Dealer card** (full listing page): address, postcode, city, GPS position, rating out of 5 (`5`), number of reviews (`11`), WhatsApp number (`+33612345678`), verified-seller mark |
| `searchUrl`, `scrapedAt`, `raw` | **Search context**: the La Centrale search the listing was found in, ISO timestamp, La Centrale's untouched data of the listing (**Include raw data**, `null` otherwise) |

### 💡 Tips

#### How to get more results

Set `maxItems` to `0`. La Centrale shows at most 8,000 listings for one search; with **Go past 8,000 listings per search** on (the default) the Actor reads on beyond that, each listing once, at the price of the listings alone. To follow the market, schedule the Actor daily with **Only new listings** (see below).

#### How to reduce costs

The price is per listing, so the levers are `maxItems`, `maxItemsPerQuery`, the vehicle filters (they are applied by La Centrale: only the matching listings are read and charged), the filters of the Actor (a filtered-out listing costs only the filter fee, lower than a listing) and `onlyNew` for recurring runs (you never pay twice for the same listing). Leave **Full listing page** off when the results already give what you need: it is billed on top, per listing, when the page was read.

#### Several searches in one run

Fill `makesModels` and / or `locations`: the Actor runs one search per vehicle × place (3 vehicles × 4 places = 12 searches, up to 500 per run). The single `make`, `model` and `location` fields still work and are added to the lists. A listing found by several searches is saved — and charged — once. Set `maxItemsPerQuery` to give every search its own cap: without it the first searches can use up the whole `maxItems` budget. You can also paste several search URLs into `startUrls`: each one is a search of its own, with the same cap.

#### A dealer's whole stock, and a radius around a postcode

Every row carries the dealer id (`sellerId`) and the dealer page: put the id, or the page address, into `sellerIds` to get everything that dealer has on sale: all sections (cars, vans, motorbikes, scooters, quads) unless you fill `vehicleTypes`. The make, model and place fields then start no search of their own (the vehicle filters still narrow the stock). To search around a place, give a postcode as `location` and a distance as `radiusKm`; a département (`29`), several (`29,22,56`) or a region (`FR-BRE`) are searched as they are.

#### Follow listings by their reference

Put the references you saved (`reference`, e.g. `E120320215`) into `listingIds`, and schedule the Actor: each run gives the current row of every listing, and a `removed` row for each one La Centrale no longer shows. The vehicle filters are not applied to these listings, whatever you asked for, and the make, model and place fields start no search beside them.

#### Monitoring: only the new listings

Tick **Only new listings** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips the listings already delivered: they are not saved, not charged, and their page is not even opened. The memory lives in a named key-value store of your account (`lacentrale-listings-scraper-seen`, up to 150,000 listings per key) and is only updated with listings that really reached the dataset, so a failed run never hides anything. Give each schedule its own `stateKey` (two schedules sharing a key would hide each other's listings), and tick `resetState` once to start over. Keep the sort **Newest first** (the default): a search then stops once it meets a long run (up to 500 in a row) of listings you already have.

#### Filter by publication date

`postedAfter` and `postedBefore` take a date (`2026-09-01`, the whole day is included, Paris time) or a period before now (`7 days`, `2 weeks`, `1 month`; via the API also `24 hours` or a full ISO date-time). La Centrale gives the day a listing was put online, not the hour: the filter reads `publishedAt`, a day, and a listing without a publication date is dropped as soon as a date bound is set. Filtered-out listings are not saved and do not count in `maxItems` (each listing dropped costs the filter fee, see Pricing); the run summary tells how many were filtered. With `postedAfter` and the default order (newest first), a search stops at the first page that is entirely too old; in any other order, or for a search over 8,000 listings, the Actor asks La Centrale only for the listings put online since the day before your date: the older ones are never read, and only that one extra day can cost filter fees. With `postedBefore` and the default order, the Actor first asks La Centrale how many listings of the search were put online after your date, then reads the search from there, newest first: fewer than 100 of the newer listings are read and dropped (one more day of them if the run goes past midnight UTC). When those newer listings fill the 8,000 La Centrale shows, or you want more than the 8,000 hold after them, the search is read in price bands, each one newest first from your date (fewer than 100 newer listings read in each; with a cap, band after band, cheapest band first). In any other order, the listings newer than `postedBefore` are read and dropped. When `postedWithinDays` holds only days after `postedBefore` (`3` with `postedBefore` set to `10 days`), no listing can match: whatever the order, the Actor reads the first results page of the search only, saves nothing and says why in the log. To let La Centrale itself keep only recent listings, use `postedWithinDays`: N calendar days, today included, counted in UTC (`1` = today only, since midnight UTC), so one day fewer than `postedAfter` with N days. Listings asked by reference (`listingIds`, or a listing page in `startUrls`) are returned whatever their date: `postedAfter` and `postedBefore` (and `excludeKeywords`) do not apply to them.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per La Centrale listing. Actor id: `nice_dev/lacentrale-listings-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/lacentrale-listings-scraper`.

Smallest input, for a cheap first call:

```json
{
    "make": "RENAULT",
    "model": "CLIO",
    "maxItems": 10
}
```

Key output fields: `url`, `title`, `price`, `year`, `mileageKm`, `energy`, `sellerName`, `sellerPhone` and `publishedAt` (with `extractDetails`: `description`, `equipment`, `marketValue`).

Cost: priced per listing plus a small fee per run start (the full listing page is billed on top), see the pricing section above. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape La Centrale?

The Actor only reads what La Centrale shows publicly to any anonymous visitor. It logs in to nothing. Results can contain personal data (the name and phone number a seller published, mostly dealers but also private sellers), which is protected by GDPR: do not store it without a legitimate reason. You are responsible for using the data in compliance with La Centrale's Terms of Use and applicable law. This Actor is not affiliated with La Centrale.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting. On the Apify free plan the included proxy is not available: add your own proxy URLs (residential ones) in **Proxy configuration**, or the run stops at once with a message. A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Is the data safe to open in Excel or to show on a web page?

Titles and descriptions are the sellers' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@` (a WhatsApp number such as `+33612345678`, a title such as `-20% today`): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. A phone number such as `0612345678` loses its leading zero when a spreadsheet reads it as a number: import it as text too. On a web page, escape every field like any text written by a stranger.

#### Known limitations

- A La Centrale search page pasted into `startUrls` keeps these filters of the site: make and model, price, year and mileage ranges, fuel, body type (city car, saloon, estate, MPV, coupé, convertible, SUV / 4x4, van under 3.5 t, small van), gearbox, doors, colour, first hand, dealer kind, region, one or more départements or one postcode (within 20 km, or the site's default of 100 km), Crit'Air, equipment, price rating, days online, the section (vans, motorbikes, scooters or quads) and the sort. Each was checked on the site: the page and the Actor count the same listings. Any other filter of the page (a warranty network, a power or CO₂ limit, another radius, several postcodes, another body type…) stops the run before the first request, with a message that names the filter and, when there is one, the field of the form to use instead: a filter is never dropped in silence, which would widen the search.
- The fields marked "option" in the table above come from the listing page: they are `null` or empty when **Full listing page** is off, and `images` then holds only the main photo and the small previews.
- A listing page that cannot be read after every try does not stop the run: the listing is delivered from the results page, with `detailScraped` at `false`, and is not charged for the page.
- `publishedAt` is a day, not a time: date filters and "newest first" work by day.
- `onlyNew` remembers listing ids, not their content: a listing whose price changed is not returned again.
- Two runs sharing the same `stateKey` at the same time may both return the same new listing.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options). With the full listing page the pace is about 20 seconds per page, several pages in parallel: for a big run, set a longer timeout.

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the listings already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the listings it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the listings of its last 2 seconds once more.

#### Something doesn't work?

The last line of the log counts the listings saved, filtered out and no longer on La Centrale (removed while the run was reading them), and the requests that failed after every retry. Those requests and the removed listings are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause (a search URL that does not exist says so, instead of "run it again").

If La Centrale changes its pages, you are told instead of paying for blank rows. A results page that counts listings but gives none the Actor can read is an error (listed in `FAILED_REQUESTS`), never a quiet "No listings found". So is a results page that no longer gives its count of listings. With `listingIds`, an answer that holds listings you did not ask for stops the run with an error, and a listing is only said `removed` when La Centrale's answer could be read in full. If the first 20 listings read all lack the same basic field (title, make, model, year, mileage, price, seller phone or publication date; with **Full listing page**, also the seller's postcode, the first price or the first-hand flag of the pages read), the run saves nothing more, stops and fails, and its last message names the missing field: at most those first listings are charged. A listing that `postedAfter` / `postedBefore` drops because it has no date at all counts among those 20. A run of fewer listings (a scheduled `onlyNew` run that finds a few new ones, a small **Max listings**) is checked at its end, from 5 listings: its listings are already saved, and the run fails with the missing field instead of ending green.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which URLs failed and why.

# Actor input Schema

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

La Centrale search-result URLs (`https://www.lacentrale.fr/listing?makesModelsCommercialNames=RENAULT%3ACLIO&…`, all pages are read). Kept from the page: make and model, price, year and mileage, fuel, body type, gearbox, doors, colour, first hand, dealer kind, region, départements or one postcode (20 km or the site's 100 km), Crit'Air, equipment, price rating, days online, section and sort; a page with any other filter is refused at the start, with the filter's name and the field below to use instead, when there is one. Also listing URLs (`https://www.lacentrale.fr/auto-occasion-annonce-69120320215.html`) or dealer pages (`https://pros.lacentrale.fr/C059526`). When this list is not empty, the make / model and location fields below start no search, but a value that is not valid is still refused (clear the field); the vehicle filters, caps and monitoring still apply. Max 1 000 URLs.

## `make` (type: `string`):

Vehicle make as La Centrale writes it: `RENAULT`, `PEUGEOT`, `MERCEDES`, `BMW`, `VOLKSWAGEN`… (case is ignored). Empty = every make.

## `model` (type: `string`):

Model of that make: `CLIO`, `308`, `CLASSE A`… A generation works too: `CLIO:CLIO 5`. Needs **Make**.

## `makesModels` (type: `array`):

Several searches in one run, one per line: `PEUGEOT`, `PEUGEOT:208`, `RENAULT:CLIO:CLIO 5`. Added to **Make** / **Model** above. Each line is crossed with each location (at most 500 searches per run).

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

Where the vehicle is: a French département (`29`, `75`; Corsica = `20`, overseas = `97`), several of them (`29,22,56`), a region (`FR-BRE`, `FR-IDF`, `BE` = Belgium, `LU` = Luxembourg), or a postcode (`29200`) searched within **Radius**. Empty = all of France, Belgium and Luxembourg.

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

Several places in one run, one per line, each written like **Location** and searched separately (crossed with each make / model, at most 500 searches per run).

## `radiusKm` (type: `integer`):

Distance around a postcode location (La Centrale's own radius search). Not used for a département or a region.

## `vehicleTypes` (type: `array`):

Which La Centrale sections to search. Empty = the sections of the chosen body types, else cars and vans; for a dealer (Dealers), every section.

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

Every vehicle on sale by these dealers, in every section (cars, vans, motorbikes, scooters, quads) unless Vehicle types is filled: the dealer id this Actor returns (`sellerId`, e.g. `C059526`) or the dealer page URL (`https://pros.lacentrale.fr/C059526`). Each dealer is one search; the vehicle filters below still apply. When this list (or Listing references) is not empty, the make / model and location fields start no search (a value that is not valid is still refused: clear the field).

## `listingIds` (type: `array`):

Fetch these listings directly, by La Centrale reference (`E120320215`, `W103541170`) or listing URL — 100 per request. A listing La Centrale no longer shows comes back with `status` = `removed` (useful to track sales). When this list is not empty, the make / model and location fields start no search (Start URLs and Dealers still run beside it); the vehicle filters are not applied to these listings.

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

Maximum number of listings to save for the whole run (after deduplication and filters). 0 = no limit.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH search (make / model × location, dealer, or search URL), so that the first search cannot use up the whole **Max listings** budget. 0 = no per-search cap.

## `splitLargeSearches` (type: `boolean`):

La Centrale returns at most 8 000 listings per search. On: a bigger search is cut into price bands (then mileage bands), each under 8 000, so that every listing is reached (free, a few more requests); with a cap and an order other than the price, the first 8 000 are read in that order, then the bands, cheapest first. Off: the first 8 000.

## `extractDetails` (type: `boolean`):

Open each listing's own page and add: the seller's description, every equipment item, first registration date, power (hp and fiscal), CO₂, consumption, Crit'Air, dimensions, seats, first hand, the range, battery capacity and battery health of an electric or plug-in hybrid vehicle, La Centrale's price estimate (`marketValue`), the price history (initial price and every change), upcoming servicing and its cost, the dealer's address, GPS position, rating and number of reviews, and all photos in large size. One more page per listing, slower (≈ 20 s per page, several in parallel); charged per listing as **Full listing page**, on top of the listing (see Pricing), only when the page was read. Off = everything La Centrale shows in its results: price, make, model, version, year, mileage, fuel, gearbox, body, colour, doors, price rating, seller name, type and phone, département, delivery, warranty, monthly price, photos.

## `includeRaw` (type: `boolean`):

Add a `raw` field with La Centrale's untouched JSON of the listing. Useful to recover a field this Actor does not map yet; makes the data much bigger.

## `priceMin` (type: `integer`):

Lowest price, in euros.

## `priceMax` (type: `integer`):

Highest price, in euros.

## `yearMin` (type: `integer`):

Oldest model year.

## `yearMax` (type: `integer`):

Newest model year.

## `mileageMin` (type: `integer`):

Lowest mileage, in km.

## `mileageMax` (type: `integer`):

Highest mileage, in km.

## `energies` (type: `array`):

One or several fuels (any of them). Empty = all.

## `gearbox` (type: `string`):

Automatic or manual.

## `categories` (type: `array`):

One or several body types (any of them). Empty = all. With no Vehicle types, the sections searched are those of the types you choose (a motorbike type searches motorbikes).

## `doors` (type: `array`):

Number of doors (any of them). Empty = all.

## `externalColors` (type: `array`):

Exterior colour (any of them). Empty = all.

## `priceRatings` (type: `array`):

La Centrale's own rating of the price against the market (any of them). Empty = all.

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

Dealers, private sellers, or both.

## `sellerFamilyCodes` (type: `array`):

Kind of dealer (any of them). Empty = all.

## `postedWithinDays` (type: `integer`):

Only listings put online on the last N calendar days, today included, filtered by La Centrale itself. Its days are UTC days: `1` = today only (since midnight UTC), `7` = today and the 6 days before. **Posted after** set to 7 days reaches one day further back. Empty = any age.

## `onlyWithPhotos` (type: `boolean`):

Only listings with at least one photo.

## `deliveryOnly` (type: `boolean`):

Only listings whose seller offers delivery.

## `firstHandOnly` (type: `boolean`):

Only vehicles marked « first hand » by their seller on La Centrale (the site's own filter); a car with one owner whose seller did not tick the mark is left out.

## `newVehiclesOnly` (type: `boolean`):

Only new (zero-kilometre) vehicles sold by dealers.

## `leaseOnly` (type: `boolean`):

Only listings with a lease-to-own (LOA) offer.

## `critAirMax` (type: `string`):

Highest Crit'Air sticker accepted (French low-emission zones): `1` keeps Crit'Air 0 and 1.

## `powerMinHp` (type: `integer`):

Lowest power, in horsepower (DIN).

## `co2Max` (type: `integer`):

Highest CO₂ emissions, in g/km.

## `consumptionMax` (type: `integer`):

Highest fuel consumption, in litres per 100 km.

## `electricRangeMin` (type: `integer`):

Lowest electric range, in km (electric and plug-in vehicles).

## `batteryCapacityMin` (type: `integer`):

Lowest battery capacity, in kWh.

## `equipment` (type: `array`):

Only vehicles with ALL these equipment items, written as La Centrale names them, in capitals with `_` between words: `GPS`, `CAMERA_DE_RECUL`, `TOIT_OUVRANT`, `ATTELAGE`, `REGULATEUR_DE_VITESSE`, `SIEGES_CHAUFFANTS`, `4X4`…

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

Order in which La Centrale returns the listings. Newest first is the default and the one used to stop early with **Only new listings**. With a cap, the order decides WHICH listings you get: the first 8 000 of a search follow the order chosen (with a price order, all of them); past 8 000, the next ones come cheapest first.

## `postedAfter` (type: `string`):

Only listings put online on or after this date (La Centrale's first online date): `2026-09-01`, or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too). Out of newest first, or past 8 000 listings, only the listings online since the day before are read.

## `postedBefore` (type: `string`):

Only listings put online on or before this date (same formats as **Posted after**). Newest first, the listings newer than it are counted and skipped, not read (fewer than 100 of them are read and dropped); past 8 000, the search is read in price bands, each one from this date (fewer than 100 newer ones read in each). In any other order, the newer listings are read and dropped.

## `excludeKeywords` (type: `array`):

Drop the listings whose title (make, model and version) contains one of these WHOLE words (case and accents ignored): `amg` drops "CLASSE A 45 AMG". Several words in one entry (`pack sport`) must appear together, in that order.

## `onlyNew` (type: `boolean`):

Skip the listings that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their page is not even opened. First run = everything is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new listings**. Give each schedule / task its own key (e.g. `clio-paris`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every listing again. Untick it afterwards.

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

Keep **Apify Proxy**: the Actor uses its own French IP addresses, included in the price (the proxy group, the country and **No proxy** chosen here are ignored). Your own proxies (`proxyUrls`) must be residential ones. On the Apify free plan the included proxy is not available: add your own proxy URLs, or the run stops at once with a message.

## `maxConcurrency` (type: `integer`):

Maximum number of requests processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to La Centrale in any 60 seconds, all of them counted (results pages of 100 listings, listing pages). Lower it if the log shows refusals.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked as failed. Behind a proxy, a request the site turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "make": "RENAULT",
  "model": "CLIO",
  "makesModels": [],
  "locations": [],
  "radiusKm": 30,
  "vehicleTypes": [],
  "sellerIds": [],
  "listingIds": [],
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "splitLargeSearches": true,
  "extractDetails": false,
  "includeRaw": false,
  "energies": [],
  "gearbox": "ANY",
  "categories": [],
  "doors": [],
  "externalColors": [],
  "priceRatings": [],
  "sellerType": "ANY",
  "sellerFamilyCodes": [],
  "onlyWithPhotos": false,
  "deliveryOnly": false,
  "firstHandOnly": false,
  "newVehiclesOnly": false,
  "leaseOnly": false,
  "equipment": [],
  "sort": "NEWEST",
  "excludeKeywords": [],
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 4,
  "maxRequestsPerMinute": 60,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# 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 = {
    "make": "RENAULT",
    "model": "CLIO",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/lacentrale-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 = {
    "make": "RENAULT",
    "model": "CLIO",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/lacentrale-listings-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 '{
  "make": "RENAULT",
  "model": "CLIO",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/lacentrale-listings-scraper --silent --output-dataset

```

## MCP server setup

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