# Romania Open Data Scraper - data.gov.ro API (`parseforge/data-gov-ro-romania-open-data-scraper`) Actor

Scrape all 5,227 datasets, 13,000+ files, 180 publishers and 5,753 SQL tables from data.gov.ro, with link-rot status and Five Stars openness scores.

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

## Pricing

from $6.23 / 1,000 datasets

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

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

### Romania Open Data Portal Scraper - data.gov.ro API

**Scrape all 5,227 datasets, about 61,000 files, 180 publishing institutions and 5,753 queryable SQL tables from data.gov.ro, Romania's national open data portal.** Every row carries the full catalogue record: Romanian title and description, publisher, author and maintainer with email addresses, licence, tags, user rating, and every file with its format, byte size, download URL and dates. No login, no API key, no registration. Export to CSV, JSON, Excel or XML.

Romania's portal already knows which of its files are dead and how open each one is, but it never shows you: it hides both behind a Python `repr()` string that no JSON parser will read. This scraper decodes it, so every row tells you whether the file still downloads and what it scores on Tim Berners-Lee's Five Stars scale. That turns a catalogue dump into a **broken link checker** for an entire government: across a 13,154-file sample, **7.3% of published files no longer download**.

| Who uses it | What they scrape data.gov.ro for |
|---|---|
| Civic tech and transparency NGOs | Auditing which public institutions actually publish, and which publish dead links |
| Data journalists | Budget execution, procurement plans, employment and health datasets across 180 institutions |
| Open data researchers | Measuring portal quality: format mix, licence coverage, Five Stars openness, update staleness |
| Government and EU consultants | Benchmarking Romanian compliance against open data and high-value-dataset rules |
| Data engineers | Building a mirror or an ETL feed of Romanian public data with checksums and stable IDs |

### What it does

- 📚 **Nine collections in one Actor** - datasets, files, contacts, organizations, categories, tags, licences, showcases and DataStore tables, each with its own row shape.
- 🔗 **Broken link status on every file** - the portal archiver's own verdict: broken flag, status text, failure reason, failure count, first failure, last success, redirect target, ETag and cached copy URL.
- ⭐ **Five Stars openness scores** - the openness grade per file with the reason text and the format the portal actually detected inside the file, which often differs from the declared one.
- 🗄️ **Live SQL tables** - 5,753 DataStore tables with real column names, PostgreSQL column types, exact row counts and preview rows read straight out of the database.
- 👤 **Contacts with emails** - dataset authors and maintainers with their institutional email addresses, deduplicated across the run.
- 📈 **View counts and revision history** - total and recent page views, plus the last 25 changes with timestamps.
- 🧮 **Computed on every dataset** - format list, total byte size, archived and broken file counts, best openness score, days since last update and a staleness flag.
- 🔎 **17 search filters** - publisher, category, format, licence, tags, author, title, description, date ranges, minimum files, minimum tags, minimum rating, open licence only, has a queryable table, has a broken link and minimum openness score.

### What you can do with Romania open data

**Audit an institution's data quality.** Filter to one ministry, tick the archive status block, and get every file it publishes with a live/dead verdict and a failure reason. The Agenția Națională de Administrare Fiscală's 2025 performance report is filed as XML and points at a PDF the archiver rejected outright with "Invalid url scheme" - that is the sort of thing a catalogue listing never surfaces.

**Build a national procurement or budget dataset.** Ministerul Dezvoltării alone publishes 1,458 datasets, most of them monthly payment and procurement files. Filter by publisher and format, take the resources collection, and you get direct download URLs with checksums and byte sizes, ready to fetch.

**Measure open data compliance.** 5,030 of 5,227 datasets carry an open licence, but the Five Stars scores tell a harsher story: across 12,358 scored files the average is 0.99 and **not one file on the portal scores above 3**. Tag filters like `HVD` and `regulamentHVD` isolate the high-value datasets the EU regulation asks for.

**Feed an AI agent or a search index.** Every row has stable IDs, a portal URL, the Romanian description and a clean format list, so it drops straight into a vector store or a RAG pipeline without a second cleaning pass.

### Why choose this scraper

| | What you get |
|---|---|
| Reaches the portal at all | data.gov.ro silently drops US traffic. Runs from a US cloud IP time out with no error and return zero rows. This Actor routes through a Romanian residential IP automatically. |
| Decodes what others skip | Archiver and openness data is stored as a Python 2 `repr()` string. The parser handled 13,154 of 13,154 archiver blocks and 12,358 of 12,358 openness blocks with zero failures. |
| Filters that actually filter | Every filter was measured against the unfiltered 5,227. A wrong field name silently returns 0 rows on this portal, and `res_format:CSV` returns 0 while `csv` returns 362, so formats are OR-expanded across all 64 spellings the portal uses. |
| Nine row types, one Actor | Datasets, files, contacts, publishers, categories, tags, licences, showcases and SQL tables, instead of one flat dump. |
| Pay only for what returns | Optional blocks are billed only when they actually return data. A dataset with no DataStore table is never charged for a schema lookup. |
| Free-plan preview | 10 rows on the free plan, so you can check the shape before paying. |

### How it compares

No Actor on the Apify Store targets data.gov.ro. The alternatives are generic CKAN harvesters you point at any portal, and they run into two walls here. First, they run from Apify's US datacenter IPs, and this portal drops US traffic outright - measured: a direct request from the container times out, a Romanian residential IP answers in 1.4 seconds. Second, they pass CKAN's JSON straight through, so the archiver and openness fields arrive as an unparsed Python string. This Actor is roughly 3.5x their per-row price, and what that buys is a route that reaches the portal, the decoded quality data, and nine row shapes instead of one.

| | This Actor | Generic CKAN harvesters | data.gov.ro website |
|---|---|---|---|
| Price per 1,000 datasets | $7.00 | about $2.00 | free |
| Reaches data.gov.ro from Apify | Yes, Romanian residential route | No, US egress is dropped | n/a |
| Broken link status per file | Yes, decoded | Raw Python string | Not shown |
| Five Stars openness score | Yes, decoded | Raw Python string | Not shown |
| DataStore column types and row counts | Yes | Sometimes | Preview only |
| Contacts with emails | Yes, deduplicated | No | One dataset at a time |
| Row types | 9 | 1 | n/a |

### What a dataset looks like

One real row from a verified run, unedited:

```json
{
  "datasetId": "76e2d469-b04a-40ca-893e-898165b426f4",
  "datasetName": "raport-de-performanta-anaf-2025",
  "title": "Raport de performanță ANAF 2025",
  "datasetUrl": "https://data.gov.ro/dataset/raport-de-performanta-anaf-2025",
  "notes": "Principalele realizări, colectarea veniturilor bugetare, îmbunătățirea serviciilor oferite, soluții digitale integrate, prevenirea si combaterea evaziunii fiscale, eficiență și transparență.",
  "organizationName": "agentia-nationala-de-administrare-fiscala",
  "organizationTitle": "Agenția Națională de Administrare Fiscală",
  "organizationUrl": "https://data.gov.ro/organization/agentia-nationala-de-administrare-fiscala",
  "author": "Ionel Onofrei",
  "authorEmail": "ionel.onofrei@anaf.ro",
  "maintainer": "IONEL VALERICA ONOFREI",
  "maintainerEmail": "Not Disclosed",
  "licenseId": "CC-BY-4.0",
  "licenseTitle": "Creative Commons Attribution 4.0",
  "licenseUrl": "https://creativecommons.org/licenses/by/4.0/",
  "isOpenLicence": "Yes",
  "version": "N/A",
  "sourceUrl": "N/A",
  "rating": 2.85,
  "ratingsCount": 153,
  "numResources": 1,
  "numTags": 1,
  "tags": ["ANAF"],
  "categories": [],
  "formats": ["XML"],
  "totalSizeBytes": 0,
  "datastoreTables": 0,
  "archivedResources": 1,
  "brokenResources": 1,
  "hasBrokenLink": "Yes",
  "opennessScoreMax": null,
  "metadataCreated": "2026-07-23T10:24:30.584220",
  "metadataModified": "2026-07-23T10:32:26.365092",
  "resources": [
    {
      "resourceId": "e840f506-e1e6-4861-9195-424feb8d0b0a",
      "resourceName": "RAPORT_PERFORMANTA_2025",
      "resourceDescription": "Principalele realizări, colectarea veniturilor bugetare, îmbunătățirea serviciilor oferite, soluții digitale integrate, prevenirea si combaterea evaziunii fiscale, eficiență și transparență.",
      "format": "XML",
      "formatRaw": "XML",
      "url": "https://static.anaf.ro/static/10/Anaf/Informatii_R/RAPORT_PERFORMANTA_2025_V6.pdf",
      "portalDownloadUrl": "https://static.anaf.ro/static/10/Anaf/Informatii_R/RAPORT_PERFORMANTA_2025_V6.pdf",
      "resourceUrl": "https://data.gov.ro/dataset/raport-de-performanta-anaf-2025/resource/e840f506-e1e6-4861-9195-424feb8d0b0a",
      "mimeType": "application/pdf",
      "sizeBytes": null,
      "contentHash": "N/A",
      "position": 0,
      "resourceType": "N/A",
      "urlType": "N/A",
      "hasDatastore": "No",
      "resourceCreated": "2026-07-23T10:25:49.749326",
      "resourceLastModified": "N/A"
    }
  ],
  "daysSinceModified": 35,
  "isStale": "No",
  "extras": [],
  "archiveStatus": [
    {
      "resourceId": "e840f506-e1e6-4861-9195-424feb8d0b0a",
      "resourceName": "RAPORT_PERFORMANTA_2025",
      "isBroken": "Yes",
      "status": "URL invalid",
      "reason": "Invalid url scheme. Please use one of: ftp http https",
      "failureCount": 1,
      "firstFailure": "2026-07-23T10:25:59.635265",
      "lastSuccess": "N/A",
      "archivedAt": "2026-07-23T10:25:59.635265",
      "archivedSizeBytes": 0,
      "contentHash": "N/A",
      "etag": "N/A",
      "redirectedTo": "N/A",
      "cachedCopyUrl": "N/A"
    }
  ],
  "scrapedAt": "2026-08-27T19:31:00.509Z"
}
```

The `openness` block is absent from this row because the portal never scored that file, and a block that returns nothing is never billed.

### Configure the run

Pick a collection under **What to scrape**, add filters, tick the optional blocks you want, set **Max Items**, and start. Filters combine with AND; multiple values inside one filter combine with OR. The directory collections (organizations, categories, tags, licences, showcases, DataStore tables) ignore the search filters except the publisher one.

Every dataset updated since the start of 2026, newest first:

```json
{
  "dataset": "datasets",
  "sortBy": "modified-desc",
  "modifiedAfter": "2026-01-01",
  "maxItems": 500
}
```

Every broken file published by the three biggest ministries, with the archiver's reason and a live re-check:

```json
{
  "dataset": "resources",
  "organization": ["mdrap", "ms", "mfp"],
  "onlyBrokenLinks": true,
  "includeArchiveStatus": true,
  "includeLinkCheck": true,
  "maxItems": 1000
}
```

Every queryable SQL table with its real column types and three sample rows:

```json
{
  "dataset": "datastore-tables",
  "includeDatastoreSchema": true,
  "includeDatastorePreview": true,
  "datastorePreviewRows": 3,
  "maxItems": 200
}
```

### Pricing

Pay per event. You are charged for the rows you receive, plus a small fixed cost per catalogue page scanned, plus the Actor start. Optional blocks are billed only when they actually return data.

| Event | Price |
|---|---|
| Dataset row | $0.007 |
| File row | $0.005 |
| Contact row | $0.005 |
| Organization, showcase, DataStore table row | $0.004 |
| Category, licence row | $0.002 |
| Tag row | $0.001 |
| Catalogue page scanned | $0.004 |
| Archive status, openness score, publisher profile | $0.002 |
| View statistics, revision history, file preview widgets | $0.003 |
| DataStore schema | $0.004 |
| DataStore preview rows, live link verification | $0.005 |
| Actor start | $0.02 |

What a plain dataset run costs, with no optional blocks:

| Datasets | Rows | Pages scanned | Start | Total |
|---|---|---|---|---|
| 100 | $0.70 | $0.008 | $0.02 | **$0.73** |
| 1,000 | $7.00 | $0.04 | $0.02 | **$7.06** |
| 5,227 (the whole portal) | $36.59 | $0.212 | $0.02 | **$36.82** |

Volume discounts apply automatically on Bronze, Silver and Gold plans.

### 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 [Romania Open Data Portal Scraper](https://apify.com/parseforge/data-gov-ro-romania-open-data-scraper?fpr=vmoqkp).
3. Pick a collection under **What to scrape**, add filters and optional blocks, set **Max Items**, 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 Romania's open data portal 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/data-gov-ro-romania-open-data-scraper"
```

Then prompt it in plain language:

- *"Which Romanian ministries publish the most datasets, and how many of their files are broken?"*
- *"Find Romanian open datasets about budget execution that have a queryable table, and show me the column names."*
- *"List every data.gov.ro dataset updated this year that still has a dead download link, with the publisher's email."*

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

```
Use the Apify Actor "parseforge/data-gov-ro-romania-open-data-scraper" to read Romania's national open data portal at data.gov.ro. Input: { "dataset": "<datasets|resources|contacts|organizations|categories|tags|licenses|showcases|datastore-tables>", "searchQuery": "<text>", "organization": ["<slug>"], "resourceFormat": ["CSV"], "maxItems": <n> }. It returns title, Romanian description, publisher, author and maintainer emails, licence, tags, rating, and every file with its format, size, download URL, broken-link status and Five Stars openness score. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**No results at all?** You probably combined filters that do not overlap. A field the portal does not know silently returns 0 rows rather than an error, so remove filters one at a time. Categories are the usual culprit: only 10 of the 14 have any datasets, and health has just one.

**Fewer rows than the match count in the log?** The log reports what the portal's search index matched. Three filters are applied afterwards because the index does not expose them: has a queryable table, has a broken link, and minimum openness score. Those trim the result after the count is printed.

**A format filter returns nothing you expected?** The portal stores 64 spellings for about 20 formats, including `xml.`, `.xlsx` and `zip, shp`. The dropdown expands each choice across every spelling, so use it rather than typing a format by hand.

**An openness score or archive block is missing on some rows?** The portal has not scored or archived that file. 12,358 of 13,337 sampled files carry an openness score and 13,154 carry archiver data; the rest genuinely have none, and you are not charged for the missing block.

**The run is slower than you expected?** data.gov.ro drops non-European traffic, so every request goes through a Romanian residential IP. Plain dataset rows run at about 8.7 rows per second; ticking optional blocks that need a request per dataset, such as view statistics or revision history, slows it to roughly one row per second.

### FAQ

| Question | Answer |
|---|---|
| Do I need an API key or a data.gov.ro account? | No. Everything the Actor reads is public and anonymous. |
| How many datasets are on data.gov.ro? | 5,227, from 180 institutions of which 130 have published at least one. |
| Can I get the whole portal in one run? | Yes. 5,227 datasets is about 10 minutes at the default 1,800 second timeout. |
| What does the broken link data mean? | It is the portal's own archiver verdict, refreshed by data.gov.ro itself, not our guess. Tick **Verify file links live** to re-check the URLs in real time as well. |
| How bad is the link rot? | 7.3% of archived files were broken across a 13,154-file sample. The most common cause is a download error, followed by a system error during archival. |
| What is the Five Stars openness score? | Tim Berners-Lee's 0 to 5 open data scale, as scored by the portal. On data.gov.ro the average is 0.99 and nothing scores above 3, because most files are Excel rather than open machine-readable formats. |
| Which formats dominate? | XML and Excel. Across a 923-dataset sample: XML 7,514 files, XLS 2,503, XLSX 1,793, CSV only 398. |
| Can I read the actual data inside the files? | For the 5,753 files loaded into the portal's SQL DataStore, yes: tick **Include DataStore preview rows** for real rows and column types. Other files come with a direct download URL. |
| Is the text in Romanian? | Yes. Titles, descriptions and institution names are Romanian, exactly as published. Slugs and field names are ASCII. |
| Can I filter by date? | Yes, on both the creation and the last-update date. 424 datasets were updated in 2026 and 339 were created in 2026. |
| Why is it more expensive than a generic CKAN scraper? | Because a generic scraper cannot reach this portal from Apify at all, and because it returns the quality fields as an unparsed Python string. |

### Related actors

- [Italy Open Data Scraper - dati.gov.it](https://apify.com/parseforge/dati-gov-it-italy-open-data-scraper?fpr=vmoqkp) - 65,960 datasets from Italy's national CKAN catalogue.
- [Uruguay Open Data Scraper](https://apify.com/parseforge/uruguay-open-data-scraper?fpr=vmoqkp) - 2,702 datasets with DataStore tables and link checks.
- [GovData Germany Scraper](https://apify.com/parseforge/govdata-germany-scraper?fpr=vmoqkp) - the German federal open data portal over CKAN.
- [EU Funding & Tenders Portal Scraper](https://apify.com/parseforge/eu-funding-tenders-scraper?fpr=vmoqkp) - EU grants and calls, including Romanian beneficiaries.
- [TED Europa Tenders Scraper](https://apify.com/parseforge/ted-europa-tenders-scraper?fpr=vmoqkp) - EU public procurement notices across all member states.

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 is an unofficial scraper, not affiliated with or endorsed by data.gov.ro, the Government of Romania or any Romanian public institution. It collects only data that data.gov.ro publishes openly and anonymously, under the licences the portal states on each dataset. Author and maintainer contact details are published by the institutions themselves as the official point of contact for each dataset; if you process them, do so in line with GDPR, CCPA and PIPL, and use them only for the purpose the portal publishes them for.

# Actor input Schema

## `dataset` (type: `string`):

Which collection to return. 'Datasets' is the main one: one row per dataset on data.gov.ro with its full resource list. 'Resources' flattens to one row per file. The directory collections (organizations, categories, tags, licenses, showcases, DataStore tables) ignore the search filters below except organization.

## `searchQuery` (type: `string`):

Free-text search across titles, descriptions and tags, in Romanian. Example: 'buget' returns 186 datasets, 'achizitii' returns 172. Leave empty to take the whole catalogue.

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

Scrape only these exact datasets. Accepts full data.gov.ro dataset URLs, dataset slugs or dataset ids. When this is set the search filters are ignored.

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

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

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

Order of the results. Only these orders are real on data.gov.ro; anything else silently falls back to relevance.

## `organization` (type: `array`):

Keep only datasets published by these institutions. 130 of the 180 organizations have at least one dataset; the 30 largest are listed here.

## `category` (type: `array`):

Keep only datasets filed under these portal groups. Groups are sparsely used on data.gov.ro: finance has 28 datasets, health has 1, and four groups are empty.

## `resourceFormat` (type: `array`):

Keep only datasets that publish at least one file in these formats. data.gov.ro stores 64 different spellings for about 20 real formats, so each choice is expanded to every spelling: picking CSV matches 570 datasets, not the 362 a plain search returns.

## `licenseId` (type: `array`):

Keep only datasets under these licences. Counts are the whole catalogue: CC-BY-4.0 covers 3,322 datasets and UK OGL covers 1,704.

## `tags` (type: `string`):

Comma separated tags; a dataset matching any of them is kept. Real examples with counts: plati (466), refugiati (392), pompierii (280), inventar (123), buget (67), statistica (85).

## `author` (type: `string`):

Exact author name as recorded on the dataset. Example: 'Ana Lazar' returns 40 datasets.

## `titleContains` (type: `string`):

Keep only datasets whose title matches this phrase. Example: 'buget' returns 87 datasets.

## `notesContains` (type: `string`):

Keep only datasets whose description matches this phrase. Example: 'achizitii' returns 88 datasets.

## `modifiedAfter` (type: `string`):

Keep only datasets updated on or after this date (YYYY-MM-DD). 2026-01-01 returns 424 datasets.

## `createdAfter` (type: `string`):

Keep only datasets first published on or after this date (YYYY-MM-DD). 2026-01-01 returns 339 datasets.

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

Keep only datasets with at least this many files. 5 or more returns 635 datasets.

## `minTags` (type: `integer`):

Keep only datasets carrying at least this many tags. 3 or more returns 1,331 datasets.

## `minRating` (type: `number`):

Keep only datasets rated at least this highly by portal users (0 to 5, decimals allowed). 2,627 datasets carry a rating of 1 or more.

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

Keep only datasets the portal flags as openly licensed. 5,030 of 5,227 datasets qualify.

## `onlyWithDatastore` (type: `boolean`):

Keep only datasets with at least one file loaded into the portal's SQL DataStore. The portal's search index does not expose this, so it is applied after the search: expect fewer rows than the match count reported in the log.

## `onlyBrokenLinks` (type: `boolean`):

Keep only datasets where the portal's own archiver has flagged at least one file as unreachable. Applied after the search. Across the catalogue 7.3% of archived files are broken.

## `minOpennessScore` (type: `integer`):

Keep only datasets whose best file scores at least this on Tim Berners-Lee's Five Stars scale. Applied after the search. Nothing on data.gov.ro scores above 3, and 56% of files score 0.

## `includeArchiveStatus` (type: `boolean`):

Adds the portal archiver's verdict for every file: broken flag, status text, failure count, first failure, last success, redirect target, content hash and the cached copy URL. Costs no extra request.

## `includeOpennessScore` (type: `boolean`):

Adds the portal's Tim Berners-Lee Five Stars grade per file, with the reason text and the format the portal actually detected inside the file. Costs no extra request.

## `includeViewStats` (type: `boolean`):

Adds total and recent page-view counts per dataset. Costs one extra request per dataset.

## `includeActivityHistory` (type: `boolean`):

Adds the last 25 changes to the dataset with timestamps and change types, plus the first and last change dates. Costs one extra request per dataset.

## `includeDatastoreSchema` (type: `boolean`):

For files loaded into the portal's SQL DataStore, adds the column names, PostgreSQL column types and the exact row count. Costs one extra request per table, up to 10 tables per dataset.

## `includeDatastorePreview` (type: `boolean`):

Adds real data rows read out of the portal's SQL DataStore. Costs one extra request per table, up to 5 tables per dataset.

## `datastorePreviewRows` (type: `integer`):

How many rows to read from each DataStore table when preview rows are enabled.

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

Adds the publishing institution's description, logo, dataset count, follower count and member count. Cached per organization, so it costs one request per distinct publisher, not per dataset.

## `includeResourceViews` (type: `boolean`):

Adds the preview widgets the portal offers for each file (table, map, graph, text, PDF). Costs one extra request per file, up to 10 files per dataset.

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

Sends a live HEAD request to each file URL to confirm it is retrievable right now, and returns the HTTP status, content type and content length. This is the current truth, unlike the archiver status which is the portal's last cached verdict. Costs one request per file, up to 10 files per dataset.

## `concurrency` (type: `integer`):

How many requests to run in parallel against data.gov.ro. The portal asks crawlers for a 10 second delay, so this defaults to a polite 4 and is capped at 10.

## Actor input object example

```json
{
  "dataset": "datasets",
  "searchQuery": "buget",
  "startUrls": [],
  "maxItems": 10,
  "sortBy": "modified-desc",
  "organization": [],
  "category": [],
  "resourceFormat": [],
  "licenseId": [],
  "tags": "buget, plati",
  "modifiedAfter": "2026-01-01",
  "createdAfter": "2026-01-01",
  "onlyOpenLicence": false,
  "onlyWithDatastore": false,
  "onlyBrokenLinks": false,
  "includeArchiveStatus": false,
  "includeOpennessScore": false,
  "includeViewStats": false,
  "includeActivityHistory": false,
  "includeDatastoreSchema": false,
  "includeDatastorePreview": false,
  "datastorePreviewRows": 5,
  "includeOrganizationProfile": false,
  "includeResourceViews": false,
  "includeLinkCheck": false,
  "concurrency": 4
}
```

# 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 = {
    "dataset": "datasets",
    "maxItems": 10,
    "sortBy": "modified-desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/data-gov-ro-romania-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 = {
    "dataset": "datasets",
    "maxItems": 10,
    "sortBy": "modified-desc",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/data-gov-ro-romania-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 '{
  "dataset": "datasets",
  "maxItems": 10,
  "sortBy": "modified-desc"
}' |
apify call parseforge/data-gov-ro-romania-open-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/data-gov-ro-romania-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/UOyzTJanh41HMGMlD/builds/C8jXzsSk9gHqbIRyZ/openapi.json