# Italy Fuel Prices for Fleets & Logistics (Official MIMIT Data) (`shelly_fen/eu-fuel-prices-official`) Actor

Official diesel, petrol, LPG, CNG and LNG prices for ~23,000 Italian fuel stations (MIMIT open data), cheapest first by radius, city or province. Replaces looking prices up by hand or joining the ministry's CSVs. For fleets, hauliers and fuel-cost budgets.

- **URL**: https://apify.com/shelly_fen/eu-fuel-prices-official.md
- **Developed by:** [shelly_fen](https://apify.com/shelly_fen) (community)
- **Categories:** Business, Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 station with prices

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

## Italy Fuel Prices API – Diesel & Petrol Prices by Station (Official MIMIT Data)

**Italy fuel prices API for fleets:** today's official diesel, petrol (benzina), LPG, CNG and LNG price per station in Italy, filtered by radius, city or province and sorted cheapest first. Useful for fleet fuel cost checks, transport quotes and fuel budgets.

| | |
|---|---|
| **Data source** | MIMIT Osservaprezzi carburanti open data (Italian Ministry of Enterprises and Made in Italy) |
| **Licence** | IODL 2.0 – attribution included in every row |
| **Update frequency** | The ministry publishes one file per day (prices as reported by stations up to the previous day) |
| **Coverage** | Italy only (~23,000 stations). No other countries. |
| **Cost example** | 20 stations + area summary = $0.005 + 20 × $0.0001 + $0.01 = **$0.017 per run** |

**What it can do:** official station prices, cheapest-first ranking, area min/median/max summary, daily monitoring of named stations.
**What it can't do:** real-time (intra-day) prices, price forecasts, countries other than Italy, fuel-card or discounted prices. Prices are what stations reported to the ministry; a station can be late in reporting.

**Input → output (shortened):**

```json
{ "latitude": 44.4949, "longitude": 11.3426, "radiusKm": 15, "fuelTypes": ["diesel"], "maxResults": 20, "includeSummary": true }
```

→ one row per station: `rank, brand, address, city, distanceKm, selectedFuelPrice (EUR/L), selectedFuelUpdatedAt, prices, dataSource, dataLicense`.

***

**For transport companies, fleet managers and anyone who budgets fuel costs in Italy:** get the official diesel, petrol, LPG, CNG and LNG prices of the stations in your area as one sorted table – cheapest first – instead of looking them up by hand.

The prices come from the **Italian Ministry of Enterprises and Made in Italy (MIMIT) – Osservaprezzi carburanti open data**, the official register that Italian stations must report their prices to. No scraping of private websites, no API key, no login.

> Not affiliated with, endorsed by, or sponsored by any government, ministry or fuel brand. Data is re-published under the IODL 2.0 open-data licence (see [Data source & licence](#data-source--licence)).

### Which manual task does it replace?

Without this Actor, getting today's diesel prices for an area usually means one of two manual routines:

1. searching station by station on the ministry's consumer site (Osservaprezzi carburanti) and copying prices into a spreadsheet, or
2. downloading the ministry's two raw CSV files (station register + prices, ~23,000 stations), joining them by station ID, mapping the fuel names (“Gasolio”, “Blue Diesel”, “Hi-Q Diesel” …), filtering to your province or radius and sorting.

This Actor does steps 1–2 in one run and returns a ready table (JSON, CSV or Excel) with the price, the date the station last changed it, and the source attribution.

**Who saves what:** a fleet or transport office that checks Italian diesel prices for its depots or routes no longer has to search the ministry site or join two CSV files by hand – it schedules one run and opens the sorted table. *(Our estimate, based only on the steps removed above: roughly 10–20 minutes per manual check of one area. Not measured with customers – your time will depend on how you work today.)*

### Who is it for?

- **Road haulage, couriers and logistics companies** – see the cheapest diesel around each depot or along a route before drivers fill up.
- **Fleet managers (company cars, vans, service vehicles)** – check whether fuel-card prices are in line with the local market, using the official median of the area as a reference.
- **Anyone who calculates fuel costs** – transport quotes, mileage reimbursements, trip budgets or cost models that need a current, citable price per litre for a province.
- **Fuel retailers** – monitor the official prices of named competitor stations every day (`stationIds`).
- **Developers and AI agents (Apify API / MCP)** – “cheapest diesel within 15 km of these coordinates” in one call.

### What it does

- ⬇️ downloads the two official Italian CSV files for you (station register + prices),
- 🔗 joins them and normalises the fuel names to one set of codes (`diesel`, `diesel_premium`, `hvo`, `gasoline_95`, `lpg`, `cng`, `lng` …),
- 📍 filters by radius around coordinates (km), city, province, brand, motorway / non-motorway, or exact station IDs,
- 💶 ranks stations **cheapest-first** (or nearest-first),
- 🧾 outputs one row per station with every price, the date it was last updated, unit (EUR/L or EUR/kg) and the self-service flag,
- 📊 optionally builds a **price summary** for your area (min / p10 / median / mean / p90 / max per fuel) – handy as a reference price in cost calculations.

### Example usage

#### 1. Daily diesel check around a depot (fleet / logistics)

Cheapest diesel within 15 km of a depot near Bologna, motorway stations excluded, with an area summary:

```json
{ "countries": ["IT"], "latitude": 44.4949, "longitude": 11.3426, "radiusKm": 15, "fuelTypes": ["diesel"], "excludeMotorway": true, "maxResults": 20, "includeSummary": true }
```

Save it as a **Task**, add a **Schedule** (e.g. once every morning – the ministry publishes one file per day) and send the dataset to e-mail, Google Sheets or your own system via Apify integrations.

#### 2. Reference price for a fuel-cost calculation

Median and range of diesel prices in the province of Milan, to use as the price per litre in a quote or budget:

```json
{ "countries": ["IT"], "provinces": ["MI"], "fuelTypes": ["diesel"], "maxResults": 1, "includeSummary": true }
```

The `SUMMARY` record in the key-value store contains min / p10 / median / mean / p90 / max for the whole province; `maxResults: 1` keeps the station list (and cost) small.

#### 3. Cheapest diesel in the province of Rome

```json
{ "countries": ["IT"], "provinces": ["RM"], "fuelTypes": ["diesel"], "maxResults": 20 }
```

#### 4. LPG in Milan, no motorway stations

```json
{ "countries": ["IT"], "cities": ["Milano"], "fuelTypes": ["lpg"], "excludeMotorway": true, "maxResults": 20 }
```

#### 5. Monitor specific stations every day

Use `stationKey` values from a previous run:

```json
{ "countries": ["IT"], "stationIds": ["IT:59989", "IT:15617"] }
```

#### 6. Whole-country snapshot (~23,000 stations – mind the cost)

```json
{ "countries": ["IT"], "maxResults": 0 }
```

#### Calling it from code (Apify API)

```bash
curl -X POST "https://api.apify.com/v2/acts/shelly_fen~eu-fuel-prices-official/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" -H "Content-Type: application/json" \
  -d '{"countries":["IT"],"provinces":["RM"],"fuelTypes":["diesel"],"maxResults":20}'
```

### How to use it

1. Click **Try for free** / **Start**.
2. Keep **Countries = Italy** and set a location: latitude + longitude + radius, or cities / provinces (2-letter codes such as `RM`, `MI`, `TO`).
3. Choose one or more **fuel types** – the first one is used for cheapest-first sorting.
4. Set **Max stations** (each station is one billable result) and run.
5. Download the results as JSON, CSV, Excel, XML or HTML, or read them via the Apify API. Schedule the run daily to build your own price history.

#### Input fields

| Field | Type | Description |
|---|---|---|
| `countries` | array | Use `IT`. (`ES` is in the code but the Spanish feed is currently unreachable from Apify's cloud – see Limitations.) |
| `latitude`, `longitude` | number | Search centre in decimal degrees. |
| `radiusKm` | number | Radius around the centre (default 10 km when coordinates are set). |
| `cities` | array | Exact municipality name, case/accent-insensitive (`"Forlì"` = `"forli"`). |
| `provinces` | array | 2-letter Italian province code (`"RM"`, `"MI"`). |
| `stationIds` | array | Exact stations, `"IT:<id>"`. |
| `fuelTypes` | array | Keep stations selling at least one of these; first one = sort key. See fuel table. |
| `onlySelectedFuels` | boolean | Output only the selected fuels in `prices`. |
| `brands` | array | “Contains” match, e.g. `"Q8"`, `"Eni"`. |
| `motorwayOnly` / `excludeMotorway` | boolean | Motorway flag. |
| `maxPriceAgeDays` | integer | Drop prices whose last update is older than N days (0 = off). |
| `sortBy` | string | `auto` (default), `cheapest`, `nearest`, `none`. |
| `maxResults` | integer | Max stations to output. `0` = no limit. Default 100. |
| `includeSummary` | boolean | Save price statistics to the key-value store record `SUMMARY`. |

#### Fuel types

The Spain column is kept for reference only – the Spanish feed is currently not reachable from Apify's cloud (see Limitations).

| Code | Meaning | Unit | Spain | Italy |
|---|---|---|---|---|
| `diesel` | Diesel (B7) | EUR/L | ✅ Gasóleo A | ✅ Gasolio |
| `diesel_premium` | Premium / additive diesel | EUR/L | ✅ Gasóleo Premium | ✅ Blue/Supreme/Hi-Q Diesel… |
| `hvo` | HVO / renewable diesel (XTL) | EUR/L | ✅ Diésel Renovable | ✅ HVO / HVOlution… |
| `biodiesel` | Biodiesel | EUR/L | ✅ | — |
| `diesel_agricultural` | Agricultural diesel (Spain Gasoleo B) | EUR/L | ✅ Gasóleo B | — |
| `gasoline_95` | Unleaded 95 (E5) | EUR/L | ✅ Gasolina 95 E5 | ✅ Benzina |
| `gasoline_95_e10` | Unleaded 95 E10 | EUR/L | ✅ Gasolina 95 E10 | — |
| `gasoline_98` | Unleaded 98 (E5) | EUR/L | ✅ Gasolina 98 E5 | ✅ Benzina 98… |
| `gasoline_98_e10` | Unleaded 98 E10 | EUR/L | ✅ | — |
| `gasoline_premium` | Premium gasoline (branded 95+/100) | EUR/L | ✅ 95 E5 Premium | ✅ Blue Super, V-Power… |
| `gasoline_renewable` | Renewable gasoline | EUR/L | ✅ | — |
| `e85` | Bioethanol E85 | EUR/L | ✅ | — |
| `lpg` | LPG / Autogas | EUR/L | ✅ GLP | ✅ GPL |
| `cng` | CNG / compressed natural gas | EUR/kg | ✅ GNC | ✅ Metano, L-GNC |
| `lng` | LNG / liquefied natural gas | EUR/kg | ✅ GNL | ✅ GNL |
| `hydrogen` | Hydrogen | EUR/kg | ✅ | — |
| `adblue` | AdBlue | EUR/L | ✅ | — |

When several products of a station map to the same code (e.g. Italian self-service and attended diesel, or two premium diesels), the **cheapest** one is kept and its original name is in `sourceFuelName`.

### Output

One dataset item per station. The **Overview** table view shows rank, brand, city, distance and the selected fuel price; the **All prices** view shows every fuel.

Sample (real run on 2026-09-29, province of Rome, diesel – first rows):

| # | Country | Brand | City | Province | Diesel EUR/L |
|---|---|---|---|---|---|
| 1 | IT | Enerpetroli | Fiano Romano | RM | 1.379 |
| 2 | IT | Smaf | Roma | RM | 1.578 |
| 3 | IT | Independent | Roma | RM | 1.599 |
| 4 | IT | SPAZIO S.R.L. | Roma | RM | 1.603 |
| … | | | | | |
| 12 | IT | Esso | Roma | RM | 1.709 |

(The 1.379 at rank 1 is reproduced exactly as the station reported it – see the FAQ on outliers.)

Sample JSON item:

```json
{
  "rank": 12,
  "stationKey": "IT:59989",
  "country": "IT",
  "stationId": "59989",
  "brand": "Esso",
  "address": "V. Aurelia 2 00165",
  "postalCode": null,
  "city": "Roma",
  "province": "RM",
  "latitude": 41.899686,
  "longitude": 12.453199,
  "distanceKm": null,
  "roadType": "road",
  "open24h": null,
  "openingHours": null,
  "selectedFuel": "diesel",
  "selectedFuelPrice": 1.709,
  "selectedFuelUpdatedAt": "2026-09-25T21:59:04+02:00",
  "fuelsAvailable": [
    "diesel",
    "diesel_premium",
    "gasoline_95"
  ],
  "prices": {
    "gasoline_95": {
      "price": 1.709,
      "currency": "EUR",
      "unit": "L",
      "updatedAt": "2026-09-25T21:59:04+02:00",
      "sourceFuelName": "Benzina",
      "selfService": true
    },
    "diesel": {
      "price": 1.709,
      "currency": "EUR",
      "unit": "L",
      "updatedAt": "2026-09-25T21:59:04+02:00",
      "sourceFuelName": "Gasolio",
      "selfService": true
    },
    "diesel_premium": {
      "price": 1.919,
      "currency": "EUR",
      "unit": "L",
      "updatedAt": "2025-01-17T14:02:10+01:00",
      "sourceFuelName": "Supreme Diesel",
      "selfService": true
    }
  },
  "mapUrl": "https://www.openstreetmap.org/?mlat=41.899686&mlon=12.453199#map=17/41.899686/12.453199",
  "dataSource": "Ministero delle Imprese e del Made in Italy (MIMIT) - Osservaprezzi carburanti",
  "dataLicense": "IODL 2.0",
  "dataSourceUrl": "https://www.mimit.gov.it/images/exportCSV/prezzo_alle_8.csv",
  "sourceUpdatedAt": "2026-09-27T08:00:00+02:00",
  "scrapedAt": "2026-09-28T23:44:59+00:00"
}
```

#### Output fields

| Field | Description |
|---|---|
| `rank` | Position after sorting. |
| `stationKey` | Stable unique ID `"<COUNTRY>:<stationId>"` – use it for monitoring and joins. |
| `brand` | Chain brand. One-off station names are shown as `Independent` (see privacy). |
| `address`, `postalCode`, `city`, `province` | Location as published (`postalCode` is empty for Italy – the Italian registry has no postcodes). |
| `latitude`, `longitude`, `distanceKm`, `mapUrl` | Coordinates, distance from your centre, OpenStreetMap link. |
| `roadType` | `motorway` or `road` (Italy). |
| `open24h`, `openingHours` | As published (Spain only; empty for Italy). |
| `selectedFuel`, `selectedFuelPrice`, `selectedFuelUpdatedAt` | Convenience columns for the first selected fuel. |
| `prices` | Object keyed by fuel code: `price`, `currency`, `unit`, `updatedAt`, `sourceFuelName`, `selfService`. |
| `dataSource`, `dataLicense`, `dataSourceUrl`, `sourceUpdatedAt` | Attribution and freshness of the official feed. |
| `scrapedAt` | When this run fetched the data (UTC). |

Optional `SUMMARY` record (key-value store) – the Italian diesel part of the summary from the same 2026-09-29 run:

```json
{
  "matchedStations": 1317,
  "byCountryAndFuel": [
    {
      "country": "IT",
      "fuel": "diesel",
      "unit": "EUR/L",
      "stations": 1317,
      "min": 1.379,
      "p10": 2.299,
      "median": 2.379,
      "mean": 2.362,
      "p90": 2.428,
      "max": 2.699
    }
  ]
}
```

### How much does it cost?

This Actor uses **pay-per-event** pricing – you pay only for what you get, platform usage is included:

| Event | Price |
|---|---|
| Actor start | $0.005 per run (default 1 GB memory = one start event) |
| **Station with prices** (primary) | **$0.0001 per station** ($0.10 per 1,000 stations) |
| Price summary report (optional) | $0.01 per run, only if `includeSummary` is on |

Examples: the 20 cheapest stations in a province ≈ **$0.007**; a daily top-50 for one city ≈ **$0.30 per month**; a full snapshot of Italy (~23,000 stations) ≈ **$2.31**. Use **Max stations** and Apify's *Maximum cost per run* to cap spending – the Actor stops cleanly when your limit is reached.

### Data source & licence

| Country | Official source | Update frequency | Licence |
|---|---|---|---|
| 🇮🇹 Italy | Ministero delle Imprese e del Made in Italy (MIMIT) – Osservaprezzi carburanti open data | daily (prices in force at 08:00 the previous day) | IODL 2.0 |

Every item carries `dataSource`, `dataLicense`, `dataSourceUrl` and `sourceUpdatedAt` so you can meet the attribution requirement (“cite the source and the date of last update”) when you re-use the data, e.g. in a quote or report. Prices are not altered – only re-formatted.

### Privacy by design

The output contains **no personal data**. Operator/manager names published in the Italian registry and free-text station names (which can contain a sole trader's name) are never read into the output; a brand is shown only when it is a chain sign used by several stations, otherwise `Independent`.

### Limitations

- **Country:** Italy only at the moment. The code also contains a reader for Spain's official feed (Ministerio para la Transición Ecológica, CC BY 4.0), but that government server does not answer requests from Apify's cloud (last checked 2026-10-09), so Spain is **not** offered. Other countries are added only when their government publishes an open feed that permits automated re-use and it works from Apify.
- **Daily snapshot, not real time:** Italian prices are those in force at 08:00 the previous day, as published by the ministry.
- **No postcodes** in the Italian registry – use coordinates, cities or provinces.
- Prices are what stations report to the ministry. Typos or late reports at the source are reproduced as-is.
- No price history is stored by the Actor – schedule runs and keep the datasets to build history.
- If the ministry server is down, the run fails and no stations are charged (only the $0.005 start event).

### FAQ

**Is this legal? Where does the data come from?**
Yes. The Italian ministry publishes these prices as official open data for re-use, including commercial re-use, under IODL 2.0. The Actor downloads the official files once per run – it does not scrape consumer websites or apps.

**Why is my result empty?**
Usually the filters exclude everything: coordinates outside Italy, a radius too small, or a province written as a name instead of the 2-letter code (`"MI"`, not `"Milano"`). The run log tells you what was skipped and why.

**One station is much cheaper than all the others – is that real?**
Possibly not. Stations type their own prices into the ministry system and occasional typos happen. The Actor never changes official values; compare with the `SUMMARY` median or check `updatedAt`.

**What does `Independent` mean?**
The station's sign is not a chain brand (fewer than 3 stations nationally), or it is unbranded (“Pompe Bianche”). One-off names are hidden because they can be a person's name.

**How fresh are the prices?**
Daily. `prices.<fuel>.updatedAt` is the last change reported by the station and `sourceUpdatedAt` is the feed time. An old `updatedAt` does not mean the price is wrong – stations only report changes.

**Are prices per litre?**
Yes, EUR per litre, except CNG and LNG, which are EUR per kg (`unit` field).

**Can I get only self-service prices?**
The cheapest price per fuel is returned and `selfService` tells you whether it is a self-service price.

**How do I monitor my competitors or my usual stations every day?**
Run once with coordinates around your depot or station, copy the `stationKey` values you care about into `stationIds`, save as a Task and add a Schedule. Each run creates a new dataset.

**Is Spain or another country supported?**
Not at the moment (see Limitations). Feel free to request a country in the Issues tab.

**Can I use it from an AI agent / MCP client or via API?**
Yes – every Apify Actor can be called through the Apify API, the official JavaScript/Python clients and the Apify MCP server.

**I found a wrong price.**
Prices are reproduced exactly as published by the ministry. Please report errors at the source; if you believe the Actor transformed something incorrectly, open an Issue with the `stationKey` and your run ID.

### More from this author

- [England Property Planning Constraints Bulk Checker](https://apify.com/shelly_fen/england-planning-constraints-checker) — bulk yes/no flags for listed buildings, conservation areas, green belt, flood zones and more (England official open data).
- [Finland Port Calls & Vessel ETA Tracker](https://apify.com/shelly_fen/finland-port-calls-vessel-eta) — ETA/ETD and berth changes for Finnish ports (Fintraffic Digitraffic, CC BY 4.0).

### Further reading

- [SEO for Actors (Apify Help)](https://help.apify.com/en/articles/2644024-seo-for-actors)
- Italian open fuel prices (MIMIT): [osservatorioprezzi.mise.gov.it](https://www.osservatorioprezzi.mise.gov.it/)

# Changelog

This Actor's version history is a separate document: https://apify.com/shelly_fen/eu-fuel-prices-official/changelog.md

# Actor input Schema

## `countries` (type: `array`):

Official national feed to query. IT = Italy (daily snapshot of prices in force at 08:00 the previous day). ES = Spain is in the code but its government server currently does not answer requests from Apify's cloud, so runs with ES fail for Spain.

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

Decimal degrees, e.g. 40.4168 (Madrid). Use together with Longitude and Radius. Tip: right-click any point in OpenStreetMap or Google Maps to copy coordinates.

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

Decimal degrees, e.g. -3.7038.

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

Only used when coordinates are set. If omitted, 10 km.

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

Prefix match, e.g. "28" (whole province of Madrid) or "08001". Spain only (the Italian registry has no postcode).

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

Exact municipality name, case- and accent-insensitive, e.g. "Málaga", "Milano".

## `provinces` (type: `array`):

Italy: 2-letter province code ("RM", "MI"). (Spain: province name, currently unavailable.)

## `stationIds` (type: `array`):

Track exact stations using the stationKey from a previous run, e.g. "ES:4375", "IT:59183".

## `fuelTypes` (type: `array`):

Keep only stations selling at least one of these fuels. The FIRST fuel is used for cheapest-first sorting and for the selectedFuelPrice column.

## `onlySelectedFuels` (type: `boolean`):

If on, the prices object contains only the fuels chosen above (smaller output).

## `brands` (type: `array`):

e.g. "Repsol", "Ballenoil", "Q8", "Esso". Stations with a one-off name are labelled "Independent".

## `motorwayOnly` (type: `boolean`):

Only Italy flags motorway (autostrada) stations; Spanish stations are excluded when this is on.

## `excludeMotorway` (type: `boolean`):

Italian motorway stations are usually more expensive.

## `maxPriceAgeDays` (type: `integer`):

0 = no limit. Note: a price stays valid until the station reports a new one, so an old timestamp is not necessarily wrong (especially in Italy).

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

auto = cheapest (if a fuel is selected), else nearest (if coordinates are set), else source order.

## `maxResults` (type: `integer`):

Maximum number of stations to output (each is one billable result). 0 = no limit (Spain ~11,500, Italy ~24,000 stations).

## `includeSummary` (type: `boolean`):

Min / p10 / median / mean / p90 / max per country and fuel over ALL matching stations (not just the first Max stations). Saved to the key-value store record SUMMARY. Charged once per run.

## Actor input object example

```json
{
  "countries": [
    "IT"
  ],
  "provinces": [
    "RM"
  ],
  "fuelTypes": [
    "diesel"
  ],
  "onlySelectedFuels": false,
  "motorwayOnly": false,
  "excludeMotorway": false,
  "maxPriceAgeDays": 0,
  "sortBy": "auto",
  "maxResults": 20,
  "includeSummary": false
}
```

# Actor output Schema

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

No description

## `stationsFull` (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 = {
    "countries": [
        "IT"
    ],
    "provinces": [
        "RM"
    ],
    "fuelTypes": [
        "diesel"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shelly_fen/eu-fuel-prices-official").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 = {
    "countries": ["IT"],
    "provinces": ["RM"],
    "fuelTypes": ["diesel"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shelly_fen/eu-fuel-prices-official").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 '{
  "countries": [
    "IT"
  ],
  "provinces": [
    "RM"
  ],
  "fuelTypes": [
    "diesel"
  ],
  "maxResults": 20
}' |
apify call shelly_fen/eu-fuel-prices-official --silent --output-dataset

```

## MCP server setup

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

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/acawc3UxS4i1fDgML/builds/GI3DNA91xvBgqyOuA/openapi.json