# Italy Open Data Scraper - dati.gov.it CKAN Catalog (`parseforge/dati-gov-it-italy-open-data-scraper`) Actor

Scrape all 65,960 datasets from Italy's national open data portal dati.gov.it: full DCAT-AP\_IT metadata, distributions, 399 publishers, licences and live link checks.

- **URL**: https://apify.com/parseforge/dati-gov-it-italy-open-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Italy Open Data Scraper - dati.gov.it CKAN Catalog

**Scrape all 65,960 datasets on dati.gov.it, Italy's national open data portal, in one run.** Every row carries the complete DCAT-AP\_IT record: publishing organization, the data holder with its IPA code, EU themes, licence, update frequency, temporal and geographic coverage, and every downloadable file. No login, no API key. Export to CSV, JSON, Excel, or XML.

dati.gov.it is a CKAN catalog that harvests 328 regional, municipal and ministerial data portals, and its own search page renders results in the browser a page at a time. This reads the catalog API directly, filters on the fields the portal actually indexes, and returns each match as one flat row with 69 columns.

| Who uses it | What they scrape dati.gov.it for |
|---|---|
| Data engineers | A machine-readable index of every open dataset Italy publishes, refreshed on a schedule |
| GIS and geospatial teams | The 6,208 datasets with a spatial extent, their bounding boxes and their WMS, SHP and GeoJSON files |
| Civic tech and journalists | What each comune, regione and ministry publishes, and which of their links have gone dead |
| Researchers | Corpora filtered by theme, licence, publisher or date, with EuroVoc subthemes already resolved |
| Procurement and policy analysts | Which public bodies publish what, under which licence, and how often they promise to update it |

### What it does

This Actor reads the dati.gov.it CKAN catalog and returns each dataset as a flat row. Every dataset carries:

- 🧾 **Core fields:** title, description, slug, portal URL, publishing organization, national identifier and both metadata dates.
- 🇮🇹 **Italian DCAT-AP\_IT fields:** the *titolare del dato* with its IPA code, the DCAT publisher and creator, `conformsTo`, access rights and the source catalog the record was harvested from.
- 🏷️ **Classification:** EU data themes with English labels, EuroVoc subthemes, CKAN groups, tags, normalised licence code and update frequency.
- 🗺️ **Coverage:** temporal start and end, temporal resolution, geographic name, GeoNames link, spatial type and bounding box.
- 📦 **Files:** how many distributions, which formats, total size in bytes, and the primary download URL. Tick one box to get a full row per file.
- 🔗 **Optional live checks:** whether each file still downloads, and what the bytes actually are versus what the portal claims.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with Italy open data

**🗂️ Build a searchable index of Italian public data.**

Sweep the whole catalog once, then re-run filtered by `modifiedFrom` on a schedule to pick up only what changed. Every row has a stable `datasetId` and a portal URL.

**🗺️ Find the geospatial layers.**

Turn on **Geospatial datasets only** and filter formats to GeoJSON, Shapefile, GML or WMS. You get the bounding box and the service endpoint on the same row.

**🔍 Audit a public body's open data.**

Filter by organization slug or by data holder name, add the publisher profile, and you have every dataset that body publishes with its certified email, website and region.

**🧪 Check the catalog is telling the truth.**

Turn on the two live checks and the run reports which download links are dead and which files are not the format the metadata declares.

### Why choose this scraper

| | What you get |
|---|---|
| **69 columns per dataset** | The full DCAT-AP\_IT record flattened, not the raw CKAN package dumped into a cell. |
| **Filters measured against totals** | Every dropdown value was checked against the live catalog count, so nothing silently returns zero. |
| **Spelling variants folded in** | The portal writes CC BY 4.0 four ways and uses 92 format spellings. One choice matches all of them. |
| **Nine extra row types** | Distributions, organizations, themes, tags, licences, formats, data holders, publishers and source catalogs. |
| **Live link and byte checks** | Optional. The portal harvests 328 catalogs and never revalidates a link. |
| **Four export formats** | CSV, JSON, Excel, and XML, from the dashboard or the API. |

### How it compares

Two other Actors read dati.gov.it and both return the CKAN package roughly as it arrives, billed per item. The generic CKAN exporters do the same for any portal. The difference here is that the Italian-specific fields are parsed out rather than left nested, the filter vocabularies were measured against live counts instead of copied from the CKAN docs, and the two live checks exist at all.

| Feature | ParseForge | benthepythondev/italy-dati-gov-scraper | datapilot/open-data-portal-harvester | straightforward\_hydra/ckan-open-data-scraper |
|---|---|---|---|---|
| DCAT-AP\_IT fields parsed out (holder, IPA code, themes, EuroVoc) | Yes, 69 columns | Raw package | Raw package | Raw package |
| Filters verified against catalog totals | Yes, all of them | No | No | No |
| Licence and format spelling variants folded | Yes | No | No | No |
| Dead-link check on distributions | Optional | No | No | No |
| Byte probe: does the file match its declared format | Optional | No | No | No |
| Directory exports (holders, publishers, source catalogs) | 9 row types | No | No | No |
| Price per 1,000 rows | $7.00 | Not published | $2.00 | $2.00 |

The generic exporters are cheaper per row. If all you need is the raw CKAN package for one portal, use them. This one costs more because the row is parsed, the vocabularies are resolved, and the optional checks go out to the publishers' own servers.

### What a dataset looks like

```json
{
  "datasetId": "d74a05d3-8056-4291-91f9-34a8168c5b24",
  "name": "rilevazione-dei-prezzi-al-consumo-del-comune-di-firenze-del-2018-gennaio1",
  "url": "https://www.dati.gov.it/dataset/rilevazione-dei-prezzi-al-consumo-del-comune-di-firenze-del-2018-gennaio1",
  "title": "Rilevazione dei prezzi al consumo del Comune di Firenze del 2018 - Gennaio",
  "description": "Il dataset contiene i dati relativi alla rilevazione dei prezzi al consumo del Comune di Firenze del 2018 nel mese di gennaio. Il separatore delle risorse CSV è \";\" (lett. punto e virgola).",
  "organization": "regione-toscana",
  "organizationTitle": "Regione Toscana",
  "organizationId": "9bcd4050-eecd-400b-8196-cd4db7b38c58",
  "holderName": "Regione Toscana",
  "holderIdentifier": "r_toscan",
  "publisherName": "Comune di Firenze",
  "publisherIdentifier": "c_d612",
  "publisherUri": "Not Disclosed",
  "publisherEmail": "Not Disclosed",
  "creatorNames": ["Comune di Firenze - Direzione Generale -  Servizio Pianificazione, Controllo e Statistica"],
  "rightsHolder": "Not Disclosed",
  "themeCodes": ["SOCI"],
  "themeLabels": ["Population and society"],
  "subThemes": [],
  "groups": ["societa"],
  "groupTitles": ["Società"],
  "tags": ["08prezzi", "comune-firenze", "consumo", "finanze", "indici", "opendata", "prezzi"],
  "tagCount": 7,
  "licenceCode": "CC-BY-4.0",
  "licenceLabel": "Creative Commons Attribution 4.0",
  "licenceRaw": "Creative Commons Attribuzione 4.0 Internazionale (CC BY 4.0)",
  "licenceUrl": "Not Disclosed",
  "isOpenLicence": "No",
  "accessRights": "Not Disclosed",
  "updateFrequency": "NOT_PLANNED",
  "updateFrequencyLabel": "Not planned",
  "updateFrequencyRaw": "NOT_PLANNED",
  "language": "ITA",
  "nationalIdentifier": "c_d612:D.6052",
  "alternateIdentifiers": [],
  "conformsTo": ["http://dati.gov.it/onto/dcatapit#"],
  "issued": "2018-01-31",
  "modified": "2018-01-31",
  "metadataCreated": "2026-06-28T03:40:05.254742",
  "metadataModified": "2026-08-22T16:56:52.194367",
  "temporalStart": "2018-01-31",
  "temporalEnd": "Not Disclosed",
  "temporalResolution": "Not Disclosed",
  "geographicalName": "ITA_FLR",
  "geoNamesUrl": "https://www.geonames.org/6542285",
  "spatialType": "N/A",
  "boundingBox": "N/A",
  "contactName": "Comune di Firenze",
  "contactEmail": "opendata@comune.fi.it",
  "contactUri": "https://dati.toscana.it/organization/881795ff-b47f-4c85-923c-b67b2d86fd8d",
  "landingPage": "https://dati.toscana.it/dataset/rilevazione-dei-prezzi-al-consumo-del-comune-di-firenze-del-2018-gennaio#",
  "sourceUri": "https://dati.toscana.it/dataset/rilevazione-dei-prezzi-al-consumo-del-comune-di-firenze-del-2018-gennaio",
  "sourceCatalogTitle": "Not Disclosed",
  "sourceCatalogHomepage": "Not Disclosed",
  "sourceCatalogPublisher": "Not Disclosed",
  "sourceCatalogModified": "Not Disclosed",
  "sourceCatalogType": "Not Disclosed",
  "harvestSourceTitle": "Regione Toscana",
  "isNativeDataset": "No",
  "resourceCount": 1,
  "resourceFormats": ["CSV"],
  "hasMachineReadable": "Yes",
  "totalSizeBytes": 688,
  "primaryDownloadUrl": "https://data.comune.fi.it/datastore/download.php?id=6052&type=1&format=csv",
  "viewCount": "N/A",
  "downloadCount": "N/A",
  "searchCount": "N/A",
  "rowType": "dataset",
  "scrapedAt": "2026-08-27T16:15:56.950Z"
}
```

Fields the portal does not fill for a given dataset come back as `Not Disclosed`; fields that do not apply come back as `N/A`. Nothing is ever `null`.

### Configure the run

Leave everything empty and the Actor sweeps the whole catalog, most recently changed first. Add filters to narrow it, or paste dataset URLs to fetch specific records. Filters run in the portal's own index, so only matching datasets are read and billed. The Input tab lists every parameter.

Sweep the catalog for a theme and keep only datasets that ship a real data file:

```json
{ "themes": ["ambiente"], "formats": ["CSV", "JSON", "GeoJSON"], "maxItems": 2000 }
```

Everything one city publishes, with its files and the publisher profile:

```json
{ "organizations": ["comune-di-milano"], "includeResources": true, "includeOrganizationProfile": true, "maxItems": 5000 }
```

Audit the geospatial layers and check the downloads still work:

```json
{ "onlyGeospatial": true, "formats": ["SHP", "WMS", "GeoJSON"], "includeLinkCheck": true, "includeFileProbe": true, "maxItems": 300 }
```

### Pricing

Pay-per-event: **$0.007 per dataset**, plus $0.004 per catalog page read (one page covers 200 datasets) and a $0.054 run-start fee. Extra row types and the optional checks have their own prices and are charged only when they return something. You pay only for rows written to your dataset.

| Datasets collected | Approximate cost |
|---|---|
| 100 | $0.76 |
| 1,000 | $7.07 |
| 10,000 | $70.25 |

At higher monthly volume the per-row rate drops on Apify's usual tiers. New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 rows as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 rows per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Italy Open Data Scraper](https://apify.com/parseforge/dati-gov-it-italy-open-data-scraper?fpr=vmoqkp).
3. Pick your `themes`, `organizations` or `formats`, set `maxItems`, tick any extra row types, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Italy's open data catalog through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/dati-gov-it-italy-open-data-scraper"
```

Then prompt it in plain language:

- *"Find Italian open datasets about air quality published as CSV and list who publishes them."*
- *"List every dataset the Comune di Milano publishes with a CC BY licence, newest first."*
- *"Pull the geospatial datasets from Regione Toscana and tell me which download links are dead."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/dati-gov-it-italy-open-data-scraper" to search Italy's national open data catalog dati.gov.it. Input: { "searchTerms": ["<keyword>"], "themes": ["<governo|ambiente|salute|trasporti|...>"], "organizations": ["<slug>"], "formats": ["CSV"], "maxItems": <n> }. It returns title, url, organization, holderName, themeLabels, licenceLabel, updateFrequencyLabel, resourceCount, resourceFormats and primaryDownloadUrl per dataset. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

A filter value the portal does not know returns zero rows rather than an error. Organization slugs, holder names, publisher names and source catalog titles must match exactly; run the matching directory box once to see the real values with their counts.

**Why fewer rows than I asked for?**

`maxItems` is a cap on total rows, not on datasets. If you also ticked distribution rows or a directory, they draw from the same budget. Directories are collected smallest first, so tags, which run to thousands of values, take whatever is left.

**Why is a field empty?**

`Not Disclosed` means the publisher did not fill that DCAT field, and `N/A` means it does not apply to that record. Both are the record's real state. `isOpenLicence` says `No` on most rows because the portal's own open flag is set on only 4,026 of 65,960 datasets even though 61,448 carry a CC BY licence; use the `licenceCode` column instead.

**Why is a download link reported dead?**

The portal harvests metadata from 328 separate catalogs and never revalidates the URLs. Some publishers' servers are also firewalled against non-Italian traffic, which the check reports as a timeout rather than an HTTP error.

**Why is the run slow?**

The catalog API answers a 200-dataset page in about eight seconds, so a full sweep of 65,960 datasets is bounded by paging. The two optional live checks go out to the publishers' own servers and are much slower than the catalog itself; raise `maxItems` gradually or lower `maxResourcesPerDataset`.

### FAQ

| Question | Answer |
|---|---|
| Do I need an account or API key for dati.gov.it? | No. The catalog API is open and anonymous, and this Actor uses no proxy. |
| How many datasets are there? | 65,960 as of 27 August 2026, from 447 registered organizations and 328 source catalogs. |
| What is the difference between organization and data holder? | The organization is the account that published the record on the portal, usually a region. The *titolare del dato* is the body legally responsible for the data, often a single comune. There are 1,763 holders against 447 organizations. |
| Can I get the actual data files, not just the metadata? | The rows give you every download URL. Tick the byte probe to also get each file's real type, delimiter and column headers without downloading it whole. |
| Can I filter by region or province? | Not directly: the portal has no region filter. Filter by organization slug, or turn on the organizations directory, which carries the Italian region for 364 of 447 bodies. |
| Why do some formats appear twice in the formats directory? | The index is case sensitive and the catalog stores 92 spellings for about 34 real formats. `GML` matches 1,521 datasets and `gml` another 92. The format filter folds them together for you. |
| Can I run a raw CKAN query? | Yes. `customFilterQuery` takes a Solr `fq` clause and is ANDed with the other filters. |
| How many rows per run? | Free plan: 10. Paid: up to 1,000,000, bounded by what the catalog and your filters return. |
| Is this an official AgID product? | No. It is unofficial and reads only the public dati.gov.it catalog API. |

### Related actors

- [GovData Germany Scraper](https://apify.com/parseforge/govdata-germany-scraper?fpr=vmoqkp): 156,000+ German datasets from the DCAT-AP.de CKAN portal.
- [Spain datos.gob.es Catalog Scraper](https://apify.com/parseforge/spain-datos-gob-es-catalog-scraper?fpr=vmoqkp): the Spanish national open data catalog.
- [EU Open Data Portal Scraper](https://apify.com/parseforge/euopendata-datasets-scraper?fpr=vmoqkp): datasets published by the EU institutions.
- [ANAC Italy Public Procurement Scraper](https://apify.com/parseforge/anac-italy-procurement-scraper?fpr=vmoqkp): Italian tenders and awards from the ANAC catalog.
- [TED Europa Tenders Scraper](https://apify.com/parseforge/ted-europa-tenders-scraper?fpr=vmoqkp): EU public procurement notices from TED.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by AgID or the Italian government. It collects only publicly available dati.gov.it catalog metadata. You are responsible for using the data in compliance with the portal's terms, the licence on each dataset, and applicable laws including GDPR, CCPA, and PIPL. Do not use it to identify, profile, or target individuals.

# Actor input Schema

## `searchTerms` (type: `array`):

Free-text queries run against the whole catalogue (title, description, tags). Italian works best: bilancio, turismo, mobilita. Leave empty to sweep every dataset.

## `startUrls` (type: `array`):

Specific dati.gov.it dataset pages, for example https://www.dati.gov.it/dataset/zone-turistiche-citta-metropolitana-di-firenze. When you supply these, only these datasets are scraped and the filters below are ignored.

## `datasetSlugs` (type: `array`):

CKAN dataset names or UUIDs, one per line. Same effect as Dataset URLs, without the URL.

## `maxItems` (type: `integer`):

Free users: limited to 10 items (preview). Paid users: up to 1,000,000.

## `themes` (type: `array`):

EU data themes as dati.gov.it groups them. Counts on 2026-08-27: governo 31,664 | societa 9,833 | economia 6,609 | ambiente 5,860 | cultura 4,356 | regioni 3,824 | trasporti 2,162 | scienza 1,576 | salute 1,162 | agricoltura 795 | giustizia 763 | energia 297 | internazionali 56.

## `organizations` (type: `array`):

Publishing body slugs, one per line, for example regione-toscana, comune-di-milano, inps, ministero-dell-economia-e-delle-finanze. 447 are registered and 399 have at least one dataset; tick 'Organizations directory' below to export the full list with dataset counts.

## `holderNames` (type: `array`):

Exact holder names, one per line, for example Comune di Milano or Istituto Nazionale Previdenza Sociale. The holder is the body legally responsible for the data and is often narrower than the publishing organization. 1,763 exist.

## `publisherNames` (type: `array`):

Exact DCAT publisher names, one per line. Populated on about 95 percent of datasets and often names a department rather than the whole body.

## `sourceCatalogs` (type: `array`):

The regional or municipal portal a dataset was harvested from, exact title, for example Open Data Veneto or MEF OpenBDAP. 328 feed the national catalogue.

## `formats` (type: `array`):

Keep only datasets that publish at least one file in these formats. Each choice expands to every spelling the catalogue really uses, because the index is case sensitive (GML matches 1,521 datasets and gml another 92).

## `licences` (type: `array`):

Each choice expands to every spelling the portal stores for that licence. CC BY 4.0 alone is recorded four different ways and covers 61,448 datasets.

## `updateFrequencies` (type: `array`):

DCAT accrual periodicity. The portal stores 44 different spellings for about 20 real frequencies (NOT\_PLANNED and NOTPLANNED are the same thing and are counted separately upstream); each choice here matches all of them.

## `tags` (type: `array`):

Keyword tags exactly as the portal stores them, one per line, for example turismo or popolazione. Tick 'Tags directory' below to export the tag list with counts.

## `language` (type: `string`):

ISO 639-3 code recorded on the dataset. Each choice matches every spelling the portal stores, including the multi-language ones: Italian 48,398 datasets, German 274, English 138, Spanish 5.

## `minResources` (type: `integer`):

Keep only datasets that ship at least this many distributions. 9,413 datasets have 5 or more.

## `modifiedFrom` (type: `string`):

Only datasets whose catalogue record changed on or after this date (YYYY-MM-DD). 60,030 changed during 2026.

## `modifiedTo` (type: `string`):

Only datasets whose catalogue record changed on or before this date (YYYY-MM-DD).

## `createdFrom` (type: `string`):

Only datasets first indexed on dati.gov.it on or after this date (YYYY-MM-DD).

## `createdTo` (type: `string`):

Only datasets first indexed on dati.gov.it on or before this date (YYYY-MM-DD).

## `issuedFrom` (type: `string`):

The publisher's own issue date, not the harvest date (YYYY-MM-DD). Populated on 92 percent of datasets.

## `issuedTo` (type: `string`):

Upper bound for the publisher's own issue date (YYYY-MM-DD).

## `onlyGeospatial` (type: `boolean`):

Keep only the 6,208 datasets that carry a spatial extent, which is what fills the boundingBox column.

## `onlyNativeDatasets` (type: `boolean`):

Keep only the 598 datasets loaded straight into the national portal instead of harvested from a regional catalogue.

## `onlyOpenLicence` (type: `boolean`):

Keep only the 4,026 datasets the portal itself flags as open. Note this flag is under-populated upstream: 61,448 datasets carry a CC BY 4.0 licence but only 4,026 have the flag set, so the Licences filter is usually the better tool.

## `customFilterQuery` (type: `string`):

Raw CKAN fq clause ANDed with everything above, for example res\_format:PARQUET AND -organization:regione-toscana. A field name that does not exist returns zero rows rather than an error.

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

Only these four orders plus relevance actually work upstream; any other value is silently ignored by the portal and falls back to relevance.

## `includeResources` (type: `boolean`):

Emit one extra row per downloadable file, with its own URL, format, size, checksum and licence. Datasets average 2.4 files each.

## `includeOrganizations` (type: `boolean`):

Emit one row for each of the 447 registered publishing bodies with its IPA code, certified email, website, Italian region and dataset count.

## `includeThemes` (type: `boolean`):

Emit the 13 EU data themes with their Italian names and dataset counts.

## `includeTags` (type: `boolean`):

Emit the keyword tags used by the datasets that match your filters, with counts.

## `includeLicences` (type: `boolean`):

Emit every licence string in the matched result set with its normalised code and dataset count.

## `includeFormats` (type: `boolean`):

Emit all 92 format spellings with their canonical name, machine-readable flag and dataset count.

## `includeHolders` (type: `boolean`):

Emit the 1,763 bodies legally responsible for the data (titolare del dato), with dataset counts.

## `includePublishers` (type: `boolean`):

Emit the 1,452 DCAT publisher names in the matched result set, with dataset counts.

## `includeSourceCatalogs` (type: `boolean`):

Emit the 328 regional and municipal portals that feed dati.gov.it, with how many datasets each one contributes.

## `includeLinkCheck` (type: `boolean`):

Request each distribution and record the HTTP status, redirect target, content type and size. dati.gov.it harvests 328 catalogues and never revalidates the links; in a 193-file sample 14 percent were unreachable.

## `includeFileProbe` (type: `boolean`):

Download the first 64 KB of each distribution and report what the bytes really are, the CSV delimiter and the column headers. The declared format is often wrong: the first file checked in research was declared CSV and turned out to be a ZIP.

## `includeOrganizationProfile` (type: `boolean`):

Add the publishing body's IPA code, contact email, telephone, website and region to every dataset row. Each organization is fetched once and reused.

## `maxResourcesPerDataset` (type: `integer`):

Upper bound on how many distributions the two checks above touch per dataset. Only used when one of them is on.

## Actor input object example

```json
{
  "searchTerms": [],
  "startUrls": [],
  "datasetSlugs": [],
  "maxItems": 10,
  "themes": [],
  "organizations": [],
  "holderNames": [],
  "publisherNames": [],
  "sourceCatalogs": [],
  "formats": [],
  "licences": [],
  "updateFrequencies": [],
  "tags": [],
  "language": "any",
  "onlyGeospatial": false,
  "onlyNativeDatasets": false,
  "onlyOpenLicence": false,
  "sortBy": "metadata_modified desc",
  "includeResources": false,
  "includeOrganizations": false,
  "includeThemes": false,
  "includeTags": false,
  "includeLicences": false,
  "includeFormats": false,
  "includeHolders": false,
  "includePublishers": false,
  "includeSourceCatalogs": false,
  "includeLinkCheck": false,
  "includeFileProbe": false,
  "includeOrganizationProfile": false,
  "maxResourcesPerDataset": 5
}
```

# Actor output Schema

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

No description

## `csv` (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 = {
    "searchTerms": [],
    "startUrls": [],
    "datasetSlugs": [],
    "maxItems": 10,
    "themes": [],
    "organizations": [],
    "holderNames": [],
    "publisherNames": [],
    "sourceCatalogs": [],
    "formats": [],
    "licences": [],
    "updateFrequencies": [],
    "tags": [],
    "sortBy": "metadata_modified desc",
    "maxResourcesPerDataset": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/dati-gov-it-italy-open-data-scraper").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 = {
    "searchTerms": [],
    "startUrls": [],
    "datasetSlugs": [],
    "maxItems": 10,
    "themes": [],
    "organizations": [],
    "holderNames": [],
    "publisherNames": [],
    "sourceCatalogs": [],
    "formats": [],
    "licences": [],
    "updateFrequencies": [],
    "tags": [],
    "sortBy": "metadata_modified desc",
    "maxResourcesPerDataset": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/dati-gov-it-italy-open-data-scraper").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 '{
  "searchTerms": [],
  "startUrls": [],
  "datasetSlugs": [],
  "maxItems": 10,
  "themes": [],
  "organizations": [],
  "holderNames": [],
  "publisherNames": [],
  "sourceCatalogs": [],
  "formats": [],
  "licences": [],
  "updateFrequencies": [],
  "tags": [],
  "sortBy": "metadata_modified desc",
  "maxResourcesPerDataset": 5
}' |
apify call parseforge/dati-gov-it-italy-open-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/dati-gov-it-italy-open-data-scraper"
        }
    }
}

```

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/mFh8ri33clPr5R4I8/builds/MSJbvdJGDhwquQKDF/openapi.json