# Italy Fuel Price Observations - MIMIT, Per Observation (`nexgensignal/it-fuel-price-observation-records`) Actor

Italy MIMIT (Osservaprezzi Carburanti) daily fuel-price observations as clean per-record data - station id, fuel type, price, self-service flag and timestamp. Joins to the station registry. IODL 2.0. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/it-fuel-price-observation-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 fuel price records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Italy Fuel Price Observations - MIMIT, Per Observation

Italy's daily fuel-price observations from MIMIT's Osservaprezzi Carburanti as clean, per-observation records - one row per station-fuel-time, with the self-service flag as a real boolean.

### What one record represents

The source is **MIMIT** (the Italian Ministry of Enterprises and Made in Italy), Osservaprezzi Carburanti,
published as a **daily open-data CSV** at `www.mimit.gov.it`. Each record is one price observation: the station id, the fuel type, the price in euro per litre, whether it is the self-service price, and the timestamp the station reported it.

### Coverage and volume

The daily extract holds about 93,036 price observations - measured at build time from the downloaded CSV.

**Sol's Wave-4 index put this door at 93,035 EXACT; measured live at build time the daily extract holds 93,036 observations - the live figure is what this listing quotes.**

The Actor downloads the daily CSV, skips its one-line extraction preamble, reads the header row and delivers
each data row, stopping as soon as your **Maximum records** cap is met.

### Licence and attribution

The data is released under the **Italian Open Data Licence 2.0 (IODL 2.0)**. The full notice travels on every
record:

> Italian Open Data Licence 2.0 (IODL 2.0): free to consult, extract, download, copy, distribute, transmit and adapt the data, including for commercial purposes, provided the source is acknowledged (MIMIT - Osservaprezzi Carburanti).

### Person-data policy

This is a price feed and carries no personal data. Only station id, fuel type, price, the self-service flag and the timestamp are emitted; a per-record assertion rejects any operator/person field (verified with a planted-field test).

### Interpretation caveat

One record per fuel-price observation from the MIMIT daily open-data extract: station id, fuel type, price (EUR/litre), self-service flag and the reporting timestamp. Prices are the stations' own reported values.

Values are reproduced verbatim from the CSV; the Actor never rewrites a field. The two MIMIT cells share the
station id (`idImpianto`), so you can join prices to stations and back.

### Provenance and compliance

Every run reads the door host's `robots.txt` at runtime; the gate result (URL, status, byte length, SHA-256
of the policy) is written to the run's `RUN_RECEIPT`, and the data path is confirmed permitted before any
fetch. The endpoint is keyless. The Actor never bypasses a block or fetches through a mirror.

### Data quality and freshness

Boolean columns are delivered as real booleans and numeric columns as real numbers. Delivery is keyed on a
stable composite id, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live door,
so the data is as fresh as the source publishes, and each record's `observed_at` stamp dates the snapshot. The
run's `RUN_RECEIPT` records the source URL and how many records were delivered and charged, and confirms
`charge_equals_delivered`.

### Billing and delivery

Pricing is per record: you are billed only for records the Actor actually delivers, at a flat rate, with the
charge raised after each record is pushed (push-then-charge), so a failed or empty run costs nothing. There is
no subscription and no minimum. The **Maximum records** cap bounds every run, so you control the spend
precisely - set it low to sample the shape of the data cheaply, then raise it once you have confirmed the cell
fits your use. Because delivery is incremental and keyed on a stable id, re-running against the same door and
upserting on that id keeps a downstream table current without re-paying for rows you already hold; only the new
and changed records add cost. Every run's receipt reconciles delivered against charged, so the billing is
auditable against the data you received.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A tabular
overview surfaces the leading fields.

### Fields in detail

The record carries `station_id`, `fuel_type`, `price`, the boolean `is_self_service` and `reported_at`, keyed on station-fuel-time. The provenance block closes every record.

### Typical uses

Fuel-price monitoring teams use this cell to track pump prices across Italy - one row per station-fuel-time, ready to chart price movements or compare self-service against served prices. Because both MIMIT cells key on the station id, a single join gives you priced, located
stations; a scheduled daily run keeps the pair current, and each record's `observed_at` stamp dates the
snapshot.

### The two-cell design

MIMIT publishes prices and the station roster as two separate daily extracts, and this fleet mirrors that: the
price cell is a fast-moving observation feed (one row per station-fuel-time), and the station cell is a slow
dimension table (one row per active station). Keeping them separate means the price feed stays lean and the
station attributes are not repeated on every price row; the station id joins them whenever you need both. Run
the price cell daily for the moving series and the station cell occasionally to refresh the roster.

### Scaling and limits

Set **Maximum records** low to sample or high to pull the full extract. The Actor streams the CSV and delivers
incrementally, so memory stays flat and you are billed only for what is delivered. Both extracts refresh daily,
so a scheduled run keeps a downstream table current; each record's `observed_at` stamp dates the snapshot.

### How the daily extract works

MIMIT republishes the price extract every day as a single CSV, with a one-line "Estrazione del <date>"
preamble above the header row. The Actor handles that preamble automatically, reads the header, and maps each
data row by column name, so a change in column order at the source would not misalign the output. Each row is
one station's price for one fuel at the moment it reported, which is why the natural key is station-fuel-time:
the same station reports several fuels, and its prices change day to day. Delivering at that grain keeps the
series faithful to how the ministry publishes it, and lets you reconstruct a price history by stacking daily
runs.

### Prices, fuels and the self-service flag

`price` is the pump price in euro per litre, exactly as the station reported it - the Actor does not round or
convert. `fuel_type` is the ministry's own description (Benzina, Gasolio, GPL, Metano and so on), so a
group-by on it gives the price distribution per fuel. `is_self_service` separates the self-service price from
the served price, which for the same station and fuel can differ; keeping it as a real boolean lets you compare
the two directly. Because the observation carries its own timestamp and the station id, the record joins to the
station registry for location and brand and stacks cleanly into a time series.

### Building a price history

A single run captures one day's snapshot. To build a history, schedule a daily run and append - each record's
`observed_at` and the source `reported_at` date the observation, and the station-fuel key lets you follow a
single pump over time. Because the price feed is lean (no station attributes repeated on each row), even a
multi-month history stays compact, and the join to the station registry adds name, brand and coordinates only
where you need them.

### Sibling Actors

It sits beside the fuel-station registry cell (same MIMIT index, the station dimension table); the two join on the station id. It shares its CSV engineering with the fleet's other records Actors.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered Italy fuel price observation record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/it-fuel-price-observation-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/it-fuel-price-observation-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/it-fuel-price-observation-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/it-fuel-price-observation-records"
        }
    }
}
```

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/lom0owtqcAef7ried/builds/3DvnwQhvYrsBwHuUl/openapi.json