# Italy Fuel Station Registry - MIMIT (`nexgensignal/it-fuel-station-registry-records`) Actor

Italy MIMIT (Osservaprezzi Carburanti) active fuel-station registry as clean per-record data - id, brand, type, name, address, municipality, province, coordinates. Operator (Gestore) dropped. IODL 2.0. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/it-fuel-station-registry-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 station 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?

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 Station Registry - MIMIT

Italy's active fuel-station registry from MIMIT's Osservaprezzi Carburanti as clean, per-station records - id, brand, type, name, address, municipality, province and coordinates. The operator field (often a person) is dropped.

### 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 active fuel station: the station id, brand (Bandiera), station type, station name, street address, municipality, province and decimal coordinates.

### Sample output

![Sample output — Italy Fuel Station Registry - MIMIT](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/it-fuel-station-registry-records.png)

*Real rows from a live run of this actor (first 5 rows, selected columns).*

One full record from the same run, exactly as delivered:

```json
{
  "station_id": "59183",
  "brand": "Agip Eni",
  "station_type": "Stradale",
  "station_name": "19829 AGRIGENTO",
  "address": "SS.189 KM. 64+649 - C.DA SAN MICHELE  S.N.C",
  "municipality": "AGRIGENTO",
  "province": "AG",
  "latitude": 37.333935,
  "longitude": 13.595533,
  "record_id": "59183",
  "source": "MIMIT - Ministero delle Imprese e del Made in Italy (Osservaprezzi Carburanti)",
  "source_dataset": "anagrafica_impianti_attivi.csv",
  "licence": "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).",
  "attribution": "MIMIT - Ministero delle Imprese e del Made in Italy (Osservaprezzi Carburanti)",
  "caveat": "One record per active Italian fuel station from the MIMIT daily registry: station id, brand (Bandiera), station type, station name, address, municipality, province and coordinates. The operator field (Gestore) - which is often a natural person or sole trader - is structurally dropped and never emitted. Join station id to the fuel-price cell for prices.",
  "observed_at": "2026-09-25T17:23:58Z"
}
```

### Coverage and volume

The registry holds about 23,976 active stations - measured at build time from the downloaded CSV.

**Sol's Wave-4 index put this door at 23,975 EXACT; measured live at build time the registry holds 23,976 active stations - 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

The source carries an operator field (Gestore) that is often a natural person or sole trader. This Actor structurally drops Gestore - it is never read or emitted - and a per-record assertion rejects any operator/person field (verified with a planted-field test). The brand and station name are business attributes; the address locates the station, not a person.

### Interpretation caveat

One record per active Italian fuel station from the MIMIT daily registry: station id, brand, station type, station name, address, municipality, province and coordinates. The operator field (Gestore) is dropped.

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`, `brand`, `station_type`, `station_name`, `address`, `municipality`, `province`, `latitude` and `longitude`, keyed on the station id. The provenance block closes every record.

### Typical uses

Station-roster and mapping teams use this cell as the located registry of Italian fuel stations - id, brand and coordinates - ready to map or to enrich a price feed. 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.

### The dimension table

This cell is the slow-moving companion to the price feed: one row per active station rather than one row per
price. That separation is deliberate. The station attributes - brand, type, name, address, municipality,
province and coordinates - change rarely, so repeating them on every price observation would bloat the price
feed for no gain. Keeping them here, keyed on the station id, means the price cell stays lean and this cell
serves as the located roster you join to whenever you need a station's name, brand or position on a map.

### Why Gestore is dropped

The source registry includes a `Gestore` (operator) column, which for the many independent and franchise
stations in Italy is frequently a natural person or a sole trader's name rather than a company. Because that is
personal data, this Actor **never reads or emits it** - it is not named in the field map, and a per-record
assertion rejects it if the source schema ever changed. Everything the cell does deliver is a business or
geographic attribute: the brand (Bandiera) is the fuel marque, the station name and address locate the site,
and the coordinates put it on a map. The result is a clean, redistributable roster with no operator identity.

### Mapping and enrichment

Because `latitude` and `longitude` are real numbers, the roster drops straight into a GIS or a map without
geocoding, and the `municipality`/`province` fields let you aggregate to administrative areas. Joined to the
price feed on the station id, it turns a stream of bare price observations into located, branded price points -
the basis for a coverage map, a brand price comparison, or a catchment analysis. The registry refreshes daily,
so an occasional scheduled run keeps the roster current as stations open or close.

### Sibling Actors

It sits beside the fuel-price observation cell (same MIMIT index, the price fact 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 station registry 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-station-registry-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-station-registry-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-station-registry-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/it-fuel-station-registry-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/YygPUdStsyqxoXu1a/builds/unDz3PKFuDUfQvaxY/openapi.json