# Fuel Prices France by Station (`iocodo/fuel-prices-france`) Actor

Current fuel prices per filling station in Italy and France, from the open data published by the two governments. Filter by city, province, postal code or distance from a point, and get one normalised row per station with every price, the cheapest one for your fuel, source, licence and dates.

- **URL**: https://apify.com/iocodo/fuel-prices-france.md
- **Developed by:** [IOCODO LLC](https://apify.com/iocodo) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 stations

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 does Fuel Prices France by Station do?

Fuel Prices France by Station downloads the current **fuel prices per filling station** that the French Ministry of the Economy publishes as open data.

It filters them by the place and fuel you choose and returns one row per station.

The source is the prix-carburants open data, the [instantaneous feed](https://www.prix-carburants.gouv.fr/rubrique/opendata/), with about 9,800 stations that report prices.

It needs no API key, no login and no browser.

### Why use it?

- **Price monitoring.** Schedule a run each day and follow the price of diesel or petrol in the cities that matter to you.
- **Fleet and travel costs.** Find the cheapest stations within a radius of a depot, a hotel or a border crossing, sorted by price.
- **Maps and apps.** Latitude, longitude and distance come ready to plot.
- **Comparison and research.** Prices per station, not averages, with the date each price was reported.

On Apify you can schedule runs, call the Actor through the API, and send results to Google Sheets, Zapier, Make or a webhook.

### What data does it return?

| Field | Example |
|---|---|
| `country` | `FR` |
| `stationId` | 69007008 |
| `brand` | `null` (the feed does not give it) |
| `stationType` | `road` or `motorway` |
| `address`, `city` | AVENUE TONY GARNIER, LYON |
| `province`, `postalCode` | `null` (not used for France), 69007 |
| `latitude`, `longitude` | 45.727, 4.829 |
| `distanceKm` | 1.4 (only when you set a point) |
| `prices` | every price: `fuel`, `fuelLabel`, `price`, `currency`, `selfService`, `updatedAt` |
| `cheapest` | `{ "fuel": "diesel", "price": 2.25 }` |
| `source_updated_at` | 2026-10-23T22:01:00.000Z (the newest price of the station) |

Every record also carries `source`, `license` and `retrieved_at`, so you know where a row came from and when it was read.

**What is not in the output.** The output is a fixed list of fields about the station. Opening hours, services and any person name never appear.

**What is left out.**

- Stations with no price for the fuels you chose.
- Prices below 0.3 or above 5 EUR, treated as typing errors in the source.
- Rows that cannot be read. They are counted as `skippedRows` in the summary.

### How to get fuel prices

1. Open the Actor and pick the **Fuels**, for example Diesel. Leave it empty for every fuel.
2. Narrow the place with a city, a postal code, or a point and a radius.
3. Choose how to sort and how many stations you want, then click **Start**.
4. Download the results as JSON, CSV, Excel or HTML.

How the filters work:

- A station must match every filter you set.
- With no place filter at all, the run returns up to `maxStations` stations.

### How much does it cost?

You pay **$1 per 1,000 stations returned** ($0.001 each), and nothing for a run that matches no station. A run stops by itself at the maximum charge you set, so a wide query cannot cost more than you allow. The monthly credit of the free Apify plan is enough to try it.

### Input

See the input tab for every option. In short:

- `fuels`: fuel codes from the table below, empty for all. The first one is used for `cheapest` and for sorting by price
- `cities`: exact city names. Case, accents and punctuation are ignored, so `Saint-Étienne` finds `SAINT ETIENNE`
- `postalCodes`: a prefix matches longer codes, so `75` gives all of Paris and `69001` gives one arrondissement
- `latitude`, `longitude` and `radiusKm`: stations within a straight-line distance of a point. The radius is in kilometres, default `10`, from `0.5` to `200`
- `maxStations`: up to 100,000 (default 1,000). It is applied after sorting
- `sortBy`: `none` (order of the source file), `price` (lowest `cheapest.price` first, needs at least one fuel) or `distance` (nearest first, needs a point)

Example, diesel in Lyon, cheapest first:

```json
{
    "fuels": ["diesel"],
    "cities": ["Lyon"],
    "maxStations": 20,
    "sortBy": "price"
}
```

### Output

One dataset row per station. This is a row from a run of the example above:

```json
{
    "country": "FR",
    "stationId": "69007008",
    "brand": null,
    "stationType": "road",
    "address": "AVENUE TONY GARNIER",
    "city": "LYON",
    "province": null,
    "postalCode": "69007",
    "latitude": 45.727,
    "longitude": 4.829,
    "distanceKm": null,
    "prices": [
        { "fuel": "diesel", "fuelLabel": "Gazole", "price": 2.25, "currency": "EUR", "selfService": null, "updatedAt": "2026-10-23T22:01:00.000Z" }
    ],
    "cheapest": { "fuel": "diesel", "price": 2.25 },
    "source": {
        "name": "Ministère de l'Économie, prix-carburants.gouv.fr open data",
        "url": "https://www.prix-carburants.gouv.fr/rubrique/opendata/"
    },
    "license": {
        "name": "Licence Ouverte 2.0 (Etalab)",
        "url": "https://www.etalab.gouv.fr/licence-ouverte-open-licence/",
        "attribution": "Source: Ministère de l'Économie (prix-carburants.gouv.fr), Licence Ouverte 2.0"
    },
    "source_updated_at": "2026-10-23T22:01:00.000Z",
    "retrieved_at": "2026-10-24T19:22:59.969Z"
}
```

A `SUMMARY` record in the key-value store lists:

- the date of the newest price in the feed
- how many stations were read and matched
- how many rows were skipped and how many records were pushed
- whether the run stopped at the charge limit

If the feed cannot be downloaded, the run fails and the log says why.

### Fuel codes

The original fuel name always stays in `fuelLabel`. The `fuel` code comes from it:

| `fuel` | France (`nom`) |
|---|---|
| `diesel` | `Gazole` |
| `gasoline` | `SP95` |
| `gasoline_e10` | `E10` |
| `gasoline_98` | `SP98` |
| `e85` | `E85` |
| `lpg` | `GPLc` |
| `other` | any other name the feed lists |

`other` cannot be picked in `fuels`. Leave `fuels` empty to get those prices too.

### Tips

- **Schedule a run as often as you need.** Stations report their prices through the day, and each price has its own `updatedAt`.
- **Check `updatedAt`.** Some stations report rarely. A price can be days or weeks old, so filter on the date in your own pipeline if you need fresh prices only.
- **No self-service flag.** The feed does not say whether a price is self-service, so `selfService` is `null`.
- **Cities with districts.** Some stations write the district in the city field (`LYON 5EME`, `PARIS 13`). For a whole city, use `postalCodes`, for example `75` for Paris or `690` for Lyon.
- **The cheapest stations near you.** Set a point and a radius, pick one fuel, set `sortBy` to `price` and `maxStations` to 10.
- **Distance** is a straight line, not a road distance.
- **Dates.** The feed gives local time without a zone. The Actor reads it as Central European time and writes UTC in `updatedAt`. Coordinates are rounded to 6 decimals and converted from the feed's degrees multiplied by 100,000.

### Data source and licence

- Publisher: Ministère de l'Économie
- Dataset: [prix-carburants.gouv.fr open data](https://www.prix-carburants.gouv.fr/rubrique/opendata/), the instantaneous feed
- Licence: [Licence Ouverte 2.0 (Etalab)](https://www.etalab.gouv.fr/licence-ouverte-open-licence/)
- Attribution: Source: Ministère de l'Économie (prix-carburants.gouv.fr), Licence Ouverte 2.0

The Actor selects, renames and converts fields (coordinates, dates, fuel names); prices are not changed.

This Actor is independent and is not affiliated with, endorsed by or approved by the French Ministry of the Economy.

Prices are what the stations reported to the publisher. Check the price at the pump before any decision that depends on it.

### FAQ

#### Which fuels are covered?

Every fuel the French feed lists: diesel (`Gazole`), petrol (`SP95`, `E10`, `SP98`), `E85` and LPG (`GPLc`). Electric charging prices are not in this feed.

#### Is Italy available?

Not at the moment.

#### Why is a station missing?

Common reasons:

- It has no price for the fuels you chose.
- Its city is written differently in the source. Try a postal code.
- It has no coordinates and you set a radius.
- Its row could not be read. The `SUMMARY` record shows how many rows were skipped.

#### Why do some prices look old?

Each price carries the time the station reported it, in `updatedAt`. The Actor does not hide old prices, so you can decide what is too old for your use.

#### Can I get the data without paying for stations I do not need?

Yes. Use the filters and `maxStations`. You pay only for the stations returned, and a run stops by itself at the maximum charge you set.

#### Found a problem?

Open an issue in the Issues tab and describe the input that went wrong.

# Actor input Schema

## `fuels` (type: `array`):

Only stations that sell at least one of these fuels are returned, and only those prices are listed. Leave empty for every fuel. The first fuel you pick is the one used for the cheapest price and for sorting by price.

## `cities` (type: `array`):

Optional. One city per line. The name must match the city exactly, ignoring case, accents and punctuation (Lyon, Saint-Étienne).

## `postalCodes` (type: `array`):

Optional. Digits only. A prefix matches every longer code, so 75 gives all of Paris and 69001 gives one arrondissement.

## `latitude` (type: `number`):

Optional. Latitude of the centre point in degrees (for example 45.764 for Lyon). Use together with longitude.

## `longitude` (type: `number`):

Optional. Longitude of the centre point in degrees (for example 4.8357 for Lyon). Use together with latitude.

## `radiusKm` (type: `number`):

Only used with latitude and longitude. Stations farther than this straight-line distance are left out.

## `maxStations` (type: `integer`):

Upper limit of stations returned. The limit is applied after sorting, so with a sort order you get the best ones.

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

Price sorts by the cheapest price of your first selected fuel, lowest first (needs at least one fuel). Distance sorts by the distance to your point, nearest first (needs latitude and longitude). None keeps the order of the source file.

## Actor input object example

```json
{
  "fuels": [
    "diesel"
  ],
  "cities": [
    "Lyon"
  ],
  "radiusKm": 10,
  "maxStations": 20,
  "sortBy": "price"
}
```

# Actor output Schema

## `stations` (type: `string`):

No description

## `summary` (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 = {
    "fuels": [
        "diesel"
    ],
    "cities": [
        "Lyon"
    ],
    "maxStations": 20,
    "sortBy": "price"
};

// Run the Actor and wait for it to finish
const run = await client.actor("iocodo/fuel-prices-france").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 = {
    "fuels": ["diesel"],
    "cities": ["Lyon"],
    "maxStations": 20,
    "sortBy": "price",
}

# Run the Actor and wait for it to finish
run = client.actor("iocodo/fuel-prices-france").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 '{
  "fuels": [
    "diesel"
  ],
  "cities": [
    "Lyon"
  ],
  "maxStations": 20,
  "sortBy": "price"
}' |
apify call iocodo/fuel-prices-france --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,iocodo/fuel-prices-france"
        }
    }
}
```

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/2B58cf7rroyEaSEGX/builds/PmaSjh6upNoZK5KZj/openapi.json