# La Centrale MCP Server: French Used Cars (`axlymxp/lacentrale-mcp-server`) Actor

MCP server for La Centrale (lacentrale.fr): search French used-car listings with seller phones, get price statistics and inventory counts from Claude, Cursor or any MCP client. Also runs as a one-off search into a dataset.

- **URL**: https://apify.com/axlymxp/lacentrale-mcp-server.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** AI, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 MCP Server: French used-car search for AI agents

Give Claude, Cursor, ChatGPT-style agents, n8n or your own MCP client **live access to La Centrale** (lacentrale.fr, a large French used-vehicle marketplace). The Actor runs as a **Model Context Protocol server** in Apify Standby mode: your agent searches current listings, asks for price statistics and inventory counts, and reasons over fresh structured data instead of pasted text.

It reads the same mobile API the La Centrale app uses. No login and no proxy are needed. It can also run as a normal one-off search that writes vehicle rows to a dataset.

### Tools

| Tool | What it does |
| --- | --- |
| `search_vehicles` | Search listings by make, model (or several `MAKE:MODEL` pairs separated by `;`), vehicle family, fuel, price, year and mileage, with sorting. Returns up to 100 rows with specs, price, deal badge, seller name and phone, department and photo. |
| `get_price_stats` | Price, mileage and year statistics (count, min, max, average, median, quartiles) for a make or model, computed from a live sample of up to 500 current listings, plus deal-badge and seller-type counts. |
| `get_market_stats` | Inventory counts by facet: make/model tree, energy, gearbox, region, deal badge, colour. Biggest buckets first. |

A tool call that fails (for example La Centrale refuses the request) or a search with no results is not charged.

### Connect it

Use the Actor's Standby URL with `/mcp` (Streamable HTTP) and your Apify token:

```json
{
    "mcpServers": {
        "lacentrale": {
            "url": "https://<username>--lacentrale-mcp-server.apify.actor/mcp",
            "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
        }
    }
}
```

Example prompts: "Cheapest diesel Peugeot 208 under 10,000 EUR with less than 100,000 km", "What is the median asking price of a 2019 Renault Clio?", "How many electric cars are listed, and in which regions?".

### Vehicle row fields (`search_vehicles` and one-off runs)

| Field | Description |
| --- | --- |
| `reference`, `url` | La Centrale listing id and 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`, seller display name and decoded phone number |
| `sellerReference`, `sellerFamilyCode` | Dealer id and dealer type |
| `department`, `country` | French department code and country |
| `goodDealBadge` | La Centrale deal rating, empty when unrated |
| `isNew`, `deliveryAvailable`, `deliveryPrices` | New-vehicle flag and delivery options |
| `picturesCount`, `photoUrl`, `publicationOptions` | Photo count, main photo, listing options |
| `firstOnlineDate`, `lastUpdate` | Publication and update dates (epoch seconds) |

Fields La Centrale does not provide for a listing are `null`.

### One-off run

Without Standby, start the Actor with a make/model and filters and it writes up to `maxItems` vehicles (cap 1,000) to the dataset. Parameters: `make`, `model`, `makesModels`, `families` (`AUTO`, `UTILITY`, `AUTO,UTILITY`, `MOTO`), `energies`, `priceMin`, `priceMax`, `yearMin`, `yearMax`, `mileageMax`, `sort`, `maxItems`.

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

You can schedule one-off runs and connect webhooks like any other Actor.

### Use cases

- **Shopping and valuation agents:** natural-language car search over live inventory.
- **Dealers and analysts:** quick price benchmarks and stock counts for a segment without writing code.
- **Lead workflows:** pull dealer names and phone numbers into n8n or Make.

### FAQ

**How fresh is the data?** Each tool call queries La Centrale at that moment.

**How many results can I reach?** La Centrale serves roughly the first 8,000 results of one search. Narrow the search with price, year or make/model filters to reach the rest.

**Is the GPL (LPG) fuel filter supported?** No: La Centrale returns nothing for it, so it is not offered.

**Are `get_price_stats` numbers the whole market?** They describe a sample (the first listings in La Centrale's default order, up to the sample size you set), and the response states the sample size and the total number of matching listings.

**Legal:** the server returns publicly visible listing data. Use it in line with La Centrale's terms and applicable law, for example GDPR for seller phone numbers.

### Related Actors

- La Centrale Car Scraper, for large dataset exports.
- La Centrale Market Analytics, for inventory facets and price statistics as datasets.

# Actor input Schema

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

One-off run only. 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`):

One-off run only: stop after this many listings (cap 1,000). La Centrale serves roughly the first 8,000 results of one search.

## Actor input object example

```json
{
  "make": "PEUGEOT",
  "model": "208",
  "families": "AUTO,UTILITY",
  "energies": "",
  "sort": "default",
  "maxItems": 20
}
```

# 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-mcp-server").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-mcp-server").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-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/lacentrale-mcp-server"
        }
    }
}
```

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/cWJtfFYGhuZNQ94Qp/builds/JgegCdVEFYMkxPyn6/openapi.json