# Romania Legislation (`openrows/romania-legislation`) Actor

Search and monitor Romania's official legislative portal (legislatie.just.ro): metadata and the official link for laws, codes, ordinances and Monitorul Oficial acts, 1964-present.

- **URL**: https://apify.com/openrows/romania-legislation.md
- **Developed by:** [openrows](https://apify.com/openrows) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00 / 1,000 legislative acts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Romania Legislation

Search and monitor Romania's official legislative portal — laws, codes, ordinances and other
Monitorul Oficial acts, from 1989 to present (older acts as far back as the 1960s also appear).

Extracts public data from [Portal Legislativ](https://legislatie.just.ro/) and delivers it as a
clean dataset you can download as JSON, CSV or Excel, or pull through the API. HTTP-only, no
browser, so runs are fast and cheap.

**This is a metadata monitor. It returns metadata and the official link; it does not reproduce the
text of acts.** For every match, you get the act's identity, type, date, issuer and its
`DetaliiDocument` page URL on legislatie.just.ro — the official reference to follow for the text
itself.

### What data you get

For every act the Actor returns:

| Field         | Description                                                                                   |
| ------------- | --------------------------------------------------------------------------------------------- |
| `url`         | The act's official reference page on legislatie.just.ro (link only, not fetched for its text) |
| `scrapedAt`   | ISO 8601 timestamp of the extraction                                                          |
| `actId`       | The site's internal document id                                                               |
| `title`       | Subject line of the act (e.g. "privind ...")                                                  |
| `actType`     | Type of act as shown by the site (LEGE, HOTARARE, ORDIN, DECRET, HG, ...)                     |
| `actNumber`   | Official act number, or `null` for acts that carry none                                       |
| `actDate`     | Date signed/adopted, ISO 8601 (`YYYY-MM-DD`)                                                  |
| `issuer`      | Issuing authority (Parlamentul, Guvernul, a named ministry, ...)                              |
| `publishedIn` | The Monitorul Oficial (or, pre-1989, Buletinul Oficial) reference                             |
| `status`      | `"repealed"` or `"in-force"` (see Limitations)                                                |

### Input

| Option               | Type    | Default          | Description                                                                                        |
| -------------------- | ------- | ---------------- | -------------------------------------------------------------------------------------------------- |
| `query`              | string  | -                | Full-text keyword search. Leave empty with `dateFrom` set for the "recent acts" use case           |
| `actType`            | string  | `(any)`          | Restrict to one act type (dropdown of common types, or a numeric type id from the site's own form) |
| `dateFrom`           | string  | -                | Only acts published on or after this date (`YYYY-MM-DD`)                                           |
| `dateTo`             | string  | -                | Only acts published on or before this date (`YYYY-MM-DD`)                                          |
| `maxItems`           | integer | `25`             | Stop after this many results (max 10,000). Also your cost cap                                      |
| `proxyConfiguration` | object  | Apify datacenter | Proxy settings                                                                                     |

**Search by keyword:**

```json
{
    "query": "proprietate",
    "actType": "Lege",
    "maxItems": 25
}
```

**"New-law alert" — acts published since a date** (leave `query` empty):

```json
{
    "dateFrom": "2026-09-01",
    "maxItems": 25
}
```

With a completely empty input, the Actor defaults to acts published in the last 30 days, so a
first run still returns useful data.

There is no option to fetch one specific act by URL: every run is a search / "acts since date"
listing.

### Output example

```json
{
    "url": "https://legislatie.just.ro/Public/DetaliiDocument/113367",
    "scrapedAt": "2026-09-22T17:14:42.287Z",
    "actId": 113367,
    "title": "privind modificarea şi completarea anexei nr. 17 la Hotărârea Guvernului nr. 1.705/2006 pentru aprobarea inventarului centralizat al bunurilor din domeniul public al statului",
    "actType": "HG",
    "actNumber": 1297,
    "actDate": "2009-10-28",
    "issuer": "GUVERNUL",
    "publishedIn": "MONITORUL OFICIAL nr. 777 din 13 noiembrie 2009",
    "status": "in-force"
}
```

A run summary (items pushed, items skipped by category, pages fetched, failed requests by
category, stop reason) is stored in the run's key-value store under the key `OUTPUT`.

### Pricing

**Pay per result.** You are charged per result and nothing else: no platform usage, no compute
units. Listing pages, retries and failed requests are free. The current rate is on the *Pricing*
tab of this Actor — that is the only place it is set, so no figure is repeated here.

- `maxItems` caps the number of results, and therefore the cost, of a run.
- The run also stops when it reaches the *maximum total charge* you set for the run in Apify
  Console or through the API.
- Real cost per result: each listing page returns up to 10 results, so a run spends roughly one
  free listing-page fetch per 10 chargeable results, plus one free fetch for the final,
  not-fully-used page.

### Tips

- Start with `maxItems: 10-20` to check the fields before a large run.
- For "give me everything published since date X", set only `dateFrom`; the underlying site sorts
  by relevance, not strictly by date, so read `actDate` on each row rather than assuming page
  order.

### Limitations

- Portal Legislativ pages that require a login are not accessible and are not scraped (in
  practice, the whole public search and document set needs no login).
- `status` only distinguishes `"repealed"` (the listing explicitly shows "ACT ABROGAT") from
  `"in-force"`. The site does not reliably mark "modified but still in force" on the listing page,
  so an amended, still-active act is reported as `"in-force"`.
- `actType` is the abbreviation the site's own listing shows (e.g. `HG` for a government
  decision), not a normalised long-form name.
- No per-record lookup: there is no way to pass one act's URL directly and get just that act back;
  every run is a search or a date-filtered listing.

**Source caveats.** What the source itself says about its data, repeated here because it limits
what the results can be used for:

- The only authentic, citable version of an act is the one printed in Monitorul Oficial. The
  portal's own consolidated (currently-in-force) texts are described on its Terms page as
  unofficial reproductions offered "cu rol consultativ" (for reference/advisory purposes only),
  and the terms state that no official document may cite a consolidated version — this Actor does
  not fetch or return that text at all, only the `url` to the act's official reference page.
- The site's Terms page also states that official legislative texts carry no copyright protection
  under Romanian Law 8/1996; separately, the site's own footer carries a general
  "Copyright © \[year] - Ministerul Justiţiei. Toate drepturile rezervate." (all rights reserved)
  notice. The two statements are not obviously reconciled on the site itself — treat the
  government-copyright footer as the more cautious signal for anything beyond individual, public
  lookups.

### Data and compliance

This Actor collects **publicly available, non-personal data only**:

- It fetches pages that are reachable without logging in and does not bypass access controls.
- It does not collect names, e-mail addresses, phone numbers or any other field that identifies a
  private person. `issuer` is always an institution, never a person, and no free-text field (only
  `title`, an official act subject line) has ever been observed to carry personal data in the
  listing pages this Actor reads.
- It identifies itself with a plain User-Agent and sends no headers that imitate a browser.
- It sends one request at a time, waits between requests, and stops instead of working around a
  block.

**Removal requests.** If you believe this Actor exposes data it should not, open an issue on the
Actor's *Issues* tab and state the URL(s) concerned. Requests are answered there, and the fields
or pages in question are removed.

You are responsible for using the extracted data in line with the terms of legislatie.just.ro and
the laws that apply to you.

### Support

Report bugs and request fields on the *Issues* tab of this Actor. Include the run ID.

### Proxy

The source answers only from Romanian residential IP addresses when run on the Apify platform, so the default `proxyConfiguration` uses Apify residential proxies in Romania. Datacenter proxies and direct connections time out. The pages are small text, so proxy bandwidth per run is minor, but it is part of the cost.

# Actor input Schema

## `query` (type: `string`):

Free-text search over the full text of acts (the site's "Cuvânt/cuvinte din text" field). Leave empty together with a Published from date for the "new-law alert" use case: every act published since that date, with no keyword filter.

## `actType` (type: `string`):

Restrict to one type of act. "(any)" leaves the filter off. This is a curated subset of the site's own ~170 document types; a numeric type id from the site's own search form also works.

## `dateFrom` (type: `string`):

Only acts published in Monitorul Oficial on or after this date. ISO format YYYY-MM-DD (e.g. "2026-09-22") — the run fails fast if this is not a real calendar date in that format, rather than silently searching the whole register. Set this alone, with no query, for the "acts published since X" alert use case.

## `dateTo` (type: `string`):

Only acts published in Monitorul Oficial on or before this date. ISO format YYYY-MM-DD (e.g. "2026-09-22") — the run fails fast if this is not a real calendar date in that format. Leave empty to mean "up to today".

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

Stop after this many results. You are charged per result, so this is also your cost cap. Maximum 10,000 per run; split a bigger job across runs.

## `proxyConfiguration` (type: `object`):

Proxy settings. Default: Apify residential proxies located in Romania — this site does not answer requests from datacenter addresses when the Actor runs on the Apify platform (verified 2026-09-22). Residential proxy bandwidth is small here (pages are text) but it is part of the run cost.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on pages fetched, including listing pages. Defaults to 5 x Max results.

## Actor input object example

```json
{
  "actType": "",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RO"
  }
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RO"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("openrows/romania-legislation").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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RO",
    } }

# Run the Actor and wait for it to finish
run = client.actor("openrows/romania-legislation").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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RO"
  }
}' |
apify call openrows/romania-legislation --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openrows/romania-legislation"
        }
    }
}
```

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/bBNtf64MGfJruk7st/builds/fb2g8bOu4WC7i5Qx3/openapi.json