# La Centrale Scraper: French Used Cars & Seller Phones (`axlymxp/lacentrale-scraper`) Actor

Scrape La Centrale (lacentrale.fr) used-car listings by make, model, fuel, price, year and mileage. Get specs, asking price, good-deal badge, dealer name and phone, photo and listing URL as JSON or CSV. No login and no search URL needed.

- **URL**: https://apify.com/axlymxp/lacentrale-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 dataset items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## La Centrale Scraper: French used cars with dealer phone numbers

Export **used-car listings from La Centrale** (lacentrale.fr, a large French used-vehicle marketplace) as clean JSON, CSV or Excel. Search by **make, model, fuel, price, year and mileage**, no search URL to build, no login. Every row has the full specs, the asking price, the good-deal badge, the **seller name and phone number**, the department and the main photo.

It reads the same mobile API the La Centrale app uses, so the data matches what the app shows. Runs work without a proxy. If La Centrale blocks the server address, the actor retries through an Apify Residential (France) exit on its own.

### What you can do with it

- **Price benchmarking:** pull every PEUGEOT 208 under 12,000 EUR and chart price against mileage and year.
- **Dealer lead lists:** collect dealer names, phone numbers and departments for a make or segment (`sellerType` tells dealers `PRO` from private sellers `PART`).
- **Inventory monitoring:** schedule a daily run sorted by newest listings and diff the `reference` field to catch new stock.
- **Deal sourcing:** sort by price and filter on `goodDealBadge` to surface underpriced cars.
- **Market datasets:** feed a French used-car price model, a valuation tool or a BI dashboard.

### Output fields

| Field | Description |
| --- | --- |
| `reference`, `url` | La Centrale listing id and the public listing URL |
| `price`, `currency` | Asking price in EUR |
| `make`, `model`, `commercialName`, `version`, `detailedModel`, `trimLevel` | Brand, model and trim naming |
| `year`, `mileageKm` | Registration year and mileage |
| `energy`, `gearbox`, `doors`, `motorization` | Powertrain details |
| `category`, `family`, `externalColor` | Body category, vehicle family, colour |
| `sellerType`, `sellerName`, `sellerPhone` | `PRO` or `PART`, the seller display name and the decoded phone number |
| `sellerReference`, `sellerFamilyCode` | Dealer id and dealer type |
| `department`, `country` | French department code and country |
| `goodDealBadge` | La Centrale deal rating (for example `GOOD_DEAL`), empty when unrated |
| `isNew`, `deliveryAvailable`, `deliveryPrices` | New-vehicle flag and delivery options |
| `publicationOptions`, `picturesCount`, `photoUrl` | Listing options, photo count, main photo URL |
| `firstOnlineDate`, `lastUpdate` | First publication date and last update (epoch seconds) |

Fields that La Centrale does not provide for a listing are `null` (for example `sellerPhone` on some private ads, or `energy` on many motorbikes).

### Input

| Parameter | Description |
| --- | --- |
| `make` | Brand in capitals, e.g. `PEUGEOT`, `RENAULT`, `BMW`. Empty searches every make. |
| `model` | Model, e.g. `208`, `CLIO`, `SERIE 3`. Needs a make. |
| `makesModels` | Advanced filter that replaces make and model: `MAKE` or `MAKE:MODEL`, several separated by `;` (`PEUGEOT:208;RENAULT:CLIO`). |
| `families` | Cars + utility (default), cars, utility vehicles or motorbikes. |
| `energies` | Petrol, diesel, electric, hybrid kinds or hydrogen. |
| `priceMin`, `priceMax` | Price range in EUR. |
| `yearMin`, `yearMax` | Registration year range. |
| `mileageMax` | Maximum mileage in km. |
| `sort` | Relevance, price, year, mileage, or newest listings. |
| `maxItems` | Stop after this many vehicles. |
| `proxyConfiguration` | Optional. Not needed normally. |

#### Example input

```json
{
    "make": "PEUGEOT",
    "model": "208",
    "families": "AUTO,UTILITY",
    "priceMax": 12000,
    "sort": "priceAsc",
    "maxItems": 50
}
```

#### Example output row

```json
{
    "reference": "E120048188",
    "url": "https://www.lacentrale.fr/auto-occasion-annonce-E120048188.html",
    "price": 9590,
    "currency": "EUR",
    "make": "PEUGEOT",
    "model": "208",
    "commercialName": "208 (2E GENERATION)",
    "version": "II 1.2 PURETECH 100 S&S ALLURE",
    "detailedModel": "PEUGEOT 208 II",
    "trimLevel": "ALLURE",
    "year": 2020,
    "mileageKm": 90884,
    "energy": "ESSENCE",
    "gearbox": "MANUAL",
    "doors": 5,
    "category": "CITADINE",
    "family": "AUTO",
    "externalColor": "Yellow",
    "motorization": "1.2 PURETECH 100",
    "sellerType": "PRO",
    "sellerName": "Peugeot Citroën DS Opel Montpellier",
    "sellerPhone": "0451259324",
    "sellerReference": "C044801",
    "sellerFamilyCode": "CONCESSIONNAIRE",
    "department": "34",
    "country": "FR",
    "goodDealBadge": "GOOD_DEAL",
    "isNew": false,
    "deliveryAvailable": false,
    "deliveryPrices": null,
    "picturesCount": 31,
    "photoUrl": "https://pictures.lacentrale.fr/classifieds/E120048188_STANDARD_0.jpg?format=webp&size=352x264",
    "firstOnlineDate": "2026-10-02",
    "lastUpdate": 1791376187
}
```

### How many results can I get?

La Centrale serves roughly the first 8,000 results of any single search (a full-catalog run returned 7,970 unique cars before the site stopped paging). To go further, split the search with filters: one run per make, per price band or per year. Each run reports the number of matching listings in its `SUMMARY` record.

### Scheduling and automation

Use Apify Schedules to run the actor daily or hourly, sort by newest listings and compare `reference` values with the previous run. Connect results to Google Sheets, Make, Zapier or a webhook, or fetch them with the Apify API and client libraries.

### FAQ

**Do I need a proxy or a La Centrale account?** No. The actor needs no login and normally runs without a proxy.

**Does it work for utility vehicles and motorbikes?** Yes, pick the vehicle family in the input. Motorbike rows carry fewer fields, for example no fuel type on many bikes.

**Why do some runs return fewer cars than `maxItems`?** The search matched fewer listings, or hit the per-search limit described above. The run status shows how many listings matched.

**Is the phone number real?** It is the contact number the seller published on the listing, decoded from the API. Use contact data in line with GDPR and French rules on cold calling (Bloctel).

**Can I ask for another field?** Open an issue on the Actor page.

# Actor input Schema

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

Brand in capitals, e.g. PEUGEOT, RENAULT, BMW, VOLKSWAGEN. Leave empty to search every make.

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

Model name in capitals, e.g. 208, CLIO, SERIE 3. Needs a make. Leave empty for all models of the make.

## `makesModels` (type: `string`):

Raw La Centrale filter, overrides Make and Model. Format MAKE or MAKE:MODEL; separate several with a semicolon, e.g. PEUGEOT:208;RENAULT:CLIO.

## `families` (type: `string`):

Which vehicle types to include.

## `energies` (type: `string`):

Optional fuel type. Hybrid matches all hybrid kinds; the specific hybrid values narrow it down.

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

Minimum price in euros.

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

Maximum price in euros.

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

Earliest registration year.

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

Latest registration year.

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

Maximum mileage in kilometres.

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

Result ordering.

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

Stop after this many vehicle listings. La Centrale serves roughly the first 7,500 to 9,000 results of one search, so split bigger searches with price or year filters.

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

Optional. The scraper works without a proxy. If La Centrale blocks the server IP it automatically retries through Apify Residential proxy (France), billed to your account as proxy usage.

## Actor input object example

```json
{
  "make": "PEUGEOT",
  "model": "208",
  "families": "AUTO,UTILITY",
  "energies": "",
  "sort": "default",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": 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": "PEUGEOT",
    "model": "208",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/lacentrale-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": "PEUGEOT",
    "model": "208",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/lacentrale-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": "PEUGEOT",
  "model": "208",
  "maxItems": 20
}' |
apify call axlymxp/lacentrale-scraper --silent --output-dataset

```

## MCP server setup

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